From dd7db943742bb1029d00b1969030dd07b7c95a74 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?=
 <kdy1997.dev@gmail.com>
Date: Sun, 21 Jul 2024 04:17:02 +0900
Subject: [PATCH] GEN

---
 crates/swc_css_visit/src/generated.rs  | 2428 ++++++++++++++++++++
 crates/swc_ecma_visit/src/generated.rs | 2876 ++++++++++++++++++++++++
 crates/swc_html_visit/src/generated.rs |  307 +++
 crates/swc_xml_visit/src/generated.rs  |  265 +++
 4 files changed, 5876 insertions(+)

diff --git a/crates/swc_css_visit/src/generated.rs b/crates/swc_css_visit/src/generated.rs
index ff0e25efb69f..725804165630 100644
--- a/crates/swc_css_visit/src/generated.rs
+++ b/crates/swc_css_visit/src/generated.rs
@@ -8,392 +8,458 @@ pub trait Visit {
     #[doc = "Visit a node of type `AbsoluteColorBase`.\n\nBy default, this method calls \
              [`AbsoluteColorBase::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
         <AbsoluteColorBase as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AlphaValue`.\n\nBy default, this method calls \
              [`AlphaValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_alpha_value(&mut self, node: &AlphaValue) {
         <AlphaValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusB`.\n\nBy default, this method calls \
              [`AnPlusB::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_an_plus_b(&mut self, node: &AnPlusB) {
         <AnPlusB as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnPlusBNotation`.\n\nBy default, this method calls \
              [`AnPlusBNotation::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
         <AnPlusBNotation as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Angle`.\n\nBy default, this method calls \
              [`Angle::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_angle(&mut self, node: &Angle) {
         <Angle as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnglePercentage`.\n\nBy default, this method calls \
              [`AnglePercentage::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
         <AnglePercentage as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AnyNamespace`.\n\nBy default, this method calls \
              [`AnyNamespace::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_any_namespace(&mut self, node: &AnyNamespace) {
         <AnyNamespace as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRule`.\n\nBy default, this method calls \
              [`AtRule::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_at_rule(&mut self, node: &AtRule) {
         <AtRule as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRuleName`.\n\nBy default, this method calls \
              [`AtRuleName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_at_rule_name(&mut self, node: &AtRuleName) {
         <AtRuleName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AtRulePrelude`.\n\nBy default, this method calls \
              [`AtRulePrelude::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
         <AtRulePrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
              [`swc_atoms :: Atom::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelector`.\n\nBy default, this method calls \
              [`AttributeSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
         <AttributeSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcher`.\n\nBy default, this method calls \
              [`AttributeSelectorMatcher::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
         <AttributeSelectorMatcher as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorMatcherValue`.\n\nBy default, this method \
              calls [`AttributeSelectorMatcherValue::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_attribute_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
         <AttributeSelectorMatcherValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorModifier`.\n\nBy default, this method calls \
              [`AttributeSelectorModifier::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
         <AttributeSelectorModifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeSelectorValue`.\n\nBy default, this method calls \
              [`AttributeSelectorValue::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
         <AttributeSelectorValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinOp`.\n\nBy default, this method calls \
              [`BinOp::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_bin_op(&mut self, node: &BinOp) {
         <BinOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperator`.\n\nBy default, this method calls \
              [`CalcOperator::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_calc_operator(&mut self, node: &CalcOperator) {
         <CalcOperator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcOperatorType`.\n\nBy default, this method calls \
              [`CalcOperatorType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
         <CalcOperatorType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProduct`.\n\nBy default, this method calls \
              [`CalcProduct::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_calc_product(&mut self, node: &CalcProduct) {
         <CalcProduct as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcProductOrOperator`.\n\nBy default, this method calls \
              [`CalcProductOrOperator::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
         <CalcProductOrOperator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcProductOrOperator >`.\n\nBy default, this method \
              calls [`Vec < CalcProductOrOperator >::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
         <[CalcProductOrOperator] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcSum`.\n\nBy default, this method calls \
              [`CalcSum::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_calc_sum(&mut self, node: &CalcSum) {
         <CalcSum as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValue`.\n\nBy default, this method calls \
              [`CalcValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_calc_value(&mut self, node: &CalcValue) {
         <CalcValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CalcValueOrOperator`.\n\nBy default, this method calls \
              [`CalcValueOrOperator::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
         <CalcValueOrOperator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CalcValueOrOperator >`.\n\nBy default, this method calls \
              [`Vec < CalcValueOrOperator >::visit_children_with`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
         <[CalcValueOrOperator] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassSelector`.\n\nBy default, this method calls \
              [`ClassSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_selector(&mut self, node: &ClassSelector) {
         <ClassSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CmykComponent`.\n\nBy default, this method calls \
              [`CmykComponent::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_cmyk_component(&mut self, node: &CmykComponent) {
         <CmykComponent as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Color`.\n\nBy default, this method calls \
              [`Color::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_color(&mut self, node: &Color) {
         <Color as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ColorProfileName`.\n\nBy default, this method calls \
              [`ColorProfileName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
         <ColorProfileName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Combinator`.\n\nBy default, this method calls \
              [`Combinator::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_combinator(&mut self, node: &Combinator) {
         <Combinator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CombinatorValue`.\n\nBy default, this method calls \
              [`CombinatorValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_combinator_value(&mut self, node: &CombinatorValue) {
         <CombinatorValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelector`.\n\nBy default, this method calls \
              [`ComplexSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_complex_selector(&mut self, node: &ComplexSelector) {
         <ComplexSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComplexSelectorChildren`.\n\nBy default, this method calls \
              [`ComplexSelectorChildren::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
         <ComplexSelectorChildren as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelectorChildren >`.\n\nBy default, this method \
              calls [`Vec < ComplexSelectorChildren >::visit_children_with`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
         <[ComplexSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComplexSelector >`.\n\nBy default, this method calls \
              [`Vec < ComplexSelector >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
         <[ComplexSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComponentValue`.\n\nBy default, this method calls \
              [`ComponentValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_component_value(&mut self, node: &ComponentValue) {
         <ComponentValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ComponentValue >`.\n\nBy default, this method calls [`Vec \
              < ComponentValue >::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_component_values(&mut self, node: &[ComponentValue]) {
         <[ComponentValue] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelector`.\n\nBy default, this method calls \
              [`CompoundSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_compound_selector(&mut self, node: &CompoundSelector) {
         <CompoundSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CompoundSelectorList`.\n\nBy default, this method calls \
              [`CompoundSelectorList::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
         <CompoundSelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CompoundSelector >`.\n\nBy default, this method calls \
              [`Vec < CompoundSelector >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
         <[CompoundSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerCondition`.\n\nBy default, this method calls \
              [`ContainerCondition::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_container_condition(&mut self, node: &ContainerCondition) {
         <ContainerCondition as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerName`.\n\nBy default, this method calls \
              [`ContainerName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_container_name(&mut self, node: &ContainerName) {
         <ContainerName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQuery`.\n\nBy default, this method calls \
              [`ContainerQuery::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_container_query(&mut self, node: &ContainerQuery) {
         <ContainerQuery as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryAnd`.\n\nBy default, this method calls \
              [`ContainerQueryAnd::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
         <ContainerQueryAnd as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryNot`.\n\nBy default, this method calls \
              [`ContainerQueryNot::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
         <ContainerQueryNot as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryOr`.\n\nBy default, this method calls \
              [`ContainerQueryOr::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
         <ContainerQueryOr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContainerQueryType`.\n\nBy default, this method calls \
              [`ContainerQueryType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
         <ContainerQueryType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ContainerQueryType >`.\n\nBy default, this method calls \
              [`Vec < ContainerQueryType >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
         <[ContainerQueryType] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomHighlightName`.\n\nBy default, this method calls \
              [`CustomHighlightName::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
         <CustomHighlightName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomIdent`.\n\nBy default, this method calls \
              [`CustomIdent::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_custom_ident(&mut self, node: &CustomIdent) {
         <CustomIdent as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < CustomIdent >`.\n\nBy default, this method calls [`Vec < \
              CustomIdent >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
         <[CustomIdent] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQuery`.\n\nBy default, this method calls \
              [`CustomMediaQuery::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
         <CustomMediaQuery as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomMediaQueryMediaType`.\n\nBy default, this method calls \
              [`CustomMediaQueryMediaType::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CustomPropertyName`.\n\nBy default, this method calls \
              [`CustomPropertyName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
         <CustomPropertyName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DashedIdent`.\n\nBy default, this method calls \
              [`DashedIdent::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_dashed_ident(&mut self, node: &DashedIdent) {
         <DashedIdent as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Declaration`.\n\nBy default, this method calls \
              [`Declaration::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_declaration(&mut self, node: &Declaration) {
         <Declaration as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationName`.\n\nBy default, this method calls \
              [`DeclarationName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_declaration_name(&mut self, node: &DeclarationName) {
         <DeclarationName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DeclarationOrAtRule`.\n\nBy default, this method calls \
              [`DeclarationOrAtRule::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
         <DeclarationOrAtRule as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Delimiter`.\n\nBy default, this method calls \
              [`Delimiter::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_delimiter(&mut self, node: &Delimiter) {
         <Delimiter as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DelimiterValue`.\n\nBy default, this method calls \
              [`DelimiterValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
         <DelimiterValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Dimension`.\n\nBy default, this method calls \
              [`Dimension::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_dimension(&mut self, node: &Dimension) {
         <Dimension as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DimensionToken`.\n\nBy default, this method calls \
              [`DimensionToken::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_dimension_token(&mut self, node: &DimensionToken) {
         <DimensionToken as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPrelude`.\n\nBy default, this method calls \
              [`DocumentPrelude::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
         <DocumentPrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentPreludeMatchingFunction`.\n\nBy default, this method \
              calls [`DocumentPreludeMatchingFunction::visit_children_with`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_document_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
         <DocumentPreludeMatchingFunction as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < DocumentPreludeMatchingFunction >`.\n\nBy default, this \
              method calls [`Vec < DocumentPreludeMatchingFunction >::visit_children_with`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_document_prelude_matching_functions(
         &mut self,
         node: &[DocumentPreludeMatchingFunction],
@@ -403,556 +469,650 @@ pub trait Visit {
     #[doc = "Visit a node of type `ExtensionName`.\n\nBy default, this method calls \
              [`ExtensionName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_extension_name(&mut self, node: &ExtensionName) {
         <ExtensionName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FamilyName`.\n\nBy default, this method calls \
              [`FamilyName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_family_name(&mut self, node: &FamilyName) {
         <FamilyName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < FamilyName >`.\n\nBy default, this method calls [`Vec < \
              FamilyName >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_family_names(&mut self, node: &[FamilyName]) {
         <[FamilyName] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Flex`.\n\nBy default, this method calls \
              [`Flex::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_flex(&mut self, node: &Flex) {
         <Flex as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FontFeatureValuesPrelude`.\n\nBy default, this method calls \
              [`FontFeatureValuesPrelude::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
         <FontFeatureValuesPrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingComplexSelector`.\n\nBy default, this method calls \
              [`ForgivingComplexSelector::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
         <ForgivingComplexSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingComplexSelector >`.\n\nBy default, this method \
              calls [`Vec < ForgivingComplexSelector >::visit_children_with`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
         <[ForgivingComplexSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelector`.\n\nBy default, this method calls \
              [`ForgivingRelativeSelector::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
         <ForgivingRelativeSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingRelativeSelectorList`.\n\nBy default, this method \
              calls [`ForgivingRelativeSelectorList::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
         <ForgivingRelativeSelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
              calls [`Vec < ForgivingRelativeSelector >::visit_children_with`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
         <[ForgivingRelativeSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForgivingSelectorList`.\n\nBy default, this method calls \
              [`ForgivingSelectorList::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
         <ForgivingSelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Frequency`.\n\nBy default, this method calls \
              [`Frequency::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_frequency(&mut self, node: &Frequency) {
         <Frequency as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FrequencyPercentage`.\n\nBy default, this method calls \
              [`FrequencyPercentage::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
         <FrequencyPercentage as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
              [`Function::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_function(&mut self, node: &Function) {
         <Function as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FunctionName`.\n\nBy default, this method calls \
              [`FunctionName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_function_name(&mut self, node: &FunctionName) {
         <FunctionName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `GeneralEnclosed`.\n\nBy default, this method calls \
              [`GeneralEnclosed::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
         <GeneralEnclosed as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `HexColor`.\n\nBy default, this method calls \
              [`HexColor::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_hex_color(&mut self, node: &HexColor) {
         <HexColor as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Hue`.\n\nBy default, this method calls \
              [`Hue::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_hue(&mut self, node: &Hue) {
         <Hue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdSelector`.\n\nBy default, this method calls \
              [`IdSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_id_selector(&mut self, node: &IdSelector) {
         <IdSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
              [`Ident::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_ident(&mut self, node: &Ident) {
         <Ident as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Ident >`.\n\nBy default, this method calls [`Vec < Ident \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_idents(&mut self, node: &[Ident]) {
         <[Ident] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportConditions`.\n\nBy default, this method calls \
              [`ImportConditions::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_import_conditions(&mut self, node: &ImportConditions) {
         <ImportConditions as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportHref`.\n\nBy default, this method calls \
              [`ImportHref::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_href(&mut self, node: &ImportHref) {
         <ImportHref as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportLayerName`.\n\nBy default, this method calls \
              [`ImportLayerName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
         <ImportLayerName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPrelude`.\n\nBy default, this method calls \
              [`ImportPrelude::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_prelude(&mut self, node: &ImportPrelude) {
         <ImportPrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportantFlag`.\n\nBy default, this method calls \
              [`ImportantFlag::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_important_flag(&mut self, node: &ImportantFlag) {
         <ImportantFlag as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Integer`.\n\nBy default, this method calls \
              [`Integer::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_integer(&mut self, node: &Integer) {
         <Integer as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeBlock`.\n\nBy default, this method calls \
              [`KeyframeBlock::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
         <KeyframeBlock as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframeSelector`.\n\nBy default, this method calls \
              [`KeyframeSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
         <KeyframeSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < KeyframeSelector >`.\n\nBy default, this method calls \
              [`Vec < KeyframeSelector >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
         <[KeyframeSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesName`.\n\nBy default, this method calls \
              [`KeyframesName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_keyframes_name(&mut self, node: &KeyframesName) {
         <KeyframesName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoFunction`.\n\nBy default, this method calls \
              [`KeyframesPseudoFunction::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
         <KeyframesPseudoFunction as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyframesPseudoPrefix`.\n\nBy default, this method calls \
              [`KeyframesPseudoPrefix::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
         <KeyframesPseudoPrefix as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerName`.\n\nBy default, this method calls \
              [`LayerName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_layer_name(&mut self, node: &LayerName) {
         <LayerName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerNameList`.\n\nBy default, this method calls \
              [`LayerNameList::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_layer_name_list(&mut self, node: &LayerNameList) {
         <LayerNameList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < LayerName >`.\n\nBy default, this method calls [`Vec < \
              LayerName >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_layer_names(&mut self, node: &[LayerName]) {
         <[LayerName] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `LayerPrelude`.\n\nBy default, this method calls \
              [`LayerPrelude::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
         <LayerPrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Length`.\n\nBy default, this method calls \
              [`Length::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_length(&mut self, node: &Length) {
         <Length as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `LengthPercentage`.\n\nBy default, this method calls \
              [`LengthPercentage::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_length_percentage(&mut self, node: &LengthPercentage) {
         <LengthPercentage as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ListOfComponentValues`.\n\nBy default, this method calls \
              [`ListOfComponentValues::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
         <ListOfComponentValues as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaAnd`.\n\nBy default, this method calls \
              [`MediaAnd::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_and(&mut self, node: &MediaAnd) {
         <MediaAnd as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaCondition`.\n\nBy default, this method calls \
              [`MediaCondition::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_condition(&mut self, node: &MediaCondition) {
         <MediaCondition as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionAllType`.\n\nBy default, this method calls \
              [`MediaConditionAllType::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
         <MediaConditionAllType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionAllType >`.\n\nBy default, this method \
              calls [`Vec < MediaConditionAllType >::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
         <[MediaConditionAllType] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionType`.\n\nBy default, this method calls \
              [`MediaConditionType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
         <MediaConditionType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOr`.\n\nBy default, this method calls \
              [`MediaConditionWithoutOr::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
         <MediaConditionWithoutOr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaConditionWithoutOrType`.\n\nBy default, this method calls \
              [`MediaConditionWithoutOrType::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaConditionWithoutOrType >`.\n\nBy default, this \
              method calls [`Vec < MediaConditionWithoutOrType >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeature`.\n\nBy default, this method calls \
              [`MediaFeature::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_feature(&mut self, node: &MediaFeature) {
         <MediaFeature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureBoolean`.\n\nBy default, this method calls \
              [`MediaFeatureBoolean::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
         <MediaFeatureBoolean as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureName`.\n\nBy default, this method calls \
              [`MediaFeatureName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
         <MediaFeatureName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeaturePlain`.\n\nBy default, this method calls \
              [`MediaFeaturePlain::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
         <MediaFeaturePlain as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRange`.\n\nBy default, this method calls \
              [`MediaFeatureRange::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
         <MediaFeatureRange as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRangeComparison`.\n\nBy default, this method calls \
              [`MediaFeatureRangeComparison::visit_children_with`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
         <MediaFeatureRangeComparison as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureRangeInterval`.\n\nBy default, this method calls \
              [`MediaFeatureRangeInterval::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
         <MediaFeatureRangeInterval as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaFeatureValue`.\n\nBy default, this method calls \
              [`MediaFeatureValue::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
         <MediaFeatureValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaInParens`.\n\nBy default, this method calls \
              [`MediaInParens::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_in_parens(&mut self, node: &MediaInParens) {
         <MediaInParens as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaNot`.\n\nBy default, this method calls \
              [`MediaNot::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_not(&mut self, node: &MediaNot) {
         <MediaNot as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaOr`.\n\nBy default, this method calls \
              [`MediaOr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_or(&mut self, node: &MediaOr) {
         <MediaOr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQuery`.\n\nBy default, this method calls \
              [`MediaQuery::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_query(&mut self, node: &MediaQuery) {
         <MediaQuery as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaQueryList`.\n\nBy default, this method calls \
              [`MediaQueryList::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_query_list(&mut self, node: &MediaQueryList) {
         <MediaQueryList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < MediaQuery >`.\n\nBy default, this method calls [`Vec < \
              MediaQuery >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_querys(&mut self, node: &[MediaQuery]) {
         <[MediaQuery] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MediaType`.\n\nBy default, this method calls \
              [`MediaType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_media_type(&mut self, node: &MediaType) {
         <MediaType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedNamespace`.\n\nBy default, this method calls \
              [`NamedNamespace::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_named_namespace(&mut self, node: &NamedNamespace) {
         <NamedNamespace as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
              [`Namespace::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_namespace(&mut self, node: &Namespace) {
         <Namespace as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrefix`.\n\nBy default, this method calls \
              [`NamespacePrefix::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
         <NamespacePrefix as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePrelude`.\n\nBy default, this method calls \
              [`NamespacePrelude::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
         <NamespacePrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamespacePreludeUri`.\n\nBy default, this method calls \
              [`NamespacePreludeUri::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
         <NamespacePreludeUri as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NestingSelector`.\n\nBy default, this method calls \
              [`NestingSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_nesting_selector(&mut self, node: &NestingSelector) {
         <NestingSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
              [`Number::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_number(&mut self, node: &Number) {
         <Number as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NumberType`.\n\nBy default, this method calls \
              [`NumberType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_number_type(&mut self, node: &NumberType) {
         <NumberType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < AtRulePrelude > >`.\n\nBy default, this method \
              calls [`Option < Box < AtRulePrelude > >::visit_children_with`]. 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 VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorMatcher >`.\n\nBy default, this \
              method calls [`Option < AttributeSelectorMatcher >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorModifier >`.\n\nBy default, this \
              method calls [`Option < AttributeSelectorModifier >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < AttributeSelectorValue >`.\n\nBy default, this method \
              calls [`Option < AttributeSelectorValue >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Combinator >`.\n\nBy default, this method calls \
              [`Option < Combinator >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
         <Option<Combinator> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ContainerName >`.\n\nBy default, this method calls \
              [`Option < ContainerName >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
              calls [`Option < ForgivingSelectorList >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Function > >`.\n\nBy default, this method calls \
              [`Option < Box < Function > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
              Ident >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_ident(&mut self, node: &Option<Ident>) {
         <Option<Ident> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportConditions > >`.\n\nBy default, this \
              method calls [`Option < Box < ImportConditions > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ImportLayerName > >`.\n\nBy default, this method \
              calls [`Option < Box < ImportLayerName > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ImportantFlag >`.\n\nBy default, this method calls \
              [`Option < ImportantFlag >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaConditionType > >`.\n\nBy default, this \
              method calls [`Option < Box < MediaConditionType > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < MediaQueryList > >`.\n\nBy default, this method \
              calls [`Option < Box < MediaQueryList > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < MediaType >`.\n\nBy default, this method calls \
              [`Option < MediaType >::visit_children_with`]. 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 VisitWith<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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
         <Option<Namespace> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NamespacePrefix >`.\n\nBy default, this method calls \
              [`Option < NamespacePrefix >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < NestingSelector >`.\n\nBy default, this method calls \
              [`Option < NestingSelector >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Number >`.\n\nBy default, this method calls [`Option < \
              Number >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_number(&mut self, node: &Option<Number>) {
         <Option<Number> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PageSelectorPseudo > >`.\n\nBy default, this \
              method calls [`Option < Vec < PageSelectorPseudo > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < PageSelectorType >`.\n\nBy default, this method calls \
              [`Option < PageSelectorType >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < PseudoClassSelectorChildren > >`.\n\nBy default, \
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &Option<Vec<PseudoClassSelectorChildren>>,
@@ -964,6 +1124,7 @@ pub trait Visit {
     #[doc = "Visit a node of type `Option < Vec < PseudoElementSelectorChildren > >`.\n\nBy \
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &Option<Vec<PseudoElementSelectorChildren>>,
@@ -975,406 +1136,475 @@ pub trait Visit {
     #[doc = "Visit a node of type `Option < SimpleBlock >`.\n\nBy default, this method calls \
              [`Option < SimpleBlock >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TypeSelector > >`.\n\nBy default, this method \
              calls [`Option < Box < TypeSelector > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < UrlModifier > >`.\n\nBy default, this method \
              calls [`Option < Vec < UrlModifier > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < UrlValue > >`.\n\nBy default, this method calls \
              [`Option < Box < UrlValue > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelector`.\n\nBy default, this method calls \
              [`PageSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_page_selector(&mut self, node: &PageSelector) {
         <PageSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorList`.\n\nBy default, this method calls \
              [`PageSelectorList::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
         <PageSelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorPseudo`.\n\nBy default, this method calls \
              [`PageSelectorPseudo::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
         <PageSelectorPseudo as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelectorPseudo >`.\n\nBy default, this method calls \
              [`Vec < PageSelectorPseudo >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
         <[PageSelectorPseudo] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PageSelectorType`.\n\nBy default, this method calls \
              [`PageSelectorType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
         <PageSelectorType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PageSelector >`.\n\nBy default, this method calls [`Vec < \
              PageSelector >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_page_selectors(&mut self, node: &[PageSelector]) {
         <[PageSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Percentage`.\n\nBy default, this method calls \
              [`Percentage::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_percentage(&mut self, node: &Percentage) {
         <Percentage as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelector`.\n\nBy default, this method calls \
              [`PseudoClassSelector::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
         <PseudoClassSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoClassSelectorChildren`.\n\nBy default, this method calls \
              [`PseudoClassSelectorChildren::visit_children_with`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
         <PseudoClassSelectorChildren as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoClassSelectorChildren >`.\n\nBy default, this \
              method calls [`Vec < PseudoClassSelectorChildren >::visit_children_with`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
         <[PseudoClassSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoElementSelector`.\n\nBy default, this method calls \
              [`PseudoElementSelector::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
         <PseudoElementSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PseudoElementSelectorChildren`.\n\nBy default, this method \
              calls [`PseudoElementSelectorChildren::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
         <PseudoElementSelectorChildren as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PseudoElementSelectorChildren >`.\n\nBy default, this \
              method calls [`Vec < PseudoElementSelectorChildren >::visit_children_with`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
         <[PseudoElementSelectorChildren] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `QualifiedRule`.\n\nBy default, this method calls \
              [`QualifiedRule::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
         <QualifiedRule as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `QualifiedRulePrelude`.\n\nBy default, this method calls \
              [`QualifiedRulePrelude::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
         <QualifiedRulePrelude as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `QueryInParens`.\n\nBy default, this method calls \
              [`QueryInParens::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_query_in_parens(&mut self, node: &QueryInParens) {
         <QueryInParens as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ratio`.\n\nBy default, this method calls \
              [`Ratio::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_ratio(&mut self, node: &Ratio) {
         <Ratio as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelector`.\n\nBy default, this method calls \
              [`RelativeSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_relative_selector(&mut self, node: &RelativeSelector) {
         <RelativeSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `RelativeSelectorList`.\n\nBy default, this method calls \
              [`RelativeSelectorList::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
         <RelativeSelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < RelativeSelector >`.\n\nBy default, this method calls \
              [`Vec < RelativeSelector >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
         <[RelativeSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Resolution`.\n\nBy default, this method calls \
              [`Resolution::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_resolution(&mut self, node: &Resolution) {
         <Resolution as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Rule`.\n\nBy default, this method calls \
              [`Rule::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_rule(&mut self, node: &Rule) {
         <Rule as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Rule >`.\n\nBy default, this method calls [`Vec < Rule \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_rules(&mut self, node: &[Rule]) {
         <[Rule] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ScopeRange`.\n\nBy default, this method calls \
              [`ScopeRange::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_scope_range(&mut self, node: &ScopeRange) {
         <ScopeRange as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SelectorList`.\n\nBy default, this method calls \
              [`SelectorList::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_selector_list(&mut self, node: &SelectorList) {
         <SelectorList as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SequenceOfCustomIdents`.\n\nBy default, this method calls \
              [`SequenceOfCustomIdents::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
         <SequenceOfCustomIdents as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SimpleBlock`.\n\nBy default, this method calls \
              [`SimpleBlock::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_simple_block(&mut self, node: &SimpleBlock) {
         <SimpleBlock as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeature`.\n\nBy default, this method calls \
              [`SizeFeature::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_size_feature(&mut self, node: &SizeFeature) {
         <SizeFeature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureBoolean`.\n\nBy default, this method calls \
              [`SizeFeatureBoolean::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
         <SizeFeatureBoolean as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureName`.\n\nBy default, this method calls \
              [`SizeFeatureName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
         <SizeFeatureName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeaturePlain`.\n\nBy default, this method calls \
              [`SizeFeaturePlain::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
         <SizeFeaturePlain as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRange`.\n\nBy default, this method calls \
              [`SizeFeatureRange::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
         <SizeFeatureRange as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeComparison`.\n\nBy default, this method calls \
              [`SizeFeatureRangeComparison::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
         <SizeFeatureRangeComparison as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureRangeInterval`.\n\nBy default, this method calls \
              [`SizeFeatureRangeInterval::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
         <SizeFeatureRangeInterval as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SizeFeatureValue`.\n\nBy default, this method calls \
              [`SizeFeatureValue::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
         <SizeFeatureValue as VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
              [`Str::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_str(&mut self, node: &Str) {
         <Str as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `StyleBlock`.\n\nBy default, this method calls \
              [`StyleBlock::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_style_block(&mut self, node: &StyleBlock) {
         <StyleBlock as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stylesheet`.\n\nBy default, this method calls \
              [`Stylesheet::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_stylesheet(&mut self, node: &Stylesheet) {
         <Stylesheet as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SubclassSelector`.\n\nBy default, this method calls \
              [`SubclassSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
         <SubclassSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SubclassSelector >`.\n\nBy default, this method calls \
              [`Vec < SubclassSelector >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
         <[SubclassSelector] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsAnd`.\n\nBy default, this method calls \
              [`SupportsAnd::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_supports_and(&mut self, node: &SupportsAnd) {
         <SupportsAnd as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsCondition`.\n\nBy default, this method calls \
              [`SupportsCondition::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_supports_condition(&mut self, node: &SupportsCondition) {
         <SupportsCondition as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsConditionType`.\n\nBy default, this method calls \
              [`SupportsConditionType::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
         <SupportsConditionType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SupportsConditionType >`.\n\nBy default, this method \
              calls [`Vec < SupportsConditionType >::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
         <[SupportsConditionType] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsFeature`.\n\nBy default, this method calls \
              [`SupportsFeature::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_supports_feature(&mut self, node: &SupportsFeature) {
         <SupportsFeature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsInParens`.\n\nBy default, this method calls \
              [`SupportsInParens::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
         <SupportsInParens as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsNot`.\n\nBy default, this method calls \
              [`SupportsNot::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_supports_not(&mut self, node: &SupportsNot) {
         <SupportsNot as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SupportsOr`.\n\nBy default, this method calls \
              [`SupportsOr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_supports_or(&mut self, node: &SupportsOr) {
         <SupportsOr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TagNameSelector`.\n\nBy default, this method calls \
              [`TagNameSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
         <TagNameSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Time`.\n\nBy default, this method calls \
              [`Time::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_time(&mut self, node: &Time) {
         <Time as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TimePercentage`.\n\nBy default, this method calls \
              [`TimePercentage::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_time_percentage(&mut self, node: &TimePercentage) {
         <TimePercentage as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
              [`Token::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_token(&mut self, node: &Token) {
         <Token as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
              [`TokenAndSpan::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
         <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TypeSelector`.\n\nBy default, this method calls \
              [`TypeSelector::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_type_selector(&mut self, node: &TypeSelector) {
         <TypeSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnicodeRange`.\n\nBy default, this method calls \
              [`UnicodeRange::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_unicode_range(&mut self, node: &UnicodeRange) {
         <UnicodeRange as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UniversalSelector`.\n\nBy default, this method calls \
              [`UniversalSelector::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_universal_selector(&mut self, node: &UniversalSelector) {
         <UniversalSelector as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnknownDimension`.\n\nBy default, this method calls \
              [`UnknownDimension::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
         <UnknownDimension as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Url`.\n\nBy default, this method calls \
              [`Url::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_url(&mut self, node: &Url) {
         <Url as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlKeyValue`.\n\nBy default, this method calls \
              [`UrlKeyValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
         <UrlKeyValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlModifier`.\n\nBy default, this method calls \
              [`UrlModifier::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_url_modifier(&mut self, node: &UrlModifier) {
         <UrlModifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < UrlModifier >`.\n\nBy default, this method calls [`Vec < \
              UrlModifier >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
         <[UrlModifier] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValue`.\n\nBy default, this method calls \
              [`UrlValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_url_value(&mut self, node: &UrlValue) {
         <UrlValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UrlValueRaw`.\n\nBy default, this method calls \
              [`UrlValueRaw::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
         <UrlValueRaw as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `WqName`.\n\nBy default, this method calls \
              [`WqName::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_wq_name(&mut self, node: &WqName) {
         <WqName as VisitWith<Self>>::visit_children_with(node, self)
     }
@@ -12918,20 +13148,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for WqName {
 }
 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))
@@ -12939,10 +13173,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [CalcProductOrOperator] {
 }
 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))
@@ -12950,10 +13186,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [CalcValueOrOperator] {
 }
 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))
@@ -12961,10 +13199,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelectorChildren] {
 }
 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))
@@ -12972,10 +13212,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ComplexSelector] {
 }
 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))
@@ -12983,10 +13225,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ComponentValue] {
 }
 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))
@@ -12994,10 +13238,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [CompoundSelector] {
 }
 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))
@@ -13005,10 +13251,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ContainerQueryType] {
 }
 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))
@@ -13016,10 +13264,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [CustomIdent] {
 }
 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)
@@ -13028,10 +13278,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [DocumentPreludeMatchingFunction] {
 }
 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))
@@ -13039,10 +13291,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [FamilyName] {
 }
 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))
@@ -13050,10 +13304,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingComplexSelector] {
 }
 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))
@@ -13061,10 +13317,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ForgivingRelativeSelector] {
 }
 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))
@@ -13072,10 +13330,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Ident] {
 }
 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))
@@ -13083,10 +13343,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [KeyframeSelector] {
 }
 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))
@@ -13094,10 +13356,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [LayerName] {
 }
 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))
@@ -13105,10 +13369,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionAllType] {
 }
 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)
@@ -13117,10 +13383,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [MediaConditionWithoutOrType] {
 }
 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))
@@ -13128,10 +13396,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [MediaQuery] {
 }
 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),
@@ -13141,10 +13411,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<AtRulePrelude>> {
 }
 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),
@@ -13154,10 +13426,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
 }
 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),
@@ -13167,10 +13441,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorMatcher> {
 }
 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),
@@ -13180,10 +13456,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorModifier> {
 }
 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),
@@ -13193,10 +13471,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<AttributeSelectorValue> {
 }
 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),
@@ -13206,10 +13486,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Combinator> {
 }
 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),
@@ -13219,10 +13501,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<ContainerName> {
 }
 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),
@@ -13232,10 +13516,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<ForgivingSelectorList> {
 }
 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),
@@ -13245,10 +13531,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Function>> {
 }
 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),
@@ -13258,10 +13546,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
 }
 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),
@@ -13271,10 +13561,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportConditions>> {
 }
 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),
@@ -13284,10 +13576,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ImportLayerName>> {
 }
 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),
@@ -13297,10 +13591,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<ImportantFlag> {
 }
 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),
@@ -13310,10 +13606,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaConditionType>> {
 }
 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),
@@ -13323,10 +13621,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<MediaQueryList>> {
 }
 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),
@@ -13336,10 +13636,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<MediaType> {
 }
 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),
@@ -13349,10 +13651,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Namespace> {
 }
 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),
@@ -13362,10 +13666,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<NamespacePrefix> {
 }
 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),
@@ -13375,10 +13681,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<NestingSelector> {
 }
 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),
@@ -13388,10 +13696,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Number> {
 }
 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),
@@ -13401,10 +13711,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PageSelectorPseudo>> {
 }
 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),
@@ -13414,10 +13726,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<PageSelectorType> {
 }
 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) => {
@@ -13429,10 +13743,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoClassSelectorChildren>
 }
 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) => {
@@ -13444,10 +13760,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<PseudoElementSelectorChildre
 }
 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),
@@ -13457,10 +13775,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<SimpleBlock> {
 }
 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),
@@ -13470,10 +13790,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TypeSelector>> {
 }
 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),
@@ -13483,10 +13805,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<UrlModifier>> {
 }
 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),
@@ -13496,10 +13820,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<UrlValue>> {
 }
 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))
@@ -13507,10 +13833,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [PageSelectorPseudo] {
 }
 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))
@@ -13518,10 +13846,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [PageSelector] {
 }
 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)
@@ -13530,10 +13860,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [PseudoClassSelectorChildren] {
 }
 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)
@@ -13542,10 +13874,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [PseudoElementSelectorChildren] {
 }
 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))
@@ -13553,10 +13887,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [RelativeSelector] {
 }
 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))
@@ -13564,20 +13900,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Rule] {
 }
 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))
@@ -13585,10 +13925,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [SubclassSelector] {
 }
 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))
@@ -13596,10 +13938,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [SupportsConditionType] {
 }
 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))
@@ -13610,11 +13954,13 @@ 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
@@ -13625,11 +13971,13 @@ 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
@@ -13642,6 +13990,7 @@ 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,
@@ -13654,6 +14003,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13664,6 +14014,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13674,6 +14025,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13686,12 +14038,14 @@ pub trait VisitAstPath {
     #[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,
@@ -13704,6 +14058,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13716,6 +14071,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13726,6 +14082,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13736,6 +14093,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13748,6 +14106,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13760,6 +14119,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13772,6 +14132,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13784,6 +14145,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13796,6 +14158,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13808,6 +14171,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13820,12 +14184,14 @@ pub trait VisitAstPath {
     #[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,
@@ -13838,6 +14204,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13850,6 +14217,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13862,6 +14230,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13874,6 +14243,7 @@ pub trait VisitAstPath {
     #[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],
@@ -13886,6 +14256,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13896,6 +14267,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13906,6 +14278,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13918,6 +14291,7 @@ pub trait VisitAstPath {
     #[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],
@@ -13930,6 +14304,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13942,6 +14317,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13954,12 +14330,14 @@ pub trait VisitAstPath {
     #[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,
@@ -13972,6 +14350,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13982,6 +14361,7 @@ pub trait VisitAstPath {
     #[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,
@@ -13994,6 +14374,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14006,6 +14387,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14018,6 +14400,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14030,6 +14413,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14042,6 +14426,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14054,6 +14439,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14066,6 +14452,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14078,6 +14465,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14090,6 +14478,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14102,6 +14491,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14114,6 +14504,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14126,6 +14517,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14138,6 +14530,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14150,6 +14543,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14162,6 +14556,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14174,6 +14569,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14186,6 +14582,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14198,6 +14595,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14210,6 +14608,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14222,6 +14621,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14234,6 +14634,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14246,6 +14647,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14258,6 +14660,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14270,6 +14673,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14282,6 +14686,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14294,6 +14699,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14306,6 +14712,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14318,6 +14725,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14328,6 +14736,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14340,6 +14749,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14350,6 +14760,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14362,6 +14773,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14374,6 +14786,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14387,6 +14800,7 @@ pub trait VisitAstPath {
              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],
@@ -14399,6 +14813,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14411,6 +14826,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14421,6 +14837,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14433,12 +14850,14 @@ pub trait VisitAstPath {
     #[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,
@@ -14451,6 +14870,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14463,6 +14883,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14475,6 +14896,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14487,6 +14909,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14499,6 +14922,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14511,6 +14935,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14523,6 +14948,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14533,6 +14959,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14545,6 +14972,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14555,6 +14983,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14567,6 +14996,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14579,6 +15009,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14589,12 +15020,14 @@ pub trait VisitAstPath {
     #[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,
@@ -14605,12 +15038,14 @@ pub trait VisitAstPath {
     #[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],
@@ -14621,6 +15056,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14633,6 +15069,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14643,6 +15080,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14655,6 +15093,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14667,6 +15106,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14679,6 +15119,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14689,6 +15130,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14701,6 +15143,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14713,6 +15156,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14725,6 +15169,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14737,6 +15182,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14749,6 +15195,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14761,6 +15208,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14771,6 +15219,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14783,6 +15232,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14795,6 +15245,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14807,12 +15258,14 @@ pub trait VisitAstPath {
     #[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,
@@ -14825,6 +15278,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14837,6 +15291,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14847,6 +15302,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14859,6 +15315,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14871,6 +15328,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14883,6 +15341,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14895,6 +15354,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14907,6 +15367,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14919,6 +15380,7 @@ pub trait VisitAstPath {
     #[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],
@@ -14931,6 +15393,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14943,6 +15406,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14955,6 +15419,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14967,6 +15432,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14979,6 +15445,7 @@ pub trait VisitAstPath {
     #[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,
@@ -14991,6 +15458,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15003,6 +15471,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15015,6 +15484,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15027,6 +15497,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15039,6 +15510,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15049,6 +15521,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15059,6 +15532,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15069,6 +15543,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15081,6 +15556,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15093,6 +15569,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15103,6 +15580,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15115,6 +15593,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15125,6 +15604,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15137,6 +15617,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15149,6 +15630,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15161,6 +15643,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15173,12 +15656,14 @@ pub trait VisitAstPath {
     #[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,
@@ -15189,6 +15674,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15201,6 +15687,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15213,6 +15700,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15225,6 +15713,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15237,6 +15726,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15249,6 +15739,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15261,6 +15752,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15273,6 +15765,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15285,6 +15778,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15297,6 +15791,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15309,6 +15804,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15321,6 +15817,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15333,6 +15830,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15345,6 +15843,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15357,6 +15856,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15369,6 +15869,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15381,6 +15882,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15393,6 +15895,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15405,6 +15908,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15417,6 +15921,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15429,6 +15934,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15441,6 +15947,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15454,6 +15961,7 @@ pub trait VisitAstPath {
              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>>,
@@ -15465,6 +15973,7 @@ pub trait VisitAstPath {
              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>>,
@@ -15475,6 +15984,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -15487,6 +15997,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15499,6 +16010,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15511,6 +16023,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -15523,6 +16036,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15535,6 +16049,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15547,6 +16062,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15559,6 +16075,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15571,6 +16088,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15583,6 +16101,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15595,6 +16114,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15605,6 +16125,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15617,6 +16138,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15629,6 +16151,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15641,6 +16164,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15653,6 +16177,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15665,6 +16190,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15677,6 +16203,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15689,6 +16216,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15701,6 +16229,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15713,12 +16242,14 @@ pub trait VisitAstPath {
     #[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,
@@ -15731,6 +16262,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15743,6 +16275,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15755,6 +16288,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15765,18 +16299,21 @@ pub trait VisitAstPath {
     #[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,
@@ -15787,6 +16324,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15799,6 +16337,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15811,6 +16350,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15823,6 +16363,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15835,6 +16376,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15847,6 +16389,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15859,6 +16402,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15871,6 +16415,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15883,6 +16428,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15895,6 +16441,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15907,6 +16454,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15919,6 +16467,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15931,12 +16480,14 @@ pub trait VisitAstPath {
     #[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,
@@ -15947,6 +16498,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15957,6 +16509,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15969,6 +16522,7 @@ pub trait VisitAstPath {
     #[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],
@@ -15981,6 +16535,7 @@ pub trait VisitAstPath {
     #[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,
@@ -15993,6 +16548,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16005,6 +16561,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16017,6 +16574,7 @@ pub trait VisitAstPath {
     #[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],
@@ -16029,6 +16587,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16041,6 +16600,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16053,6 +16613,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16065,6 +16626,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16075,6 +16637,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16087,12 +16650,14 @@ pub trait VisitAstPath {
     #[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,
@@ -16105,12 +16670,14 @@ pub trait VisitAstPath {
     #[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,
@@ -16123,6 +16690,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16135,6 +16703,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16147,6 +16716,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16159,6 +16729,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16171,12 +16742,14 @@ pub trait VisitAstPath {
     #[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,
@@ -16189,6 +16762,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16201,6 +16775,7 @@ pub trait VisitAstPath {
     #[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],
@@ -16213,6 +16788,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16223,6 +16799,7 @@ pub trait VisitAstPath {
     #[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,
@@ -16235,6 +16812,7 @@ pub trait VisitAstPath {
     #[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,
@@ -36658,6 +37236,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for WqName {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36666,6 +37245,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
         <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36678,6 +37258,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36686,6 +37267,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcProductOrOperator] {
         <V as VisitAstPath>::visit_calc_product_or_operators(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36702,6 +37284,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcProductOrOperator] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36710,6 +37293,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcValueOrOperator] {
         <V as VisitAstPath>::visit_calc_value_or_operators(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36726,6 +37310,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CalcValueOrOperator] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36734,6 +37319,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelectorChildren]
         <V as VisitAstPath>::visit_complex_selector_childrens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36750,6 +37336,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelectorChildren]
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36758,6 +37345,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelector] {
         <V as VisitAstPath>::visit_complex_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36772,6 +37360,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComplexSelector] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36780,6 +37369,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComponentValue] {
         <V as VisitAstPath>::visit_component_values(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36794,6 +37384,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ComponentValue] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36802,6 +37393,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CompoundSelector] {
         <V as VisitAstPath>::visit_compound_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36818,6 +37410,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CompoundSelector] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36826,6 +37419,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ContainerQueryType] {
         <V as VisitAstPath>::visit_container_query_types(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36842,6 +37436,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ContainerQueryType] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36850,6 +37445,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CustomIdent] {
         <V as VisitAstPath>::visit_custom_idents(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36865,6 +37461,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [CustomIdent] {
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [DocumentPreludeMatchingFunction] {
     #[doc = "Calls [VisitAstPath`::visit_document_prelude_matching_functions`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36873,6 +37470,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [DocumentPreludeMatchingF
         <V as VisitAstPath>::visit_document_prelude_matching_functions(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36889,6 +37487,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [DocumentPreludeMatchingF
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36897,6 +37496,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [FamilyName] {
         <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,
@@ -36911,6 +37511,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [FamilyName] {
 #[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,
@@ -36919,6 +37520,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingComplexSelector
         <V as VisitAstPath>::visit_forgiving_complex_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36935,6 +37537,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingComplexSelector
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36943,6 +37546,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingRelativeSelecto
         <V as VisitAstPath>::visit_forgiving_relative_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36959,6 +37563,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ForgivingRelativeSelecto
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36967,6 +37572,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Ident] {
         <V as VisitAstPath>::visit_idents(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36981,6 +37587,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Ident] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -36989,6 +37596,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [KeyframeSelector] {
         <V as VisitAstPath>::visit_keyframe_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37005,6 +37613,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [KeyframeSelector] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37013,6 +37622,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [LayerName] {
         <V as VisitAstPath>::visit_layer_names(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37027,6 +37637,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [LayerName] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37035,6 +37646,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionAllType] {
         <V as VisitAstPath>::visit_media_condition_all_types(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37052,6 +37664,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionAllType] {
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionWithoutOrType] {
     #[doc = "Calls [VisitAstPath`::visit_media_condition_without_or_types`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37060,6 +37673,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionWithoutOrT
         <V as VisitAstPath>::visit_media_condition_without_or_types(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37076,6 +37690,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaConditionWithoutOrT
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37084,6 +37699,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaQuery] {
         <V as VisitAstPath>::visit_media_querys(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37098,6 +37714,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [MediaQuery] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37106,6 +37723,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<AtRulePrelude>
         <V as VisitAstPath>::visit_opt_at_rule_prelude(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37123,6 +37741,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<AtRulePrelude>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37131,6 +37750,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
         <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37148,6 +37768,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37156,6 +37777,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorM
         <V as VisitAstPath>::visit_opt_attribute_selector_matcher(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37174,6 +37796,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorM
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorModifier> {
     #[doc = "Calls [VisitAstPath`::visit_opt_attribute_selector_modifier`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37182,6 +37805,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorM
         <V as VisitAstPath>::visit_opt_attribute_selector_modifier(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37199,6 +37823,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorM
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37207,6 +37832,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorV
         <V as VisitAstPath>::visit_opt_attribute_selector_value(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37224,6 +37850,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<AttributeSelectorV
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37232,6 +37859,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Combinator> {
         <V as VisitAstPath>::visit_opt_combinator(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37249,6 +37877,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Combinator> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37257,6 +37886,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ContainerName> {
         <V as VisitAstPath>::visit_opt_container_name(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37274,6 +37904,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ContainerName> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37282,6 +37913,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ForgivingSelectorL
         <V as VisitAstPath>::visit_opt_forgiving_selector_list(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37299,6 +37931,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ForgivingSelectorL
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37307,6 +37940,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Function>> {
         <V as VisitAstPath>::visit_opt_function(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37324,6 +37958,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Function>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37332,6 +37967,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
         <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37349,6 +37985,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37357,6 +37994,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportConditio
         <V as VisitAstPath>::visit_opt_import_conditions(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37374,6 +38012,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportConditio
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37382,6 +38021,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportLayerNam
         <V as VisitAstPath>::visit_opt_import_layer_name(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37399,6 +38039,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ImportLayerNam
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37407,6 +38048,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ImportantFlag> {
         <V as VisitAstPath>::visit_opt_important_flag(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37424,6 +38066,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ImportantFlag> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37432,6 +38075,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaCondition
         <V as VisitAstPath>::visit_opt_media_condition_type(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37449,6 +38093,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaCondition
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37457,6 +38102,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaQueryList
         <V as VisitAstPath>::visit_opt_media_query_list(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37474,6 +38120,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<MediaQueryList
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37482,6 +38129,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<MediaType> {
         <V as VisitAstPath>::visit_opt_media_type(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37499,6 +38147,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<MediaType> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37507,6 +38156,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
         <V as VisitAstPath>::visit_opt_namespace(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37524,6 +38174,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37532,6 +38183,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NamespacePrefix> {
         <V as VisitAstPath>::visit_opt_namespace_prefix(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37549,6 +38201,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NamespacePrefix> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37557,6 +38210,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NestingSelector> {
         <V as VisitAstPath>::visit_opt_nesting_selector(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37574,6 +38228,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<NestingSelector> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37582,6 +38237,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Number> {
         <V as VisitAstPath>::visit_opt_number(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37599,6 +38255,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Number> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37607,6 +38264,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PageSelectorPs
         <V as VisitAstPath>::visit_opt_page_selector_pseudos(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37624,6 +38282,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PageSelectorPs
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37632,6 +38291,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<PageSelectorType>
         <V as VisitAstPath>::visit_opt_page_selector_type(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37650,6 +38310,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<PageSelectorType>
 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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37658,6 +38319,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoClassSel
         <V as VisitAstPath>::visit_opt_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37678,6 +38340,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoClassSel
 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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37686,6 +38349,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoElementS
         <V as VisitAstPath>::visit_opt_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37705,6 +38369,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<PseudoElementS
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37713,6 +38378,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<SimpleBlock> {
         <V as VisitAstPath>::visit_opt_simple_block(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37730,6 +38396,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<SimpleBlock> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37738,6 +38405,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TypeSelector>>
         <V as VisitAstPath>::visit_opt_type_selector(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37755,6 +38423,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TypeSelector>>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37763,6 +38432,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<UrlModifier>>
         <V as VisitAstPath>::visit_opt_url_modifiers(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37780,6 +38450,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<UrlModifier>>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37788,6 +38459,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<UrlValue>> {
         <V as VisitAstPath>::visit_opt_url_value(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37805,6 +38477,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<UrlValue>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37813,6 +38486,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelectorPseudo] {
         <V as VisitAstPath>::visit_page_selector_pseudos(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37829,6 +38503,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelectorPseudo] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37837,6 +38512,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelector] {
         <V as VisitAstPath>::visit_page_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37852,6 +38528,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PageSelector] {
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoClassSelectorChildren] {
     #[doc = "Calls [VisitAstPath`::visit_pseudo_class_selector_childrens`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37860,6 +38537,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoClassSelectorChild
         <V as VisitAstPath>::visit_pseudo_class_selector_childrens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37877,6 +38555,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoClassSelectorChild
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoElementSelectorChildren] {
     #[doc = "Calls [VisitAstPath`::visit_pseudo_element_selector_childrens`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37885,6 +38564,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoElementSelectorChi
         <V as VisitAstPath>::visit_pseudo_element_selector_childrens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37901,6 +38581,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PseudoElementSelectorChi
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37909,6 +38590,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [RelativeSelector] {
         <V as VisitAstPath>::visit_relative_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37925,6 +38607,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [RelativeSelector] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37933,6 +38616,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Rule] {
         <V as VisitAstPath>::visit_rules(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37947,6 +38631,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Rule] {
 #[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,
@@ -37955,6 +38640,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
         <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37967,6 +38653,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37975,6 +38662,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SubclassSelector] {
         <V as VisitAstPath>::visit_subclass_selectors(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37991,6 +38679,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SubclassSelector] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -37999,6 +38688,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SupportsConditionType] {
         <V as VisitAstPath>::visit_supports_condition_types(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38015,6 +38705,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SupportsConditionType] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38023,6 +38714,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [UrlModifier] {
         <V as VisitAstPath>::visit_url_modifiers(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38040,6 +38732,7 @@ where
     V: ?Sized + VisitAstPath,
     T: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38049,6 +38742,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38066,6 +38760,7 @@ where
     V: ?Sized + VisitAstPath,
     [T]: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38075,6 +38770,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -38090,84 +38786,98 @@ 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
@@ -38177,306 +38887,357 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              it manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
@@ -38486,6 +39247,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_document_prelude_matching_functions(
         &mut self,
         node: &mut Vec<DocumentPreludeMatchingFunction>,
@@ -38497,54 +39259,63 @@ pub trait VisitMut {
     #[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 \
              it manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
@@ -38554,6 +39325,7 @@ pub trait VisitMut {
     #[doc = "Visit a node of type `Vec < ForgivingRelativeSelector >`.\n\nBy default, this method \
              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>,
@@ -38563,221 +39335,258 @@ pub trait VisitMut {
     #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              call it manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              it manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
@@ -38787,6 +39596,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_without_or_types(
         &mut self,
         node: &mut Vec<MediaConditionWithoutOrType>,
@@ -38798,156 +39608,182 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_opt_attribute_selector_matcher(
         &mut self,
         node: &mut Option<AttributeSelectorMatcher>,
@@ -38959,6 +39795,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_opt_attribute_selector_modifier(
         &mut self,
         node: &mut Option<AttributeSelectorModifier>,
@@ -38970,6 +39807,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
@@ -38979,108 +39817,126 @@ pub trait VisitMut {
     #[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)
     }
     #[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 \
              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)
     }
     #[doc = "Visit a node of type `Option < ForgivingSelectorList >`.\n\nBy default, this method \
              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>) {
         <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)
     }
     #[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."]
+    #[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)
     }
     #[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 \
              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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoClassSelectorChildren>>,
@@ -39092,6 +39948,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Option<Vec<PseudoElementSelectorChildren>>,
@@ -39103,84 +39960,98 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_class_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoClassSelectorChildren>,
@@ -39192,12 +40063,14 @@ pub trait VisitMut {
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
@@ -39207,6 +40080,7 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_element_selector_childrens(
         &mut self,
         node: &mut Vec<PseudoElementSelectorChildren>,
@@ -39218,311 +40092,363 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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 `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_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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
     #[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)
     }
@@ -50165,20 +51091,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for WqName {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_calc_product_or_operators(visitor, self)
     }
 
+    #[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)
@@ -50187,10 +51117,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcProductOrOperator> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_calc_value_or_operators(visitor, self)
     }
 
+    #[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)
@@ -50199,10 +51131,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CalcValueOrOperator> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_complex_selector_childrens(visitor, self)
     }
 
+    #[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)
@@ -50211,10 +51145,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelectorChildren> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_complex_selectors(visitor, self)
     }
 
+    #[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))
@@ -50222,10 +51158,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComplexSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_component_values(visitor, self)
     }
 
+    #[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))
@@ -50233,10 +51171,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ComponentValue> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_compound_selectors(visitor, self)
     }
 
+    #[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))
@@ -50244,10 +51184,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CompoundSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_container_query_types(visitor, self)
     }
 
+    #[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))
@@ -50255,10 +51197,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ContainerQueryType> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_custom_idents(visitor, self)
     }
 
+    #[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))
@@ -50267,10 +51211,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<CustomIdent> {
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_document_prelude_matching_functions(visitor, self)
     }
 
+    #[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)
@@ -50279,10 +51225,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<DocumentPreludeMatchingFuncti
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_family_names(visitor, self)
     }
 
+    #[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))
@@ -50290,10 +51238,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<FamilyName> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_forgiving_complex_selectors(visitor, self)
     }
 
+    #[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)
@@ -50302,10 +51252,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingComplexSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_forgiving_relative_selectors(visitor, self)
     }
 
+    #[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)
@@ -50314,10 +51266,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ForgivingRelativeSelector> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Ident> {
     #[doc = "Calls [VisitMut`::visit_mut_idents`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_idents(visitor, self)
     }
 
+    #[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))
@@ -50325,10 +51279,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Ident> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_keyframe_selectors(visitor, self)
     }
 
+    #[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))
@@ -50336,10 +51292,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<KeyframeSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_layer_names(visitor, self)
     }
 
+    #[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))
@@ -50347,10 +51305,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<LayerName> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_media_condition_all_types(visitor, self)
     }
 
+    #[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)
@@ -50360,10 +51320,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionAllType> {
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_media_condition_without_or_types(visitor, self)
     }
 
+    #[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)
@@ -50372,10 +51334,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaConditionWithoutOrType>
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_media_querys(visitor, self)
     }
 
+    #[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))
@@ -50383,10 +51347,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<MediaQuery> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_at_rule_prelude(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<AtRulePrelude> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50396,10 +51362,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<AtRulePrelude>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50409,10 +51377,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_attribute_selector_matcher(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50425,10 +51395,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorMatcher>
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_attribute_selector_modifier(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50440,10 +51412,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorModifier>
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_attribute_selector_value(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50455,10 +51429,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<AttributeSelectorValue> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_combinator(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Combinator as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50468,10 +51444,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Combinator> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_container_name(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <ContainerName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50481,10 +51459,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ContainerName> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_forgiving_selector_list(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50496,10 +51476,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ForgivingSelectorList> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_function(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Function> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50509,10 +51491,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Function>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50522,10 +51506,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_import_conditions(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50537,10 +51523,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportConditions>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_import_layer_name(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50552,10 +51540,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ImportLayerName>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_important_flag(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <ImportantFlag as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50565,10 +51555,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ImportantFlag> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_media_condition_type(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50580,10 +51572,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaConditionType>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_media_query_list(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<MediaQueryList> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50593,10 +51587,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<MediaQueryList>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_media_type(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <MediaType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50606,10 +51602,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<MediaType> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Namespace as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50619,10 +51617,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Namespace> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_namespace_prefix(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <NamespacePrefix as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50632,10 +51632,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NamespacePrefix> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_nesting_selector(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <NestingSelector as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50645,10 +51647,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<NestingSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_number(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Number as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50658,10 +51662,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Number> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_page_selector_pseudos(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -50673,10 +51679,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PageSelectorPseudo>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_page_selector_type(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <PageSelectorType as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50687,10 +51695,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<PageSelectorType> {
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<PseudoClassSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
@@ -50703,10 +51713,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoClassSelectorChi
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_pseudo_element_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<PseudoElementSelectorChildren> as VisitMutWith<V>>::visit_mut_with(
@@ -50718,10 +51730,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<PseudoElementSelectorC
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_simple_block(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <SimpleBlock as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50731,10 +51745,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<SimpleBlock> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_type_selector(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TypeSelector> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50744,10 +51760,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TypeSelector>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_url_modifiers(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<UrlModifier> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -50757,10 +51775,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<UrlModifier>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_url_value(visitor, self)
     }
 
+    #[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),
@@ -50770,10 +51790,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<UrlValue>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_page_selector_pseudos(visitor, self)
     }
 
+    #[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))
@@ -50781,10 +51803,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelectorPseudo> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_page_selectors(visitor, self)
     }
 
+    #[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))
@@ -50793,10 +51817,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PageSelector> {
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[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)
@@ -50806,10 +51832,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoClassSelectorChildren>
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_pseudo_element_selector_childrens(visitor, self)
     }
 
+    #[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)
@@ -50818,10 +51846,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PseudoElementSelectorChildren
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_relative_selectors(visitor, self)
     }
 
+    #[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))
@@ -50829,10 +51859,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<RelativeSelector> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Rule> {
     #[doc = "Calls [VisitMut`::visit_mut_rules`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_rules(visitor, self)
     }
 
+    #[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))
@@ -50840,20 +51872,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Rule> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_subclass_selectors(visitor, self)
     }
 
+    #[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))
@@ -50861,10 +51897,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SubclassSelector> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_supports_condition_types(visitor, self)
     }
 
+    #[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)
@@ -50873,10 +51911,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SupportsConditionType> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_url_modifiers(visitor, self)
     }
 
+    #[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))
@@ -50887,11 +51927,13 @@ where
     V: ?Sized + VisitMut,
     T: VisitMutWith<V>,
 {
+    #[inline]
     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(&mut self, visitor: &mut V) {
         let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
@@ -50904,6 +51946,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_absolute_color_base(
         &mut self,
         node: &mut AbsoluteColorBase,
@@ -50916,6 +51959,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50924,6 +51968,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50932,6 +51977,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_an_plus_b_notation(
         &mut self,
         node: &mut AnPlusBNotation,
@@ -50944,6 +51990,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50952,6 +51999,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_angle_percentage(
         &mut self,
         node: &mut AnglePercentage,
@@ -50964,6 +52012,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50972,6 +52021,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50980,6 +52030,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -50988,6 +52039,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_at_rule_prelude(
         &mut self,
         node: &mut AtRulePrelude,
@@ -51000,6 +52052,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51008,6 +52061,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector(
         &mut self,
         node: &mut AttributeSelector,
@@ -51020,6 +52074,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector_matcher(
         &mut self,
         node: &mut AttributeSelectorMatcher,
@@ -51032,6 +52087,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector_matcher_value(
         &mut self,
         node: &mut AttributeSelectorMatcherValue,
@@ -51042,6 +52098,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector_modifier(
         &mut self,
         node: &mut AttributeSelectorModifier,
@@ -51054,6 +52111,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_attribute_selector_value(
         &mut self,
         node: &mut AttributeSelectorValue,
@@ -51066,6 +52124,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51074,6 +52133,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51082,6 +52142,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_calc_operator_type(
         &mut self,
         node: &mut CalcOperatorType,
@@ -51094,6 +52155,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51102,6 +52164,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_calc_product_or_operator(
         &mut self,
         node: &mut CalcProductOrOperator,
@@ -51114,6 +52177,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_calc_product_or_operators(
         &mut self,
         node: &mut Vec<CalcProductOrOperator>,
@@ -51126,6 +52190,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51134,6 +52199,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51142,6 +52208,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_calc_value_or_operator(
         &mut self,
         node: &mut CalcValueOrOperator,
@@ -51154,6 +52221,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_calc_value_or_operators(
         &mut self,
         node: &mut Vec<CalcValueOrOperator>,
@@ -51166,6 +52234,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51174,6 +52243,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51182,6 +52252,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51190,6 +52261,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_color_profile_name(
         &mut self,
         node: &mut ColorProfileName,
@@ -51202,6 +52274,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51210,6 +52283,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_combinator_value(
         &mut self,
         node: &mut CombinatorValue,
@@ -51222,6 +52296,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_complex_selector(
         &mut self,
         node: &mut ComplexSelector,
@@ -51234,6 +52309,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_complex_selector_children(
         &mut self,
         node: &mut ComplexSelectorChildren,
@@ -51246,6 +52322,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_complex_selector_childrens(
         &mut self,
         node: &mut Vec<ComplexSelectorChildren>,
@@ -51256,6 +52333,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_complex_selectors(
         &mut self,
         node: &mut Vec<ComplexSelector>,
@@ -51268,6 +52346,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_component_value(
         &mut self,
         node: &mut ComponentValue,
@@ -51280,6 +52359,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_component_values(
         &mut self,
         node: &mut Vec<ComponentValue>,
@@ -51292,6 +52372,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_compound_selector(
         &mut self,
         node: &mut CompoundSelector,
@@ -51304,6 +52385,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_compound_selector_list(
         &mut self,
         node: &mut CompoundSelectorList,
@@ -51316,6 +52398,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_compound_selectors(
         &mut self,
         node: &mut Vec<CompoundSelector>,
@@ -51328,6 +52411,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_condition(
         &mut self,
         node: &mut ContainerCondition,
@@ -51340,6 +52424,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51348,6 +52433,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query(
         &mut self,
         node: &mut ContainerQuery,
@@ -51360,6 +52446,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query_and(
         &mut self,
         node: &mut ContainerQueryAnd,
@@ -51372,6 +52459,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query_not(
         &mut self,
         node: &mut ContainerQueryNot,
@@ -51384,6 +52472,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query_or(
         &mut self,
         node: &mut ContainerQueryOr,
@@ -51396,6 +52485,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query_type(
         &mut self,
         node: &mut ContainerQueryType,
@@ -51408,6 +52498,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_container_query_types(
         &mut self,
         node: &mut Vec<ContainerQueryType>,
@@ -51420,6 +52511,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_custom_highlight_name(
         &mut self,
         node: &mut CustomHighlightName,
@@ -51432,6 +52524,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51440,6 +52533,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_custom_idents(
         &mut self,
         node: &mut Vec<CustomIdent>,
@@ -51452,6 +52546,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_custom_media_query(
         &mut self,
         node: &mut CustomMediaQuery,
@@ -51464,6 +52559,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_custom_media_query_media_type(
         &mut self,
         node: &mut CustomMediaQueryMediaType,
@@ -51476,6 +52572,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_custom_property_name(
         &mut self,
         node: &mut CustomPropertyName,
@@ -51488,6 +52585,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51496,6 +52594,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51504,6 +52603,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_declaration_name(
         &mut self,
         node: &mut DeclarationName,
@@ -51516,6 +52616,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_declaration_or_at_rule(
         &mut self,
         node: &mut DeclarationOrAtRule,
@@ -51528,6 +52629,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51536,6 +52638,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_delimiter_value(
         &mut self,
         node: &mut DelimiterValue,
@@ -51548,6 +52651,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51556,6 +52660,7 @@ pub trait VisitMutAstPath {
     #[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,
@@ -51568,6 +52673,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_document_prelude(
         &mut self,
         node: &mut DocumentPrelude,
@@ -51580,6 +52686,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_document_prelude_matching_function(
         &mut self,
         node: &mut DocumentPreludeMatchingFunction,
@@ -51591,6 +52698,7 @@ pub trait VisitMutAstPath {
              method calls [`Vec < DocumentPreludeMatchingFunction \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -51601,6 +52709,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51609,6 +52718,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51617,6 +52727,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51625,6 +52736,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51633,6 +52745,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_font_feature_values_prelude(
         &mut self,
         node: &mut FontFeatureValuesPrelude,
@@ -51645,6 +52758,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_complex_selector(
         &mut self,
         node: &mut ForgivingComplexSelector,
@@ -51657,6 +52771,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_complex_selectors(
         &mut self,
         node: &mut Vec<ForgivingComplexSelector>,
@@ -51667,6 +52782,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_relative_selector(
         &mut self,
         node: &mut ForgivingRelativeSelector,
@@ -51679,6 +52795,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_relative_selector_list(
         &mut self,
         node: &mut ForgivingRelativeSelectorList,
@@ -51689,6 +52806,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_relative_selectors(
         &mut self,
         node: &mut Vec<ForgivingRelativeSelector>,
@@ -51699,6 +52817,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_forgiving_selector_list(
         &mut self,
         node: &mut ForgivingSelectorList,
@@ -51711,6 +52830,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51719,6 +52839,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_frequency_percentage(
         &mut self,
         node: &mut FrequencyPercentage,
@@ -51731,6 +52852,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51739,6 +52861,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51747,6 +52870,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_general_enclosed(
         &mut self,
         node: &mut GeneralEnclosed,
@@ -51759,6 +52883,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51767,12 +52892,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -51781,6 +52908,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51789,6 +52917,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51797,6 +52926,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_conditions(
         &mut self,
         node: &mut ImportConditions,
@@ -51809,6 +52939,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51817,6 +52948,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_layer_name(
         &mut self,
         node: &mut ImportLayerName,
@@ -51829,6 +52961,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51837,6 +52970,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51845,6 +52979,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51853,6 +52988,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51861,6 +52997,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_keyframe_selector(
         &mut self,
         node: &mut KeyframeSelector,
@@ -51873,6 +53010,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_keyframe_selectors(
         &mut self,
         node: &mut Vec<KeyframeSelector>,
@@ -51885,6 +53023,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51893,6 +53032,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_keyframes_pseudo_function(
         &mut self,
         node: &mut KeyframesPseudoFunction,
@@ -51905,6 +53045,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_keyframes_pseudo_prefix(
         &mut self,
         node: &mut KeyframesPseudoPrefix,
@@ -51917,6 +53058,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51925,6 +53067,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_layer_name_list(
         &mut self,
         node: &mut LayerNameList,
@@ -51937,6 +53080,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51945,6 +53089,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51953,6 +53098,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51961,6 +53107,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_length_percentage(
         &mut self,
         node: &mut LengthPercentage,
@@ -51973,6 +53120,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_list_of_component_values(
         &mut self,
         node: &mut ListOfComponentValues,
@@ -51985,6 +53133,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -51993,6 +53142,7 @@ pub trait VisitMutAstPath {
     #[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,
@@ -52005,6 +53155,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_all_type(
         &mut self,
         node: &mut MediaConditionAllType,
@@ -52017,6 +53168,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_all_types(
         &mut self,
         node: &mut Vec<MediaConditionAllType>,
@@ -52029,6 +53181,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_type(
         &mut self,
         node: &mut MediaConditionType,
@@ -52041,6 +53194,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_without_or(
         &mut self,
         node: &mut MediaConditionWithoutOr,
@@ -52053,6 +53207,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_condition_without_or_type(
         &mut self,
         node: &mut MediaConditionWithoutOrType,
@@ -52066,6 +53221,7 @@ pub trait VisitMutAstPath {
              method calls [`Vec < MediaConditionWithoutOrType \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -52076,6 +53232,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52084,6 +53241,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_boolean(
         &mut self,
         node: &mut MediaFeatureBoolean,
@@ -52096,6 +53254,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_name(
         &mut self,
         node: &mut MediaFeatureName,
@@ -52108,6 +53267,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_plain(
         &mut self,
         node: &mut MediaFeaturePlain,
@@ -52120,6 +53280,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_range(
         &mut self,
         node: &mut MediaFeatureRange,
@@ -52132,6 +53293,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_range_comparison(
         &mut self,
         node: &mut MediaFeatureRangeComparison,
@@ -52144,6 +53306,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_range_interval(
         &mut self,
         node: &mut MediaFeatureRangeInterval,
@@ -52156,6 +53319,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_feature_value(
         &mut self,
         node: &mut MediaFeatureValue,
@@ -52168,6 +53332,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_in_parens(
         &mut self,
         node: &mut MediaInParens,
@@ -52180,6 +53345,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52188,6 +53354,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52196,6 +53363,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52204,6 +53372,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_media_query_list(
         &mut self,
         node: &mut MediaQueryList,
@@ -52216,6 +53385,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52224,6 +53394,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52232,6 +53403,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_named_namespace(
         &mut self,
         node: &mut NamedNamespace,
@@ -52244,6 +53416,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52252,6 +53425,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_namespace_prefix(
         &mut self,
         node: &mut NamespacePrefix,
@@ -52264,6 +53438,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_namespace_prelude(
         &mut self,
         node: &mut NamespacePrelude,
@@ -52276,6 +53451,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_namespace_prelude_uri(
         &mut self,
         node: &mut NamespacePreludeUri,
@@ -52288,6 +53464,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_nesting_selector(
         &mut self,
         node: &mut NestingSelector,
@@ -52300,6 +53477,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52308,6 +53486,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52316,6 +53495,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_at_rule_prelude(
         &mut self,
         node: &mut Option<Box<AtRulePrelude>>,
@@ -52328,6 +53508,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_atom(
         &mut self,
         node: &mut Option<swc_atoms::Atom>,
@@ -52341,6 +53522,7 @@ pub trait VisitMutAstPath {
              method calls [`Option < AttributeSelectorMatcher \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -52352,6 +53534,7 @@ pub trait VisitMutAstPath {
              method calls [`Option < AttributeSelectorModifier \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -52362,6 +53545,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_attribute_selector_value(
         &mut self,
         node: &mut Option<AttributeSelectorValue>,
@@ -52372,6 +53556,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_combinator(
         &mut self,
         node: &mut Option<Combinator>,
@@ -52384,6 +53569,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_container_name(
         &mut self,
         node: &mut Option<ContainerName>,
@@ -52396,6 +53582,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_forgiving_selector_list(
         &mut self,
         node: &mut Option<ForgivingSelectorList>,
@@ -52406,6 +53593,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_function(
         &mut self,
         node: &mut Option<Box<Function>>,
@@ -52418,6 +53606,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52427,6 +53616,7 @@ pub trait VisitMutAstPath {
              method calls [`Option < Box < ImportConditions > \
              >::visit_mut_children_with_ast_path`]. 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>>,
@@ -52437,6 +53627,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_import_layer_name(
         &mut self,
         node: &mut Option<Box<ImportLayerName>>,
@@ -52447,6 +53638,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_important_flag(
         &mut self,
         node: &mut Option<ImportantFlag>,
@@ -52460,6 +53652,7 @@ pub trait VisitMutAstPath {
              method calls [`Option < Box < MediaConditionType > \
              >::visit_mut_children_with_ast_path`]. 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>>,
@@ -52470,6 +53663,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_media_query_list(
         &mut self,
         node: &mut Option<Box<MediaQueryList>>,
@@ -52482,6 +53676,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_media_type(
         &mut self,
         node: &mut Option<MediaType>,
@@ -52494,6 +53689,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_namespace(
         &mut self,
         node: &mut Option<Namespace>,
@@ -52506,6 +53702,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_namespace_prefix(
         &mut self,
         node: &mut Option<NamespacePrefix>,
@@ -52518,6 +53715,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_nesting_selector(
         &mut self,
         node: &mut Option<NestingSelector>,
@@ -52530,6 +53728,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52539,6 +53738,7 @@ pub trait VisitMutAstPath {
              method calls [`Option < Vec < PageSelectorPseudo > \
              >::visit_mut_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>>,
@@ -52549,6 +53749,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_page_selector_type(
         &mut self,
         node: &mut Option<PageSelectorType>,
@@ -52562,6 +53763,7 @@ pub trait VisitMutAstPath {
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
              >::visit_mut_children_with_ast_path`]. 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>>,
@@ -52573,6 +53775,7 @@ pub trait VisitMutAstPath {
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
              >::visit_mut_children_with_ast_path`]. 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>>,
@@ -52583,6 +53786,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_simple_block(
         &mut self,
         node: &mut Option<SimpleBlock>,
@@ -52595,6 +53799,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_type_selector(
         &mut self,
         node: &mut Option<Box<TypeSelector>>,
@@ -52607,6 +53812,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_url_modifiers(
         &mut self,
         node: &mut Option<Vec<UrlModifier>>,
@@ -52619,6 +53825,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_url_value(
         &mut self,
         node: &mut Option<Box<UrlValue>>,
@@ -52631,6 +53838,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52639,6 +53847,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_page_selector_list(
         &mut self,
         node: &mut PageSelectorList,
@@ -52651,6 +53860,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_page_selector_pseudo(
         &mut self,
         node: &mut PageSelectorPseudo,
@@ -52663,6 +53873,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_page_selector_pseudos(
         &mut self,
         node: &mut Vec<PageSelectorPseudo>,
@@ -52675,6 +53886,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_page_selector_type(
         &mut self,
         node: &mut PageSelectorType,
@@ -52687,6 +53899,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_page_selectors(
         &mut self,
         node: &mut Vec<PageSelector>,
@@ -52699,6 +53912,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52707,6 +53921,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_class_selector(
         &mut self,
         node: &mut PseudoClassSelector,
@@ -52719,6 +53934,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_class_selector_children(
         &mut self,
         node: &mut PseudoClassSelectorChildren,
@@ -52732,6 +53948,7 @@ pub trait VisitMutAstPath {
              method calls [`Vec < PseudoClassSelectorChildren \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -52742,6 +53959,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_element_selector(
         &mut self,
         node: &mut PseudoElementSelector,
@@ -52754,6 +53972,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_pseudo_element_selector_children(
         &mut self,
         node: &mut PseudoElementSelectorChildren,
@@ -52765,6 +53984,7 @@ pub trait VisitMutAstPath {
              method calls [`Vec < PseudoElementSelectorChildren \
              >::visit_mut_children_with_ast_path`]. 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>,
@@ -52775,6 +53995,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52783,6 +54004,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_qualified_rule_prelude(
         &mut self,
         node: &mut QualifiedRulePrelude,
@@ -52795,6 +54017,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_query_in_parens(
         &mut self,
         node: &mut QueryInParens,
@@ -52807,6 +54030,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52815,6 +54039,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_relative_selector(
         &mut self,
         node: &mut RelativeSelector,
@@ -52827,6 +54052,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_relative_selector_list(
         &mut self,
         node: &mut RelativeSelectorList,
@@ -52839,6 +54065,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_relative_selectors(
         &mut self,
         node: &mut Vec<RelativeSelector>,
@@ -52851,6 +54078,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52859,6 +54087,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52867,6 +54096,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52875,6 +54105,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52883,6 +54114,7 @@ pub trait VisitMutAstPath {
     #[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,
@@ -52891,6 +54123,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_sequence_of_custom_idents(
         &mut self,
         node: &mut SequenceOfCustomIdents,
@@ -52903,6 +54136,7 @@ pub trait VisitMutAstPath {
     #[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 \
              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,
@@ -52911,6 +54145,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -52919,6 +54154,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_boolean(
         &mut self,
         node: &mut SizeFeatureBoolean,
@@ -52931,6 +54167,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_name(
         &mut self,
         node: &mut SizeFeatureName,
@@ -52943,6 +54180,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_plain(
         &mut self,
         node: &mut SizeFeaturePlain,
@@ -52955,6 +54193,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_range(
         &mut self,
         node: &mut SizeFeatureRange,
@@ -52967,6 +54206,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_range_comparison(
         &mut self,
         node: &mut SizeFeatureRangeComparison,
@@ -52979,6 +54219,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_range_interval(
         &mut self,
         node: &mut SizeFeatureRangeInterval,
@@ -52991,6 +54232,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_size_feature_value(
         &mut self,
         node: &mut SizeFeatureValue,
@@ -53003,6 +54245,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53011,12 +54254,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -53025,6 +54270,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53033,6 +54279,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_subclass_selector(
         &mut self,
         node: &mut SubclassSelector,
@@ -53045,6 +54292,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_subclass_selectors(
         &mut self,
         node: &mut Vec<SubclassSelector>,
@@ -53057,6 +54305,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53065,6 +54314,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_supports_condition(
         &mut self,
         node: &mut SupportsCondition,
@@ -53077,6 +54327,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_supports_condition_type(
         &mut self,
         node: &mut SupportsConditionType,
@@ -53089,6 +54340,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_supports_condition_types(
         &mut self,
         node: &mut Vec<SupportsConditionType>,
@@ -53101,6 +54353,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_supports_feature(
         &mut self,
         node: &mut SupportsFeature,
@@ -53113,6 +54366,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_supports_in_parens(
         &mut self,
         node: &mut SupportsInParens,
@@ -53125,6 +54379,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53133,6 +54388,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53141,6 +54397,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_tag_name_selector(
         &mut self,
         node: &mut TagNameSelector,
@@ -53153,6 +54410,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53161,6 +54419,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_time_percentage(
         &mut self,
         node: &mut TimePercentage,
@@ -53173,6 +54432,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53181,6 +54441,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53189,6 +54450,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53197,6 +54459,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53205,6 +54468,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_universal_selector(
         &mut self,
         node: &mut UniversalSelector,
@@ -53217,6 +54481,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_unknown_dimension(
         &mut self,
         node: &mut UnknownDimension,
@@ -53229,12 +54494,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -53243,6 +54510,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53251,6 +54519,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_url_modifiers(
         &mut self,
         node: &mut Vec<UrlModifier>,
@@ -53263,6 +54532,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53271,6 +54541,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -53279,6 +54550,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -70970,10 +72242,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for WqName {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -70983,10 +72257,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcProductOrOperator> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <CalcProductOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -70999,10 +72275,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcProductOrOp
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <CalcValueOrOperator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71016,10 +72294,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CalcValueOrOper
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelectorChildren> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ComplexSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71032,10 +72312,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelector
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71048,10 +72330,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComplexSelector
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ComponentValue as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71064,10 +72348,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ComponentValue>
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <CompoundSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71080,10 +72366,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CompoundSelecto
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ContainerQueryType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71096,10 +72384,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ContainerQueryT
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <CustomIdent as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71113,12 +72403,14 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<CustomIdent> {
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
     #[doc = "Calls [VisitMutAstPath`::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,
         )
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <DocumentPreludeMatchingFunction as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71131,10 +72423,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<DocumentPrelude
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <FamilyName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71148,10 +72442,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<FamilyName> {
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingComplexSelector> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ForgivingComplexSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71165,10 +72461,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingComple
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingRelativeSelector> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ForgivingRelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71181,10 +72479,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ForgivingRelati
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Ident as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -71195,10 +72495,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Ident> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <KeyframeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71211,10 +72513,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<KeyframeSelecto
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <LayerName as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71228,10 +72532,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<LayerName> {
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionAllType> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <MediaConditionAllType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71245,12 +72551,14 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionA
 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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <MediaConditionWithoutOrType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71263,10 +72571,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaConditionW
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <MediaQuery as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71279,10 +72589,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<MediaQuery> {
 #[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 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 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(
@@ -71296,10 +72608,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<AtRulePr
 #[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 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 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(
@@ -71314,10 +72628,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::A
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorMatcher> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71334,10 +72650,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSel
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorModifier> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71354,10 +72672,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSel
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSelectorValue> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71373,10 +72693,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<AttributeSel
 #[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 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 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(
@@ -71390,10 +72712,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Combinator>
 #[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 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 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(
@@ -71408,10 +72732,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ContainerNam
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ForgivingSelectorList> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71427,10 +72753,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ForgivingSel
 #[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 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 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(
@@ -71444,10 +72772,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Function
 #[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 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 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(
@@ -71461,10 +72791,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71480,10 +72812,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportCo
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71499,10 +72833,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ImportLa
 #[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 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 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(
@@ -71517,10 +72853,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ImportantFla
 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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71536,10 +72874,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaCon
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71555,10 +72895,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<MediaQue
 #[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 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 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(
@@ -71572,10 +72914,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<MediaType> {
 #[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 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 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(
@@ -71589,10 +72933,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Namespace> {
 #[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 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 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(
@@ -71606,10 +72952,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NamespacePre
 #[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 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 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(
@@ -71623,10 +72971,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<NestingSelec
 #[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 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 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(
@@ -71641,10 +72991,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Number> {
 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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -71660,10 +73012,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<PageSele
 #[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 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 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(
@@ -71680,12 +73034,14 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
 {
     #[doc = "Calls [VisitMutAstPath`::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,
         )
     }
 
+    #[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 => { } }
     }
@@ -71697,12 +73053,14 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
 {
     #[doc = "Calls [VisitMutAstPath`::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,
         )
     }
 
+    #[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 => { } }
     }
@@ -71711,10 +73069,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V>
 #[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 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 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(
@@ -71728,10 +73088,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<SimpleBlock>
 #[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 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 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(
@@ -71745,10 +73107,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TypeSele
 #[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 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 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(
@@ -71762,10 +73126,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<UrlModif
 #[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 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 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(
@@ -71779,10 +73145,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<UrlValue
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <PageSelectorPseudo as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71795,10 +73163,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelectorPse
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <PageSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71812,10 +73182,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PageSelector> {
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoClassSelectorChildren> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <PseudoClassSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71829,12 +73201,14 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoClassSele
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
     #[doc = "Calls [VisitMutAstPath`::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,
         )
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <PseudoElementSelectorChildren as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71847,10 +73221,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PseudoElementSe
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <RelativeSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71863,10 +73239,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<RelativeSelecto
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Rule as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -71877,10 +73255,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Rule> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -71889,10 +73269,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <SubclassSelector as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71906,10 +73288,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SubclassSelecto
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SupportsConditionType> {
     #[doc = "Calls [VisitMutAstPath`::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)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <SupportsConditionType as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71922,10 +73306,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SupportsConditi
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <UrlModifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -71941,6 +73327,7 @@ where
     V: ?Sized + VisitMutAstPath,
     T: VisitMutWithAstPath<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,
@@ -71950,6 +73337,7 @@ where
         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,
@@ -71964,75 +73352,88 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
@@ -72042,6 +73443,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
@@ -72051,6 +73453,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
@@ -72060,6 +73463,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
@@ -72068,30 +73472,35 @@ pub trait Fold {
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
@@ -72101,6 +73510,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
@@ -72109,24 +73519,28 @@ pub trait Fold {
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
@@ -72136,47 +73550,55 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
@@ -72186,6 +73608,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
@@ -72195,84 +73618,98 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
@@ -72282,30 +73719,35 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
@@ -72315,66 +73757,77 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
@@ -72384,6 +73837,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
@@ -72393,29 +73847,34 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
@@ -72425,6 +73884,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
@@ -72434,6 +73894,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
@@ -72443,6 +73904,7 @@ pub trait Fold {
     #[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,
@@ -72452,6 +73914,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
@@ -72461,6 +73924,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
@@ -72470,6 +73934,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
@@ -72479,122 +73944,143 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
@@ -72604,6 +74090,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
@@ -72613,41 +74100,48 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
@@ -72657,18 +74151,21 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
@@ -72678,6 +74175,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
@@ -72687,12 +74185,14 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
@@ -72702,6 +74202,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
@@ -72711,6 +74212,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
@@ -72720,36 +74222,42 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
@@ -72759,6 +74267,7 @@ pub trait Fold {
     #[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,
@@ -72768,100 +74277,117 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
@@ -72871,12 +74397,14 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
@@ -72886,6 +74414,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
@@ -72895,6 +74424,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
@@ -72904,18 +74434,21 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
@@ -72925,17 +74458,20 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. If you want \
              to recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
@@ -72945,6 +74481,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
@@ -72954,12 +74491,14 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
@@ -72969,6 +74508,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
@@ -72978,18 +74518,21 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
@@ -72999,6 +74542,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
@@ -73007,12 +74551,14 @@ pub trait Fold {
     }
     #[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."]
+    #[inline]
     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`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
@@ -73022,6 +74568,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
@@ -73031,6 +74578,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_pseudo_class_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoClassSelectorChildren>>,
@@ -73040,6 +74588,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_pseudo_element_selector_childrens(
         &mut self,
         node: Option<Vec<PseudoElementSelectorChildren>>,
@@ -73051,12 +74600,14 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
@@ -73066,6 +74617,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
@@ -73075,30 +74627,35 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
@@ -73108,30 +74665,35 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
@@ -73141,6 +74703,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
@@ -73150,6 +74713,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
@@ -73159,6 +74723,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
@@ -73168,6 +74733,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
@@ -73177,75 +74743,88 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
@@ -73255,42 +74834,49 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
@@ -73300,6 +74886,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
@@ -73309,59 +74896,69 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
@@ -73371,6 +74968,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
@@ -73380,116 +74978,136 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_wq_name(&mut self, node: WqName) -> WqName {
         <WqName as FoldWith<Self>>::fold_children_with(node, self)
     }
@@ -84468,20 +86086,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for WqName {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
     #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_calc_product_or_operators(visitor, self)
     }
 
+    #[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)
@@ -84490,10 +86112,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcProductOrOperator> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_calc_value_or_operators(visitor, self)
     }
 
+    #[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)
@@ -84502,10 +86126,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<CalcValueOrOperator> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelectorChildren> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -84514,10 +86140,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelectorChildren> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelector> {
     #[doc = "Calls [Fold`::fold_complex_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_complex_selectors(visitor, self)
     }
 
+    #[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)
@@ -84526,10 +86154,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComplexSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComponentValue> {
     #[doc = "Calls [Fold`::fold_component_values`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_component_values(visitor, self)
     }
 
+    #[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)
@@ -84538,10 +86168,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ComponentValue> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<CompoundSelector> {
     #[doc = "Calls [Fold`::fold_compound_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_compound_selectors(visitor, self)
     }
 
+    #[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)
@@ -84550,10 +86182,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<CompoundSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ContainerQueryType> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -84562,10 +86196,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ContainerQueryType> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<CustomIdent> {
     #[doc = "Calls [Fold`::fold_custom_idents`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_custom_idents(visitor, self)
     }
 
+    #[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)
@@ -84574,10 +86210,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<CustomIdent> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_document_prelude_matching_functions(visitor, self)
     }
 
+    #[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)
@@ -84586,10 +86224,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<DocumentPreludeMatchingFunction> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<FamilyName> {
     #[doc = "Calls [Fold`::fold_family_names`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_family_names(visitor, self)
     }
 
+    #[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)
@@ -84598,10 +86238,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<FamilyName> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingComplexSelector> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -84610,10 +86252,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingComplexSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingRelativeSelector> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -84622,10 +86266,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ForgivingRelativeSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Ident> {
     #[doc = "Calls [Fold`::fold_idents`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_idents(visitor, self)
     }
 
+    #[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)
@@ -84634,10 +86280,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Ident> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<KeyframeSelector> {
     #[doc = "Calls [Fold`::fold_keyframe_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_keyframe_selectors(visitor, self)
     }
 
+    #[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)
@@ -84646,10 +86294,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<KeyframeSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<LayerName> {
     #[doc = "Calls [Fold`::fold_layer_names`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_layer_names(visitor, self)
     }
 
+    #[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)
@@ -84658,10 +86308,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<LayerName> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_media_condition_all_types(visitor, self)
     }
 
+    #[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)
@@ -84670,10 +86322,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionAllType> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_media_condition_without_or_types(visitor, self)
     }
 
+    #[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)
@@ -84682,10 +86336,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaConditionWithoutOrType> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaQuery> {
     #[doc = "Calls [Fold`::fold_media_querys`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_media_querys(visitor, self)
     }
 
+    #[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)
@@ -84694,230 +86350,276 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<MediaQuery> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_at_rule_prelude(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<AtRulePrelude> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_attribute_selector_matcher(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <AttributeSelectorMatcher as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_attribute_selector_modifier(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <AttributeSelectorModifier as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_attribute_selector_value(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <AttributeSelectorValue as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Combinator> {
     #[doc = "Calls [Fold`::fold_opt_combinator`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_combinator(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Combinator as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<ContainerName> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <ContainerName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_forgiving_selector_list(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <ForgivingSelectorList as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Function>> {
     #[doc = "Calls [Fold`::fold_opt_function`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_function(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<Function> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
     #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_import_conditions(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<ImportConditions> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_import_layer_name(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<ImportLayerName> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<ImportantFlag> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <ImportantFlag as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_media_condition_type(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<MediaConditionType> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_media_query_list(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<MediaQueryList> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<MediaType> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <MediaType as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Namespace> {
     #[doc = "Calls [Fold`::fold_opt_namespace`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Namespace as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<NamespacePrefix> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <NamespacePrefix as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<NestingSelector> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <NestingSelector as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Number> {
     #[doc = "Calls [Fold`::fold_opt_number`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_number(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Number as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_page_selector_pseudos(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Vec<PageSelectorPseudo> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_page_selector_type(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <PageSelectorType as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| {
             <Vec<PseudoClassSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
@@ -84926,10 +86628,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoClassSelectorChildren>>
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_pseudo_element_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| {
             <Vec<PseudoElementSelectorChildren> as FoldWith<V>>::fold_with(inner, visitor)
@@ -84938,50 +86642,60 @@ impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<PseudoElementSelectorChildren>
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<SimpleBlock> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <SimpleBlock as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_type_selector(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<TypeSelector> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_url_modifiers(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Vec<UrlModifier> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_url_value(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<UrlValue> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelectorPseudo> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -84990,10 +86704,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelectorPseudo> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelector> {
     #[doc = "Calls [Fold`::fold_page_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_page_selectors(visitor, self)
     }
 
+    #[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)
@@ -85002,10 +86718,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<PageSelector> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[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)
@@ -85014,10 +86732,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoClassSelectorChildren> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_pseudo_element_selector_childrens(visitor, self)
     }
 
+    #[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)
@@ -85026,10 +86746,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<PseudoElementSelectorChildren> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<RelativeSelector> {
     #[doc = "Calls [Fold`::fold_relative_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_relative_selectors(visitor, self)
     }
 
+    #[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)
@@ -85038,10 +86760,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<RelativeSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Rule> {
     #[doc = "Calls [Fold`::fold_rules`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_rules(visitor, self)
     }
 
+    #[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)
@@ -85050,20 +86774,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Rule> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
     #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_span(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<SubclassSelector> {
     #[doc = "Calls [Fold`::fold_subclass_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_subclass_selectors(visitor, self)
     }
 
+    #[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)
@@ -85072,10 +86800,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<SubclassSelector> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<SupportsConditionType> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -85084,10 +86814,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<SupportsConditionType> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<UrlModifier> {
     #[doc = "Calls [Fold`::fold_url_modifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_url_modifiers(visitor, self)
     }
 
+    #[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)
@@ -85099,10 +86831,12 @@ where
     V: ?Sized + Fold,
     T: FoldWith<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))
     }
 
+    #[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)
@@ -85116,6 +86850,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_absolute_color_base(
         &mut self,
         node: AbsoluteColorBase,
@@ -85128,18 +86863,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_an_plus_b_notation(
         &mut self,
         node: AnPlusBNotation,
@@ -85152,12 +86890,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_angle_percentage(
         &mut self,
         node: AnglePercentage,
@@ -85170,6 +86910,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_any_namespace(
         &mut self,
         node: AnyNamespace,
@@ -85180,18 +86921,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_at_rule_prelude(
         &mut self,
         node: AtRulePrelude,
@@ -85204,6 +86948,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_atom(
         &mut self,
         node: swc_atoms::Atom,
@@ -85216,6 +86961,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_attribute_selector(
         &mut self,
         node: AttributeSelector,
@@ -85228,6 +86974,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_matcher(
         &mut self,
         node: AttributeSelectorMatcher,
@@ -85240,6 +86987,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_matcher_value(
         &mut self,
         node: AttributeSelectorMatcherValue,
@@ -85252,6 +87000,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_modifier(
         &mut self,
         node: AttributeSelectorModifier,
@@ -85264,6 +87013,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_attribute_selector_value(
         &mut self,
         node: AttributeSelectorValue,
@@ -85276,12 +87026,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_calc_operator(
         &mut self,
         node: CalcOperator,
@@ -85292,6 +87044,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_calc_operator_type(
         &mut self,
         node: CalcOperatorType,
@@ -85304,6 +87057,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_calc_product(
         &mut self,
         node: CalcProduct,
@@ -85314,6 +87068,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_calc_product_or_operator(
         &mut self,
         node: CalcProductOrOperator,
@@ -85326,6 +87081,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_calc_product_or_operators(
         &mut self,
         node: Vec<CalcProductOrOperator>,
@@ -85338,18 +87094,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_calc_value_or_operator(
         &mut self,
         node: CalcValueOrOperator,
@@ -85362,6 +87121,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_calc_value_or_operators(
         &mut self,
         node: Vec<CalcValueOrOperator>,
@@ -85374,6 +87134,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_class_selector(
         &mut self,
         node: ClassSelector,
@@ -85386,6 +87147,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_cmyk_component(
         &mut self,
         node: CmykComponent,
@@ -85398,12 +87160,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_color_profile_name(
         &mut self,
         node: ColorProfileName,
@@ -85416,12 +87180,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_combinator_value(
         &mut self,
         node: CombinatorValue,
@@ -85434,6 +87200,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_complex_selector(
         &mut self,
         node: ComplexSelector,
@@ -85446,6 +87213,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_complex_selector_children(
         &mut self,
         node: ComplexSelectorChildren,
@@ -85458,6 +87226,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_complex_selector_childrens(
         &mut self,
         node: Vec<ComplexSelectorChildren>,
@@ -85470,6 +87239,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_complex_selectors(
         &mut self,
         node: Vec<ComplexSelector>,
@@ -85482,6 +87252,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_component_value(
         &mut self,
         node: ComponentValue,
@@ -85494,6 +87265,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_component_values(
         &mut self,
         node: Vec<ComponentValue>,
@@ -85506,6 +87278,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_compound_selector(
         &mut self,
         node: CompoundSelector,
@@ -85518,6 +87291,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_compound_selector_list(
         &mut self,
         node: CompoundSelectorList,
@@ -85530,6 +87304,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_compound_selectors(
         &mut self,
         node: Vec<CompoundSelector>,
@@ -85542,6 +87317,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_condition(
         &mut self,
         node: ContainerCondition,
@@ -85554,6 +87330,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_name(
         &mut self,
         node: ContainerName,
@@ -85566,6 +87343,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query(
         &mut self,
         node: ContainerQuery,
@@ -85578,6 +87356,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query_and(
         &mut self,
         node: ContainerQueryAnd,
@@ -85590,6 +87369,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query_not(
         &mut self,
         node: ContainerQueryNot,
@@ -85602,6 +87382,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query_or(
         &mut self,
         node: ContainerQueryOr,
@@ -85614,6 +87395,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query_type(
         &mut self,
         node: ContainerQueryType,
@@ -85626,6 +87408,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_container_query_types(
         &mut self,
         node: Vec<ContainerQueryType>,
@@ -85638,6 +87421,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_highlight_name(
         &mut self,
         node: CustomHighlightName,
@@ -85650,6 +87434,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_ident(
         &mut self,
         node: CustomIdent,
@@ -85660,6 +87445,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_idents(
         &mut self,
         node: Vec<CustomIdent>,
@@ -85672,6 +87458,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_media_query(
         &mut self,
         node: CustomMediaQuery,
@@ -85684,6 +87471,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_media_query_media_type(
         &mut self,
         node: CustomMediaQueryMediaType,
@@ -85696,6 +87484,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_custom_property_name(
         &mut self,
         node: CustomPropertyName,
@@ -85708,6 +87497,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_dashed_ident(
         &mut self,
         node: DashedIdent,
@@ -85718,12 +87508,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_declaration_name(
         &mut self,
         node: DeclarationName,
@@ -85736,6 +87528,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_declaration_or_at_rule(
         &mut self,
         node: DeclarationOrAtRule,
@@ -85748,12 +87541,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_delimiter_value(
         &mut self,
         node: DelimiterValue,
@@ -85766,12 +87561,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_dimension_token(
         &mut self,
         node: DimensionToken,
@@ -85784,6 +87581,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_document_prelude(
         &mut self,
         node: DocumentPrelude,
@@ -85796,6 +87594,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_document_prelude_matching_function(
         &mut self,
         node: DocumentPreludeMatchingFunction,
@@ -85809,6 +87608,7 @@ pub trait FoldAstPath {
              method calls [`Vec < DocumentPreludeMatchingFunction \
              >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_prelude_matching_functions(
         &mut self,
         node: Vec<DocumentPreludeMatchingFunction>,
@@ -85821,6 +87621,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_extension_name(
         &mut self,
         node: ExtensionName,
@@ -85833,12 +87634,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_family_names(
         &mut self,
         node: Vec<FamilyName>,
@@ -85851,12 +87654,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_font_feature_values_prelude(
         &mut self,
         node: FontFeatureValuesPrelude,
@@ -85869,6 +87674,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_complex_selector(
         &mut self,
         node: ForgivingComplexSelector,
@@ -85881,6 +87687,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_complex_selectors(
         &mut self,
         node: Vec<ForgivingComplexSelector>,
@@ -85893,6 +87700,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_relative_selector(
         &mut self,
         node: ForgivingRelativeSelector,
@@ -85905,6 +87713,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_relative_selector_list(
         &mut self,
         node: ForgivingRelativeSelectorList,
@@ -85917,6 +87726,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_relative_selectors(
         &mut self,
         node: Vec<ForgivingRelativeSelector>,
@@ -85929,6 +87739,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_forgiving_selector_list(
         &mut self,
         node: ForgivingSelectorList,
@@ -85941,12 +87752,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_frequency_percentage(
         &mut self,
         node: FrequencyPercentage,
@@ -85959,12 +87772,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_function_name(
         &mut self,
         node: FunctionName,
@@ -85975,6 +87790,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_general_enclosed(
         &mut self,
         node: GeneralEnclosed,
@@ -85987,36 +87803,42 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_import_conditions(
         &mut self,
         node: ImportConditions,
@@ -86029,12 +87851,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_import_layer_name(
         &mut self,
         node: ImportLayerName,
@@ -86047,6 +87871,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_prelude(
         &mut self,
         node: ImportPrelude,
@@ -86059,6 +87884,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_important_flag(
         &mut self,
         node: ImportantFlag,
@@ -86071,12 +87897,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_keyframe_block(
         &mut self,
         node: KeyframeBlock,
@@ -86089,6 +87917,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_keyframe_selector(
         &mut self,
         node: KeyframeSelector,
@@ -86101,6 +87930,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_keyframe_selectors(
         &mut self,
         node: Vec<KeyframeSelector>,
@@ -86113,6 +87943,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_keyframes_name(
         &mut self,
         node: KeyframesName,
@@ -86125,6 +87956,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_keyframes_pseudo_function(
         &mut self,
         node: KeyframesPseudoFunction,
@@ -86137,6 +87969,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_keyframes_pseudo_prefix(
         &mut self,
         node: KeyframesPseudoPrefix,
@@ -86149,12 +87982,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_layer_name_list(
         &mut self,
         node: LayerNameList,
@@ -86167,6 +88002,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_layer_names(
         &mut self,
         node: Vec<LayerName>,
@@ -86179,6 +88015,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_layer_prelude(
         &mut self,
         node: LayerPrelude,
@@ -86189,12 +88026,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_length_percentage(
         &mut self,
         node: LengthPercentage,
@@ -86207,6 +88046,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_list_of_component_values(
         &mut self,
         node: ListOfComponentValues,
@@ -86219,12 +88059,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_media_condition(
         &mut self,
         node: MediaCondition,
@@ -86237,6 +88079,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_all_type(
         &mut self,
         node: MediaConditionAllType,
@@ -86249,6 +88092,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_all_types(
         &mut self,
         node: Vec<MediaConditionAllType>,
@@ -86261,6 +88105,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_type(
         &mut self,
         node: MediaConditionType,
@@ -86273,6 +88118,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_without_or(
         &mut self,
         node: MediaConditionWithoutOr,
@@ -86285,6 +88131,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_without_or_type(
         &mut self,
         node: MediaConditionWithoutOrType,
@@ -86297,6 +88144,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_condition_without_or_types(
         &mut self,
         node: Vec<MediaConditionWithoutOrType>,
@@ -86309,6 +88157,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature(
         &mut self,
         node: MediaFeature,
@@ -86319,6 +88168,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_boolean(
         &mut self,
         node: MediaFeatureBoolean,
@@ -86331,6 +88181,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_name(
         &mut self,
         node: MediaFeatureName,
@@ -86343,6 +88194,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_plain(
         &mut self,
         node: MediaFeaturePlain,
@@ -86355,6 +88207,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_range(
         &mut self,
         node: MediaFeatureRange,
@@ -86367,6 +88220,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_range_comparison(
         &mut self,
         node: MediaFeatureRangeComparison,
@@ -86379,6 +88233,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_range_interval(
         &mut self,
         node: MediaFeatureRangeInterval,
@@ -86391,6 +88246,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_feature_value(
         &mut self,
         node: MediaFeatureValue,
@@ -86403,6 +88259,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_in_parens(
         &mut self,
         node: MediaInParens,
@@ -86415,24 +88272,28 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_media_query_list(
         &mut self,
         node: MediaQueryList,
@@ -86445,6 +88306,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_media_querys(
         &mut self,
         node: Vec<MediaQuery>,
@@ -86457,12 +88319,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_named_namespace(
         &mut self,
         node: NamedNamespace,
@@ -86475,12 +88339,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_namespace_prefix(
         &mut self,
         node: NamespacePrefix,
@@ -86493,6 +88359,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_namespace_prelude(
         &mut self,
         node: NamespacePrelude,
@@ -86505,6 +88372,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_namespace_prelude_uri(
         &mut self,
         node: NamespacePreludeUri,
@@ -86517,6 +88385,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_nesting_selector(
         &mut self,
         node: NestingSelector,
@@ -86529,18 +88398,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_at_rule_prelude(
         &mut self,
         node: Option<Box<AtRulePrelude>>,
@@ -86553,6 +88425,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_atom(
         &mut self,
         node: Option<swc_atoms::Atom>,
@@ -86565,6 +88438,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_matcher(
         &mut self,
         node: Option<AttributeSelectorMatcher>,
@@ -86577,6 +88451,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_modifier(
         &mut self,
         node: Option<AttributeSelectorModifier>,
@@ -86589,6 +88464,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_attribute_selector_value(
         &mut self,
         node: Option<AttributeSelectorValue>,
@@ -86601,6 +88477,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_combinator(
         &mut self,
         node: Option<Combinator>,
@@ -86613,6 +88490,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_container_name(
         &mut self,
         node: Option<ContainerName>,
@@ -86625,6 +88503,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_forgiving_selector_list(
         &mut self,
         node: Option<ForgivingSelectorList>,
@@ -86637,6 +88516,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_function(
         &mut self,
         node: Option<Box<Function>>,
@@ -86649,6 +88529,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ident(
         &mut self,
         node: Option<Ident>,
@@ -86661,6 +88542,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_import_conditions(
         &mut self,
         node: Option<Box<ImportConditions>>,
@@ -86673,6 +88555,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_import_layer_name(
         &mut self,
         node: Option<Box<ImportLayerName>>,
@@ -86685,6 +88568,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_important_flag(
         &mut self,
         node: Option<ImportantFlag>,
@@ -86697,6 +88581,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_media_condition_type(
         &mut self,
         node: Option<Box<MediaConditionType>>,
@@ -86709,6 +88594,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_media_query_list(
         &mut self,
         node: Option<Box<MediaQueryList>>,
@@ -86721,6 +88607,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_media_type(
         &mut self,
         node: Option<MediaType>,
@@ -86733,6 +88620,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_namespace(
         &mut self,
         node: Option<Namespace>,
@@ -86745,6 +88633,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_namespace_prefix(
         &mut self,
         node: Option<NamespacePrefix>,
@@ -86757,6 +88646,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_nesting_selector(
         &mut self,
         node: Option<NestingSelector>,
@@ -86769,6 +88659,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_number(
         &mut self,
         node: Option<Number>,
@@ -86781,6 +88672,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_page_selector_pseudos(
         &mut self,
         node: Option<Vec<PageSelectorPseudo>>,
@@ -86793,6 +88685,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_page_selector_type(
         &mut self,
         node: Option<PageSelectorType>,
@@ -86806,6 +88699,7 @@ pub trait FoldAstPath {
              this method calls [`Option < Vec < PseudoClassSelectorChildren > \
              >::fold_children_with_ast_path`]. 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>>,
@@ -86817,6 +88711,7 @@ pub trait FoldAstPath {
              default, this method calls [`Option < Vec < PseudoElementSelectorChildren > \
              >::fold_children_with_ast_path`]. 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>>,
@@ -86827,6 +88722,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_simple_block(
         &mut self,
         node: Option<SimpleBlock>,
@@ -86839,6 +88735,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_type_selector(
         &mut self,
         node: Option<Box<TypeSelector>>,
@@ -86851,6 +88748,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_url_modifiers(
         &mut self,
         node: Option<Vec<UrlModifier>>,
@@ -86863,6 +88761,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_url_value(
         &mut self,
         node: Option<Box<UrlValue>>,
@@ -86875,6 +88774,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_page_selector(
         &mut self,
         node: PageSelector,
@@ -86885,6 +88785,7 @@ pub trait FoldAstPath {
     #[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,
@@ -86897,6 +88798,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_page_selector_pseudo(
         &mut self,
         node: PageSelectorPseudo,
@@ -86909,6 +88811,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_page_selector_pseudos(
         &mut self,
         node: Vec<PageSelectorPseudo>,
@@ -86921,6 +88824,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_page_selector_type(
         &mut self,
         node: PageSelectorType,
@@ -86933,6 +88837,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_page_selectors(
         &mut self,
         node: Vec<PageSelector>,
@@ -86945,12 +88850,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_pseudo_class_selector(
         &mut self,
         node: PseudoClassSelector,
@@ -86963,6 +88870,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_pseudo_class_selector_children(
         &mut self,
         node: PseudoClassSelectorChildren,
@@ -86975,6 +88883,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_pseudo_class_selector_childrens(
         &mut self,
         node: Vec<PseudoClassSelectorChildren>,
@@ -86987,6 +88896,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector(
         &mut self,
         node: PseudoElementSelector,
@@ -86999,6 +88909,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector_children(
         &mut self,
         node: PseudoElementSelectorChildren,
@@ -87011,6 +88922,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_pseudo_element_selector_childrens(
         &mut self,
         node: Vec<PseudoElementSelectorChildren>,
@@ -87023,6 +88935,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_qualified_rule(
         &mut self,
         node: QualifiedRule,
@@ -87035,6 +88948,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_qualified_rule_prelude(
         &mut self,
         node: QualifiedRulePrelude,
@@ -87047,6 +88961,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_query_in_parens(
         &mut self,
         node: QueryInParens,
@@ -87059,12 +88974,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_relative_selector(
         &mut self,
         node: RelativeSelector,
@@ -87077,6 +88994,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_relative_selector_list(
         &mut self,
         node: RelativeSelectorList,
@@ -87089,6 +89007,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_relative_selectors(
         &mut self,
         node: Vec<RelativeSelector>,
@@ -87101,30 +89020,35 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_selector_list(
         &mut self,
         node: SelectorList,
@@ -87135,6 +89059,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_sequence_of_custom_idents(
         &mut self,
         node: SequenceOfCustomIdents,
@@ -87147,6 +89072,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_simple_block(
         &mut self,
         node: SimpleBlock,
@@ -87157,6 +89083,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature(
         &mut self,
         node: SizeFeature,
@@ -87167,6 +89094,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_boolean(
         &mut self,
         node: SizeFeatureBoolean,
@@ -87179,6 +89107,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_name(
         &mut self,
         node: SizeFeatureName,
@@ -87191,6 +89120,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_plain(
         &mut self,
         node: SizeFeaturePlain,
@@ -87203,6 +89133,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_range(
         &mut self,
         node: SizeFeatureRange,
@@ -87215,6 +89146,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_range_comparison(
         &mut self,
         node: SizeFeatureRangeComparison,
@@ -87227,6 +89159,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_range_interval(
         &mut self,
         node: SizeFeatureRangeInterval,
@@ -87239,6 +89172,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_size_feature_value(
         &mut self,
         node: SizeFeatureValue,
@@ -87251,6 +89185,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_span(
         &mut self,
         node: swc_common::Span,
@@ -87263,24 +89198,28 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_subclass_selector(
         &mut self,
         node: SubclassSelector,
@@ -87293,6 +89232,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_subclass_selectors(
         &mut self,
         node: Vec<SubclassSelector>,
@@ -87305,6 +89245,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_and(
         &mut self,
         node: SupportsAnd,
@@ -87315,6 +89256,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_condition(
         &mut self,
         node: SupportsCondition,
@@ -87327,6 +89269,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_condition_type(
         &mut self,
         node: SupportsConditionType,
@@ -87339,6 +89282,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_condition_types(
         &mut self,
         node: Vec<SupportsConditionType>,
@@ -87351,6 +89295,7 @@ pub trait FoldAstPath {
     #[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,
@@ -87363,6 +89308,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_in_parens(
         &mut self,
         node: SupportsInParens,
@@ -87375,6 +89321,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_supports_not(
         &mut self,
         node: SupportsNot,
@@ -87385,12 +89332,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_tag_name_selector(
         &mut self,
         node: TagNameSelector,
@@ -87403,12 +89352,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_time_percentage(
         &mut self,
         node: TimePercentage,
@@ -87421,12 +89372,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_token_and_span(
         &mut self,
         node: TokenAndSpan,
@@ -87437,6 +89390,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_type_selector(
         &mut self,
         node: TypeSelector,
@@ -87447,6 +89401,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_unicode_range(
         &mut self,
         node: UnicodeRange,
@@ -87457,6 +89412,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_universal_selector(
         &mut self,
         node: UniversalSelector,
@@ -87469,6 +89425,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_unknown_dimension(
         &mut self,
         node: UnknownDimension,
@@ -87481,12 +89438,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_url_key_value(
         &mut self,
         node: UrlKeyValue,
@@ -87497,6 +89456,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_url_modifier(
         &mut self,
         node: UrlModifier,
@@ -87507,6 +89467,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_url_modifiers(
         &mut self,
         node: Vec<UrlModifier>,
@@ -87519,12 +89480,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_url_value_raw(
         &mut self,
         node: UrlValueRaw,
@@ -87535,6 +89498,7 @@ pub trait FoldAstPath {
     #[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)
     }
@@ -106031,10 +107995,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for WqName {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -106043,10 +108009,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <CalcProductOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106059,10 +108027,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcProductOrOperator>
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <CalcValueOrOperator as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106075,10 +108045,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CalcValueOrOperator> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ComplexSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106091,10 +108063,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelectorChildren
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106105,10 +108079,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComplexSelector> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ComponentValue as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106119,10 +108095,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ComponentValue> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <CompoundSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106133,10 +108111,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CompoundSelector> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ContainerQueryType as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106149,10 +108129,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ContainerQueryType> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <CustomIdent as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106164,10 +108146,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<CustomIdent> {
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<DocumentPreludeMatchingFunction> {
     #[doc = "Calls [FoldAstPath`::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)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <DocumentPreludeMatchingFunction as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106180,10 +108164,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<DocumentPreludeMatching
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <FamilyName as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106194,10 +108180,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<FamilyName> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ForgivingComplexSelector as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106210,10 +108198,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingComplexSelecto
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ForgivingRelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106226,10 +108216,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ForgivingRelativeSelect
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_idents(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Ident as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106240,10 +108232,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Ident> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <KeyframeSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106254,10 +108248,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<KeyframeSelector> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <LayerName as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106268,10 +108264,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<LayerName> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <MediaConditionAllType as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106284,10 +108282,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionAllType>
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <MediaConditionWithoutOrType as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106300,10 +108300,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaConditionWithoutOr
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <MediaQuery as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106314,10 +108316,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<MediaQuery> {
 #[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 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 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(
@@ -106330,10 +108334,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<AtRulePrelude>>
 #[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 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 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)
@@ -106344,10 +108350,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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 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 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(
@@ -106360,10 +108368,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorMat
 #[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 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 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(
@@ -106376,10 +108386,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorMod
 #[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 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 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(
@@ -106392,10 +108404,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<AttributeSelectorVal
 #[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 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 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)
@@ -106406,10 +108420,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Combinator> {
 #[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 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 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)
@@ -106420,10 +108436,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ContainerName> {
 #[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 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 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(
@@ -106436,10 +108454,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ForgivingSelectorLis
 #[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 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 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)
@@ -106450,10 +108470,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Function>> {
 #[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 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 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)
@@ -106464,10 +108486,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
 #[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 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 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(
@@ -106480,10 +108504,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportConditions
 #[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 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 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(
@@ -106496,10 +108522,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ImportLayerName>
 #[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 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 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)
@@ -106510,10 +108538,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ImportantFlag> {
 #[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 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 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(
@@ -106526,10 +108556,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaConditionTy
 #[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 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 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(
@@ -106542,10 +108574,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<MediaQueryList>>
 #[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 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 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)
@@ -106556,10 +108590,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<MediaType> {
 #[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 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 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)
@@ -106570,10 +108606,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Namespace> {
 #[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 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 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)
@@ -106584,10 +108622,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NamespacePrefix> {
 #[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 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 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)
@@ -106598,10 +108638,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<NestingSelector> {
 #[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 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 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)
@@ -106612,10 +108654,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Number> {
 #[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 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 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(
@@ -106628,10 +108672,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PageSelectorPseu
 #[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 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 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)
@@ -106643,10 +108689,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<PageSelectorType> {
 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 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 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(
@@ -106660,10 +108708,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoClassSelec
 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 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 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(
@@ -106676,10 +108726,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<PseudoElementSel
 #[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 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 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)
@@ -106690,10 +108742,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<SimpleBlock> {
 #[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 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 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(
@@ -106706,10 +108760,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TypeSelector>> {
 #[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 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 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)
@@ -106720,10 +108776,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<UrlModifier>> {
 #[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 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 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)
@@ -106734,10 +108792,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<UrlValue>> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <PageSelectorPseudo as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106750,10 +108810,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelectorPseudo> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <PageSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106764,10 +108826,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PageSelector> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <PseudoClassSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106781,10 +108845,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoClassSelectorChil
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoElementSelectorChildren> {
     #[doc = "Calls [FoldAstPath`::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)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <PseudoElementSelectorChildren as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106797,10 +108863,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PseudoElementSelectorCh
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <RelativeSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106811,10 +108879,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<RelativeSelector> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_rules(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Rule as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106825,10 +108895,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Rule> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -106837,10 +108909,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <SubclassSelector as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106851,10 +108925,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SubclassSelector> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <SupportsConditionType as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -106867,10 +108943,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SupportsConditionType>
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <UrlModifier as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -106884,12 +108962,14 @@ where
     V: ?Sized + FoldAstPath,
     T: FoldWithAstPath<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)
         })
     }
 
+    #[inline]
     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)
@@ -106901,78 +108981,91 @@ pub trait VisitAll {
     #[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]."]
+    #[inline]
     fn visit_absolute_color_base(&mut self, node: &AbsoluteColorBase) {
         <AbsoluteColorBase as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_alpha_value(&mut self, node: &AlphaValue) {
         <AlphaValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_an_plus_b(&mut self, node: &AnPlusB) {
         <AnPlusB as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_an_plus_b_notation(&mut self, node: &AnPlusBNotation) {
         <AnPlusBNotation as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_angle(&mut self, node: &Angle) {
         <Angle as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_angle_percentage(&mut self, node: &AnglePercentage) {
         <AnglePercentage as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_any_namespace(&mut self, node: &AnyNamespace) {
         <AnyNamespace as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_at_rule(&mut self, node: &AtRule) {
         <AtRule as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_at_rule_name(&mut self, node: &AtRuleName) {
         <AtRuleName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_at_rule_prelude(&mut self, node: &AtRulePrelude) {
         <AtRulePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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 `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]."]
+    #[inline]
     fn visit_attribute_selector(&mut self, node: &AttributeSelector) {
         <AttributeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_attribute_selector_matcher(&mut self, node: &AttributeSelectorMatcher) {
         <AttributeSelectorMatcher as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -106980,48 +109073,56 @@ pub trait VisitAll {
              calls [`AttributeSelectorMatcherValue::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_selector_matcher_value(&mut self, node: &AttributeSelectorMatcherValue) {
         <AttributeSelectorMatcherValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_attribute_selector_modifier(&mut self, node: &AttributeSelectorModifier) {
         <AttributeSelectorModifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_attribute_selector_value(&mut self, node: &AttributeSelectorValue) {
         <AttributeSelectorValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_bin_op(&mut self, node: &BinOp) {
         <BinOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_operator(&mut self, node: &CalcOperator) {
         <CalcOperator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_operator_type(&mut self, node: &CalcOperatorType) {
         <CalcOperatorType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_product(&mut self, node: &CalcProduct) {
         <CalcProduct as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_product_or_operator(&mut self, node: &CalcProductOrOperator) {
         <CalcProductOrOperator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107029,24 +109130,28 @@ pub trait VisitAll {
              calls [`Vec < CalcProductOrOperator >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_calc_product_or_operators(&mut self, node: &[CalcProductOrOperator]) {
         <[CalcProductOrOperator] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_sum(&mut self, node: &CalcSum) {
         <CalcSum as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_value(&mut self, node: &CalcValue) {
         <CalcValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_calc_value_or_operator(&mut self, node: &CalcValueOrOperator) {
         <CalcValueOrOperator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107054,54 +109159,63 @@ pub trait VisitAll {
              [`Vec < CalcValueOrOperator >::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_calc_value_or_operators(&mut self, node: &[CalcValueOrOperator]) {
         <[CalcValueOrOperator] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_selector(&mut self, node: &ClassSelector) {
         <ClassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_cmyk_component(&mut self, node: &CmykComponent) {
         <CmykComponent as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_color(&mut self, node: &Color) {
         <Color as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_color_profile_name(&mut self, node: &ColorProfileName) {
         <ColorProfileName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_combinator(&mut self, node: &Combinator) {
         <Combinator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_combinator_value(&mut self, node: &CombinatorValue) {
         <CombinatorValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_complex_selector(&mut self, node: &ComplexSelector) {
         <ComplexSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_complex_selector_children(&mut self, node: &ComplexSelectorChildren) {
         <ComplexSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107109,84 +109223,98 @@ pub trait VisitAll {
              calls [`Vec < ComplexSelectorChildren >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_complex_selector_childrens(&mut self, node: &[ComplexSelectorChildren]) {
         <[ComplexSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_complex_selectors(&mut self, node: &[ComplexSelector]) {
         <[ComplexSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_component_value(&mut self, node: &ComponentValue) {
         <ComponentValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_component_values(&mut self, node: &[ComponentValue]) {
         <[ComponentValue] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_compound_selector(&mut self, node: &CompoundSelector) {
         <CompoundSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_compound_selector_list(&mut self, node: &CompoundSelectorList) {
         <CompoundSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_compound_selectors(&mut self, node: &[CompoundSelector]) {
         <[CompoundSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_condition(&mut self, node: &ContainerCondition) {
         <ContainerCondition as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_name(&mut self, node: &ContainerName) {
         <ContainerName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_query(&mut self, node: &ContainerQuery) {
         <ContainerQuery as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_query_and(&mut self, node: &ContainerQueryAnd) {
         <ContainerQueryAnd as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_query_not(&mut self, node: &ContainerQueryNot) {
         <ContainerQueryNot as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_query_or(&mut self, node: &ContainerQueryOr) {
         <ContainerQueryOr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_container_query_type(&mut self, node: &ContainerQueryType) {
         <ContainerQueryType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107194,96 +109322,112 @@ pub trait VisitAll {
              [`Vec < ContainerQueryType >::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_container_query_types(&mut self, node: &[ContainerQueryType]) {
         <[ContainerQueryType] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_highlight_name(&mut self, node: &CustomHighlightName) {
         <CustomHighlightName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_ident(&mut self, node: &CustomIdent) {
         <CustomIdent as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_idents(&mut self, node: &[CustomIdent]) {
         <[CustomIdent] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_media_query(&mut self, node: &CustomMediaQuery) {
         <CustomMediaQuery as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_media_query_media_type(&mut self, node: &CustomMediaQueryMediaType) {
         <CustomMediaQueryMediaType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_custom_property_name(&mut self, node: &CustomPropertyName) {
         <CustomPropertyName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_dashed_ident(&mut self, node: &DashedIdent) {
         <DashedIdent as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_declaration(&mut self, node: &Declaration) {
         <Declaration as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_declaration_name(&mut self, node: &DeclarationName) {
         <DeclarationName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_declaration_or_at_rule(&mut self, node: &DeclarationOrAtRule) {
         <DeclarationOrAtRule as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_delimiter(&mut self, node: &Delimiter) {
         <Delimiter as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_delimiter_value(&mut self, node: &DelimiterValue) {
         <DelimiterValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_dimension(&mut self, node: &Dimension) {
         <Dimension as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_dimension_token(&mut self, node: &DimensionToken) {
         <DimensionToken as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_document_prelude(&mut self, node: &DocumentPrelude) {
         <DocumentPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107291,6 +109435,7 @@ pub trait VisitAll {
              calls [`DocumentPreludeMatchingFunction::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_prelude_matching_function(&mut self, node: &DocumentPreludeMatchingFunction) {
         <DocumentPreludeMatchingFunction as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107298,6 +109443,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_document_prelude_matching_functions(
         &mut self,
         node: &[DocumentPreludeMatchingFunction],
@@ -107307,36 +109453,42 @@ pub trait VisitAll {
     #[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]."]
+    #[inline]
     fn visit_extension_name(&mut self, node: &ExtensionName) {
         <ExtensionName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_family_name(&mut self, node: &FamilyName) {
         <FamilyName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_family_names(&mut self, node: &[FamilyName]) {
         <[FamilyName] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_flex(&mut self, node: &Flex) {
         <Flex as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_font_feature_values_prelude(&mut self, node: &FontFeatureValuesPrelude) {
         <FontFeatureValuesPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_forgiving_complex_selector(&mut self, node: &ForgivingComplexSelector) {
         <ForgivingComplexSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107344,12 +109496,14 @@ pub trait VisitAll {
              calls [`Vec < ForgivingComplexSelector >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_forgiving_complex_selectors(&mut self, node: &[ForgivingComplexSelector]) {
         <[ForgivingComplexSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_forgiving_relative_selector(&mut self, node: &ForgivingRelativeSelector) {
         <ForgivingRelativeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107357,6 +109511,7 @@ pub trait VisitAll {
              calls [`ForgivingRelativeSelectorList::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_forgiving_relative_selector_list(&mut self, node: &ForgivingRelativeSelectorList) {
         <ForgivingRelativeSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107364,204 +109519,238 @@ pub trait VisitAll {
              calls [`Vec < ForgivingRelativeSelector >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_forgiving_relative_selectors(&mut self, node: &[ForgivingRelativeSelector]) {
         <[ForgivingRelativeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_forgiving_selector_list(&mut self, node: &ForgivingSelectorList) {
         <ForgivingSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_frequency(&mut self, node: &Frequency) {
         <Frequency as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_frequency_percentage(&mut self, node: &FrequencyPercentage) {
         <FrequencyPercentage as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_function(&mut self, node: &Function) {
         <Function as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_function_name(&mut self, node: &FunctionName) {
         <FunctionName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_general_enclosed(&mut self, node: &GeneralEnclosed) {
         <GeneralEnclosed as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_hex_color(&mut self, node: &HexColor) {
         <HexColor as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_hue(&mut self, node: &Hue) {
         <Hue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_id_selector(&mut self, node: &IdSelector) {
         <IdSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ident(&mut self, node: &Ident) {
         <Ident as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_idents(&mut self, node: &[Ident]) {
         <[Ident] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_conditions(&mut self, node: &ImportConditions) {
         <ImportConditions as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_href(&mut self, node: &ImportHref) {
         <ImportHref as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_layer_name(&mut self, node: &ImportLayerName) {
         <ImportLayerName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_prelude(&mut self, node: &ImportPrelude) {
         <ImportPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_important_flag(&mut self, node: &ImportantFlag) {
         <ImportantFlag as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_integer(&mut self, node: &Integer) {
         <Integer as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframe_block(&mut self, node: &KeyframeBlock) {
         <KeyframeBlock as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframe_selector(&mut self, node: &KeyframeSelector) {
         <KeyframeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframe_selectors(&mut self, node: &[KeyframeSelector]) {
         <[KeyframeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframes_name(&mut self, node: &KeyframesName) {
         <KeyframesName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframes_pseudo_function(&mut self, node: &KeyframesPseudoFunction) {
         <KeyframesPseudoFunction as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_keyframes_pseudo_prefix(&mut self, node: &KeyframesPseudoPrefix) {
         <KeyframesPseudoPrefix as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_layer_name(&mut self, node: &LayerName) {
         <LayerName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_layer_name_list(&mut self, node: &LayerNameList) {
         <LayerNameList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_layer_names(&mut self, node: &[LayerName]) {
         <[LayerName] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_layer_prelude(&mut self, node: &LayerPrelude) {
         <LayerPrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_length(&mut self, node: &Length) {
         <Length as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_length_percentage(&mut self, node: &LengthPercentage) {
         <LengthPercentage as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_list_of_component_values(&mut self, node: &ListOfComponentValues) {
         <ListOfComponentValues as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_and(&mut self, node: &MediaAnd) {
         <MediaAnd as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_condition(&mut self, node: &MediaCondition) {
         <MediaCondition as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_condition_all_type(&mut self, node: &MediaConditionAllType) {
         <MediaConditionAllType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107569,18 +109758,21 @@ pub trait VisitAll {
              calls [`Vec < MediaConditionAllType >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_media_condition_all_types(&mut self, node: &[MediaConditionAllType]) {
         <[MediaConditionAllType] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_condition_type(&mut self, node: &MediaConditionType) {
         <MediaConditionType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_condition_without_or(&mut self, node: &MediaConditionWithoutOr) {
         <MediaConditionWithoutOr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107588,6 +109780,7 @@ pub trait VisitAll {
              [`MediaConditionWithoutOrType::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_media_condition_without_or_type(&mut self, node: &MediaConditionWithoutOrType) {
         <MediaConditionWithoutOrType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107595,36 +109788,42 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_media_condition_without_or_types(&mut self, node: &[MediaConditionWithoutOrType]) {
         <[MediaConditionWithoutOrType] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature(&mut self, node: &MediaFeature) {
         <MediaFeature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_boolean(&mut self, node: &MediaFeatureBoolean) {
         <MediaFeatureBoolean as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_name(&mut self, node: &MediaFeatureName) {
         <MediaFeatureName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_plain(&mut self, node: &MediaFeaturePlain) {
         <MediaFeaturePlain as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_range(&mut self, node: &MediaFeatureRange) {
         <MediaFeatureRange as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107632,108 +109831,126 @@ pub trait VisitAll {
              [`MediaFeatureRangeComparison::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_media_feature_range_comparison(&mut self, node: &MediaFeatureRangeComparison) {
         <MediaFeatureRangeComparison as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_range_interval(&mut self, node: &MediaFeatureRangeInterval) {
         <MediaFeatureRangeInterval as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_feature_value(&mut self, node: &MediaFeatureValue) {
         <MediaFeatureValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_in_parens(&mut self, node: &MediaInParens) {
         <MediaInParens as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_not(&mut self, node: &MediaNot) {
         <MediaNot as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_or(&mut self, node: &MediaOr) {
         <MediaOr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_query(&mut self, node: &MediaQuery) {
         <MediaQuery as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_query_list(&mut self, node: &MediaQueryList) {
         <MediaQueryList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_querys(&mut self, node: &[MediaQuery]) {
         <[MediaQuery] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_media_type(&mut self, node: &MediaType) {
         <MediaType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_named_namespace(&mut self, node: &NamedNamespace) {
         <NamedNamespace 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 `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]."]
+    #[inline]
     fn visit_namespace_prefix(&mut self, node: &NamespacePrefix) {
         <NamespacePrefix as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_namespace_prelude(&mut self, node: &NamespacePrelude) {
         <NamespacePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_namespace_prelude_uri(&mut self, node: &NamespacePreludeUri) {
         <NamespacePreludeUri as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_nesting_selector(&mut self, node: &NestingSelector) {
         <NestingSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_number(&mut self, node: &Number) {
         <Number as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_number_type(&mut self, node: &NumberType) {
         <NumberType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107741,6 +109958,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_at_rule_prelude(&mut self, node: &Option<Box<AtRulePrelude>>) {
         <Option<Box<AtRulePrelude>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107748,6 +109966,7 @@ pub trait VisitAll {
              [`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)
     }
@@ -107755,6 +109974,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_attribute_selector_matcher(&mut self, node: &Option<AttributeSelectorMatcher>) {
         <Option<AttributeSelectorMatcher> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107762,6 +109982,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_attribute_selector_modifier(&mut self, node: &Option<AttributeSelectorModifier>) {
         <Option<AttributeSelectorModifier> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107769,18 +109990,21 @@ pub trait VisitAll {
              calls [`Option < AttributeSelectorValue >::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_attribute_selector_value(&mut self, node: &Option<AttributeSelectorValue>) {
         <Option<AttributeSelectorValue> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_combinator(&mut self, node: &Option<Combinator>) {
         <Option<Combinator> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_container_name(&mut self, node: &Option<ContainerName>) {
         <Option<ContainerName> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107788,6 +110012,7 @@ pub trait VisitAll {
              calls [`Option < ForgivingSelectorList >::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_forgiving_selector_list(&mut self, node: &Option<ForgivingSelectorList>) {
         <Option<ForgivingSelectorList> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107795,12 +110020,14 @@ pub trait VisitAll {
              [`Option < Box < Function > >::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_function(&mut self, node: &Option<Box<Function>>) {
         <Option<Box<Function>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_ident(&mut self, node: &Option<Ident>) {
         <Option<Ident> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107808,6 +110035,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_import_conditions(&mut self, node: &Option<Box<ImportConditions>>) {
         <Option<Box<ImportConditions>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107815,12 +110043,14 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_import_layer_name(&mut self, node: &Option<Box<ImportLayerName>>) {
         <Option<Box<ImportLayerName>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_important_flag(&mut self, node: &Option<ImportantFlag>) {
         <Option<ImportantFlag> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107828,6 +110058,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_media_condition_type(&mut self, node: &Option<Box<MediaConditionType>>) {
         <Option<Box<MediaConditionType>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107835,18 +110066,21 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_media_query_list(&mut self, node: &Option<Box<MediaQueryList>>) {
         <Option<Box<MediaQueryList>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_media_type(&mut self, node: &Option<MediaType>) {
         <Option<MediaType> 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)
     }
@@ -107854,6 +110088,7 @@ pub trait VisitAll {
              [`Option < NamespacePrefix >::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_prefix(&mut self, node: &Option<NamespacePrefix>) {
         <Option<NamespacePrefix> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107861,12 +110096,14 @@ pub trait VisitAll {
              [`Option < NestingSelector >::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_nesting_selector(&mut self, node: &Option<NestingSelector>) {
         <Option<NestingSelector> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_number(&mut self, node: &Option<Number>) {
         <Option<Number> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107874,6 +110111,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_page_selector_pseudos(&mut self, node: &Option<Vec<PageSelectorPseudo>>) {
         <Option<Vec<PageSelectorPseudo>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107881,6 +110119,7 @@ pub trait VisitAll {
              [`Option < PageSelectorType >::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_page_selector_type(&mut self, node: &Option<PageSelectorType>) {
         <Option<PageSelectorType> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107888,6 +110127,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_pseudo_class_selector_childrens(
         &mut self,
         node: &Option<Vec<PseudoClassSelectorChildren>>,
@@ -107900,6 +110140,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_pseudo_element_selector_childrens(
         &mut self,
         node: &Option<Vec<PseudoElementSelectorChildren>>,
@@ -107911,6 +110152,7 @@ pub trait VisitAll {
     #[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]."]
+    #[inline]
     fn visit_opt_simple_block(&mut self, node: &Option<SimpleBlock>) {
         <Option<SimpleBlock> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107918,6 +110160,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_type_selector(&mut self, node: &Option<Box<TypeSelector>>) {
         <Option<Box<TypeSelector>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107925,6 +110168,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_url_modifiers(&mut self, node: &Option<Vec<UrlModifier>>) {
         <Option<Vec<UrlModifier>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107932,24 +110176,28 @@ pub trait VisitAll {
              [`Option < Box < UrlValue > >::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_url_value(&mut self, node: &Option<Box<UrlValue>>) {
         <Option<Box<UrlValue>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_page_selector(&mut self, node: &PageSelector) {
         <PageSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_page_selector_list(&mut self, node: &PageSelectorList) {
         <PageSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_page_selector_pseudo(&mut self, node: &PageSelectorPseudo) {
         <PageSelectorPseudo as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107957,30 +110205,35 @@ pub trait VisitAll {
              [`Vec < PageSelectorPseudo >::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_page_selector_pseudos(&mut self, node: &[PageSelectorPseudo]) {
         <[PageSelectorPseudo] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_page_selector_type(&mut self, node: &PageSelectorType) {
         <PageSelectorType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_page_selectors(&mut self, node: &[PageSelector]) {
         <[PageSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_percentage(&mut self, node: &Percentage) {
         <Percentage as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_pseudo_class_selector(&mut self, node: &PseudoClassSelector) {
         <PseudoClassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107988,6 +110241,7 @@ pub trait VisitAll {
              [`PseudoClassSelectorChildren::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_pseudo_class_selector_children(&mut self, node: &PseudoClassSelectorChildren) {
         <PseudoClassSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -107995,12 +110249,14 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_pseudo_class_selector_childrens(&mut self, node: &[PseudoClassSelectorChildren]) {
         <[PseudoClassSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_pseudo_element_selector(&mut self, node: &PseudoElementSelector) {
         <PseudoElementSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -108008,6 +110264,7 @@ pub trait VisitAll {
              calls [`PseudoElementSelectorChildren::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_pseudo_element_selector_children(&mut self, node: &PseudoElementSelectorChildren) {
         <PseudoElementSelectorChildren as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -108015,120 +110272,140 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_pseudo_element_selector_childrens(&mut self, node: &[PseudoElementSelectorChildren]) {
         <[PseudoElementSelectorChildren] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_qualified_rule(&mut self, node: &QualifiedRule) {
         <QualifiedRule as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_qualified_rule_prelude(&mut self, node: &QualifiedRulePrelude) {
         <QualifiedRulePrelude as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_query_in_parens(&mut self, node: &QueryInParens) {
         <QueryInParens as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ratio(&mut self, node: &Ratio) {
         <Ratio as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_relative_selector(&mut self, node: &RelativeSelector) {
         <RelativeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_relative_selector_list(&mut self, node: &RelativeSelectorList) {
         <RelativeSelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_relative_selectors(&mut self, node: &[RelativeSelector]) {
         <[RelativeSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_resolution(&mut self, node: &Resolution) {
         <Resolution as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_rule(&mut self, node: &Rule) {
         <Rule as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_rules(&mut self, node: &[Rule]) {
         <[Rule] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_scope_range(&mut self, node: &ScopeRange) {
         <ScopeRange as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_selector_list(&mut self, node: &SelectorList) {
         <SelectorList as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_sequence_of_custom_idents(&mut self, node: &SequenceOfCustomIdents) {
         <SequenceOfCustomIdents as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_simple_block(&mut self, node: &SimpleBlock) {
         <SimpleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature(&mut self, node: &SizeFeature) {
         <SizeFeature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_boolean(&mut self, node: &SizeFeatureBoolean) {
         <SizeFeatureBoolean as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_name(&mut self, node: &SizeFeatureName) {
         <SizeFeatureName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_plain(&mut self, node: &SizeFeaturePlain) {
         <SizeFeaturePlain as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_range(&mut self, node: &SizeFeatureRange) {
         <SizeFeatureRange as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -108136,72 +110413,84 @@ pub trait VisitAll {
              [`SizeFeatureRangeComparison::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_size_feature_range_comparison(&mut self, node: &SizeFeatureRangeComparison) {
         <SizeFeatureRangeComparison as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_range_interval(&mut self, node: &SizeFeatureRangeInterval) {
         <SizeFeatureRangeInterval as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_size_feature_value(&mut self, node: &SizeFeatureValue) {
         <SizeFeatureValue 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 `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]."]
+    #[inline]
     fn visit_str(&mut self, node: &Str) {
         <Str as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_style_block(&mut self, node: &StyleBlock) {
         <StyleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_stylesheet(&mut self, node: &Stylesheet) {
         <Stylesheet as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_subclass_selector(&mut self, node: &SubclassSelector) {
         <SubclassSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_subclass_selectors(&mut self, node: &[SubclassSelector]) {
         <[SubclassSelector] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_and(&mut self, node: &SupportsAnd) {
         <SupportsAnd as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_condition(&mut self, node: &SupportsCondition) {
         <SupportsCondition as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_condition_type(&mut self, node: &SupportsConditionType) {
         <SupportsConditionType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -108209,126 +110498,147 @@ pub trait VisitAll {
              calls [`Vec < SupportsConditionType >::visit_children_with`]. This method \
              unconditionally calls the visitor method for all children because it's defined in the \
              trait [VisitAll]."]
+    #[inline]
     fn visit_supports_condition_types(&mut self, node: &[SupportsConditionType]) {
         <[SupportsConditionType] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_feature(&mut self, node: &SupportsFeature) {
         <SupportsFeature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_in_parens(&mut self, node: &SupportsInParens) {
         <SupportsInParens as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_not(&mut self, node: &SupportsNot) {
         <SupportsNot as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_supports_or(&mut self, node: &SupportsOr) {
         <SupportsOr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_tag_name_selector(&mut self, node: &TagNameSelector) {
         <TagNameSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_time(&mut self, node: &Time) {
         <Time as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_time_percentage(&mut self, node: &TimePercentage) {
         <TimePercentage 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)
     }
     #[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]."]
+    #[inline]
     fn visit_type_selector(&mut self, node: &TypeSelector) {
         <TypeSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_unicode_range(&mut self, node: &UnicodeRange) {
         <UnicodeRange as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_universal_selector(&mut self, node: &UniversalSelector) {
         <UniversalSelector as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_unknown_dimension(&mut self, node: &UnknownDimension) {
         <UnknownDimension as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url(&mut self, node: &Url) {
         <Url as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url_key_value(&mut self, node: &UrlKeyValue) {
         <UrlKeyValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url_modifier(&mut self, node: &UrlModifier) {
         <UrlModifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url_modifiers(&mut self, node: &[UrlModifier]) {
         <[UrlModifier] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url_value(&mut self, node: &UrlValue) {
         <UrlValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_url_value_raw(&mut self, node: &UrlValueRaw) {
         <UrlValueRaw as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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)
     }
@@ -118585,20 +120895,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for WqName {
 }
 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 [CalcProductOrOperator] {
     #[doc = "Calls [VisitAll`::visit_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)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <CalcProductOrOperator as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118606,10 +120920,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CalcProductOrOperator] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CalcValueOrOperator] {
     #[doc = "Calls [VisitAll`::visit_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)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <CalcValueOrOperator as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118617,10 +120933,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CalcValueOrOperator] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelectorChildren] {
     #[doc = "Calls [VisitAll`::visit_complex_selector_childrens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_complex_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <ComplexSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
@@ -118629,10 +120947,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelectorChildren] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelector] {
     #[doc = "Calls [VisitAll`::visit_complex_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_complex_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ComplexSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118640,10 +120960,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComplexSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComponentValue] {
     #[doc = "Calls [VisitAll`::visit_component_values`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_component_values(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ComponentValue as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118651,10 +120973,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ComponentValue] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CompoundSelector] {
     #[doc = "Calls [VisitAll`::visit_compound_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_compound_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <CompoundSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118662,10 +120986,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CompoundSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ContainerQueryType] {
     #[doc = "Calls [VisitAll`::visit_container_query_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_container_query_types(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ContainerQueryType as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118673,10 +120999,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ContainerQueryType] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CustomIdent] {
     #[doc = "Calls [VisitAll`::visit_custom_idents`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_custom_idents(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <CustomIdent as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118685,10 +121013,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [CustomIdent] {
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [DocumentPreludeMatchingFunction] {
     #[doc = "Calls [VisitAll`::visit_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)
@@ -118697,10 +121027,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [DocumentPreludeMatchingFunction]
 }
 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)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <FamilyName as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118708,10 +121040,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [FamilyName] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingComplexSelector] {
     #[doc = "Calls [VisitAll`::visit_forgiving_complex_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_forgiving_complex_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <ForgivingComplexSelector as VisitAllWith<V>>::visit_with(item, visitor)
@@ -118720,10 +121054,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingComplexSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingRelativeSelector] {
     #[doc = "Calls [VisitAll`::visit_forgiving_relative_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_forgiving_relative_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <ForgivingRelativeSelector as VisitAllWith<V>>::visit_with(item, visitor)
@@ -118732,10 +121068,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ForgivingRelativeSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Ident] {
     #[doc = "Calls [VisitAll`::visit_idents`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_idents(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Ident as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118743,10 +121081,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Ident] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [KeyframeSelector] {
     #[doc = "Calls [VisitAll`::visit_keyframe_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_keyframe_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <KeyframeSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118754,10 +121094,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [KeyframeSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [LayerName] {
     #[doc = "Calls [VisitAll`::visit_layer_names`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_layer_names(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <LayerName as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118765,10 +121107,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [LayerName] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionAllType] {
     #[doc = "Calls [VisitAll`::visit_media_condition_all_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_media_condition_all_types(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <MediaConditionAllType as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118776,10 +121120,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionAllType] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionWithoutOrType] {
     #[doc = "Calls [VisitAll`::visit_media_condition_without_or_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_media_condition_without_or_types(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <MediaConditionWithoutOrType as VisitAllWith<V>>::visit_with(item, visitor)
@@ -118788,10 +121134,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaConditionWithoutOrType] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaQuery] {
     #[doc = "Calls [VisitAll`::visit_media_querys`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_media_querys(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <MediaQuery as VisitAllWith<V>>::visit_with(item, visitor))
@@ -118799,10 +121147,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [MediaQuery] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<AtRulePrelude>> {
     #[doc = "Calls [VisitAll`::visit_opt_at_rule_prelude`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_at_rule_prelude(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<AtRulePrelude> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118812,10 +121162,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<AtRulePrelude>> {
 }
 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),
@@ -118825,10 +121177,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorMatcher> {
     #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_matcher`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_attribute_selector_matcher(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -118840,10 +121194,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorMatcher>
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorModifier> {
     #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_modifier`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_attribute_selector_modifier(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -118855,10 +121211,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorModifier>
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorValue> {
     #[doc = "Calls [VisitAll`::visit_opt_attribute_selector_value`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_attribute_selector_value(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <AttributeSelectorValue as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118868,10 +121226,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<AttributeSelectorValue> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Combinator> {
     #[doc = "Calls [VisitAll`::visit_opt_combinator`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_combinator(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Combinator as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118881,10 +121241,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Combinator> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ContainerName> {
     #[doc = "Calls [VisitAll`::visit_opt_container_name`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_container_name(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <ContainerName as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118894,10 +121256,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ContainerName> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ForgivingSelectorList> {
     #[doc = "Calls [VisitAll`::visit_opt_forgiving_selector_list`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_forgiving_selector_list(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <ForgivingSelectorList as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118907,10 +121271,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ForgivingSelectorList> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Function>> {
     #[doc = "Calls [VisitAll`::visit_opt_function`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_function(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Function> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118920,10 +121286,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Function>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
     #[doc = "Calls [VisitAll`::visit_opt_ident`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Ident as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118933,10 +121301,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportConditions>> {
     #[doc = "Calls [VisitAll`::visit_opt_import_conditions`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_import_conditions(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<ImportConditions> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118946,10 +121316,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportConditions>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportLayerName>> {
     #[doc = "Calls [VisitAll`::visit_opt_import_layer_name`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_import_layer_name(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<ImportLayerName> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118959,10 +121331,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ImportLayerName>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ImportantFlag> {
     #[doc = "Calls [VisitAll`::visit_opt_important_flag`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_important_flag(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <ImportantFlag as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118972,10 +121346,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ImportantFlag> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaConditionType>> {
     #[doc = "Calls [VisitAll`::visit_opt_media_condition_type`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_media_condition_type(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<MediaConditionType> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118985,10 +121361,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaConditionType>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaQueryList>> {
     #[doc = "Calls [VisitAll`::visit_opt_media_query_list`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_media_query_list(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<MediaQueryList> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -118998,10 +121376,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<MediaQueryList>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<MediaType> {
     #[doc = "Calls [VisitAll`::visit_opt_media_type`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_media_type(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <MediaType as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119011,10 +121391,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<MediaType> {
 }
 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),
@@ -119024,10 +121406,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NamespacePrefix> {
     #[doc = "Calls [VisitAll`::visit_opt_namespace_prefix`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_namespace_prefix(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <NamespacePrefix as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119037,10 +121421,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NamespacePrefix> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NestingSelector> {
     #[doc = "Calls [VisitAll`::visit_opt_nesting_selector`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_nesting_selector(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <NestingSelector as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119050,10 +121436,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<NestingSelector> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Number> {
     #[doc = "Calls [VisitAll`::visit_opt_number`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_number(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Number as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119063,10 +121451,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Number> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PageSelectorPseudo>> {
     #[doc = "Calls [VisitAll`::visit_opt_page_selector_pseudos`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_page_selector_pseudos(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<PageSelectorPseudo> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119076,10 +121466,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PageSelectorPseudo>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<PageSelectorType> {
     #[doc = "Calls [VisitAll`::visit_opt_page_selector_type`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_page_selector_type(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <PageSelectorType as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119090,10 +121482,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<PageSelectorType> {
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoClassSelectorChildren>> {
     #[doc = "Calls [VisitAll`::visit_opt_pseudo_class_selector_childrens`] with `self`. (Extra \
              impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -119106,10 +121500,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoClassSelectorChi
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoElementSelectorChildren>> {
     #[doc = "Calls [VisitAll`::visit_opt_pseudo_element_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)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -119121,10 +121517,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<PseudoElementSelectorC
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<SimpleBlock> {
     #[doc = "Calls [VisitAll`::visit_opt_simple_block`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_simple_block(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <SimpleBlock as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119134,10 +121532,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<SimpleBlock> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TypeSelector>> {
     #[doc = "Calls [VisitAll`::visit_opt_type_selector`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_type_selector(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TypeSelector> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119147,10 +121547,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TypeSelector>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<UrlModifier>> {
     #[doc = "Calls [VisitAll`::visit_opt_url_modifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_url_modifiers(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<UrlModifier> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119160,10 +121562,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<UrlModifier>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<UrlValue>> {
     #[doc = "Calls [VisitAll`::visit_opt_url_value`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_url_value(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<UrlValue> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -119173,10 +121577,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<UrlValue>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelectorPseudo] {
     #[doc = "Calls [VisitAll`::visit_page_selector_pseudos`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_page_selector_pseudos(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <PageSelectorPseudo as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119184,10 +121590,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelectorPseudo] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelector] {
     #[doc = "Calls [VisitAll`::visit_page_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_page_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <PageSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119195,10 +121603,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PageSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoClassSelectorChildren] {
     #[doc = "Calls [VisitAll`::visit_pseudo_class_selector_childrens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_pseudo_class_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <PseudoClassSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
@@ -119207,10 +121617,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoClassSelectorChildren] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoElementSelectorChildren] {
     #[doc = "Calls [VisitAll`::visit_pseudo_element_selector_childrens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_pseudo_element_selector_childrens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter().for_each(|item| {
             <PseudoElementSelectorChildren as VisitAllWith<V>>::visit_with(item, visitor)
@@ -119219,10 +121631,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PseudoElementSelectorChildren] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [RelativeSelector] {
     #[doc = "Calls [VisitAll`::visit_relative_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_relative_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <RelativeSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119230,10 +121644,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [RelativeSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Rule] {
     #[doc = "Calls [VisitAll`::visit_rules`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_rules(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Rule as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119241,20 +121657,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Rule] {
 }
 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: ?Sized + VisitAll> VisitAllWith<V> for [SubclassSelector] {
     #[doc = "Calls [VisitAll`::visit_subclass_selectors`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_subclass_selectors(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <SubclassSelector as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119262,10 +121682,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SubclassSelector] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SupportsConditionType] {
     #[doc = "Calls [VisitAll`::visit_supports_condition_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_supports_condition_types(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <SupportsConditionType as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119273,10 +121695,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SupportsConditionType] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [UrlModifier] {
     #[doc = "Calls [VisitAll`::visit_url_modifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_url_modifiers(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <UrlModifier as VisitAllWith<V>>::visit_with(item, visitor))
@@ -119287,11 +121711,13 @@ 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
@@ -119302,11 +121728,13 @@ 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
diff --git a/crates/swc_ecma_visit/src/generated.rs b/crates/swc_ecma_visit/src/generated.rs
index 0f1d84403a50..9667015ec479 100644
--- a/crates/swc_ecma_visit/src/generated.rs
+++ b/crates/swc_ecma_visit/src/generated.rs
@@ -8,912 +8,1067 @@ pub trait Visit {
     #[doc = "Visit a node of type `Accessibility`.\n\nBy default, this method calls \
              [`Accessibility::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_accessibility(&mut self, node: &Accessibility) {
         <Accessibility as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayLit`.\n\nBy default, this method calls \
              [`ArrayLit::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_array_lit(&mut self, node: &ArrayLit) {
         <ArrayLit as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrayPat`.\n\nBy default, this method calls \
              [`ArrayPat::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_array_pat(&mut self, node: &ArrayPat) {
         <ArrayPat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ArrowExpr`.\n\nBy default, this method calls \
              [`ArrowExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
         <ArrowExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignExpr`.\n\nBy default, this method calls \
              [`AssignExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_expr(&mut self, node: &AssignExpr) {
         <AssignExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignOp`.\n\nBy default, this method calls \
              [`AssignOp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_op(&mut self, node: &AssignOp) {
         <AssignOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPat`.\n\nBy default, this method calls \
              [`AssignPat::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_pat(&mut self, node: &AssignPat) {
         <AssignPat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignPatProp`.\n\nBy default, this method calls \
              [`AssignPatProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
         <AssignPatProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignProp`.\n\nBy default, this method calls \
              [`AssignProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_prop(&mut self, node: &AssignProp) {
         <AssignProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTarget`.\n\nBy default, this method calls \
              [`AssignTarget::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_target(&mut self, node: &AssignTarget) {
         <AssignTarget as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AssignTargetPat`.\n\nBy default, this method calls \
              [`AssignTargetPat::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
         <AssignTargetPat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
              [`swc_atoms :: Atom::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AutoAccessor`.\n\nBy default, this method calls \
              [`AutoAccessor::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
         <AutoAccessor as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AwaitExpr`.\n\nBy default, this method calls \
              [`AwaitExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_await_expr(&mut self, node: &AwaitExpr) {
         <AwaitExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigInt`.\n\nBy default, this method calls \
              [`BigInt::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_big_int(&mut self, node: &BigInt) {
         <BigInt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BigIntValue`.\n\nBy default, this method calls \
              [`BigIntValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_big_int_value(&mut self, node: &BigIntValue) {
         <BigIntValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinExpr`.\n\nBy default, this method calls \
              [`BinExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_bin_expr(&mut self, node: &BinExpr) {
         <BinExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BinaryOp`.\n\nBy default, this method calls \
              [`BinaryOp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_binary_op(&mut self, node: &BinaryOp) {
         <BinaryOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BindingIdent`.\n\nBy default, this method calls \
              [`BindingIdent::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_binding_ident(&mut self, node: &BindingIdent) {
         <BindingIdent as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmt`.\n\nBy default, this method calls \
              [`BlockStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_block_stmt(&mut self, node: &BlockStmt) {
         <BlockStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BlockStmtOrExpr`.\n\nBy default, this method calls \
              [`BlockStmtOrExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
         <BlockStmtOrExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Bool`.\n\nBy default, this method calls \
              [`Bool::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_bool(&mut self, node: &Bool) {
         <Bool as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `BreakStmt`.\n\nBy default, this method calls \
              [`BreakStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_break_stmt(&mut self, node: &BreakStmt) {
         <BreakStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CallExpr`.\n\nBy default, this method calls \
              [`CallExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_call_expr(&mut self, node: &CallExpr) {
         <CallExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Callee`.\n\nBy default, this method calls \
              [`Callee::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_callee(&mut self, node: &Callee) {
         <Callee as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CatchClause`.\n\nBy default, this method calls \
              [`CatchClause::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_catch_clause(&mut self, node: &CatchClause) {
         <CatchClause as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Class`.\n\nBy default, this method calls \
              [`Class::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_class(&mut self, node: &Class) {
         <Class as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassDecl`.\n\nBy default, this method calls \
              [`ClassDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_decl(&mut self, node: &ClassDecl) {
         <ClassDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassExpr`.\n\nBy default, this method calls \
              [`ClassExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_expr(&mut self, node: &ClassExpr) {
         <ClassExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMember`.\n\nBy default, this method calls \
              [`ClassMember::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_member(&mut self, node: &ClassMember) {
         <ClassMember as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ClassMember >`.\n\nBy default, this method calls [`Vec < \
              ClassMember >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_members(&mut self, node: &[ClassMember]) {
         <[ClassMember] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassMethod`.\n\nBy default, this method calls \
              [`ClassMethod::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_method(&mut self, node: &ClassMethod) {
         <ClassMethod as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ClassProp`.\n\nBy default, this method calls \
              [`ClassProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_class_prop(&mut self, node: &ClassProp) {
         <ClassProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ComputedPropName`.\n\nBy default, this method calls \
              [`ComputedPropName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
         <ComputedPropName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CondExpr`.\n\nBy default, this method calls \
              [`CondExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_cond_expr(&mut self, node: &CondExpr) {
         <CondExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Constructor`.\n\nBy default, this method calls \
              [`Constructor::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_constructor(&mut self, node: &Constructor) {
         <Constructor as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ContinueStmt`.\n\nBy default, this method calls \
              [`ContinueStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
         <ContinueStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DebuggerStmt`.\n\nBy default, this method calls \
              [`DebuggerStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
         <DebuggerStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decl`.\n\nBy default, this method calls \
              [`Decl::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_decl(&mut self, node: &Decl) {
         <Decl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Decorator`.\n\nBy default, this method calls \
              [`Decorator::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_decorator(&mut self, node: &Decorator) {
         <Decorator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Decorator >`.\n\nBy default, this method calls [`Vec < \
              Decorator >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_decorators(&mut self, node: &[Decorator]) {
         <[Decorator] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DefaultDecl`.\n\nBy default, this method calls \
              [`DefaultDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_default_decl(&mut self, node: &DefaultDecl) {
         <DefaultDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DoWhileStmt`.\n\nBy default, this method calls \
              [`DoWhileStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
         <DoWhileStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `EmptyStmt`.\n\nBy default, this method calls \
              [`EmptyStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
         <EmptyStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `EsVersion`.\n\nBy default, this method calls \
              [`EsVersion::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_es_version(&mut self, node: &EsVersion) {
         <EsVersion as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportAll`.\n\nBy default, this method calls \
              [`ExportAll::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_export_all(&mut self, node: &ExportAll) {
         <ExportAll as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDecl`.\n\nBy default, this method calls \
              [`ExportDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_export_decl(&mut self, node: &ExportDecl) {
         <ExportDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultDecl`.\n\nBy default, this method calls \
              [`ExportDefaultDecl::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
         <ExportDefaultDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultExpr`.\n\nBy default, this method calls \
              [`ExportDefaultExpr::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
         <ExportDefaultExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportDefaultSpecifier`.\n\nBy default, this method calls \
              [`ExportDefaultSpecifier::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
         <ExportDefaultSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamedSpecifier`.\n\nBy default, this method calls \
              [`ExportNamedSpecifier::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
         <ExportNamedSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportNamespaceSpecifier`.\n\nBy default, this method calls \
              [`ExportNamespaceSpecifier::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
         <ExportNamespaceSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExportSpecifier`.\n\nBy default, this method calls \
              [`ExportSpecifier::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
         <ExportSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExportSpecifier >`.\n\nBy default, this method calls \
              [`Vec < ExportSpecifier >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
         <[ExportSpecifier] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Expr`.\n\nBy default, this method calls \
              [`Expr::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_expr(&mut self, node: &Expr) {
         <Expr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprOrSpread`.\n\nBy default, this method calls \
              [`ExprOrSpread::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
         <ExprOrSpread as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ExprOrSpread >`.\n\nBy default, this method calls [`Vec < \
              ExprOrSpread >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
         <[ExprOrSpread] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ExprStmt`.\n\nBy default, this method calls \
              [`ExprStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_expr_stmt(&mut self, node: &ExprStmt) {
         <ExprStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < Expr > >`.\n\nBy default, this method calls [`Vec < \
              Box < Expr > >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_exprs(&mut self, node: &[Box<Expr>]) {
         <[Box<Expr>] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnDecl`.\n\nBy default, this method calls \
              [`FnDecl::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_fn_decl(&mut self, node: &FnDecl) {
         <FnDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `FnExpr`.\n\nBy default, this method calls \
              [`FnExpr::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_fn_expr(&mut self, node: &FnExpr) {
         <FnExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForHead`.\n\nBy default, this method calls \
              [`ForHead::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_for_head(&mut self, node: &ForHead) {
         <ForHead as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForInStmt`.\n\nBy default, this method calls \
              [`ForInStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
         <ForInStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForOfStmt`.\n\nBy default, this method calls \
              [`ForOfStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
         <ForOfStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ForStmt`.\n\nBy default, this method calls \
              [`ForStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_for_stmt(&mut self, node: &ForStmt) {
         <ForStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Function`.\n\nBy default, this method calls \
              [`Function::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_function(&mut self, node: &Function) {
         <Function as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `GetterProp`.\n\nBy default, this method calls \
              [`GetterProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_getter_prop(&mut self, node: &GetterProp) {
         <GetterProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Ident`.\n\nBy default, this method calls \
              [`Ident::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_ident(&mut self, node: &Ident) {
         <Ident as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `IdentName`.\n\nBy default, this method calls \
              [`IdentName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ident_name(&mut self, node: &IdentName) {
         <IdentName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `IfStmt`.\n\nBy default, this method calls \
              [`IfStmt::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_if_stmt(&mut self, node: &IfStmt) {
         <IfStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Import`.\n\nBy default, this method calls \
              [`Import::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_import(&mut self, node: &Import) {
         <Import as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDecl`.\n\nBy default, this method calls \
              [`ImportDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_decl(&mut self, node: &ImportDecl) {
         <ImportDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportDefaultSpecifier`.\n\nBy default, this method calls \
              [`ImportDefaultSpecifier::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
         <ImportDefaultSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportNamedSpecifier`.\n\nBy default, this method calls \
              [`ImportNamedSpecifier::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
         <ImportNamedSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportPhase`.\n\nBy default, this method calls \
              [`ImportPhase::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_phase(&mut self, node: &ImportPhase) {
         <ImportPhase as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportSpecifier`.\n\nBy default, this method calls \
              [`ImportSpecifier::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
         <ImportSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportSpecifier >`.\n\nBy default, this method calls \
              [`Vec < ImportSpecifier >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
         <[ImportSpecifier] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportStarAsSpecifier`.\n\nBy default, this method calls \
              [`ImportStarAsSpecifier::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
         <ImportStarAsSpecifier as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportWith`.\n\nBy default, this method calls \
              [`ImportWith::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_with(&mut self, node: &ImportWith) {
         <ImportWith as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ImportWithItem`.\n\nBy default, this method calls \
              [`ImportWithItem::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_import_with_item(&mut self, node: &ImportWithItem) {
         <ImportWithItem as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ImportWithItem >`.\n\nBy default, this method calls [`Vec \
              < ImportWithItem >::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
         <[ImportWithItem] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Invalid`.\n\nBy default, this method calls \
              [`Invalid::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_invalid(&mut self, node: &Invalid) {
         <Invalid as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttr`.\n\nBy default, this method calls \
              [`JSXAttr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_attr(&mut self, node: &JSXAttr) {
         <JSXAttr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrName`.\n\nBy default, this method calls \
              [`JSXAttrName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
         <JSXAttrName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrOrSpread`.\n\nBy default, this method calls \
              [`JSXAttrOrSpread::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
         <JSXAttrOrSpread as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXAttrOrSpread >`.\n\nBy default, this method calls \
              [`Vec < JSXAttrOrSpread >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
         <[JSXAttrOrSpread] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXAttrValue`.\n\nBy default, this method calls \
              [`JSXAttrValue::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
         <JSXAttrValue as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingElement`.\n\nBy default, this method calls \
              [`JSXClosingElement::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
         <JSXClosingElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXClosingFragment`.\n\nBy default, this method calls \
              [`JSXClosingFragment::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
         <JSXClosingFragment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElement`.\n\nBy default, this method calls \
              [`JSXElement::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_element(&mut self, node: &JSXElement) {
         <JSXElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementChild`.\n\nBy default, this method calls \
              [`JSXElementChild::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
         <JSXElementChild as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < JSXElementChild >`.\n\nBy default, this method calls \
              [`Vec < JSXElementChild >::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
         <[JSXElementChild] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXElementName`.\n\nBy default, this method calls \
              [`JSXElementName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
         <JSXElementName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXEmptyExpr`.\n\nBy default, this method calls \
              [`JSXEmptyExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
         <JSXEmptyExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExpr`.\n\nBy default, this method calls \
              [`JSXExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_expr(&mut self, node: &JSXExpr) {
         <JSXExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXExprContainer`.\n\nBy default, this method calls \
              [`JSXExprContainer::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
         <JSXExprContainer as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXFragment`.\n\nBy default, this method calls \
              [`JSXFragment::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
         <JSXFragment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXMemberExpr`.\n\nBy default, this method calls \
              [`JSXMemberExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
         <JSXMemberExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXNamespacedName`.\n\nBy default, this method calls \
              [`JSXNamespacedName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
         <JSXNamespacedName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXObject`.\n\nBy default, this method calls \
              [`JSXObject::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_object(&mut self, node: &JSXObject) {
         <JSXObject as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningElement`.\n\nBy default, this method calls \
              [`JSXOpeningElement::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
         <JSXOpeningElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXOpeningFragment`.\n\nBy default, this method calls \
              [`JSXOpeningFragment::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
         <JSXOpeningFragment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXSpreadChild`.\n\nBy default, this method calls \
              [`JSXSpreadChild::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
         <JSXSpreadChild as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `JSXText`.\n\nBy default, this method calls \
              [`JSXText::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_jsx_text(&mut self, node: &JSXText) {
         <JSXText as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Key`.\n\nBy default, this method calls \
              [`Key::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_key(&mut self, node: &Key) {
         <Key as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValuePatProp`.\n\nBy default, this method calls \
              [`KeyValuePatProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
         <KeyValuePatProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `KeyValueProp`.\n\nBy default, this method calls \
              [`KeyValueProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
         <KeyValueProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `LabeledStmt`.\n\nBy default, this method calls \
              [`LabeledStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
         <LabeledStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Lit`.\n\nBy default, this method calls \
              [`Lit::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_lit(&mut self, node: &Lit) {
         <Lit as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberExpr`.\n\nBy default, this method calls \
              [`MemberExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_member_expr(&mut self, node: &MemberExpr) {
         <MemberExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MemberProp`.\n\nBy default, this method calls \
              [`MemberProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_member_prop(&mut self, node: &MemberProp) {
         <MemberProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropExpr`.\n\nBy default, this method calls \
              [`MetaPropExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
         <MetaPropExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MetaPropKind`.\n\nBy default, this method calls \
              [`MetaPropKind::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
         <MetaPropKind as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodKind`.\n\nBy default, this method calls \
              [`MethodKind::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_method_kind(&mut self, node: &MethodKind) {
         <MethodKind as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `MethodProp`.\n\nBy default, this method calls \
              [`MethodProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_method_prop(&mut self, node: &MethodProp) {
         <MethodProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Module`.\n\nBy default, this method calls \
              [`Module::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_module(&mut self, node: &Module) {
         <Module as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleDecl`.\n\nBy default, this method calls \
              [`ModuleDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_module_decl(&mut self, node: &ModuleDecl) {
         <ModuleDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleExportName`.\n\nBy default, this method calls \
              [`ModuleExportName::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_module_export_name(&mut self, node: &ModuleExportName) {
         <ModuleExportName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ModuleItem`.\n\nBy default, this method calls \
              [`ModuleItem::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_module_item(&mut self, node: &ModuleItem) {
         <ModuleItem as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ModuleItem >`.\n\nBy default, this method calls [`Vec < \
              ModuleItem >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_module_items(&mut self, node: &[ModuleItem]) {
         <[ModuleItem] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NamedExport`.\n\nBy default, this method calls \
              [`NamedExport::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_named_export(&mut self, node: &NamedExport) {
         <NamedExport as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `NewExpr`.\n\nBy default, this method calls \
              [`NewExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_new_expr(&mut self, node: &NewExpr) {
         <NewExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Null`.\n\nBy default, this method calls \
              [`Null::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_null(&mut self, node: &Null) {
         <Null as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Number`.\n\nBy default, this method calls \
              [`Number::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_number(&mut self, node: &Number) {
         <Number as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectLit`.\n\nBy default, this method calls \
              [`ObjectLit::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_object_lit(&mut self, node: &ObjectLit) {
         <ObjectLit as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPat`.\n\nBy default, this method calls \
              [`ObjectPat::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_object_pat(&mut self, node: &ObjectPat) {
         <ObjectPat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ObjectPatProp`.\n\nBy default, this method calls \
              [`ObjectPatProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
         <ObjectPatProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ObjectPatProp >`.\n\nBy default, this method calls [`Vec \
              < ObjectPatProp >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
         <[ObjectPatProp] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Accessibility >`.\n\nBy default, this method calls \
              [`Option < Accessibility >::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
         <Option<Accessibility> as VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < BlockStmt >`.\n\nBy default, this method calls \
              [`Option < BlockStmt >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptCall`.\n\nBy default, this method calls \
              [`OptCall::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_opt_call(&mut self, node: &OptCall) {
         <OptCall as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < CatchClause >`.\n\nBy default, this method calls \
              [`Option < CatchClause >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainBase`.\n\nBy default, this method calls \
              [`OptChainBase::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
         <OptChainBase as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `OptChainExpr`.\n\nBy default, this method calls \
              [`OptChainExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
         <OptChainExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Expr > >`.\n\nBy default, this method calls \
              [`Option < Box < Expr > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ExprOrSpread >`.\n\nBy default, this method calls \
              [`Option < ExprOrSpread >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < ExprOrSpread > >`.\n\nBy default, this method \
              calls [`Option < Vec < ExprOrSpread > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Ident >`.\n\nBy default, this method calls [`Option < \
              Ident >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_ident(&mut self, node: &Option<Ident>) {
         <Option<Ident> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < JSXAttrValue >`.\n\nBy default, this method calls \
              [`Option < JSXAttrValue >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < JSXClosingElement >`.\n\nBy default, this method calls \
              [`Option < JSXClosingElement >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < ModuleExportName >`.\n\nBy default, this method calls \
              [`Option < ModuleExportName >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::visit_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_opt_module_items(&mut self, node: &Option<Vec<ModuleItem>>) {
         <Option<Vec<ModuleItem>> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < ObjectLit > >`.\n\nBy default, this method calls \
              [`Option < Box < ObjectLit > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Pat >`.\n\nBy default, this method calls [`Option < \
              Pat >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_pat(&mut self, node: &Option<Pat>) {
         <Option<Pat> as VisitWith<Self>>::visit_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_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Stmt > >`.\n\nBy default, this method calls \
              [`Option < Box < Stmt > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < Str > >`.\n\nBy default, this method calls \
              [`Option < Box < Str > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TruePlusMinus >`.\n\nBy default, this method calls \
              [`Option < TruePlusMinus >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsEntityName >`.\n\nBy default, this method calls \
              [`Option < TsEntityName >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < TsNamespaceBody >`.\n\nBy default, this method calls \
              [`Option < TsNamespaceBody >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsType > >`.\n\nBy default, this method calls \
              [`Option < Box < TsType > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeAnn > >`.\n\nBy default, this method calls \
              [`Option < Box < TsTypeAnn > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamDecl > >`.\n\nBy default, this method \
              calls [`Option < Box < TsTypeParamDecl > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Option < Box < TsTypeParamInstantiation > >`.\n\nBy default, \
              this method calls [`Option < Box < TsTypeParamInstantiation > \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_ts_type_param_instantiation(
         &mut self,
         node: &Option<Box<TsTypeParamInstantiation>>,
@@ -923,820 +1078,959 @@ pub trait Visit {
     #[doc = "Visit a node of type `Option < VarDeclOrExpr >`.\n\nBy default, this method calls \
              [`Option < VarDeclOrExpr >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < ExprOrSpread > >`.\n\nBy default, this method \
              calls [`Vec < Option < ExprOrSpread > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Option < Pat > >`.\n\nBy default, this method calls [`Vec \
              < Option < Pat > >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Param`.\n\nBy default, this method calls \
              [`Param::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_param(&mut self, node: &Param) {
         <Param as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParamOrTsParamProp`.\n\nBy default, this method calls \
              [`ParamOrTsParamProp::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < ParamOrTsParamProp >`.\n\nBy default, this method calls \
              [`Vec < ParamOrTsParamProp >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Param >`.\n\nBy default, this method calls [`Vec < Param \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_params(&mut self, node: &[Param]) {
         <[Param] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ParenExpr`.\n\nBy default, this method calls \
              [`ParenExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_paren_expr(&mut self, node: &ParenExpr) {
         <ParenExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Pat`.\n\nBy default, this method calls \
              [`Pat::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_pat(&mut self, node: &Pat) {
         <Pat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Pat >`.\n\nBy default, this method calls [`Vec < Pat \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_pats(&mut self, node: &[Pat]) {
         <[Pat] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateMethod`.\n\nBy default, this method calls \
              [`PrivateMethod::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_private_method(&mut self, node: &PrivateMethod) {
         <PrivateMethod as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateName`.\n\nBy default, this method calls \
              [`PrivateName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_private_name(&mut self, node: &PrivateName) {
         <PrivateName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PrivateProp`.\n\nBy default, this method calls \
              [`PrivateProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_private_prop(&mut self, node: &PrivateProp) {
         <PrivateProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Program`.\n\nBy default, this method calls \
              [`Program::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_program(&mut self, node: &Program) {
         <Program as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Prop`.\n\nBy default, this method calls \
              [`Prop::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_prop(&mut self, node: &Prop) {
         <Prop as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropName`.\n\nBy default, this method calls \
              [`PropName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_prop_name(&mut self, node: &PropName) {
         <PropName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `PropOrSpread`.\n\nBy default, this method calls \
              [`PropOrSpread::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
         <PropOrSpread as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < PropOrSpread >`.\n\nBy default, this method calls [`Vec < \
              PropOrSpread >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
         <[PropOrSpread] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Regex`.\n\nBy default, this method calls \
              [`Regex::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_regex(&mut self, node: &Regex) {
         <Regex as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_reserved_unused(&mut self, node: &ReservedUnused) {
         <ReservedUnused as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `RestPat`.\n\nBy default, this method calls \
              [`RestPat::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_rest_pat(&mut self, node: &RestPat) {
         <RestPat as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ReturnStmt`.\n\nBy default, this method calls \
              [`ReturnStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_return_stmt(&mut self, node: &ReturnStmt) {
         <ReturnStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Script`.\n\nBy default, this method calls \
              [`Script::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_script(&mut self, node: &Script) {
         <Script as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SeqExpr`.\n\nBy default, this method calls \
              [`SeqExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_seq_expr(&mut self, node: &SeqExpr) {
         <SeqExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SetterProp`.\n\nBy default, this method calls \
              [`SetterProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_setter_prop(&mut self, node: &SetterProp) {
         <SetterProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SimpleAssignTarget`.\n\nBy default, this method calls \
              [`SimpleAssignTarget::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
         <SimpleAssignTarget as VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SpreadElement`.\n\nBy default, this method calls \
              [`SpreadElement::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_spread_element(&mut self, node: &SpreadElement) {
         <SpreadElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `StaticBlock`.\n\nBy default, this method calls \
              [`StaticBlock::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_static_block(&mut self, node: &StaticBlock) {
         <StaticBlock as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Stmt`.\n\nBy default, this method calls \
              [`Stmt::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_stmt(&mut self, node: &Stmt) {
         <Stmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Stmt >`.\n\nBy default, this method calls [`Vec < Stmt \
              >::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_stmts(&mut self, node: &[Stmt]) {
         <[Stmt] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Str`.\n\nBy default, this method calls \
              [`Str::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_str(&mut self, node: &Str) {
         <Str as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Super`.\n\nBy default, this method calls \
              [`Super::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_super(&mut self, node: &Super) {
         <Super as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperProp`.\n\nBy default, this method calls \
              [`SuperProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_super_prop(&mut self, node: &SuperProp) {
         <SuperProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SuperPropExpr`.\n\nBy default, this method calls \
              [`SuperPropExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
         <SuperPropExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchCase`.\n\nBy default, this method calls \
              [`SwitchCase::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_switch_case(&mut self, node: &SwitchCase) {
         <SwitchCase as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < SwitchCase >`.\n\nBy default, this method calls [`Vec < \
              SwitchCase >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
         <[SwitchCase] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `SwitchStmt`.\n\nBy default, this method calls \
              [`SwitchStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
         <SwitchStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `swc_common :: SyntaxContext`.\n\nBy default, this method calls \
              [`swc_common :: SyntaxContext::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TaggedTpl`.\n\nBy default, this method calls \
              [`TaggedTpl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
         <TaggedTpl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThisExpr`.\n\nBy default, this method calls \
              [`ThisExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_this_expr(&mut self, node: &ThisExpr) {
         <ThisExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ThrowStmt`.\n\nBy default, this method calls \
              [`ThrowStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
         <ThrowStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Tpl`.\n\nBy default, this method calls \
              [`Tpl::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_tpl(&mut self, node: &Tpl) {
         <Tpl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TplElement`.\n\nBy default, this method calls \
              [`TplElement::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_tpl_element(&mut self, node: &TplElement) {
         <TplElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TplElement >`.\n\nBy default, this method calls [`Vec < \
              TplElement >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_tpl_elements(&mut self, node: &[TplElement]) {
         <[TplElement] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TruePlusMinus`.\n\nBy default, this method calls \
              [`TruePlusMinus::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
         <TruePlusMinus as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TryStmt`.\n\nBy default, this method calls \
              [`TryStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_try_stmt(&mut self, node: &TryStmt) {
         <TryStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsArrayType`.\n\nBy default, this method calls \
              [`TsArrayType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_array_type(&mut self, node: &TsArrayType) {
         <TsArrayType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsAsExpr`.\n\nBy default, this method calls \
              [`TsAsExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
         <TsAsExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsCallSignatureDecl`.\n\nBy default, this method calls \
              [`TsCallSignatureDecl::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
         <TsCallSignatureDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConditionalType`.\n\nBy default, this method calls \
              [`TsConditionalType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
         <TsConditionalType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstAssertion`.\n\nBy default, this method calls \
              [`TsConstAssertion::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
         <TsConstAssertion as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructSignatureDecl`.\n\nBy default, this method calls \
              [`TsConstructSignatureDecl::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
         <TsConstructSignatureDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsConstructorType`.\n\nBy default, this method calls \
              [`TsConstructorType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
         <TsConstructorType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEntityName`.\n\nBy default, this method calls \
              [`TsEntityName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
         <TsEntityName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumDecl`.\n\nBy default, this method calls \
              [`TsEnumDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
         <TsEnumDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMember`.\n\nBy default, this method calls \
              [`TsEnumMember::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
         <TsEnumMember as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsEnumMemberId`.\n\nBy default, this method calls \
              [`TsEnumMemberId::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
         <TsEnumMemberId as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsEnumMember >`.\n\nBy default, this method calls [`Vec < \
              TsEnumMember >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
         <[TsEnumMember] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExportAssignment`.\n\nBy default, this method calls \
              [`TsExportAssignment::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
         <TsExportAssignment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExprWithTypeArgs`.\n\nBy default, this method calls \
              [`TsExprWithTypeArgs::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsExprWithTypeArgs >`.\n\nBy default, this method calls \
              [`Vec < TsExprWithTypeArgs >::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsExternalModuleRef`.\n\nBy default, this method calls \
              [`TsExternalModuleRef::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
         <TsExternalModuleRef as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnOrConstructorType`.\n\nBy default, this method calls \
              [`TsFnOrConstructorType::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnParam`.\n\nBy default, this method calls \
              [`TsFnParam::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
         <TsFnParam as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsFnParam >`.\n\nBy default, this method calls [`Vec < \
              TsFnParam >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
         <[TsFnParam] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsFnType`.\n\nBy default, this method calls \
              [`TsFnType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_fn_type(&mut self, node: &TsFnType) {
         <TsFnType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsGetterSignature`.\n\nBy default, this method calls \
              [`TsGetterSignature::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
         <TsGetterSignature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportEqualsDecl`.\n\nBy default, this method calls \
              [`TsImportEqualsDecl::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
         <TsImportEqualsDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsImportType`.\n\nBy default, this method calls \
              [`TsImportType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_import_type(&mut self, node: &TsImportType) {
         <TsImportType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexSignature`.\n\nBy default, this method calls \
              [`TsIndexSignature::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
         <TsIndexSignature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIndexedAccessType`.\n\nBy default, this method calls \
              [`TsIndexedAccessType::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
         <TsIndexedAccessType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInferType`.\n\nBy default, this method calls \
              [`TsInferType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_infer_type(&mut self, node: &TsInferType) {
         <TsInferType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInstantiation`.\n\nBy default, this method calls \
              [`TsInstantiation::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
         <TsInstantiation as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceBody`.\n\nBy default, this method calls \
              [`TsInterfaceBody::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
         <TsInterfaceBody as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsInterfaceDecl`.\n\nBy default, this method calls \
              [`TsInterfaceDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
         <TsInterfaceDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsIntersectionType`.\n\nBy default, this method calls \
              [`TsIntersectionType::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
         <TsIntersectionType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordType`.\n\nBy default, this method calls \
              [`TsKeywordType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
         <TsKeywordType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsKeywordTypeKind`.\n\nBy default, this method calls \
              [`TsKeywordTypeKind::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
         <TsKeywordTypeKind as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLit`.\n\nBy default, this method calls \
              [`TsLit::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_ts_lit(&mut self, node: &TsLit) {
         <TsLit as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsLitType`.\n\nBy default, this method calls \
              [`TsLitType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_lit_type(&mut self, node: &TsLitType) {
         <TsLitType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMappedType`.\n\nBy default, this method calls \
              [`TsMappedType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
         <TsMappedType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsMethodSignature`.\n\nBy default, this method calls \
              [`TsMethodSignature::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
         <TsMethodSignature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleBlock`.\n\nBy default, this method calls \
              [`TsModuleBlock::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
         <TsModuleBlock as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleDecl`.\n\nBy default, this method calls \
              [`TsModuleDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
         <TsModuleDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleName`.\n\nBy default, this method calls \
              [`TsModuleName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_module_name(&mut self, node: &TsModuleName) {
         <TsModuleName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsModuleRef`.\n\nBy default, this method calls \
              [`TsModuleRef::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
         <TsModuleRef as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceBody`.\n\nBy default, this method calls \
              [`TsNamespaceBody::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
         <TsNamespaceBody as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceDecl`.\n\nBy default, this method calls \
              [`TsNamespaceDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
         <TsNamespaceDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNamespaceExportDecl`.\n\nBy default, this method calls \
              [`TsNamespaceExportDecl::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
         <TsNamespaceExportDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsNonNullExpr`.\n\nBy default, this method calls \
              [`TsNonNullExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
         <TsNonNullExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsOptionalType`.\n\nBy default, this method calls \
              [`TsOptionalType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
         <TsOptionalType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamProp`.\n\nBy default, this method calls \
              [`TsParamProp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
         <TsParamProp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParamPropParam`.\n\nBy default, this method calls \
              [`TsParamPropParam::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
         <TsParamPropParam as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsParenthesizedType`.\n\nBy default, this method calls \
              [`TsParenthesizedType::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
         <TsParenthesizedType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsPropertySignature`.\n\nBy default, this method calls \
              [`TsPropertySignature::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
         <TsPropertySignature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsQualifiedName`.\n\nBy default, this method calls \
              [`TsQualifiedName::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
         <TsQualifiedName as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsRestType`.\n\nBy default, this method calls \
              [`TsRestType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_rest_type(&mut self, node: &TsRestType) {
         <TsRestType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSatisfiesExpr`.\n\nBy default, this method calls \
              [`TsSatisfiesExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
         <TsSatisfiesExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsSetterSignature`.\n\nBy default, this method calls \
              [`TsSetterSignature::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
         <TsSetterSignature as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisType`.\n\nBy default, this method calls \
              [`TsThisType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_this_type(&mut self, node: &TsThisType) {
         <TsThisType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsThisTypeOrIdent`.\n\nBy default, this method calls \
              [`TsThisTypeOrIdent::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTplLitType`.\n\nBy default, this method calls \
              [`TsTplLitType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
         <TsTplLitType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleElement`.\n\nBy default, this method calls \
              [`TsTupleElement::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
         <TsTupleElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTupleElement >`.\n\nBy default, this method calls [`Vec \
              < TsTupleElement >::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
         <[TsTupleElement] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTupleType`.\n\nBy default, this method calls \
              [`TsTupleType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
         <TsTupleType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsType`.\n\nBy default, this method calls \
              [`TsType::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_ts_type(&mut self, node: &TsType) {
         <TsType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAliasDecl`.\n\nBy default, this method calls \
              [`TsTypeAliasDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
         <TsTypeAliasDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAnn`.\n\nBy default, this method calls \
              [`TsTypeAnn::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
         <TsTypeAnn as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeAssertion`.\n\nBy default, this method calls \
              [`TsTypeAssertion::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
         <TsTypeAssertion as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeElement`.\n\nBy default, this method calls \
              [`TsTypeElement::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
         <TsTypeElement as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeElement >`.\n\nBy default, this method calls [`Vec \
              < TsTypeElement >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
         <[TsTypeElement] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeLit`.\n\nBy default, this method calls \
              [`TsTypeLit::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
         <TsTypeLit as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperator`.\n\nBy default, this method calls \
              [`TsTypeOperator::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
         <TsTypeOperator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeOperatorOp`.\n\nBy default, this method calls \
              [`TsTypeOperatorOp::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
         <TsTypeOperatorOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParam`.\n\nBy default, this method calls \
              [`TsTypeParam::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
         <TsTypeParam as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamDecl`.\n\nBy default, this method calls \
              [`TsTypeParamDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
         <TsTypeParamDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeParamInstantiation`.\n\nBy default, this method calls \
              [`TsTypeParamInstantiation::visit_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
         <TsTypeParamInstantiation as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < TsTypeParam >`.\n\nBy default, this method calls [`Vec < \
              TsTypeParam >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
         <[TsTypeParam] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypePredicate`.\n\nBy default, this method calls \
              [`TsTypePredicate::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
         <TsTypePredicate as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQuery`.\n\nBy default, this method calls \
              [`TsTypeQuery::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
         <TsTypeQuery as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeQueryExpr`.\n\nBy default, this method calls \
              [`TsTypeQueryExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
         <TsTypeQueryExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsTypeRef`.\n\nBy default, this method calls \
              [`TsTypeRef::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
         <TsTypeRef as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Box < TsType > >`.\n\nBy default, this method calls [`Vec \
              < Box < TsType > >::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
         <[Box<TsType>] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionOrIntersectionType`.\n\nBy default, this method calls \
              [`TsUnionOrIntersectionType::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TsUnionType`.\n\nBy default, this method calls \
              [`TsUnionType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_ts_union_type(&mut self, node: &TsUnionType) {
         <TsUnionType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryExpr`.\n\nBy default, this method calls \
              [`UnaryExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_unary_expr(&mut self, node: &UnaryExpr) {
         <UnaryExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UnaryOp`.\n\nBy default, this method calls \
              [`UnaryOp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_unary_op(&mut self, node: &UnaryOp) {
         <UnaryOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateExpr`.\n\nBy default, this method calls \
              [`UpdateExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_update_expr(&mut self, node: &UpdateExpr) {
         <UpdateExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UpdateOp`.\n\nBy default, this method calls \
              [`UpdateOp::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_update_op(&mut self, node: &UpdateOp) {
         <UpdateOp as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `UsingDecl`.\n\nBy default, this method calls \
              [`UsingDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_using_decl(&mut self, node: &UsingDecl) {
         <UsingDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDecl`.\n\nBy default, this method calls \
              [`VarDecl::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_var_decl(&mut self, node: &VarDecl) {
         <VarDecl as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclKind`.\n\nBy default, this method calls \
              [`VarDeclKind::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
         <VarDeclKind as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclOrExpr`.\n\nBy default, this method calls \
              [`VarDeclOrExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
         <VarDeclOrExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `VarDeclarator`.\n\nBy default, this method calls \
              [`VarDeclarator::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_var_declarator(&mut self, node: &VarDeclarator) {
         <VarDeclarator as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < VarDeclarator >`.\n\nBy default, this method calls [`Vec \
              < VarDeclarator >::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
         <[VarDeclarator] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `WhileStmt`.\n\nBy default, this method calls \
              [`WhileStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_while_stmt(&mut self, node: &WhileStmt) {
         <WhileStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `WithStmt`.\n\nBy default, this method calls \
              [`WithStmt::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_with_stmt(&mut self, node: &WithStmt) {
         <WithStmt as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `YieldExpr`.\n\nBy default, this method calls \
              [`YieldExpr::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_yield_expr(&mut self, node: &YieldExpr) {
         <YieldExpr as VisitWith<Self>>::visit_children_with(node, self)
     }
@@ -17022,30 +17316,36 @@ impl<V: ?Sized + Visit> VisitWith<V> for YieldExpr {
 }
 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))
@@ -17053,10 +17353,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ClassMember] {
 }
 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))
@@ -17064,10 +17366,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Decorator] {
 }
 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))
@@ -17075,10 +17379,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ExportSpecifier] {
 }
 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))
@@ -17086,10 +17392,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ExprOrSpread] {
 }
 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))
@@ -17097,10 +17405,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Box<Expr>] {
 }
 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))
@@ -17108,10 +17418,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ImportSpecifier] {
 }
 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))
@@ -17119,10 +17431,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ImportWithItem] {
 }
 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))
@@ -17130,10 +17444,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [JSXAttrOrSpread] {
 }
 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))
@@ -17141,10 +17457,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [JSXElementChild] {
 }
 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))
@@ -17152,10 +17470,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ModuleItem] {
 }
 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))
@@ -17163,10 +17483,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ObjectPatProp] {
 }
 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),
@@ -17176,10 +17498,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Accessibility> {
 }
 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),
@@ -17189,10 +17513,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
 }
 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),
@@ -17202,10 +17528,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<BlockStmt> {
 }
 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),
@@ -17215,10 +17543,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<CatchClause> {
 }
 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),
@@ -17228,10 +17558,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Expr>> {
 }
 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),
@@ -17241,10 +17573,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<ExprOrSpread> {
 }
 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),
@@ -17254,10 +17588,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<ExprOrSpread>> {
 }
 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),
@@ -17267,10 +17603,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Ident> {
 }
 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),
@@ -17280,10 +17618,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXAttrValue> {
 }
 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),
@@ -17293,10 +17633,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<JSXClosingElement> {
 }
 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),
@@ -17306,10 +17648,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<ModuleExportName> {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [Visit`::visit_opt_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_opt_module_items(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<ModuleItem> as VisitWith<V>>::visit_with(inner, visitor),
@@ -17319,10 +17663,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Vec<ModuleItem>> {
 }
 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),
@@ -17332,10 +17678,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<ObjectLit>> {
 }
 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),
@@ -17345,10 +17693,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Pat> {
 }
 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),
@@ -17358,10 +17708,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_common::Span> {
 }
 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),
@@ -17371,10 +17723,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Stmt>> {
 }
 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),
@@ -17384,10 +17738,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<Str>> {
 }
 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),
@@ -17397,10 +17753,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<TruePlusMinus> {
 }
 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),
@@ -17410,10 +17768,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<TsEntityName> {
 }
 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),
@@ -17423,10 +17783,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<TsNamespaceBody> {
 }
 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),
@@ -17436,10 +17798,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsType>> {
 }
 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),
@@ -17449,10 +17813,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeAnn>> {
 }
 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),
@@ -17462,10 +17828,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamDecl>> {
 }
 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) => {
@@ -17477,10 +17845,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Box<TsTypeParamInstantiation>> {
 }
 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),
@@ -17490,10 +17860,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<VarDeclOrExpr> {
 }
 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))
@@ -17501,10 +17873,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Option<ExprOrSpread>] {
 }
 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))
@@ -17512,10 +17886,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Option<Pat>] {
 }
 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))
@@ -17523,10 +17899,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [ParamOrTsParamProp] {
 }
 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))
@@ -17534,10 +17912,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Param] {
 }
 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))
@@ -17545,10 +17925,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Pat] {
 }
 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))
@@ -17556,20 +17938,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for [PropOrSpread] {
 }
 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))
@@ -17577,10 +17963,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Stmt] {
 }
 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))
@@ -17588,20 +17976,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for [SwitchCase] {
 }
 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))
@@ -17609,10 +18001,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TplElement] {
 }
 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))
@@ -17620,10 +18014,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsEnumMember] {
 }
 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))
@@ -17631,10 +18027,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsExprWithTypeArgs] {
 }
 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))
@@ -17642,10 +18040,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsFnParam] {
 }
 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))
@@ -17653,10 +18053,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsTupleElement] {
 }
 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))
@@ -17664,10 +18066,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeElement] {
 }
 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))
@@ -17675,10 +18079,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [TsTypeParam] {
 }
 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))
@@ -17686,10 +18092,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Box<TsType>] {
 }
 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))
@@ -17700,11 +18108,13 @@ 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
@@ -17715,11 +18125,13 @@ 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
@@ -17732,6 +18144,7 @@ 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,
@@ -17744,6 +18157,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17754,6 +18168,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17764,6 +18179,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17774,6 +18190,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17784,6 +18201,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17794,6 +18212,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17804,6 +18223,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17816,6 +18236,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17826,6 +18247,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17838,6 +18260,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17850,6 +18273,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17862,6 +18286,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17874,6 +18299,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17884,6 +18310,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17894,6 +18321,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17906,6 +18334,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17916,6 +18345,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17926,6 +18356,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17938,6 +18369,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17948,6 +18380,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17960,12 +18393,14 @@ pub trait VisitAstPath {
     #[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,
@@ -17976,6 +18411,7 @@ pub trait VisitAstPath {
     #[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,
@@ -17986,12 +18422,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18004,12 +18442,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18020,6 +18460,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18030,6 +18471,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18042,6 +18484,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18054,6 +18497,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18066,6 +18510,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18076,6 +18521,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18088,6 +18534,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18098,6 +18545,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18110,6 +18558,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18122,6 +18571,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18134,12 +18584,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18150,6 +18602,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18162,6 +18615,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18174,6 +18628,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18186,6 +18641,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18196,6 +18652,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18206,6 +18663,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18216,6 +18674,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18226,6 +18685,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18238,6 +18698,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18250,6 +18711,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18262,6 +18724,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18274,6 +18737,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18286,6 +18750,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18298,6 +18763,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18310,12 +18776,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18328,6 +18796,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18340,6 +18809,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18350,6 +18820,7 @@ pub trait VisitAstPath {
     #[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>],
@@ -18362,6 +18833,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18372,6 +18844,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18382,6 +18855,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18392,6 +18866,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18402,6 +18877,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18412,6 +18888,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18422,6 +18899,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18432,6 +18910,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18442,12 +18921,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18458,6 +18939,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18468,12 +18950,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18484,6 +18968,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18496,6 +18981,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18508,6 +18994,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18520,6 +19007,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18532,6 +19020,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18544,6 +19033,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18556,6 +19046,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18566,6 +19057,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18578,6 +19070,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18590,6 +19083,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18600,6 +19094,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18610,6 +19105,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18622,6 +19118,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18634,6 +19131,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18646,6 +19144,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18658,6 +19157,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18670,6 +19170,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18682,6 +19183,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18692,6 +19194,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18704,6 +19207,7 @@ pub trait VisitAstPath {
     #[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],
@@ -18716,6 +19220,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18728,6 +19233,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18740,6 +19246,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18750,6 +19257,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18762,6 +19270,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18774,6 +19283,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18786,6 +19296,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18798,6 +19309,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18808,6 +19320,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18820,6 +19333,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18832,6 +19346,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18844,6 +19359,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18854,12 +19370,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18872,6 +19390,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18884,6 +19403,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18896,12 +19416,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18912,6 +19434,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18922,6 +19445,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18934,6 +19458,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18946,6 +19471,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18956,6 +19482,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18966,12 +19493,14 @@ pub trait VisitAstPath {
     #[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,
@@ -18982,6 +19511,7 @@ pub trait VisitAstPath {
     #[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,
@@ -18994,6 +19524,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19004,6 +19535,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19016,6 +19548,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19028,6 +19561,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19038,18 +19572,21 @@ pub trait VisitAstPath {
     #[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,
@@ -19060,6 +19597,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19070,6 +19608,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19082,6 +19621,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19094,6 +19634,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19106,6 +19647,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19118,6 +19660,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19130,6 +19673,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19140,6 +19684,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19152,6 +19697,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19164,6 +19710,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19176,6 +19723,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19188,6 +19736,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19200,6 +19749,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19212,6 +19762,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19224,6 +19775,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19236,6 +19788,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19248,6 +19801,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19260,6 +19814,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_module_items<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Option<Vec<ModuleItem>>,
@@ -19272,6 +19827,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19284,6 +19840,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19296,6 +19853,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19308,6 +19866,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19320,6 +19879,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19332,6 +19892,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19344,6 +19905,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19356,6 +19918,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19368,6 +19931,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19380,6 +19944,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19392,6 +19957,7 @@ pub trait VisitAstPath {
     #[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>>,
@@ -19405,6 +19971,7 @@ pub trait VisitAstPath {
              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>>,
@@ -19415,6 +19982,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -19427,6 +19995,7 @@ pub trait VisitAstPath {
     #[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>],
@@ -19439,6 +20008,7 @@ pub trait VisitAstPath {
     #[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>],
@@ -19451,12 +20021,14 @@ pub trait VisitAstPath {
     #[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,
@@ -19469,6 +20041,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19481,6 +20054,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19491,6 +20065,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19501,18 +20076,21 @@ pub trait VisitAstPath {
     #[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,
@@ -19525,6 +20103,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19537,6 +20116,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19549,6 +20129,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19559,12 +20140,14 @@ pub trait VisitAstPath {
     #[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,
@@ -19575,6 +20158,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19587,6 +20171,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19599,12 +20184,14 @@ pub trait VisitAstPath {
     #[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 `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_reserved_unused<'ast: 'r, 'r>(
         &mut self,
         node: &'ast ReservedUnused,
@@ -19617,6 +20204,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19627,6 +20215,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19637,12 +20226,14 @@ pub trait VisitAstPath {
     #[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,
@@ -19653,6 +20244,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19663,6 +20255,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19675,6 +20268,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19687,6 +20281,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19699,6 +20294,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19711,30 +20307,35 @@ pub trait VisitAstPath {
     #[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,
@@ -19745,6 +20346,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19757,6 +20359,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19767,6 +20370,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19779,6 +20383,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19789,6 +20394,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19801,6 +20407,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19811,6 +20418,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19821,6 +20429,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19831,12 +20440,14 @@ pub trait VisitAstPath {
     #[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,
@@ -19847,6 +20458,7 @@ pub trait VisitAstPath {
     #[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],
@@ -19859,6 +20471,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19871,6 +20484,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19881,6 +20495,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19893,6 +20508,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19903,6 +20519,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19915,6 +20532,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19927,6 +20545,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19939,6 +20558,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19951,6 +20571,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19963,6 +20584,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19975,6 +20597,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19985,6 +20608,7 @@ pub trait VisitAstPath {
     #[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,
@@ -19997,6 +20621,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20009,6 +20634,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20021,6 +20647,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20033,6 +20660,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20045,6 +20673,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20057,6 +20686,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20069,6 +20699,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20081,6 +20712,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20091,6 +20723,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20103,6 +20736,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20113,6 +20747,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20125,6 +20760,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20137,6 +20773,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20149,6 +20786,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20161,6 +20799,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20173,6 +20812,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20185,6 +20825,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20197,6 +20838,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20209,6 +20851,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20221,6 +20864,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20233,6 +20877,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20245,6 +20890,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20257,12 +20903,14 @@ pub trait VisitAstPath {
     #[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,
@@ -20273,6 +20921,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20285,6 +20934,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20297,6 +20947,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20309,6 +20960,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20321,6 +20973,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20333,6 +20986,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20345,6 +20999,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20357,6 +21012,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20369,6 +21025,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20381,6 +21038,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20393,6 +21051,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20405,6 +21064,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20417,6 +21077,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20429,6 +21090,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20441,6 +21103,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20453,6 +21116,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20465,6 +21129,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20475,6 +21140,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20487,6 +21153,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20499,6 +21166,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20509,6 +21177,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20521,6 +21190,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20533,6 +21203,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20545,6 +21216,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20557,6 +21229,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20569,6 +21242,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20579,6 +21253,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20591,6 +21266,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20601,6 +21277,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20613,6 +21290,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20625,6 +21303,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20637,6 +21316,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20647,6 +21327,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20659,6 +21340,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20671,6 +21353,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20683,6 +21366,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20695,6 +21379,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20707,6 +21392,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20719,6 +21405,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20731,6 +21418,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20743,6 +21431,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20755,6 +21444,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20765,6 +21455,7 @@ pub trait VisitAstPath {
     #[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>],
@@ -20777,6 +21468,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20789,6 +21481,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20801,6 +21494,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20811,6 +21505,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20821,6 +21516,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20831,6 +21527,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20841,6 +21538,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20851,6 +21549,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20861,6 +21560,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20873,6 +21573,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20885,6 +21586,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20897,6 +21599,7 @@ pub trait VisitAstPath {
     #[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],
@@ -20909,6 +21612,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20919,6 +21623,7 @@ pub trait VisitAstPath {
     #[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,
@@ -20929,6 +21634,7 @@ pub trait VisitAstPath {
     #[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,
@@ -48151,6 +48857,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for YieldExpr {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48159,6 +48866,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
         <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48171,6 +48879,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48179,6 +48888,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigIntValue {
         <V as VisitAstPath>::visit_big_int_value(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48191,6 +48901,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for BigIntValue {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48199,6 +48910,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ClassMember] {
         <V as VisitAstPath>::visit_class_members(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48213,6 +48925,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ClassMember] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48221,6 +48934,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Decorator] {
         <V as VisitAstPath>::visit_decorators(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48235,6 +48949,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Decorator] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48243,6 +48958,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExportSpecifier] {
         <V as VisitAstPath>::visit_export_specifiers(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48257,6 +48973,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExportSpecifier] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48265,6 +48982,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExprOrSpread] {
         <V as VisitAstPath>::visit_expr_or_spreads(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48279,6 +48997,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ExprOrSpread] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48287,6 +49006,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<Expr>] {
         <V as VisitAstPath>::visit_exprs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48301,6 +49021,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<Expr>] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48309,6 +49030,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportSpecifier] {
         <V as VisitAstPath>::visit_import_specifiers(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48323,6 +49045,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportSpecifier] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48331,6 +49054,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportWithItem] {
         <V as VisitAstPath>::visit_import_with_items(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48345,6 +49069,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ImportWithItem] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48353,6 +49078,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXAttrOrSpread] {
         <V as VisitAstPath>::visit_jsx_attr_or_spreads(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48367,6 +49093,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXAttrOrSpread] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48375,6 +49102,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXElementChild] {
         <V as VisitAstPath>::visit_jsx_element_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48389,6 +49117,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [JSXElementChild] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48397,6 +49126,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ModuleItem] {
         <V as VisitAstPath>::visit_module_items(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48411,6 +49141,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ModuleItem] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48419,6 +49150,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ObjectPatProp] {
         <V as VisitAstPath>::visit_object_pat_props(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48433,6 +49165,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ObjectPatProp] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48441,6 +49174,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Accessibility> {
         <V as VisitAstPath>::visit_opt_accessibility(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48458,6 +49192,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Accessibility> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48466,6 +49201,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
         <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48483,6 +49219,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48491,6 +49228,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<BlockStmt> {
         <V as VisitAstPath>::visit_opt_block_stmt(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48508,6 +49246,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<BlockStmt> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48516,6 +49255,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<CatchClause> {
         <V as VisitAstPath>::visit_opt_catch_clause(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48533,6 +49273,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<CatchClause> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48541,6 +49282,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Expr>> {
         <V as VisitAstPath>::visit_opt_expr(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48558,6 +49300,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Expr>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48566,6 +49309,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ExprOrSpread> {
         <V as VisitAstPath>::visit_opt_expr_or_spread(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48583,6 +49327,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ExprOrSpread> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48591,6 +49336,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ExprOrSpread>>
         <V as VisitAstPath>::visit_opt_expr_or_spreads(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48608,6 +49354,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ExprOrSpread>>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48616,6 +49363,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
         <V as VisitAstPath>::visit_opt_ident(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48633,6 +49381,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Ident> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48641,6 +49390,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXAttrValue> {
         <V as VisitAstPath>::visit_opt_jsx_attr_value(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48658,6 +49408,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXAttrValue> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48666,6 +49417,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXClosingElement>
         <V as VisitAstPath>::visit_opt_jsx_closing_element(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48683,6 +49435,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<JSXClosingElement>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48691,6 +49444,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ModuleExportName>
         <V as VisitAstPath>::visit_opt_module_export_name(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48708,6 +49462,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<ModuleExportName>
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [VisitAstPath`::visit_opt_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48716,6 +49471,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ModuleItem>> {
         <V as VisitAstPath>::visit_opt_module_items(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48733,6 +49489,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Vec<ModuleItem>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48741,6 +49498,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ObjectLit>> {
         <V as VisitAstPath>::visit_opt_object_lit(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48758,6 +49516,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<ObjectLit>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48766,6 +49525,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Pat> {
         <V as VisitAstPath>::visit_opt_pat(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48783,6 +49543,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Pat> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48791,6 +49552,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_common::Span>
         <V as VisitAstPath>::visit_opt_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48808,6 +49570,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_common::Span>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48816,6 +49579,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Stmt>> {
         <V as VisitAstPath>::visit_opt_stmt(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48833,6 +49597,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Stmt>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48841,6 +49606,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Str>> {
         <V as VisitAstPath>::visit_opt_str(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48858,6 +49624,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<Str>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48866,6 +49633,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TruePlusMinus> {
         <V as VisitAstPath>::visit_opt_true_plus_minus(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48883,6 +49651,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TruePlusMinus> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48891,6 +49660,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsEntityName> {
         <V as VisitAstPath>::visit_opt_ts_entity_name(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48908,6 +49678,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsEntityName> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48916,6 +49687,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsNamespaceBody> {
         <V as VisitAstPath>::visit_opt_ts_namespace_body(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48933,6 +49705,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<TsNamespaceBody> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48941,6 +49714,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsType>> {
         <V as VisitAstPath>::visit_opt_ts_type(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48958,6 +49732,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsType>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48966,6 +49741,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeAnn>> {
         <V as VisitAstPath>::visit_opt_ts_type_ann(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48983,6 +49759,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeAnn>> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -48991,6 +49768,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamDec
         <V as VisitAstPath>::visit_opt_ts_type_param_decl(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49009,6 +49787,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamDec
 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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49017,6 +49796,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamIns
         <V as VisitAstPath>::visit_opt_ts_type_param_instantiation(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49036,6 +49816,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Box<TsTypeParamIns
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49044,6 +49825,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<VarDeclOrExpr> {
         <V as VisitAstPath>::visit_opt_var_decl_or_expr(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49061,6 +49843,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<VarDeclOrExpr> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49069,6 +49852,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<ExprOrSpread>] {
         <V as VisitAstPath>::visit_opt_vec_expr_or_spreads(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49085,6 +49869,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<ExprOrSpread>] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49093,6 +49878,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<Pat>] {
         <V as VisitAstPath>::visit_opt_vec_pats(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49107,6 +49893,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Option<Pat>] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49115,6 +49902,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ParamOrTsParamProp] {
         <V as VisitAstPath>::visit_param_or_ts_param_props(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49131,6 +49919,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [ParamOrTsParamProp] {
 #[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,
@@ -49139,6 +49928,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Param] {
         <V as VisitAstPath>::visit_params(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49153,6 +49943,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Param] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49161,6 +49952,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Pat] {
         <V as VisitAstPath>::visit_pats(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49175,6 +49967,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Pat] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49183,6 +49976,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PropOrSpread] {
         <V as VisitAstPath>::visit_prop_or_spreads(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49197,6 +49991,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [PropOrSpread] {
 #[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,
@@ -49205,6 +50000,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
         <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49217,6 +50013,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49225,6 +50022,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Stmt] {
         <V as VisitAstPath>::visit_stmts(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49239,6 +50037,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Stmt] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49247,6 +50046,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SwitchCase] {
         <V as VisitAstPath>::visit_switch_cases(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49261,6 +50061,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [SwitchCase] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49269,6 +50070,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::SyntaxContext
         <V as VisitAstPath>::visit_syntax_context(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49281,6 +50083,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::SyntaxContext
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49289,6 +50092,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TplElement] {
         <V as VisitAstPath>::visit_tpl_elements(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49303,6 +50107,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TplElement] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49311,6 +50116,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsEnumMember] {
         <V as VisitAstPath>::visit_ts_enum_members(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49325,6 +50131,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsEnumMember] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49333,6 +50140,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsExprWithTypeArgs] {
         <V as VisitAstPath>::visit_ts_expr_with_type_argss(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49349,6 +50157,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsExprWithTypeArgs] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49357,6 +50166,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsFnParam] {
         <V as VisitAstPath>::visit_ts_fn_params(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49371,6 +50181,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsFnParam] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49379,6 +50190,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTupleElement] {
         <V as VisitAstPath>::visit_ts_tuple_elements(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49393,6 +50205,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTupleElement] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49401,6 +50214,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeElement] {
         <V as VisitAstPath>::visit_ts_type_elements(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49415,6 +50229,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeElement] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49423,6 +50238,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeParam] {
         <V as VisitAstPath>::visit_ts_type_params(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49437,6 +50253,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [TsTypeParam] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49445,6 +50262,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<TsType>] {
         <V as VisitAstPath>::visit_ts_types(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49459,6 +50277,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Box<TsType>] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49467,6 +50286,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [VarDeclarator] {
         <V as VisitAstPath>::visit_var_declarators(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49484,6 +50304,7 @@ where
     V: ?Sized + VisitAstPath,
     T: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49493,6 +50314,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49510,6 +50332,7 @@ where
     V: ?Sized + VisitAstPath,
     [T]: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49519,6 +50342,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -49534,930 +50358,1085 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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 < 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::visit_mut_children_with`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_mut_opt_module_items(&mut self, node: &mut Option<Vec<ModuleItem>>) {
         <Option<Vec<ModuleItem>> 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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_type_param_instantiation(
         &mut self,
         node: &mut Option<Box<TsTypeParamInstantiation>>,
@@ -50469,831 +51448,970 @@ pub trait VisitMut {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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 `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_reserved_unused(&mut self, node: &mut ReservedUnused) {
         <ReservedUnused 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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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 \
              manually."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_yield_expr(&mut self, node: &mut YieldExpr) {
         <YieldExpr as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
@@ -65175,30 +66293,36 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for YieldExpr {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_big_int_value(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_class_members(visitor, self)
     }
 
+    #[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))
@@ -65206,10 +66330,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ClassMember> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Decorator> {
     #[doc = "Calls [VisitMut`::visit_mut_decorators`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_decorators(visitor, self)
     }
 
+    #[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))
@@ -65217,10 +66343,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Decorator> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_export_specifiers(visitor, self)
     }
 
+    #[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))
@@ -65228,10 +66356,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExportSpecifier> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_expr_or_spreads(visitor, self)
     }
 
+    #[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))
@@ -65239,10 +66369,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ExprOrSpread> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_exprs(visitor, self)
     }
 
+    #[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))
@@ -65250,10 +66382,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<Expr>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_import_specifiers(visitor, self)
     }
 
+    #[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))
@@ -65261,10 +66395,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportSpecifier> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_import_with_items(visitor, self)
     }
 
+    #[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))
@@ -65272,10 +66408,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ImportWithItem> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_jsx_attr_or_spreads(visitor, self)
     }
 
+    #[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))
@@ -65283,10 +66421,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXAttrOrSpread> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_jsx_element_childs(visitor, self)
     }
 
+    #[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))
@@ -65294,10 +66434,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<JSXElementChild> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_module_items(visitor, self)
     }
 
+    #[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))
@@ -65305,10 +66447,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ModuleItem> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_object_pat_props(visitor, self)
     }
 
+    #[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))
@@ -65316,10 +66460,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ObjectPatProp> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_accessibility(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Accessibility as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65329,10 +66475,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Accessibility> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65342,10 +66490,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_block_stmt(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <BlockStmt as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65355,10 +66505,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<BlockStmt> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_catch_clause(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <CatchClause as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65368,10 +66520,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<CatchClause> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_expr(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Expr> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65381,10 +66535,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Expr>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_expr_or_spread(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <ExprOrSpread as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65394,10 +66550,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ExprOrSpread> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_expr_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<ExprOrSpread> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65407,10 +66565,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<ExprOrSpread>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Ident as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65420,10 +66580,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Ident> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_jsx_attr_value(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <JSXAttrValue as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65433,10 +66595,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXAttrValue> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_jsx_closing_element(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <JSXClosingElement as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65446,10 +66610,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<JSXClosingElement> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_module_export_name(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <ModuleExportName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65459,10 +66625,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<ModuleExportName> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [VisitMut`::visit_mut_opt_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_module_items(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<ModuleItem> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65472,10 +66640,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Vec<ModuleItem>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_object_lit(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<ObjectLit> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65485,10 +66655,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<ObjectLit>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_pat(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Pat as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65498,10 +66670,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Pat> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_span(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_common::Span as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65511,10 +66685,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_common::Span> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_stmt(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Stmt> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65524,10 +66700,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Stmt>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_str(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Str> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65537,10 +66715,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<Str>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_true_plus_minus(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <TruePlusMinus as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65550,10 +66730,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TruePlusMinus> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_entity_name(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <TsEntityName as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65563,10 +66745,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsEntityName> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_namespace_body(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <TsNamespaceBody as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65576,10 +66760,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<TsNamespaceBody> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_type(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TsType> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65589,10 +66775,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsType>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_type_ann(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TsTypeAnn> as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65602,10 +66790,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeAnn>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_type_param_decl(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -65618,10 +66808,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamDecl>> {
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_ts_type_param_instantiation(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -65633,10 +66825,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Box<TsTypeParamInstantiati
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_var_decl_or_expr(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <VarDeclOrExpr as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -65646,10 +66840,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<VarDeclOrExpr> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_vec_expr_or_spreads(visitor, self)
     }
 
+    #[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)
@@ -65658,10 +66854,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<ExprOrSpread>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_vec_pats(visitor, self)
     }
 
+    #[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))
@@ -65669,10 +66867,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Option<Pat>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_param_or_ts_param_props(visitor, self)
     }
 
+    #[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))
@@ -65680,10 +66880,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<ParamOrTsParamProp> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Param> {
     #[doc = "Calls [VisitMut`::visit_mut_params`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_params(visitor, self)
     }
 
+    #[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))
@@ -65691,10 +66893,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Param> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Pat> {
     #[doc = "Calls [VisitMut`::visit_mut_pats`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_pats(visitor, self)
     }
 
+    #[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))
@@ -65702,10 +66906,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Pat> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_prop_or_spreads(visitor, self)
     }
 
+    #[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))
@@ -65713,20 +66919,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<PropOrSpread> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Stmt> {
     #[doc = "Calls [VisitMut`::visit_mut_stmts`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_stmts(visitor, self)
     }
 
+    #[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))
@@ -65734,10 +66944,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Stmt> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_switch_cases(visitor, self)
     }
 
+    #[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))
@@ -65745,20 +66957,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<SwitchCase> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_syntax_context(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_tpl_elements(visitor, self)
     }
 
+    #[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))
@@ -65766,10 +66982,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TplElement> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_enum_members(visitor, self)
     }
 
+    #[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))
@@ -65777,10 +66995,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsEnumMember> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_expr_with_type_argss(visitor, self)
     }
 
+    #[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))
@@ -65788,10 +67008,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsExprWithTypeArgs> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_fn_params(visitor, self)
     }
 
+    #[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))
@@ -65799,10 +67021,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsFnParam> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_tuple_elements(visitor, self)
     }
 
+    #[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))
@@ -65810,10 +67034,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTupleElement> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_type_elements(visitor, self)
     }
 
+    #[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))
@@ -65821,10 +67047,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeElement> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_type_params(visitor, self)
     }
 
+    #[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))
@@ -65832,10 +67060,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<TsTypeParam> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_ts_types(visitor, self)
     }
 
+    #[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))
@@ -65843,10 +67073,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Box<TsType>> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_var_declarators(visitor, self)
     }
 
+    #[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))
@@ -65857,11 +67089,13 @@ where
     V: ?Sized + VisitMut,
     T: VisitMutWith<V>,
 {
+    #[inline]
     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(&mut self, visitor: &mut V) {
         let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
@@ -65874,6 +67108,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65882,6 +67117,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65890,6 +67126,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65898,6 +67135,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65906,6 +67144,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65914,6 +67153,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65922,6 +67162,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65930,6 +67171,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_assign_pat_prop(
         &mut self,
         node: &mut AssignPatProp,
@@ -65942,6 +67184,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65950,6 +67193,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65958,6 +67202,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_assign_target_pat(
         &mut self,
         node: &mut AssignTargetPat,
@@ -65970,6 +67215,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65978,6 +67224,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65986,6 +67233,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -65994,6 +67242,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66002,6 +67251,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66010,6 +67260,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66018,6 +67269,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66026,6 +67278,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66034,6 +67287,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66042,6 +67296,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_block_stmt_or_expr(
         &mut self,
         node: &mut BlockStmtOrExpr,
@@ -66054,6 +67309,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66062,6 +67318,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66070,6 +67327,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66078,6 +67336,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66086,6 +67345,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66094,6 +67354,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66102,6 +67363,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66110,6 +67372,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66118,6 +67381,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66126,6 +67390,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_class_members(
         &mut self,
         node: &mut Vec<ClassMember>,
@@ -66138,6 +67403,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66146,6 +67412,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66154,6 +67421,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_computed_prop_name(
         &mut self,
         node: &mut ComputedPropName,
@@ -66166,6 +67434,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66174,6 +67443,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66182,6 +67452,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66190,6 +67461,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66198,6 +67470,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66206,6 +67479,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66214,6 +67488,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66222,6 +67497,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66230,6 +67506,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66238,6 +67515,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66246,6 +67524,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66254,6 +67533,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66262,6 +67542,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66270,6 +67551,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_default_decl(
         &mut self,
         node: &mut ExportDefaultDecl,
@@ -66282,6 +67564,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_default_expr(
         &mut self,
         node: &mut ExportDefaultExpr,
@@ -66294,6 +67577,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_default_specifier(
         &mut self,
         node: &mut ExportDefaultSpecifier,
@@ -66306,6 +67590,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_named_specifier(
         &mut self,
         node: &mut ExportNamedSpecifier,
@@ -66318,6 +67603,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_namespace_specifier(
         &mut self,
         node: &mut ExportNamespaceSpecifier,
@@ -66330,6 +67616,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_specifier(
         &mut self,
         node: &mut ExportSpecifier,
@@ -66342,6 +67629,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_export_specifiers(
         &mut self,
         node: &mut Vec<ExportSpecifier>,
@@ -66354,6 +67642,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66362,6 +67651,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66370,6 +67660,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_expr_or_spreads(
         &mut self,
         node: &mut Vec<ExprOrSpread>,
@@ -66382,6 +67673,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66390,6 +67682,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66398,6 +67691,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66406,6 +67700,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66414,6 +67709,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66422,6 +67718,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66430,6 +67727,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66438,6 +67736,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66446,6 +67745,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66454,6 +67754,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66462,6 +67763,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66470,6 +67772,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66478,6 +67781,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66486,6 +67790,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66494,6 +67799,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66502,6 +67808,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_default_specifier(
         &mut self,
         node: &mut ImportDefaultSpecifier,
@@ -66514,6 +67821,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_named_specifier(
         &mut self,
         node: &mut ImportNamedSpecifier,
@@ -66526,6 +67834,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66534,6 +67843,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_specifier(
         &mut self,
         node: &mut ImportSpecifier,
@@ -66546,6 +67856,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_specifiers(
         &mut self,
         node: &mut Vec<ImportSpecifier>,
@@ -66558,6 +67869,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_star_as_specifier(
         &mut self,
         node: &mut ImportStarAsSpecifier,
@@ -66570,6 +67882,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66578,6 +67891,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_with_item(
         &mut self,
         node: &mut ImportWithItem,
@@ -66590,6 +67904,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_import_with_items(
         &mut self,
         node: &mut Vec<ImportWithItem>,
@@ -66602,6 +67917,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66610,6 +67926,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66618,6 +67935,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66626,6 +67944,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_attr_or_spread(
         &mut self,
         node: &mut JSXAttrOrSpread,
@@ -66638,6 +67957,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_attr_or_spreads(
         &mut self,
         node: &mut Vec<JSXAttrOrSpread>,
@@ -66650,6 +67970,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66658,6 +67979,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_closing_element(
         &mut self,
         node: &mut JSXClosingElement,
@@ -66670,6 +67992,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_closing_fragment(
         &mut self,
         node: &mut JSXClosingFragment,
@@ -66682,6 +68005,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66690,6 +68014,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_element_child(
         &mut self,
         node: &mut JSXElementChild,
@@ -66702,6 +68027,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_element_childs(
         &mut self,
         node: &mut Vec<JSXElementChild>,
@@ -66714,6 +68040,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_element_name(
         &mut self,
         node: &mut JSXElementName,
@@ -66726,6 +68053,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66734,6 +68062,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66742,6 +68071,7 @@ pub trait VisitMutAstPath {
     #[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 visit_mut_jsx_expr_container(
         &mut self,
         node: &mut JSXExprContainer,
@@ -66754,6 +68084,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66762,6 +68093,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_member_expr(
         &mut self,
         node: &mut JSXMemberExpr,
@@ -66774,6 +68106,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_namespaced_name(
         &mut self,
         node: &mut JSXNamespacedName,
@@ -66786,6 +68119,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66794,6 +68128,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_opening_element(
         &mut self,
         node: &mut JSXOpeningElement,
@@ -66806,6 +68141,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_opening_fragment(
         &mut self,
         node: &mut JSXOpeningFragment,
@@ -66818,6 +68154,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_jsx_spread_child(
         &mut self,
         node: &mut JSXSpreadChild,
@@ -66830,6 +68167,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66838,12 +68176,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn visit_mut_key_value_pat_prop(
         &mut self,
         node: &mut KeyValuePatProp,
@@ -66856,6 +68196,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66864,6 +68205,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66872,12 +68214,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -66886,6 +68230,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66894,6 +68239,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66902,6 +68248,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66910,6 +68257,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66918,6 +68266,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66926,6 +68275,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66934,6 +68284,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66942,6 +68293,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_module_export_name(
         &mut self,
         node: &mut ModuleExportName,
@@ -66954,6 +68306,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66962,6 +68315,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66970,6 +68324,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66978,6 +68333,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66986,6 +68342,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -66994,6 +68351,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67002,6 +68360,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67010,6 +68369,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67018,6 +68378,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_object_pat_prop(
         &mut self,
         node: &mut ObjectPatProp,
@@ -67030,6 +68391,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_object_pat_props(
         &mut self,
         node: &mut Vec<ObjectPatProp>,
@@ -67042,6 +68404,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_accessibility(
         &mut self,
         node: &mut Option<Accessibility>,
@@ -67054,6 +68417,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_atom(
         &mut self,
         node: &mut Option<swc_atoms::Atom>,
@@ -67066,6 +68430,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_block_stmt(
         &mut self,
         node: &mut Option<BlockStmt>,
@@ -67078,6 +68443,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67086,6 +68452,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_catch_clause(
         &mut self,
         node: &mut Option<CatchClause>,
@@ -67098,6 +68465,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67106,6 +68474,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67114,6 +68483,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67122,6 +68492,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_expr_or_spread(
         &mut self,
         node: &mut Option<ExprOrSpread>,
@@ -67134,6 +68505,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_expr_or_spreads(
         &mut self,
         node: &mut Option<Vec<ExprOrSpread>>,
@@ -67146,6 +68518,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67154,6 +68527,7 @@ pub trait VisitMutAstPath {
     #[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>,
@@ -67166,6 +68540,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_jsx_closing_element(
         &mut self,
         node: &mut Option<JSXClosingElement>,
@@ -67178,6 +68553,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_module_export_name(
         &mut self,
         node: &mut Option<ModuleExportName>,
@@ -67190,6 +68566,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::visit_mut_children_with_ast_path`]. If you \
              want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_mut_opt_module_items(
         &mut self,
         node: &mut Option<Vec<ModuleItem>>,
@@ -67202,6 +68579,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_object_lit(
         &mut self,
         node: &mut Option<Box<ObjectLit>>,
@@ -67214,6 +68592,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67222,6 +68601,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_span(
         &mut self,
         node: &mut Option<swc_common::Span>,
@@ -67234,6 +68614,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67242,6 +68623,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67250,6 +68632,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_true_plus_minus(
         &mut self,
         node: &mut Option<TruePlusMinus>,
@@ -67262,6 +68645,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_entity_name(
         &mut self,
         node: &mut Option<TsEntityName>,
@@ -67274,6 +68658,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_namespace_body(
         &mut self,
         node: &mut Option<TsNamespaceBody>,
@@ -67286,6 +68671,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_type(
         &mut self,
         node: &mut Option<Box<TsType>>,
@@ -67298,6 +68684,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_type_ann(
         &mut self,
         node: &mut Option<Box<TsTypeAnn>>,
@@ -67310,6 +68697,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_ts_type_param_decl(
         &mut self,
         node: &mut Option<Box<TsTypeParamDecl>>,
@@ -67321,6 +68709,7 @@ pub trait VisitMutAstPath {
              this method calls [`Option < Box < TsTypeParamInstantiation > \
              >::visit_mut_children_with_ast_path`]. 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>>,
@@ -67331,6 +68720,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_var_decl_or_expr(
         &mut self,
         node: &mut Option<VarDeclOrExpr>,
@@ -67343,6 +68733,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_vec_expr_or_spreads(
         &mut self,
         node: &mut Vec<Option<ExprOrSpread>>,
@@ -67355,6 +68746,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_vec_pats(
         &mut self,
         node: &mut Vec<Option<Pat>>,
@@ -67367,6 +68759,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67375,6 +68768,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_param_or_ts_param_prop(
         &mut self,
         node: &mut ParamOrTsParamProp,
@@ -67387,6 +68781,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_param_or_ts_param_props(
         &mut self,
         node: &mut Vec<ParamOrTsParamProp>,
@@ -67399,6 +68794,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67407,6 +68803,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67415,12 +68812,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -67429,6 +68828,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67437,6 +68837,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67445,6 +68846,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67453,6 +68855,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67461,6 +68864,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67469,6 +68873,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67477,6 +68882,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67485,6 +68891,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_prop_or_spreads(
         &mut self,
         node: &mut Vec<PropOrSpread>,
@@ -67497,6 +68904,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67505,6 +68913,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_reserved_unused(
         &mut self,
         node: &mut ReservedUnused,
@@ -67517,6 +68926,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67525,6 +68935,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67533,6 +68944,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67541,6 +68953,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67549,6 +68962,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67557,6 +68971,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_simple_assign_target(
         &mut self,
         node: &mut SimpleAssignTarget,
@@ -67569,6 +68984,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67577,6 +68993,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67585,6 +69002,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67593,6 +69011,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67601,6 +69020,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67609,12 +69029,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -67623,6 +69045,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67631,6 +69054,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_super_prop_expr(
         &mut self,
         node: &mut SuperPropExpr,
@@ -67643,6 +69067,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67651,6 +69076,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67659,6 +69085,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67667,6 +69094,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_syntax_context(
         &mut self,
         node: &mut swc_common::SyntaxContext,
@@ -67679,6 +69107,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67687,6 +69116,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67695,6 +69125,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67703,12 +69134,14 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -67717,6 +69150,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67725,6 +69159,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_true_plus_minus(
         &mut self,
         node: &mut TruePlusMinus,
@@ -67737,6 +69172,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67745,6 +69181,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67753,6 +69190,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67761,6 +69199,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_call_signature_decl(
         &mut self,
         node: &mut TsCallSignatureDecl,
@@ -67773,6 +69212,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_conditional_type(
         &mut self,
         node: &mut TsConditionalType,
@@ -67785,6 +69225,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_const_assertion(
         &mut self,
         node: &mut TsConstAssertion,
@@ -67797,6 +69238,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_construct_signature_decl(
         &mut self,
         node: &mut TsConstructSignatureDecl,
@@ -67809,6 +69251,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_constructor_type(
         &mut self,
         node: &mut TsConstructorType,
@@ -67821,6 +69264,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67829,6 +69273,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67837,6 +69282,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67845,6 +69291,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_enum_member_id(
         &mut self,
         node: &mut TsEnumMemberId,
@@ -67857,6 +69304,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_enum_members(
         &mut self,
         node: &mut Vec<TsEnumMember>,
@@ -67869,6 +69317,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_export_assignment(
         &mut self,
         node: &mut TsExportAssignment,
@@ -67881,6 +69330,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_expr_with_type_args(
         &mut self,
         node: &mut TsExprWithTypeArgs,
@@ -67893,6 +69343,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_expr_with_type_argss(
         &mut self,
         node: &mut Vec<TsExprWithTypeArgs>,
@@ -67905,6 +69356,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_external_module_ref(
         &mut self,
         node: &mut TsExternalModuleRef,
@@ -67917,6 +69369,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_fn_or_constructor_type(
         &mut self,
         node: &mut TsFnOrConstructorType,
@@ -67929,6 +69382,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67937,6 +69391,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67945,6 +69400,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67953,6 +69409,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_getter_signature(
         &mut self,
         node: &mut TsGetterSignature,
@@ -67965,6 +69422,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_import_equals_decl(
         &mut self,
         node: &mut TsImportEqualsDecl,
@@ -67977,6 +69435,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -67985,6 +69444,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_index_signature(
         &mut self,
         node: &mut TsIndexSignature,
@@ -67997,6 +69457,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_indexed_access_type(
         &mut self,
         node: &mut TsIndexedAccessType,
@@ -68009,6 +69470,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68017,6 +69479,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_instantiation(
         &mut self,
         node: &mut TsInstantiation,
@@ -68029,6 +69492,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_interface_body(
         &mut self,
         node: &mut TsInterfaceBody,
@@ -68041,6 +69505,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_interface_decl(
         &mut self,
         node: &mut TsInterfaceDecl,
@@ -68053,6 +69518,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_intersection_type(
         &mut self,
         node: &mut TsIntersectionType,
@@ -68065,6 +69531,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_keyword_type(
         &mut self,
         node: &mut TsKeywordType,
@@ -68077,6 +69544,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_keyword_type_kind(
         &mut self,
         node: &mut TsKeywordTypeKind,
@@ -68089,6 +69557,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68097,6 +69566,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68105,6 +69575,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68113,6 +69584,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_method_signature(
         &mut self,
         node: &mut TsMethodSignature,
@@ -68125,6 +69597,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_module_block(
         &mut self,
         node: &mut TsModuleBlock,
@@ -68137,6 +69610,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68145,6 +69619,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68153,6 +69628,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68161,6 +69637,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_namespace_body(
         &mut self,
         node: &mut TsNamespaceBody,
@@ -68173,6 +69650,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_namespace_decl(
         &mut self,
         node: &mut TsNamespaceDecl,
@@ -68185,6 +69663,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_namespace_export_decl(
         &mut self,
         node: &mut TsNamespaceExportDecl,
@@ -68197,6 +69676,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_non_null_expr(
         &mut self,
         node: &mut TsNonNullExpr,
@@ -68209,6 +69689,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_optional_type(
         &mut self,
         node: &mut TsOptionalType,
@@ -68221,6 +69702,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68229,6 +69711,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_param_prop_param(
         &mut self,
         node: &mut TsParamPropParam,
@@ -68241,6 +69724,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_parenthesized_type(
         &mut self,
         node: &mut TsParenthesizedType,
@@ -68253,6 +69737,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_property_signature(
         &mut self,
         node: &mut TsPropertySignature,
@@ -68265,6 +69750,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_qualified_name(
         &mut self,
         node: &mut TsQualifiedName,
@@ -68277,6 +69763,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68285,6 +69772,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_satisfies_expr(
         &mut self,
         node: &mut TsSatisfiesExpr,
@@ -68297,6 +69785,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_setter_signature(
         &mut self,
         node: &mut TsSetterSignature,
@@ -68309,6 +69798,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68317,6 +69807,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_this_type_or_ident(
         &mut self,
         node: &mut TsThisTypeOrIdent,
@@ -68329,6 +69820,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68337,6 +69829,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_tuple_element(
         &mut self,
         node: &mut TsTupleElement,
@@ -68349,6 +69842,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_tuple_elements(
         &mut self,
         node: &mut Vec<TsTupleElement>,
@@ -68361,6 +69855,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68369,6 +69864,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68377,6 +69873,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_alias_decl(
         &mut self,
         node: &mut TsTypeAliasDecl,
@@ -68389,6 +69886,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68397,6 +69895,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_assertion(
         &mut self,
         node: &mut TsTypeAssertion,
@@ -68409,6 +69908,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_element(
         &mut self,
         node: &mut TsTypeElement,
@@ -68421,6 +69921,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_elements(
         &mut self,
         node: &mut Vec<TsTypeElement>,
@@ -68433,6 +69934,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68441,6 +69943,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_operator(
         &mut self,
         node: &mut TsTypeOperator,
@@ -68453,6 +69956,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_operator_op(
         &mut self,
         node: &mut TsTypeOperatorOp,
@@ -68465,6 +69969,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68473,6 +69978,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_param_decl(
         &mut self,
         node: &mut TsTypeParamDecl,
@@ -68485,6 +69991,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_param_instantiation(
         &mut self,
         node: &mut TsTypeParamInstantiation,
@@ -68497,6 +70004,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_params(
         &mut self,
         node: &mut Vec<TsTypeParam>,
@@ -68509,6 +70017,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_predicate(
         &mut self,
         node: &mut TsTypePredicate,
@@ -68521,6 +70030,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68529,6 +70039,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_type_query_expr(
         &mut self,
         node: &mut TsTypeQueryExpr,
@@ -68541,6 +70052,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68549,6 +70061,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68557,6 +70070,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_ts_union_or_intersection_type(
         &mut self,
         node: &mut TsUnionOrIntersectionType,
@@ -68569,6 +70083,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68577,6 +70092,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68585,6 +70101,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68593,6 +70110,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68601,6 +70119,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68609,6 +70128,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68617,6 +70137,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68625,6 +70146,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68633,6 +70155,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_var_decl_or_expr(
         &mut self,
         node: &mut VarDeclOrExpr,
@@ -68645,6 +70168,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68653,6 +70177,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_var_declarators(
         &mut self,
         node: &mut Vec<VarDeclarator>,
@@ -68665,6 +70190,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68673,6 +70199,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -68681,6 +70208,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -90889,10 +92417,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for YieldExpr {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -90901,10 +92431,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -90913,10 +92445,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for BigIntValue {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ClassMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -90929,10 +92463,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ClassMember> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Decorator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -90945,10 +92481,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Decorator> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ExportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -90961,10 +92499,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExportSpecifier
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ExprOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -90977,10 +92517,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ExprOrSpread> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Box<Expr> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -90993,10 +92535,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<Expr>> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ImportSpecifier as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91009,10 +92553,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportSpecifier
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ImportWithItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91025,10 +92571,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ImportWithItem>
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <JSXAttrOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91041,10 +92589,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXAttrOrSpread
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <JSXElementChild as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91057,10 +92607,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<JSXElementChild
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ModuleItem as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91073,10 +92625,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ModuleItem> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ObjectPatProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91089,10 +92643,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ObjectPatProp>
 #[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 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 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(
@@ -91106,10 +92662,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Accessibilit
 #[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 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 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(
@@ -91123,10 +92681,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::A
 #[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 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 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(
@@ -91140,10 +92700,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<BlockStmt> {
 #[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 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 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(
@@ -91157,10 +92719,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<CatchClause>
 #[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 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 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(
@@ -91174,10 +92738,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Expr>> {
 #[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 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 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(
@@ -91191,10 +92757,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ExprOrSpread
 #[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 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 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(
@@ -91208,10 +92776,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<ExprOrSp
 #[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 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 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(
@@ -91225,10 +92795,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Ident> {
 #[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 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 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(
@@ -91242,10 +92814,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXAttrValue
 #[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 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 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(
@@ -91259,10 +92833,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<JSXClosingEl
 #[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 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 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(
@@ -91276,10 +92852,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<ModuleExport
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_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_opt_module_items(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => <Vec<ModuleItem> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91293,10 +92871,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Vec<ModuleIt
 #[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 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 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(
@@ -91310,10 +92890,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<ObjectLi
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -91327,10 +92909,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Pat> {
 #[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 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 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(
@@ -91344,10 +92928,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_common::
 #[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 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 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(
@@ -91361,10 +92947,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Stmt>> {
 #[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 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 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(
@@ -91378,10 +92966,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<Str>> {
 #[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 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 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(
@@ -91395,10 +92985,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TruePlusMinu
 #[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 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 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(
@@ -91412,10 +93004,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsEntityName
 #[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 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 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(
@@ -91429,10 +93023,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<TsNamespaceB
 #[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 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 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(
@@ -91446,10 +93042,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsType>>
 #[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 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 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(
@@ -91463,10 +93061,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypeAn
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -91483,10 +93083,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypePa
 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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -91502,10 +93104,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Box<TsTypePa
 #[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 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 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(
@@ -91519,10 +93123,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<VarDeclOrExp
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Option<ExprOrSpread> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91535,10 +93141,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<ExprOrSp
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Option<Pat> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91551,10 +93159,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Option<Pat>> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <ParamOrTsParamProp as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91567,10 +93177,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<ParamOrTsParamP
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Param as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -91581,10 +93193,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Param> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Pat as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -91595,10 +93209,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Pat> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <PropOrSpread as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91611,10 +93227,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<PropOrSpread> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -91623,10 +93241,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::Span {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Stmt as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -91637,10 +93257,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Stmt> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <SwitchCase as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91653,10 +93275,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<SwitchCase> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -91665,10 +93289,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_common::SyntaxC
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TplElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91681,10 +93307,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TplElement> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsEnumMember as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91697,10 +93325,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsEnumMember> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsExprWithTypeArgs as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91713,10 +93343,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsExprWithTypeA
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsFnParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91729,10 +93361,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsFnParam> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsTupleElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91745,10 +93379,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTupleElement>
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsTypeElement as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91761,10 +93397,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeElement>
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <TsTypeParam as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91777,10 +93415,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<TsTypeParam> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Box<TsType> as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91793,10 +93433,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Box<TsType>> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <VarDeclarator as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -91812,6 +93454,7 @@ where
     V: ?Sized + VisitMutAstPath,
     T: VisitMutWithAstPath<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,
@@ -91821,6 +93464,7 @@ where
         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,
@@ -91835,294 +93479,344 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
@@ -92132,12 +93826,14 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
@@ -92147,118 +93843,139 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
@@ -92268,30 +93985,35 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
@@ -92301,349 +94023,409 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
@@ -92652,18 +94434,21 @@ pub trait Fold {
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
@@ -92673,6 +94458,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
@@ -92682,53 +94468,62 @@ pub trait Fold {
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::fold_children_with`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn fold_opt_module_items(&mut self, node: Option<Vec<ModuleItem>>) -> Option<Vec<ModuleItem>> {
         <Option<Vec<ModuleItem>> 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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
@@ -92738,18 +94533,21 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
@@ -92759,6 +94557,7 @@ pub trait Fold {
     #[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."]
+    #[inline]
     fn fold_opt_ts_type_param_instantiation(
         &mut self,
         node: Option<Box<TsTypeParamInstantiation>>,
@@ -92768,12 +94567,14 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
@@ -92783,23 +94584,27 @@ pub trait Fold {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
@@ -92808,186 +94613,219 @@ pub trait Fold {
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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 `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_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 `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_reserved_unused(&mut self, node: ReservedUnused) -> ReservedUnused {
         <ReservedUnused 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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
@@ -92997,82 +94835,96 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
@@ -93082,54 +94934,63 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
@@ -93139,12 +95000,14 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
@@ -93154,155 +95017,181 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
@@ -93312,167 +95201,195 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
@@ -93482,42 +95399,49 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
@@ -93527,82 +95451,96 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
     #[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."]
+    #[inline]
     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`]. 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)
     }
@@ -107568,30 +109506,36 @@ impl<V: ?Sized + Fold> FoldWith<V> for YieldExpr {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
     #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for BigIntValue {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ClassMember> {
     #[doc = "Calls [Fold`::fold_class_members`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_class_members(visitor, self)
     }
 
+    #[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)
@@ -107600,10 +109544,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ClassMember> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Decorator> {
     #[doc = "Calls [Fold`::fold_decorators`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_decorators(visitor, self)
     }
 
+    #[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)
@@ -107612,10 +109558,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Decorator> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExportSpecifier> {
     #[doc = "Calls [Fold`::fold_export_specifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_export_specifiers(visitor, self)
     }
 
+    #[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)
@@ -107624,10 +109572,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExportSpecifier> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExprOrSpread> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -107636,10 +109586,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ExprOrSpread> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<Expr>> {
     #[doc = "Calls [Fold`::fold_exprs`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_exprs(visitor, self)
     }
 
+    #[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)
@@ -107648,10 +109600,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<Expr>> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportSpecifier> {
     #[doc = "Calls [Fold`::fold_import_specifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_import_specifiers(visitor, self)
     }
 
+    #[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)
@@ -107660,10 +109614,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportSpecifier> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportWithItem> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -107672,10 +109628,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ImportWithItem> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_jsx_attr_or_spreads(visitor, self)
     }
 
+    #[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)
@@ -107684,10 +109642,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXAttrOrSpread> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXElementChild> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -107696,10 +109656,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<JSXElementChild> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ModuleItem> {
     #[doc = "Calls [Fold`::fold_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_module_items(visitor, self)
     }
 
+    #[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)
@@ -107708,10 +109670,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ModuleItem> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<ObjectPatProp> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -107720,260 +109684,312 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ObjectPatProp> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Accessibility> {
     #[doc = "Calls [Fold`::fold_opt_accessibility`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_accessibility(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Accessibility as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<BlockStmt> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <BlockStmt as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<CatchClause> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <CatchClause as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Expr>> {
     #[doc = "Calls [Fold`::fold_opt_expr`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_expr(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<Expr> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_expr_or_spread(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <ExprOrSpread as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_expr_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Vec<ExprOrSpread> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Ident> {
     #[doc = "Calls [Fold`::fold_opt_ident`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Ident as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_jsx_attr_value(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <JSXAttrValue as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_jsx_closing_element(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <JSXClosingElement as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_module_export_name(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <ModuleExportName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [Fold`::fold_opt_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_module_items(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Vec<ModuleItem> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_object_lit(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<ObjectLit> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Pat> {
     #[doc = "Calls [Fold`::fold_opt_pat`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_pat(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Pat as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_span(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <swc_common::Span as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Stmt>> {
     #[doc = "Calls [Fold`::fold_opt_stmt`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_stmt(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<Stmt> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Box<Str>> {
     #[doc = "Calls [Fold`::fold_opt_str`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_str(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<Str> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_true_plus_minus(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <TruePlusMinus as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_entity_name(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <TsEntityName as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_namespace_body(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <TsNamespaceBody as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_type(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<TsType> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_type_ann(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<TsTypeAnn> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_type_param_decl(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<TsTypeParamDecl> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_ts_type_param_instantiation(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Box<TsTypeParamInstantiation> as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_var_decl_or_expr(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <VarDeclOrExpr as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_vec_expr_or_spreads(visitor, self)
     }
 
+    #[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)
@@ -107982,10 +109998,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<ExprOrSpread>> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_vec_pats(visitor, self)
     }
 
+    #[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)
@@ -107994,10 +110012,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Option<Pat>> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_param_or_ts_param_props(visitor, self)
     }
 
+    #[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)
@@ -108006,10 +110026,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<ParamOrTsParamProp> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Param> {
     #[doc = "Calls [Fold`::fold_params`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_params(visitor, self)
     }
 
+    #[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)
@@ -108018,10 +110040,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Param> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Pat> {
     #[doc = "Calls [Fold`::fold_pats`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_pats(visitor, self)
     }
 
+    #[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)
@@ -108030,10 +110054,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Pat> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<PropOrSpread> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108042,20 +110068,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<PropOrSpread> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
     #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_span(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Stmt> {
     #[doc = "Calls [Fold`::fold_stmts`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_stmts(visitor, self)
     }
 
+    #[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)
@@ -108064,10 +110094,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Stmt> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<SwitchCase> {
     #[doc = "Calls [Fold`::fold_switch_cases`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_switch_cases(visitor, self)
     }
 
+    #[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)
@@ -108076,20 +110108,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<SwitchCase> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_common::SyntaxContext {
     #[doc = "Calls [Fold`::fold_syntax_context`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_syntax_context(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TplElement> {
     #[doc = "Calls [Fold`::fold_tpl_elements`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_tpl_elements(visitor, self)
     }
 
+    #[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)
@@ -108098,10 +110134,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TplElement> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsEnumMember> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108110,10 +110148,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsEnumMember> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_ts_expr_with_type_argss(visitor, self)
     }
 
+    #[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)
@@ -108122,10 +110162,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsExprWithTypeArgs> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsFnParam> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108134,10 +110176,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsFnParam> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTupleElement> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108146,10 +110190,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTupleElement> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeElement> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108158,10 +110204,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeElement> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeParam> {
     #[doc = "Calls [Fold`::fold_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)
     }
 
+    #[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)
@@ -108170,10 +110218,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<TsTypeParam> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<TsType>> {
     #[doc = "Calls [Fold`::fold_ts_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_ts_types(visitor, self)
     }
 
+    #[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)
@@ -108182,10 +110232,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Box<TsType>> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<VarDeclarator> {
     #[doc = "Calls [Fold`::fold_var_declarators`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_var_declarators(visitor, self)
     }
 
+    #[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)
@@ -108197,10 +110249,12 @@ where
     V: ?Sized + Fold,
     T: FoldWith<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))
     }
 
+    #[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)
@@ -108214,6 +110268,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_accessibility(
         &mut self,
         node: Accessibility,
@@ -108226,42 +110281,49 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_assign_pat_prop(
         &mut self,
         node: AssignPatProp,
@@ -108274,12 +110336,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_assign_target(
         &mut self,
         node: AssignTarget,
@@ -108290,6 +110354,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_assign_target_pat(
         &mut self,
         node: AssignTargetPat,
@@ -108302,6 +110367,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_atom(
         &mut self,
         node: swc_atoms::Atom,
@@ -108314,6 +110380,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_auto_accessor(
         &mut self,
         node: AutoAccessor,
@@ -108324,18 +110391,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_big_int_value(
         &mut self,
         node: BigIntValue,
@@ -108346,18 +110416,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_binding_ident(
         &mut self,
         node: BindingIdent,
@@ -108368,12 +110441,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_block_stmt_or_expr(
         &mut self,
         node: BlockStmtOrExpr,
@@ -108386,30 +110461,35 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_catch_clause(
         &mut self,
         node: CatchClause,
@@ -108420,24 +110500,28 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_class_member(
         &mut self,
         node: ClassMember,
@@ -108448,6 +110532,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_class_members(
         &mut self,
         node: Vec<ClassMember>,
@@ -108460,6 +110545,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_class_method(
         &mut self,
         node: ClassMethod,
@@ -108470,12 +110556,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_computed_prop_name(
         &mut self,
         node: ComputedPropName,
@@ -108488,18 +110576,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_continue_stmt(
         &mut self,
         node: ContinueStmt,
@@ -108510,6 +110601,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_debugger_stmt(
         &mut self,
         node: DebuggerStmt,
@@ -108520,18 +110612,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_decorators(
         &mut self,
         node: Vec<Decorator>,
@@ -108544,6 +110639,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_default_decl(
         &mut self,
         node: DefaultDecl,
@@ -108554,6 +110650,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_do_while_stmt(
         &mut self,
         node: DoWhileStmt,
@@ -108564,30 +110661,35 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_export_default_decl(
         &mut self,
         node: ExportDefaultDecl,
@@ -108600,6 +110702,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_default_expr(
         &mut self,
         node: ExportDefaultExpr,
@@ -108612,6 +110715,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_default_specifier(
         &mut self,
         node: ExportDefaultSpecifier,
@@ -108624,6 +110728,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_named_specifier(
         &mut self,
         node: ExportNamedSpecifier,
@@ -108636,6 +110741,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_namespace_specifier(
         &mut self,
         node: ExportNamespaceSpecifier,
@@ -108648,6 +110754,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_specifier(
         &mut self,
         node: ExportSpecifier,
@@ -108660,6 +110767,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_export_specifiers(
         &mut self,
         node: Vec<ExportSpecifier>,
@@ -108672,12 +110780,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_expr_or_spread(
         &mut self,
         node: ExprOrSpread,
@@ -108688,6 +110798,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_expr_or_spreads(
         &mut self,
         node: Vec<ExprOrSpread>,
@@ -108700,12 +110811,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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,
@@ -108714,84 +110827,98 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_import_default_specifier(
         &mut self,
         node: ImportDefaultSpecifier,
@@ -108804,6 +110931,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_named_specifier(
         &mut self,
         node: ImportNamedSpecifier,
@@ -108816,6 +110944,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_phase(
         &mut self,
         node: ImportPhase,
@@ -108826,6 +110955,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_specifier(
         &mut self,
         node: ImportSpecifier,
@@ -108838,6 +110968,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_specifiers(
         &mut self,
         node: Vec<ImportSpecifier>,
@@ -108850,6 +110981,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_star_as_specifier(
         &mut self,
         node: ImportStarAsSpecifier,
@@ -108862,12 +110994,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_with_item(
         &mut self,
         node: ImportWithItem,
@@ -108880,6 +111014,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_import_with_items(
         &mut self,
         node: Vec<ImportWithItem>,
@@ -108892,18 +111027,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_jsx_attr_name(
         &mut self,
         node: JSXAttrName,
@@ -108914,6 +111052,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_attr_or_spread(
         &mut self,
         node: JSXAttrOrSpread,
@@ -108926,6 +111065,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_attr_or_spreads(
         &mut self,
         node: Vec<JSXAttrOrSpread>,
@@ -108938,6 +111078,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_attr_value(
         &mut self,
         node: JSXAttrValue,
@@ -108948,6 +111089,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_closing_element(
         &mut self,
         node: JSXClosingElement,
@@ -108960,6 +111102,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_closing_fragment(
         &mut self,
         node: JSXClosingFragment,
@@ -108972,12 +111115,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_jsx_element_child(
         &mut self,
         node: JSXElementChild,
@@ -108990,6 +111135,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_element_childs(
         &mut self,
         node: Vec<JSXElementChild>,
@@ -109002,6 +111148,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_element_name(
         &mut self,
         node: JSXElementName,
@@ -109014,6 +111161,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_empty_expr(
         &mut self,
         node: JSXEmptyExpr,
@@ -109024,12 +111172,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_jsx_expr_container(
         &mut self,
         node: JSXExprContainer,
@@ -109042,6 +111192,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_fragment(
         &mut self,
         node: JSXFragment,
@@ -109052,6 +111203,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_member_expr(
         &mut self,
         node: JSXMemberExpr,
@@ -109064,6 +111216,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_namespaced_name(
         &mut self,
         node: JSXNamespacedName,
@@ -109076,12 +111229,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_jsx_opening_element(
         &mut self,
         node: JSXOpeningElement,
@@ -109094,6 +111249,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_opening_fragment(
         &mut self,
         node: JSXOpeningFragment,
@@ -109106,6 +111262,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_jsx_spread_child(
         &mut self,
         node: JSXSpreadChild,
@@ -109118,18 +111275,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_key_value_pat_prop(
         &mut self,
         node: KeyValuePatProp,
@@ -109142,6 +111302,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_key_value_prop(
         &mut self,
         node: KeyValueProp,
@@ -109152,6 +111313,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_labeled_stmt(
         &mut self,
         node: LabeledStmt,
@@ -109162,24 +111324,28 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_meta_prop_expr(
         &mut self,
         node: MetaPropExpr,
@@ -109190,6 +111356,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_meta_prop_kind(
         &mut self,
         node: MetaPropKind,
@@ -109200,30 +111367,35 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_module_export_name(
         &mut self,
         node: ModuleExportName,
@@ -109236,12 +111408,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_module_items(
         &mut self,
         node: Vec<ModuleItem>,
@@ -109254,6 +111428,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_named_export(
         &mut self,
         node: NamedExport,
@@ -109264,36 +111439,42 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_object_pat_prop(
         &mut self,
         node: ObjectPatProp,
@@ -109306,6 +111487,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_object_pat_props(
         &mut self,
         node: Vec<ObjectPatProp>,
@@ -109318,6 +111500,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_accessibility(
         &mut self,
         node: Option<Accessibility>,
@@ -109330,6 +111513,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_atom(
         &mut self,
         node: Option<swc_atoms::Atom>,
@@ -109342,6 +111526,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_block_stmt(
         &mut self,
         node: Option<BlockStmt>,
@@ -109354,12 +111539,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_catch_clause(
         &mut self,
         node: Option<CatchClause>,
@@ -109372,6 +111559,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_chain_base(
         &mut self,
         node: OptChainBase,
@@ -109382,6 +111570,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_chain_expr(
         &mut self,
         node: OptChainExpr,
@@ -109392,6 +111581,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_expr(
         &mut self,
         node: Option<Box<Expr>>,
@@ -109404,6 +111594,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_expr_or_spread(
         &mut self,
         node: Option<ExprOrSpread>,
@@ -109416,6 +111607,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_expr_or_spreads(
         &mut self,
         node: Option<Vec<ExprOrSpread>>,
@@ -109428,6 +111620,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ident(
         &mut self,
         node: Option<Ident>,
@@ -109440,6 +111633,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_jsx_attr_value(
         &mut self,
         node: Option<JSXAttrValue>,
@@ -109452,6 +111646,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_jsx_closing_element(
         &mut self,
         node: Option<JSXClosingElement>,
@@ -109464,6 +111659,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_module_export_name(
         &mut self,
         node: Option<ModuleExportName>,
@@ -109476,6 +111672,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Option < Vec < ModuleItem > >`.\n\nBy default, this method \
              calls [`Option < Vec < ModuleItem > >::fold_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_module_items(
         &mut self,
         node: Option<Vec<ModuleItem>>,
@@ -109488,6 +111685,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_object_lit(
         &mut self,
         node: Option<Box<ObjectLit>>,
@@ -109500,12 +111698,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_span(
         &mut self,
         node: Option<swc_common::Span>,
@@ -109518,6 +111718,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_stmt(
         &mut self,
         node: Option<Box<Stmt>>,
@@ -109530,6 +111731,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_str(
         &mut self,
         node: Option<Box<Str>>,
@@ -109542,6 +111744,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_true_plus_minus(
         &mut self,
         node: Option<TruePlusMinus>,
@@ -109554,6 +111757,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ts_entity_name(
         &mut self,
         node: Option<TsEntityName>,
@@ -109566,6 +111770,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ts_namespace_body(
         &mut self,
         node: Option<TsNamespaceBody>,
@@ -109578,6 +111783,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ts_type(
         &mut self,
         node: Option<Box<TsType>>,
@@ -109590,6 +111796,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ts_type_ann(
         &mut self,
         node: Option<Box<TsTypeAnn>>,
@@ -109602,6 +111809,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_ts_type_param_decl(
         &mut self,
         node: Option<Box<TsTypeParamDecl>>,
@@ -109615,6 +111823,7 @@ pub trait FoldAstPath {
              this method calls [`Option < Box < TsTypeParamInstantiation > \
              >::fold_children_with_ast_path`]. 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>>,
@@ -109625,6 +111834,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_var_decl_or_expr(
         &mut self,
         node: Option<VarDeclOrExpr>,
@@ -109637,6 +111847,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_vec_expr_or_spreads(
         &mut self,
         node: Vec<Option<ExprOrSpread>>,
@@ -109649,6 +111860,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_vec_pats(
         &mut self,
         node: Vec<Option<Pat>>,
@@ -109661,12 +111873,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_param_or_ts_param_prop(
         &mut self,
         node: ParamOrTsParamProp,
@@ -109679,6 +111893,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_param_or_ts_param_props(
         &mut self,
         node: Vec<ParamOrTsParamProp>,
@@ -109691,30 +111906,35 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_private_method(
         &mut self,
         node: PrivateMethod,
@@ -109727,6 +111947,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_private_name(
         &mut self,
         node: PrivateName,
@@ -109737,6 +111958,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_private_prop(
         &mut self,
         node: PrivateProp,
@@ -109747,24 +111969,28 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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,
@@ -109775,6 +112001,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_prop_or_spreads(
         &mut self,
         node: Vec<PropOrSpread>,
@@ -109787,12 +112014,14 @@ pub trait FoldAstPath {
     #[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 \
              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)
     }
     #[doc = "Visit a node of type `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_reserved_unused(
         &mut self,
         node: ReservedUnused,
@@ -109805,36 +112034,42 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_simple_assign_target(
         &mut self,
         node: SimpleAssignTarget,
@@ -109847,6 +112082,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_span(
         &mut self,
         node: swc_common::Span,
@@ -109859,6 +112095,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_spread_element(
         &mut self,
         node: SpreadElement,
@@ -109871,6 +112108,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_static_block(
         &mut self,
         node: StaticBlock,
@@ -109881,36 +112119,42 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_super_prop_expr(
         &mut self,
         node: SuperPropExpr,
@@ -109923,12 +112167,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_switch_cases(
         &mut self,
         node: Vec<SwitchCase>,
@@ -109941,12 +112187,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_syntax_context(
         &mut self,
         node: swc_common::SyntaxContext,
@@ -109959,36 +112207,42 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_tpl_elements(
         &mut self,
         node: Vec<TplElement>,
@@ -110001,6 +112255,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_true_plus_minus(
         &mut self,
         node: TruePlusMinus,
@@ -110013,12 +112268,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_array_type(
         &mut self,
         node: TsArrayType,
@@ -110029,12 +112286,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_call_signature_decl(
         &mut self,
         node: TsCallSignatureDecl,
@@ -110047,6 +112306,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_conditional_type(
         &mut self,
         node: TsConditionalType,
@@ -110059,6 +112319,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_const_assertion(
         &mut self,
         node: TsConstAssertion,
@@ -110071,6 +112332,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_construct_signature_decl(
         &mut self,
         node: TsConstructSignatureDecl,
@@ -110083,6 +112345,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_constructor_type(
         &mut self,
         node: TsConstructorType,
@@ -110095,6 +112358,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_entity_name(
         &mut self,
         node: TsEntityName,
@@ -110105,12 +112369,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_enum_member(
         &mut self,
         node: TsEnumMember,
@@ -110121,6 +112387,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_enum_member_id(
         &mut self,
         node: TsEnumMemberId,
@@ -110133,6 +112400,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_enum_members(
         &mut self,
         node: Vec<TsEnumMember>,
@@ -110145,6 +112413,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_export_assignment(
         &mut self,
         node: TsExportAssignment,
@@ -110157,6 +112426,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_expr_with_type_args(
         &mut self,
         node: TsExprWithTypeArgs,
@@ -110169,6 +112439,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_expr_with_type_argss(
         &mut self,
         node: Vec<TsExprWithTypeArgs>,
@@ -110181,6 +112452,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_external_module_ref(
         &mut self,
         node: TsExternalModuleRef,
@@ -110193,6 +112465,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_fn_or_constructor_type(
         &mut self,
         node: TsFnOrConstructorType,
@@ -110205,12 +112478,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_fn_params(
         &mut self,
         node: Vec<TsFnParam>,
@@ -110223,12 +112498,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_getter_signature(
         &mut self,
         node: TsGetterSignature,
@@ -110241,6 +112518,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_import_equals_decl(
         &mut self,
         node: TsImportEqualsDecl,
@@ -110253,6 +112531,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_import_type(
         &mut self,
         node: TsImportType,
@@ -110263,6 +112542,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_index_signature(
         &mut self,
         node: TsIndexSignature,
@@ -110275,6 +112555,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_indexed_access_type(
         &mut self,
         node: TsIndexedAccessType,
@@ -110287,6 +112568,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_infer_type(
         &mut self,
         node: TsInferType,
@@ -110297,6 +112579,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_instantiation(
         &mut self,
         node: TsInstantiation,
@@ -110309,6 +112592,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_interface_body(
         &mut self,
         node: TsInterfaceBody,
@@ -110321,6 +112605,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_interface_decl(
         &mut self,
         node: TsInterfaceDecl,
@@ -110333,6 +112618,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_intersection_type(
         &mut self,
         node: TsIntersectionType,
@@ -110345,6 +112631,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_keyword_type(
         &mut self,
         node: TsKeywordType,
@@ -110357,6 +112644,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_keyword_type_kind(
         &mut self,
         node: TsKeywordTypeKind,
@@ -110369,18 +112657,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_mapped_type(
         &mut self,
         node: TsMappedType,
@@ -110391,6 +112682,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_method_signature(
         &mut self,
         node: TsMethodSignature,
@@ -110403,6 +112695,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_module_block(
         &mut self,
         node: TsModuleBlock,
@@ -110415,6 +112708,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_module_decl(
         &mut self,
         node: TsModuleDecl,
@@ -110425,6 +112719,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_module_name(
         &mut self,
         node: TsModuleName,
@@ -110435,6 +112730,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_module_ref(
         &mut self,
         node: TsModuleRef,
@@ -110445,6 +112741,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_namespace_body(
         &mut self,
         node: TsNamespaceBody,
@@ -110457,6 +112754,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_namespace_decl(
         &mut self,
         node: TsNamespaceDecl,
@@ -110469,6 +112767,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_namespace_export_decl(
         &mut self,
         node: TsNamespaceExportDecl,
@@ -110481,6 +112780,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_non_null_expr(
         &mut self,
         node: TsNonNullExpr,
@@ -110493,6 +112793,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_optional_type(
         &mut self,
         node: TsOptionalType,
@@ -110505,6 +112806,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_param_prop(
         &mut self,
         node: TsParamProp,
@@ -110515,6 +112817,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_param_prop_param(
         &mut self,
         node: TsParamPropParam,
@@ -110527,6 +112830,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_parenthesized_type(
         &mut self,
         node: TsParenthesizedType,
@@ -110539,6 +112843,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_property_signature(
         &mut self,
         node: TsPropertySignature,
@@ -110551,6 +112856,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_qualified_name(
         &mut self,
         node: TsQualifiedName,
@@ -110563,12 +112869,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_satisfies_expr(
         &mut self,
         node: TsSatisfiesExpr,
@@ -110581,6 +112889,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_setter_signature(
         &mut self,
         node: TsSetterSignature,
@@ -110593,12 +112902,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_this_type_or_ident(
         &mut self,
         node: TsThisTypeOrIdent,
@@ -110611,6 +112922,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_tpl_lit_type(
         &mut self,
         node: TsTplLitType,
@@ -110621,6 +112933,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_tuple_element(
         &mut self,
         node: TsTupleElement,
@@ -110633,6 +112946,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_tuple_elements(
         &mut self,
         node: Vec<TsTupleElement>,
@@ -110645,6 +112959,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_tuple_type(
         &mut self,
         node: TsTupleType,
@@ -110655,12 +112970,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_type_alias_decl(
         &mut self,
         node: TsTypeAliasDecl,
@@ -110673,12 +112990,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_type_assertion(
         &mut self,
         node: TsTypeAssertion,
@@ -110691,6 +113010,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_element(
         &mut self,
         node: TsTypeElement,
@@ -110703,6 +113023,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_elements(
         &mut self,
         node: Vec<TsTypeElement>,
@@ -110715,12 +113036,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_type_operator(
         &mut self,
         node: TsTypeOperator,
@@ -110733,6 +113056,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_operator_op(
         &mut self,
         node: TsTypeOperatorOp,
@@ -110745,6 +113069,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_param(
         &mut self,
         node: TsTypeParam,
@@ -110755,6 +113080,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_param_decl(
         &mut self,
         node: TsTypeParamDecl,
@@ -110767,6 +113093,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_param_instantiation(
         &mut self,
         node: TsTypeParamInstantiation,
@@ -110779,6 +113106,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_params(
         &mut self,
         node: Vec<TsTypeParam>,
@@ -110791,6 +113119,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_predicate(
         &mut self,
         node: TsTypePredicate,
@@ -110803,6 +113132,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_query(
         &mut self,
         node: TsTypeQuery,
@@ -110813,6 +113143,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_type_query_expr(
         &mut self,
         node: TsTypeQueryExpr,
@@ -110825,12 +113156,14 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_ts_types(
         &mut self,
         node: Vec<Box<TsType>>,
@@ -110843,6 +113176,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_union_or_intersection_type(
         &mut self,
         node: TsUnionOrIntersectionType,
@@ -110855,6 +113189,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_ts_union_type(
         &mut self,
         node: TsUnionType,
@@ -110865,42 +113200,49 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     fn fold_var_decl_kind(
         &mut self,
         node: VarDeclKind,
@@ -110911,6 +113253,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_var_decl_or_expr(
         &mut self,
         node: VarDeclOrExpr,
@@ -110923,6 +113266,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_var_declarator(
         &mut self,
         node: VarDeclarator,
@@ -110935,6 +113279,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_var_declarators(
         &mut self,
         node: Vec<VarDeclarator>,
@@ -110947,18 +113292,21 @@ pub trait FoldAstPath {
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[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)
     }
@@ -134930,10 +137278,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for YieldExpr {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -134942,10 +137292,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -134954,10 +137306,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for BigIntValue {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ClassMember as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -134968,10 +137322,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ClassMember> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_decorators(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Decorator as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -134982,10 +137338,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Decorator> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ExportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -134996,10 +137354,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExportSpecifier> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ExprOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135010,10 +137370,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ExprOrSpread> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_exprs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Box<Expr> as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135024,10 +137386,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<Expr>> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ImportSpecifier as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135038,10 +137402,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportSpecifier> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ImportWithItem as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135052,10 +137418,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ImportWithItem> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <JSXAttrOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135066,10 +137434,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXAttrOrSpread> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <JSXElementChild as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135080,10 +137450,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<JSXElementChild> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ModuleItem as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135094,10 +137466,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ModuleItem> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ObjectPatProp as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135108,10 +137482,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ObjectPatProp> {
 #[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 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 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)
@@ -135122,10 +137498,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Accessibility> {
 #[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 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 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)
@@ -135136,10 +137514,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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 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 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)
@@ -135150,10 +137530,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<BlockStmt> {
 #[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 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 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)
@@ -135164,10 +137546,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<CatchClause> {
 #[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 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 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)
@@ -135178,10 +137562,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Expr>> {
 #[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 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 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)
@@ -135192,10 +137578,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ExprOrSpread> {
 #[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 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 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(
@@ -135208,10 +137596,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<ExprOrSpread>> {
 #[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 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 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)
@@ -135222,10 +137612,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Ident> {
 #[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 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 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)
@@ -135236,10 +137628,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXAttrValue> {
 #[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 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 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(
@@ -135252,10 +137646,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<JSXClosingElement> {
 #[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 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 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)
@@ -135266,10 +137662,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<ModuleExportName> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [FoldAstPath`::fold_opt_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_opt_module_items(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self.map(|inner| {
             <Vec<ModuleItem> as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
@@ -135280,10 +137678,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Vec<ModuleItem>> {
 #[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 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 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)
@@ -135294,10 +137694,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<ObjectLit>> {
 #[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 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 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)
@@ -135308,10 +137710,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Pat> {
 #[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 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 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)
@@ -135322,10 +137726,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_common::Span> {
 #[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 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 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)
@@ -135336,10 +137742,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Stmt>> {
 #[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 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 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)
@@ -135350,10 +137758,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<Str>> {
 #[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 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 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)
@@ -135364,10 +137774,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TruePlusMinus> {
 #[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 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 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)
@@ -135378,10 +137790,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsEntityName> {
 #[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 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 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)
@@ -135392,10 +137806,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<TsNamespaceBody> {
 #[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 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 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)
@@ -135406,10 +137822,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsType>> {
 #[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 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 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)
@@ -135420,10 +137838,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeAnn>> {
 #[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 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 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(
@@ -135436,10 +137856,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamDecl>
 #[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 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 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(
@@ -135452,10 +137874,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Box<TsTypeParamInsta
 #[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 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 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)
@@ -135466,10 +137890,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<VarDeclOrExpr> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Option<ExprOrSpread> as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -135482,10 +137908,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<ExprOrSpread>> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Option<Pat> as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135496,10 +137924,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Option<Pat>> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <ParamOrTsParamProp as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -135512,10 +137942,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<ParamOrTsParamProp> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_params(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Param as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135526,10 +137958,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Param> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_pats(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Pat as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135540,10 +137974,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Pat> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <PropOrSpread as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135554,10 +137990,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<PropOrSpread> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -135566,10 +138004,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::Span {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_stmts(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Stmt as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135580,10 +138020,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Stmt> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <SwitchCase as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135594,10 +138036,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<SwitchCase> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -135606,10 +138050,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_common::SyntaxContext {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TplElement as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135620,10 +138066,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TplElement> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsEnumMember as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135634,10 +138082,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsEnumMember> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsExprWithTypeArgs as FoldWithAstPath<V>>::fold_with_ast_path(
@@ -135650,10 +138100,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsExprWithTypeArgs> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsFnParam as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135664,10 +138116,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsFnParam> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsTupleElement as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135678,10 +138132,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTupleElement> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsTypeElement as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135692,10 +138148,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeElement> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <TsTypeParam as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135706,10 +138164,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<TsTypeParam> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Box<TsType> as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135720,10 +138180,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Box<TsType>> {
 #[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 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 fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <VarDeclarator as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -135737,12 +138199,14 @@ where
     V: ?Sized + FoldAstPath,
     T: FoldWithAstPath<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)
         })
     }
 
+    #[inline]
     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)
@@ -135754,774 +138218,903 @@ pub trait VisitAll {
     #[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]."]
+    #[inline]
     fn visit_accessibility(&mut self, node: &Accessibility) {
         <Accessibility as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_array_lit(&mut self, node: &ArrayLit) {
         <ArrayLit as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_array_pat(&mut self, node: &ArrayPat) {
         <ArrayPat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_arrow_expr(&mut self, node: &ArrowExpr) {
         <ArrowExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_expr(&mut self, node: &AssignExpr) {
         <AssignExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_op(&mut self, node: &AssignOp) {
         <AssignOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_pat(&mut self, node: &AssignPat) {
         <AssignPat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) {
         <AssignPatProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_prop(&mut self, node: &AssignProp) {
         <AssignProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_target(&mut self, node: &AssignTarget) {
         <AssignTarget as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_assign_target_pat(&mut self, node: &AssignTargetPat) {
         <AssignTargetPat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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 `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]."]
+    #[inline]
     fn visit_auto_accessor(&mut self, node: &AutoAccessor) {
         <AutoAccessor as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_await_expr(&mut self, node: &AwaitExpr) {
         <AwaitExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_big_int(&mut self, node: &BigInt) {
         <BigInt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_big_int_value(&mut self, node: &BigIntValue) {
         <BigIntValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_bin_expr(&mut self, node: &BinExpr) {
         <BinExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_binary_op(&mut self, node: &BinaryOp) {
         <BinaryOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_binding_ident(&mut self, node: &BindingIdent) {
         <BindingIdent as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_block_stmt(&mut self, node: &BlockStmt) {
         <BlockStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_block_stmt_or_expr(&mut self, node: &BlockStmtOrExpr) {
         <BlockStmtOrExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_bool(&mut self, node: &Bool) {
         <Bool as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_break_stmt(&mut self, node: &BreakStmt) {
         <BreakStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_call_expr(&mut self, node: &CallExpr) {
         <CallExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_callee(&mut self, node: &Callee) {
         <Callee as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_catch_clause(&mut self, node: &CatchClause) {
         <CatchClause as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class(&mut self, node: &Class) {
         <Class as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_decl(&mut self, node: &ClassDecl) {
         <ClassDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_expr(&mut self, node: &ClassExpr) {
         <ClassExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_member(&mut self, node: &ClassMember) {
         <ClassMember as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_members(&mut self, node: &[ClassMember]) {
         <[ClassMember] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_method(&mut self, node: &ClassMethod) {
         <ClassMethod as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_class_prop(&mut self, node: &ClassProp) {
         <ClassProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_computed_prop_name(&mut self, node: &ComputedPropName) {
         <ComputedPropName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_cond_expr(&mut self, node: &CondExpr) {
         <CondExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_constructor(&mut self, node: &Constructor) {
         <Constructor as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_continue_stmt(&mut self, node: &ContinueStmt) {
         <ContinueStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_debugger_stmt(&mut self, node: &DebuggerStmt) {
         <DebuggerStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_decl(&mut self, node: &Decl) {
         <Decl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_decorator(&mut self, node: &Decorator) {
         <Decorator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_decorators(&mut self, node: &[Decorator]) {
         <[Decorator] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_default_decl(&mut self, node: &DefaultDecl) {
         <DefaultDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_do_while_stmt(&mut self, node: &DoWhileStmt) {
         <DoWhileStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_empty_stmt(&mut self, node: &EmptyStmt) {
         <EmptyStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_es_version(&mut self, node: &EsVersion) {
         <EsVersion as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_all(&mut self, node: &ExportAll) {
         <ExportAll as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_decl(&mut self, node: &ExportDecl) {
         <ExportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_default_decl(&mut self, node: &ExportDefaultDecl) {
         <ExportDefaultDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_default_expr(&mut self, node: &ExportDefaultExpr) {
         <ExportDefaultExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_default_specifier(&mut self, node: &ExportDefaultSpecifier) {
         <ExportDefaultSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_named_specifier(&mut self, node: &ExportNamedSpecifier) {
         <ExportNamedSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_namespace_specifier(&mut self, node: &ExportNamespaceSpecifier) {
         <ExportNamespaceSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_specifier(&mut self, node: &ExportSpecifier) {
         <ExportSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_export_specifiers(&mut self, node: &[ExportSpecifier]) {
         <[ExportSpecifier] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_expr(&mut self, node: &Expr) {
         <Expr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_expr_or_spread(&mut self, node: &ExprOrSpread) {
         <ExprOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_expr_or_spreads(&mut self, node: &[ExprOrSpread]) {
         <[ExprOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_expr_stmt(&mut self, node: &ExprStmt) {
         <ExprStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_exprs(&mut self, node: &[Box<Expr>]) {
         <[Box<Expr>] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_fn_decl(&mut self, node: &FnDecl) {
         <FnDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_fn_expr(&mut self, node: &FnExpr) {
         <FnExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_for_head(&mut self, node: &ForHead) {
         <ForHead as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_for_in_stmt(&mut self, node: &ForInStmt) {
         <ForInStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_for_of_stmt(&mut self, node: &ForOfStmt) {
         <ForOfStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_for_stmt(&mut self, node: &ForStmt) {
         <ForStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_function(&mut self, node: &Function) {
         <Function as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_getter_prop(&mut self, node: &GetterProp) {
         <GetterProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ident(&mut self, node: &Ident) {
         <Ident as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ident_name(&mut self, node: &IdentName) {
         <IdentName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_if_stmt(&mut self, node: &IfStmt) {
         <IfStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import(&mut self, node: &Import) {
         <Import as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_decl(&mut self, node: &ImportDecl) {
         <ImportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_default_specifier(&mut self, node: &ImportDefaultSpecifier) {
         <ImportDefaultSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_named_specifier(&mut self, node: &ImportNamedSpecifier) {
         <ImportNamedSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_phase(&mut self, node: &ImportPhase) {
         <ImportPhase as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_specifier(&mut self, node: &ImportSpecifier) {
         <ImportSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_specifiers(&mut self, node: &[ImportSpecifier]) {
         <[ImportSpecifier] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_star_as_specifier(&mut self, node: &ImportStarAsSpecifier) {
         <ImportStarAsSpecifier as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_with(&mut self, node: &ImportWith) {
         <ImportWith as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_with_item(&mut self, node: &ImportWithItem) {
         <ImportWithItem as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_import_with_items(&mut self, node: &[ImportWithItem]) {
         <[ImportWithItem] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_invalid(&mut self, node: &Invalid) {
         <Invalid as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_attr(&mut self, node: &JSXAttr) {
         <JSXAttr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_attr_name(&mut self, node: &JSXAttrName) {
         <JSXAttrName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_attr_or_spread(&mut self, node: &JSXAttrOrSpread) {
         <JSXAttrOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_attr_or_spreads(&mut self, node: &[JSXAttrOrSpread]) {
         <[JSXAttrOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_attr_value(&mut self, node: &JSXAttrValue) {
         <JSXAttrValue as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_closing_element(&mut self, node: &JSXClosingElement) {
         <JSXClosingElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_closing_fragment(&mut self, node: &JSXClosingFragment) {
         <JSXClosingFragment as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_element(&mut self, node: &JSXElement) {
         <JSXElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_element_child(&mut self, node: &JSXElementChild) {
         <JSXElementChild as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_element_childs(&mut self, node: &[JSXElementChild]) {
         <[JSXElementChild] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_element_name(&mut self, node: &JSXElementName) {
         <JSXElementName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_empty_expr(&mut self, node: &JSXEmptyExpr) {
         <JSXEmptyExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_expr(&mut self, node: &JSXExpr) {
         <JSXExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_expr_container(&mut self, node: &JSXExprContainer) {
         <JSXExprContainer as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_fragment(&mut self, node: &JSXFragment) {
         <JSXFragment as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_member_expr(&mut self, node: &JSXMemberExpr) {
         <JSXMemberExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_namespaced_name(&mut self, node: &JSXNamespacedName) {
         <JSXNamespacedName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_object(&mut self, node: &JSXObject) {
         <JSXObject as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_opening_element(&mut self, node: &JSXOpeningElement) {
         <JSXOpeningElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_opening_fragment(&mut self, node: &JSXOpeningFragment) {
         <JSXOpeningFragment as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_spread_child(&mut self, node: &JSXSpreadChild) {
         <JSXSpreadChild as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_jsx_text(&mut self, node: &JSXText) {
         <JSXText as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_key(&mut self, node: &Key) {
         <Key as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_key_value_pat_prop(&mut self, node: &KeyValuePatProp) {
         <KeyValuePatProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_key_value_prop(&mut self, node: &KeyValueProp) {
         <KeyValueProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_labeled_stmt(&mut self, node: &LabeledStmt) {
         <LabeledStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_lit(&mut self, node: &Lit) {
         <Lit as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_member_expr(&mut self, node: &MemberExpr) {
         <MemberExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_member_prop(&mut self, node: &MemberProp) {
         <MemberProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_meta_prop_expr(&mut self, node: &MetaPropExpr) {
         <MetaPropExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_meta_prop_kind(&mut self, node: &MetaPropKind) {
         <MetaPropKind as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_method_kind(&mut self, node: &MethodKind) {
         <MethodKind as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_method_prop(&mut self, node: &MethodProp) {
         <MethodProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_module(&mut self, node: &Module) {
         <Module as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_module_decl(&mut self, node: &ModuleDecl) {
         <ModuleDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_module_export_name(&mut self, node: &ModuleExportName) {
         <ModuleExportName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_module_item(&mut self, node: &ModuleItem) {
         <ModuleItem as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_module_items(&mut self, node: &[ModuleItem]) {
         <[ModuleItem] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_named_export(&mut self, node: &NamedExport) {
         <NamedExport as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_new_expr(&mut self, node: &NewExpr) {
         <NewExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_null(&mut self, node: &Null) {
         <Null as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_number(&mut self, node: &Number) {
         <Number as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_object_lit(&mut self, node: &ObjectLit) {
         <ObjectLit as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_object_pat(&mut self, node: &ObjectPat) {
         <ObjectPat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_object_pat_prop(&mut self, node: &ObjectPatProp) {
         <ObjectPatProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_object_pat_props(&mut self, node: &[ObjectPatProp]) {
         <[ObjectPatProp] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_accessibility(&mut self, node: &Option<Accessibility>) {
         <Option<Accessibility> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136529,48 +139122,56 @@ pub trait VisitAll {
              [`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 < 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]."]
+    #[inline]
     fn visit_opt_block_stmt(&mut self, node: &Option<BlockStmt>) {
         <Option<BlockStmt> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_call(&mut self, node: &OptCall) {
         <OptCall as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_catch_clause(&mut self, node: &Option<CatchClause>) {
         <Option<CatchClause> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_chain_base(&mut self, node: &OptChainBase) {
         <OptChainBase as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_chain_expr(&mut self, node: &OptChainExpr) {
         <OptChainExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_expr(&mut self, node: &Option<Box<Expr>>) {
         <Option<Box<Expr>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_expr_or_spread(&mut self, node: &Option<ExprOrSpread>) {
         <Option<ExprOrSpread> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136578,18 +139179,21 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_expr_or_spreads(&mut self, node: &Option<Vec<ExprOrSpread>>) {
         <Option<Vec<ExprOrSpread>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_ident(&mut self, node: &Option<Ident>) {
         <Option<Ident> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_jsx_attr_value(&mut self, node: &Option<JSXAttrValue>) {
         <Option<JSXAttrValue> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136597,6 +139201,7 @@ pub trait VisitAll {
              [`Option < JSXClosingElement >::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_jsx_closing_element(&mut self, node: &Option<JSXClosingElement>) {
         <Option<JSXClosingElement> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136604,6 +139209,7 @@ pub trait VisitAll {
              [`Option < ModuleExportName >::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_module_export_name(&mut self, node: &Option<ModuleExportName>) {
         <Option<ModuleExportName> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136611,6 +139217,7 @@ pub trait VisitAll {
              calls [`Option < Vec < ModuleItem > >::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_module_items(&mut self, node: &Option<Vec<ModuleItem>>) {
         <Option<Vec<ModuleItem>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136618,12 +139225,14 @@ pub trait VisitAll {
              [`Option < Box < ObjectLit > >::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_object_lit(&mut self, node: &Option<Box<ObjectLit>>) {
         <Option<Box<ObjectLit>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_pat(&mut self, node: &Option<Pat>) {
         <Option<Pat> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136631,30 +139240,35 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_span(&mut self, node: &Option<swc_common::Span>) {
         <Option<swc_common::Span> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_stmt(&mut self, node: &Option<Box<Stmt>>) {
         <Option<Box<Stmt>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_str(&mut self, node: &Option<Box<Str>>) {
         <Option<Box<Str>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_true_plus_minus(&mut self, node: &Option<TruePlusMinus>) {
         <Option<TruePlusMinus> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_ts_entity_name(&mut self, node: &Option<TsEntityName>) {
         <Option<TsEntityName> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136662,12 +139276,14 @@ pub trait VisitAll {
              [`Option < TsNamespaceBody >::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_ts_namespace_body(&mut self, node: &Option<TsNamespaceBody>) {
         <Option<TsNamespaceBody> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_ts_type(&mut self, node: &Option<Box<TsType>>) {
         <Option<Box<TsType>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136675,6 +139291,7 @@ pub trait VisitAll {
              [`Option < Box < TsTypeAnn > >::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_ts_type_ann(&mut self, node: &Option<Box<TsTypeAnn>>) {
         <Option<Box<TsTypeAnn>> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136682,6 +139299,7 @@ pub trait VisitAll {
              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]."]
+    #[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)
     }
@@ -136689,6 +139307,7 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_ts_type_param_instantiation(
         &mut self,
         node: &Option<Box<TsTypeParamInstantiation>>,
@@ -136700,6 +139319,7 @@ pub trait VisitAll {
     #[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]."]
+    #[inline]
     fn visit_opt_var_decl_or_expr(&mut self, node: &Option<VarDeclOrExpr>) {
         <Option<VarDeclOrExpr> as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136707,24 +139327,28 @@ pub trait VisitAll {
              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]."]
+    #[inline]
     fn visit_opt_vec_expr_or_spreads(&mut self, node: &[Option<ExprOrSpread>]) {
         <[Option<ExprOrSpread>] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_opt_vec_pats(&mut self, node: &[Option<Pat>]) {
         <[Option<Pat>] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_param(&mut self, node: &Param) {
         <Param as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_param_or_ts_param_prop(&mut self, node: &ParamOrTsParamProp) {
         <ParamOrTsParamProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136732,198 +139356,231 @@ pub trait VisitAll {
              [`Vec < ParamOrTsParamProp >::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_param_or_ts_param_props(&mut self, node: &[ParamOrTsParamProp]) {
         <[ParamOrTsParamProp] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_params(&mut self, node: &[Param]) {
         <[Param] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_paren_expr(&mut self, node: &ParenExpr) {
         <ParenExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_pat(&mut self, node: &Pat) {
         <Pat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_pats(&mut self, node: &[Pat]) {
         <[Pat] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_private_method(&mut self, node: &PrivateMethod) {
         <PrivateMethod as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_private_name(&mut self, node: &PrivateName) {
         <PrivateName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_private_prop(&mut self, node: &PrivateProp) {
         <PrivateProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_program(&mut self, node: &Program) {
         <Program as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_prop(&mut self, node: &Prop) {
         <Prop as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_prop_name(&mut self, node: &PropName) {
         <PropName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_prop_or_spread(&mut self, node: &PropOrSpread) {
         <PropOrSpread as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_prop_or_spreads(&mut self, node: &[PropOrSpread]) {
         <[PropOrSpread] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_regex(&mut self, node: &Regex) {
         <Regex as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ReservedUnused`.\n\nBy default, this method calls \
              [`ReservedUnused::visit_children_with`]. This method unconditionally calls the \
              visitor method for all children because it's defined in the trait [VisitAll]."]
+    #[inline]
     fn visit_reserved_unused(&mut self, node: &ReservedUnused) {
         <ReservedUnused as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_rest_pat(&mut self, node: &RestPat) {
         <RestPat as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_return_stmt(&mut self, node: &ReturnStmt) {
         <ReturnStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_script(&mut self, node: &Script) {
         <Script as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_seq_expr(&mut self, node: &SeqExpr) {
         <SeqExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_setter_prop(&mut self, node: &SetterProp) {
         <SetterProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_simple_assign_target(&mut self, node: &SimpleAssignTarget) {
         <SimpleAssignTarget 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 `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]."]
+    #[inline]
     fn visit_spread_element(&mut self, node: &SpreadElement) {
         <SpreadElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_static_block(&mut self, node: &StaticBlock) {
         <StaticBlock as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_stmt(&mut self, node: &Stmt) {
         <Stmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_stmts(&mut self, node: &[Stmt]) {
         <[Stmt] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_str(&mut self, node: &Str) {
         <Str as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_super(&mut self, node: &Super) {
         <Super as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_super_prop(&mut self, node: &SuperProp) {
         <SuperProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_super_prop_expr(&mut self, node: &SuperPropExpr) {
         <SuperPropExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_switch_case(&mut self, node: &SwitchCase) {
         <SwitchCase as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_switch_cases(&mut self, node: &[SwitchCase]) {
         <[SwitchCase] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_switch_stmt(&mut self, node: &SwitchStmt) {
         <SwitchStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -136931,138 +139588,161 @@ pub trait VisitAll {
              [`swc_common :: SyntaxContext::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_syntax_context(&mut self, node: &swc_common::SyntaxContext) {
         <swc_common::SyntaxContext as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_tagged_tpl(&mut self, node: &TaggedTpl) {
         <TaggedTpl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_this_expr(&mut self, node: &ThisExpr) {
         <ThisExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_throw_stmt(&mut self, node: &ThrowStmt) {
         <ThrowStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_tpl(&mut self, node: &Tpl) {
         <Tpl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_tpl_element(&mut self, node: &TplElement) {
         <TplElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_tpl_elements(&mut self, node: &[TplElement]) {
         <[TplElement] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_true_plus_minus(&mut self, node: &TruePlusMinus) {
         <TruePlusMinus as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_try_stmt(&mut self, node: &TryStmt) {
         <TryStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_array_type(&mut self, node: &TsArrayType) {
         <TsArrayType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_as_expr(&mut self, node: &TsAsExpr) {
         <TsAsExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_call_signature_decl(&mut self, node: &TsCallSignatureDecl) {
         <TsCallSignatureDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_conditional_type(&mut self, node: &TsConditionalType) {
         <TsConditionalType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_const_assertion(&mut self, node: &TsConstAssertion) {
         <TsConstAssertion as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_construct_signature_decl(&mut self, node: &TsConstructSignatureDecl) {
         <TsConstructSignatureDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_constructor_type(&mut self, node: &TsConstructorType) {
         <TsConstructorType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_entity_name(&mut self, node: &TsEntityName) {
         <TsEntityName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_enum_decl(&mut self, node: &TsEnumDecl) {
         <TsEnumDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_enum_member(&mut self, node: &TsEnumMember) {
         <TsEnumMember as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_enum_member_id(&mut self, node: &TsEnumMemberId) {
         <TsEnumMemberId as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_enum_members(&mut self, node: &[TsEnumMember]) {
         <[TsEnumMember] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_export_assignment(&mut self, node: &TsExportAssignment) {
         <TsExportAssignment as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_expr_with_type_args(&mut self, node: &TsExprWithTypeArgs) {
         <TsExprWithTypeArgs as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -137070,468 +139750,546 @@ pub trait VisitAll {
              [`Vec < TsExprWithTypeArgs >::visit_children_with`]. This method unconditionally \
              calls the visitor method for all children because it's defined in the trait \
              [VisitAll]."]
+    #[inline]
     fn visit_ts_expr_with_type_argss(&mut self, node: &[TsExprWithTypeArgs]) {
         <[TsExprWithTypeArgs] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_external_module_ref(&mut self, node: &TsExternalModuleRef) {
         <TsExternalModuleRef as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_fn_or_constructor_type(&mut self, node: &TsFnOrConstructorType) {
         <TsFnOrConstructorType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_fn_param(&mut self, node: &TsFnParam) {
         <TsFnParam as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_fn_params(&mut self, node: &[TsFnParam]) {
         <[TsFnParam] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_fn_type(&mut self, node: &TsFnType) {
         <TsFnType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_getter_signature(&mut self, node: &TsGetterSignature) {
         <TsGetterSignature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_import_equals_decl(&mut self, node: &TsImportEqualsDecl) {
         <TsImportEqualsDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_import_type(&mut self, node: &TsImportType) {
         <TsImportType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_index_signature(&mut self, node: &TsIndexSignature) {
         <TsIndexSignature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_indexed_access_type(&mut self, node: &TsIndexedAccessType) {
         <TsIndexedAccessType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_infer_type(&mut self, node: &TsInferType) {
         <TsInferType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_instantiation(&mut self, node: &TsInstantiation) {
         <TsInstantiation as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_interface_body(&mut self, node: &TsInterfaceBody) {
         <TsInterfaceBody as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_interface_decl(&mut self, node: &TsInterfaceDecl) {
         <TsInterfaceDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_intersection_type(&mut self, node: &TsIntersectionType) {
         <TsIntersectionType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_keyword_type(&mut self, node: &TsKeywordType) {
         <TsKeywordType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_keyword_type_kind(&mut self, node: &TsKeywordTypeKind) {
         <TsKeywordTypeKind as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_lit(&mut self, node: &TsLit) {
         <TsLit as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_lit_type(&mut self, node: &TsLitType) {
         <TsLitType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_mapped_type(&mut self, node: &TsMappedType) {
         <TsMappedType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_method_signature(&mut self, node: &TsMethodSignature) {
         <TsMethodSignature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_module_block(&mut self, node: &TsModuleBlock) {
         <TsModuleBlock as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_module_decl(&mut self, node: &TsModuleDecl) {
         <TsModuleDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_module_name(&mut self, node: &TsModuleName) {
         <TsModuleName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_module_ref(&mut self, node: &TsModuleRef) {
         <TsModuleRef as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_namespace_body(&mut self, node: &TsNamespaceBody) {
         <TsNamespaceBody as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_namespace_decl(&mut self, node: &TsNamespaceDecl) {
         <TsNamespaceDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_namespace_export_decl(&mut self, node: &TsNamespaceExportDecl) {
         <TsNamespaceExportDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_non_null_expr(&mut self, node: &TsNonNullExpr) {
         <TsNonNullExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_optional_type(&mut self, node: &TsOptionalType) {
         <TsOptionalType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_param_prop(&mut self, node: &TsParamProp) {
         <TsParamProp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_param_prop_param(&mut self, node: &TsParamPropParam) {
         <TsParamPropParam as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_parenthesized_type(&mut self, node: &TsParenthesizedType) {
         <TsParenthesizedType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_property_signature(&mut self, node: &TsPropertySignature) {
         <TsPropertySignature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_qualified_name(&mut self, node: &TsQualifiedName) {
         <TsQualifiedName as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_rest_type(&mut self, node: &TsRestType) {
         <TsRestType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_satisfies_expr(&mut self, node: &TsSatisfiesExpr) {
         <TsSatisfiesExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_setter_signature(&mut self, node: &TsSetterSignature) {
         <TsSetterSignature as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_this_type(&mut self, node: &TsThisType) {
         <TsThisType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_this_type_or_ident(&mut self, node: &TsThisTypeOrIdent) {
         <TsThisTypeOrIdent as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_tpl_lit_type(&mut self, node: &TsTplLitType) {
         <TsTplLitType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_tuple_element(&mut self, node: &TsTupleElement) {
         <TsTupleElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_tuple_elements(&mut self, node: &[TsTupleElement]) {
         <[TsTupleElement] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_tuple_type(&mut self, node: &TsTupleType) {
         <TsTupleType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type(&mut self, node: &TsType) {
         <TsType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_alias_decl(&mut self, node: &TsTypeAliasDecl) {
         <TsTypeAliasDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_ann(&mut self, node: &TsTypeAnn) {
         <TsTypeAnn as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_assertion(&mut self, node: &TsTypeAssertion) {
         <TsTypeAssertion as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_element(&mut self, node: &TsTypeElement) {
         <TsTypeElement as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_elements(&mut self, node: &[TsTypeElement]) {
         <[TsTypeElement] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_lit(&mut self, node: &TsTypeLit) {
         <TsTypeLit as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_operator(&mut self, node: &TsTypeOperator) {
         <TsTypeOperator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_operator_op(&mut self, node: &TsTypeOperatorOp) {
         <TsTypeOperatorOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_param(&mut self, node: &TsTypeParam) {
         <TsTypeParam as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_param_decl(&mut self, node: &TsTypeParamDecl) {
         <TsTypeParamDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_param_instantiation(&mut self, node: &TsTypeParamInstantiation) {
         <TsTypeParamInstantiation as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_params(&mut self, node: &[TsTypeParam]) {
         <[TsTypeParam] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_predicate(&mut self, node: &TsTypePredicate) {
         <TsTypePredicate as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_query(&mut self, node: &TsTypeQuery) {
         <TsTypeQuery as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_query_expr(&mut self, node: &TsTypeQueryExpr) {
         <TsTypeQueryExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_type_ref(&mut self, node: &TsTypeRef) {
         <TsTypeRef as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_types(&mut self, node: &[Box<TsType>]) {
         <[Box<TsType>] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_union_or_intersection_type(&mut self, node: &TsUnionOrIntersectionType) {
         <TsUnionOrIntersectionType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_ts_union_type(&mut self, node: &TsUnionType) {
         <TsUnionType as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_unary_expr(&mut self, node: &UnaryExpr) {
         <UnaryExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_unary_op(&mut self, node: &UnaryOp) {
         <UnaryOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_update_expr(&mut self, node: &UpdateExpr) {
         <UpdateExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_update_op(&mut self, node: &UpdateOp) {
         <UpdateOp as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_using_decl(&mut self, node: &UsingDecl) {
         <UsingDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_var_decl(&mut self, node: &VarDecl) {
         <VarDecl as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_var_decl_kind(&mut self, node: &VarDeclKind) {
         <VarDeclKind as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_var_decl_or_expr(&mut self, node: &VarDeclOrExpr) {
         <VarDeclOrExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_var_declarator(&mut self, node: &VarDeclarator) {
         <VarDeclarator as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_var_declarators(&mut self, node: &[VarDeclarator]) {
         <[VarDeclarator] as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_while_stmt(&mut self, node: &WhileStmt) {
         <WhileStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_with_stmt(&mut self, node: &WithStmt) {
         <WithStmt as VisitAllWith<Self>>::visit_children_with(node, self)
     }
     #[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]."]
+    #[inline]
     fn visit_yield_expr(&mut self, node: &YieldExpr) {
         <YieldExpr as VisitAllWith<Self>>::visit_children_with(node, self)
     }
@@ -151156,30 +153914,36 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for YieldExpr {
 }
 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)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_big_int_value(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ClassMember] {
     #[doc = "Calls [VisitAll`::visit_class_members`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_class_members(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ClassMember as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151187,10 +153951,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ClassMember] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Decorator] {
     #[doc = "Calls [VisitAll`::visit_decorators`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_decorators(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Decorator as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151198,10 +153964,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Decorator] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExportSpecifier] {
     #[doc = "Calls [VisitAll`::visit_export_specifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_export_specifiers(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ExportSpecifier as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151209,10 +153977,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExportSpecifier] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExprOrSpread] {
     #[doc = "Calls [VisitAll`::visit_expr_or_spreads`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_expr_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ExprOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151220,10 +153990,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ExprOrSpread] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<Expr>] {
     #[doc = "Calls [VisitAll`::visit_exprs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_exprs(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Box<Expr> as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151231,10 +154003,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<Expr>] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportSpecifier] {
     #[doc = "Calls [VisitAll`::visit_import_specifiers`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_import_specifiers(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ImportSpecifier as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151242,10 +154016,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportSpecifier] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportWithItem] {
     #[doc = "Calls [VisitAll`::visit_import_with_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_import_with_items(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ImportWithItem as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151253,10 +154029,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ImportWithItem] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXAttrOrSpread] {
     #[doc = "Calls [VisitAll`::visit_jsx_attr_or_spreads`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_jsx_attr_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <JSXAttrOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151264,10 +154042,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXAttrOrSpread] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXElementChild] {
     #[doc = "Calls [VisitAll`::visit_jsx_element_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_jsx_element_childs(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <JSXElementChild as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151275,10 +154055,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [JSXElementChild] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ModuleItem] {
     #[doc = "Calls [VisitAll`::visit_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_module_items(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ModuleItem as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151286,10 +154068,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ModuleItem] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ObjectPatProp] {
     #[doc = "Calls [VisitAll`::visit_object_pat_props`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_object_pat_props(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ObjectPatProp as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151297,10 +154081,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ObjectPatProp] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Accessibility> {
     #[doc = "Calls [VisitAll`::visit_opt_accessibility`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_accessibility(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Accessibility as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151310,10 +154096,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Accessibility> {
 }
 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),
@@ -151323,10 +154111,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<BlockStmt> {
     #[doc = "Calls [VisitAll`::visit_opt_block_stmt`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_block_stmt(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <BlockStmt as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151336,10 +154126,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<BlockStmt> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<CatchClause> {
     #[doc = "Calls [VisitAll`::visit_opt_catch_clause`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_catch_clause(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <CatchClause as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151349,10 +154141,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<CatchClause> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Expr>> {
     #[doc = "Calls [VisitAll`::visit_opt_expr`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_expr(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Expr> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151362,10 +154156,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Expr>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ExprOrSpread> {
     #[doc = "Calls [VisitAll`::visit_opt_expr_or_spread`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_expr_or_spread(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <ExprOrSpread as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151375,10 +154171,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ExprOrSpread> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<ExprOrSpread>> {
     #[doc = "Calls [VisitAll`::visit_opt_expr_or_spreads`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_expr_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<ExprOrSpread> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151388,10 +154186,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<ExprOrSpread>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
     #[doc = "Calls [VisitAll`::visit_opt_ident`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ident(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Ident as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151401,10 +154201,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Ident> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXAttrValue> {
     #[doc = "Calls [VisitAll`::visit_opt_jsx_attr_value`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_jsx_attr_value(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <JSXAttrValue as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151414,10 +154216,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXAttrValue> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXClosingElement> {
     #[doc = "Calls [VisitAll`::visit_opt_jsx_closing_element`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_jsx_closing_element(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <JSXClosingElement as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151427,10 +154231,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<JSXClosingElement> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ModuleExportName> {
     #[doc = "Calls [VisitAll`::visit_opt_module_export_name`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_module_export_name(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <ModuleExportName as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151440,10 +154246,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<ModuleExportName> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<ModuleItem>> {
     #[doc = "Calls [VisitAll`::visit_opt_module_items`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_module_items(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Vec<ModuleItem> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151453,10 +154261,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Vec<ModuleItem>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ObjectLit>> {
     #[doc = "Calls [VisitAll`::visit_opt_object_lit`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_object_lit(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<ObjectLit> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151466,10 +154276,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<ObjectLit>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Pat> {
     #[doc = "Calls [VisitAll`::visit_opt_pat`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_pat(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Pat as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151479,10 +154291,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Pat> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_common::Span> {
     #[doc = "Calls [VisitAll`::visit_opt_span`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_span(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_common::Span as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151492,10 +154306,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_common::Span> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Stmt>> {
     #[doc = "Calls [VisitAll`::visit_opt_stmt`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_stmt(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Stmt> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151505,10 +154321,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Stmt>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Str>> {
     #[doc = "Calls [VisitAll`::visit_opt_str`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_str(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<Str> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151518,10 +154336,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<Str>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TruePlusMinus> {
     #[doc = "Calls [VisitAll`::visit_opt_true_plus_minus`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_true_plus_minus(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <TruePlusMinus as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151531,10 +154351,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TruePlusMinus> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsEntityName> {
     #[doc = "Calls [VisitAll`::visit_opt_ts_entity_name`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ts_entity_name(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <TsEntityName as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151544,10 +154366,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsEntityName> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsNamespaceBody> {
     #[doc = "Calls [VisitAll`::visit_opt_ts_namespace_body`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ts_namespace_body(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <TsNamespaceBody as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151557,10 +154381,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<TsNamespaceBody> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsType>> {
     #[doc = "Calls [VisitAll`::visit_opt_ts_type`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ts_type(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TsType> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151570,10 +154396,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsType>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeAnn>> {
     #[doc = "Calls [VisitAll`::visit_opt_ts_type_ann`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ts_type_ann(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TsTypeAnn> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151583,10 +154411,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeAnn>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamDecl>> {
     #[doc = "Calls [VisitAll`::visit_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_decl(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Box<TsTypeParamDecl> as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151596,10 +154426,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamDecl>> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamInstantiation>> {
     #[doc = "Calls [VisitAll`::visit_opt_ts_type_param_instantiation`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_ts_type_param_instantiation(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => {
@@ -151611,10 +154443,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Box<TsTypeParamInstantiati
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<VarDeclOrExpr> {
     #[doc = "Calls [VisitAll`::visit_opt_var_decl_or_expr`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_var_decl_or_expr(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <VarDeclOrExpr as VisitAllWith<V>>::visit_with(inner, visitor),
@@ -151624,10 +154458,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<VarDeclOrExpr> {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<ExprOrSpread>] {
     #[doc = "Calls [VisitAll`::visit_opt_vec_expr_or_spreads`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::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 VisitAllWith<V>>::visit_with(item, visitor))
@@ -151635,10 +154471,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<ExprOrSpread>] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<Pat>] {
     #[doc = "Calls [VisitAll`::visit_opt_vec_pats`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_opt_vec_pats(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Option<Pat> as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151646,10 +154484,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Option<Pat>] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ParamOrTsParamProp] {
     #[doc = "Calls [VisitAll`::visit_param_or_ts_param_props`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_param_or_ts_param_props(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <ParamOrTsParamProp as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151657,10 +154497,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [ParamOrTsParamProp] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Param] {
     #[doc = "Calls [VisitAll`::visit_params`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_params(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Param as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151668,10 +154510,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Param] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Pat] {
     #[doc = "Calls [VisitAll`::visit_pats`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_pats(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Pat as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151679,10 +154523,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Pat] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PropOrSpread] {
     #[doc = "Calls [VisitAll`::visit_prop_or_spreads`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_prop_or_spreads(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <PropOrSpread as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151690,20 +154536,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [PropOrSpread] {
 }
 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: ?Sized + VisitAll> VisitAllWith<V> for [Stmt] {
     #[doc = "Calls [VisitAll`::visit_stmts`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_stmts(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Stmt as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151711,10 +154561,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Stmt] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SwitchCase] {
     #[doc = "Calls [VisitAll`::visit_switch_cases`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_switch_cases(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <SwitchCase as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151722,20 +154574,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [SwitchCase] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for swc_common::SyntaxContext {
     #[doc = "Calls [VisitAll`::visit_syntax_context`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_syntax_context(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         {}
     }
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TplElement] {
     #[doc = "Calls [VisitAll`::visit_tpl_elements`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_tpl_elements(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TplElement as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151743,10 +154599,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TplElement] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsEnumMember] {
     #[doc = "Calls [VisitAll`::visit_ts_enum_members`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_enum_members(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsEnumMember as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151754,10 +154612,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsEnumMember] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsExprWithTypeArgs] {
     #[doc = "Calls [VisitAll`::visit_ts_expr_with_type_argss`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_expr_with_type_argss(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsExprWithTypeArgs as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151765,10 +154625,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsExprWithTypeArgs] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsFnParam] {
     #[doc = "Calls [VisitAll`::visit_ts_fn_params`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_fn_params(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsFnParam as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151776,10 +154638,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsFnParam] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTupleElement] {
     #[doc = "Calls [VisitAll`::visit_ts_tuple_elements`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_tuple_elements(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsTupleElement as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151787,10 +154651,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTupleElement] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeElement] {
     #[doc = "Calls [VisitAll`::visit_ts_type_elements`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_type_elements(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsTypeElement as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151798,10 +154664,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeElement] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeParam] {
     #[doc = "Calls [VisitAll`::visit_ts_type_params`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_type_params(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <TsTypeParam as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151809,10 +154677,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [TsTypeParam] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<TsType>] {
     #[doc = "Calls [VisitAll`::visit_ts_types`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_ts_types(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Box<TsType> as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151820,10 +154690,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Box<TsType>] {
 }
 impl<V: ?Sized + VisitAll> VisitAllWith<V> for [VarDeclarator] {
     #[doc = "Calls [VisitAll`::visit_var_declarators`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as VisitAll>::visit_var_declarators(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <VarDeclarator as VisitAllWith<V>>::visit_with(item, visitor))
@@ -151834,11 +154706,13 @@ 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
@@ -151849,11 +154723,13 @@ 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
diff --git a/crates/swc_html_visit/src/generated.rs b/crates/swc_html_visit/src/generated.rs
index 4e229ff7f499..6bc0b0a5f475 100644
--- a/crates/swc_html_visit/src/generated.rs
+++ b/crates/swc_html_visit/src/generated.rs
@@ -8,132 +8,155 @@ pub trait Visit {
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
              [`swc_atoms :: Atom::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attribute(&mut self, node: &Attribute) {
         <Attribute as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attribute_token(&mut self, node: &AttributeToken) {
         <AttributeToken as VisitWith<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`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
         <[AttributeToken] as VisitWith<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`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attributes(&mut self, node: &[Attribute]) {
         <[Attribute] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_child(&mut self, node: &Child) {
         <Child as VisitWith<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`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_childs(&mut self, node: &[Child]) {
         <[Child] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_comment(&mut self, node: &Comment) {
         <Comment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document(&mut self, node: &Document) {
         <Document as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::visit_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_document_fragment(&mut self, node: &DocumentFragment) {
         <DocumentFragment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document_mode(&mut self, node: &DocumentMode) {
         <DocumentMode as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document_type(&mut self, node: &DocumentType) {
         <DocumentType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_element(&mut self, node: &Element) {
         <Element as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
              [`Namespace::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_namespace(&mut self, node: &Namespace) {
         <Namespace as VisitWith<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`]. 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 VisitWith<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`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_opt_document_fragment(&mut self, node: &Option<DocumentFragment>) {
         <Option<DocumentFragment> as VisitWith<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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
         <Option<Namespace> as VisitWith<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`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_raw(&mut self, node: &Option<Raw>) {
         <Option<Raw> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_raw(&mut self, node: &Raw) {
         <Raw as VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_text(&mut self, node: &Text) {
         <Text as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
              [`Token::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_token(&mut self, node: &Token) {
         <Token as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
              [`TokenAndSpan::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
         <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self)
     }
@@ -1307,20 +1330,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for TokenAndSpan {
 }
 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 [AttributeToken] {
     #[doc = "Calls [Visit`::visit_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <AttributeToken as VisitWith<V>>::visit_with(item, visitor))
@@ -1328,10 +1355,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [AttributeToken] {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for [Attribute] {
     #[doc = "Calls [Visit`::visit_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_attributes(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Attribute as VisitWith<V>>::visit_with(item, visitor))
@@ -1339,10 +1368,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Attribute] {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for [Child] {
     #[doc = "Calls [Visit`::visit_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_childs(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Child as VisitWith<V>>::visit_with(item, visitor))
@@ -1350,10 +1381,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Child] {
 }
 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),
@@ -1363,10 +1396,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for Option<DocumentFragment> {
     #[doc = "Calls [Visit`::visit_opt_document_fragment`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_opt_document_fragment(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <DocumentFragment as VisitWith<V>>::visit_with(inner, visitor),
@@ -1376,10 +1411,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<DocumentFragment> {
 }
 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),
@@ -1389,10 +1426,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Namespace> {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for Option<Raw> {
     #[doc = "Calls [Visit`::visit_opt_raw`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_opt_raw(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         match self {
             Some(inner) => <Raw as VisitWith<V>>::visit_with(inner, visitor),
@@ -1402,10 +1441,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Raw> {
 }
 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) {
         {}
     }
@@ -1415,11 +1456,13 @@ 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
@@ -1430,11 +1473,13 @@ 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
@@ -1447,6 +1492,7 @@ pub trait VisitAstPath {
     #[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,
@@ -1459,6 +1505,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attribute<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Attribute,
@@ -1469,6 +1516,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_attribute_token<'ast: 'r, 'r>(
         &mut self,
         node: &'ast AttributeToken,
@@ -1481,6 +1529,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_attribute_tokens<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [AttributeToken],
@@ -1493,6 +1542,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attributes<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [Attribute],
@@ -1505,12 +1555,14 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_child<'ast: 'r, 'r>(&mut self, node: &'ast Child, __ast_path: &mut AstNodePath<'r>) {
         <Child as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_childs<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [Child],
@@ -1521,6 +1573,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_comment<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Comment,
@@ -1531,6 +1584,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_document<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Document,
@@ -1541,6 +1595,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_document_fragment<'ast: 'r, 'r>(
         &mut self,
         node: &'ast DocumentFragment,
@@ -1553,6 +1608,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_document_mode<'ast: 'r, 'r>(
         &mut self,
         node: &'ast DocumentMode,
@@ -1565,6 +1621,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_document_type<'ast: 'r, 'r>(
         &mut self,
         node: &'ast DocumentType,
@@ -1577,6 +1634,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_element<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Element,
@@ -1587,6 +1645,7 @@ pub trait VisitAstPath {
     #[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,
@@ -1597,6 +1656,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -1609,6 +1669,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
              [`Option < DocumentFragment >::visit_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_opt_document_fragment<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Option<DocumentFragment>,
@@ -1621,6 +1682,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -1633,6 +1695,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Option < Raw >`.\n\nBy default, this method calls [`Option < \
              Raw >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_opt_raw<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Option<Raw>,
@@ -1645,12 +1708,14 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_raw<'ast: 'r, 'r>(&mut self, node: &'ast Raw, __ast_path: &mut AstNodePath<'r>) {
         <Raw 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,
@@ -1663,18 +1728,21 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_text<'ast: 'r, 'r>(&mut self, node: &'ast Text, __ast_path: &mut AstNodePath<'r>) {
         <Text 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,
@@ -3699,6 +3767,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TokenAndSpan {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3707,6 +3776,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
         <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3719,6 +3789,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
     #[doc = "Calls [VisitAstPath`::visit_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3727,6 +3798,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
         <V as VisitAstPath>::visit_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3741,6 +3813,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
     #[doc = "Calls [VisitAstPath`::visit_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3749,6 +3822,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
         <V as VisitAstPath>::visit_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3763,6 +3837,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
     #[doc = "Calls [VisitAstPath`::visit_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3771,6 +3846,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
         <V as VisitAstPath>::visit_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3785,6 +3861,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3793,6 +3870,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
         <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3810,6 +3888,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<DocumentFragment> {
     #[doc = "Calls [VisitAstPath`::visit_opt_document_fragment`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3818,6 +3897,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<DocumentFragment>
         <V as VisitAstPath>::visit_opt_document_fragment(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3835,6 +3915,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<DocumentFragment>
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3843,6 +3924,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
         <V as VisitAstPath>::visit_opt_namespace(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3860,6 +3942,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Raw> {
     #[doc = "Calls [VisitAstPath`::visit_opt_raw`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3868,6 +3951,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Raw> {
         <V as VisitAstPath>::visit_opt_raw(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3885,6 +3969,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Raw> {
 #[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,
@@ -3893,6 +3978,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
         <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3908,6 +3994,7 @@ where
     V: ?Sized + VisitAstPath,
     T: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3917,6 +4004,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3934,6 +4022,7 @@ where
     V: ?Sized + VisitAstPath,
     [T]: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3943,6 +4032,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3958,137 +4048,160 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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 `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_attribute(&mut self, node: &mut Attribute) {
         <Attribute as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_attribute_token(&mut self, node: &mut AttributeToken) {
         <AttributeToken as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_mut_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attribute_tokens(&mut self, node: &mut Vec<AttributeToken>) {
         <Vec<AttributeToken> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_attributes(&mut self, node: &mut Vec<Attribute>) {
         <Vec<Attribute> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_child(&mut self, node: &mut Child) {
         <Child as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_mut_childs(&mut self, node: &mut Vec<Child>) {
         <Vec<Child> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_comment(&mut self, node: &mut Comment) {
         <Comment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_document(&mut self, node: &mut Document) {
         <Document as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::visit_mut_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_document_fragment(&mut self, node: &mut DocumentFragment) {
         <DocumentFragment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_document_mode(&mut self, node: &mut DocumentMode) {
         <DocumentMode as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_document_type(&mut self, node: &mut DocumentType) {
         <DocumentType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_element(&mut self, node: &mut Element) {
         <Element 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
              [`Option < DocumentFragment >::visit_mut_children_with`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_opt_document_fragment(&mut self, node: &mut Option<DocumentFragment>) {
         <Option<DocumentFragment> 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`]. 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)
     }
     #[doc = "Visit a node of type `Option < Raw >`.\n\nBy default, this method calls [`Option < \
              Raw >::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_opt_raw(&mut self, node: &mut Option<Raw>) {
         <Option<Raw> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_raw(&mut self, node: &mut Raw) {
         <Raw 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`]. 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)
     }
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_text(&mut self, node: &mut Text) {
         <Text 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`]. 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)
     }
     #[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)
     }
@@ -5136,20 +5249,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TokenAndSpan {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<AttributeToken> {
     #[doc = "Calls [VisitMut`::visit_mut_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <AttributeToken as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -5157,10 +5274,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<AttributeToken> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Attribute> {
     #[doc = "Calls [VisitMut`::visit_mut_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_attributes(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <Attribute as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -5168,10 +5287,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Attribute> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Child> {
     #[doc = "Calls [VisitMut`::visit_mut_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_childs(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <Child as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -5179,10 +5300,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Child> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -5192,10 +5315,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<DocumentFragment> {
     #[doc = "Calls [VisitMut`::visit_mut_opt_document_fragment`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_document_fragment(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <DocumentFragment as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -5205,10 +5330,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<DocumentFragment> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Namespace as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -5218,10 +5345,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Namespace> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Raw> {
     #[doc = "Calls [VisitMut`::visit_mut_opt_raw`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_raw(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Raw as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -5231,10 +5360,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Raw> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
@@ -5244,11 +5375,13 @@ where
     V: ?Sized + VisitMut,
     T: VisitMutWith<V>,
 {
+    #[inline]
     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(&mut self, visitor: &mut V) {
         let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
@@ -5261,6 +5394,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5269,6 +5403,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attribute(&mut self, node: &mut Attribute, __ast_path: &mut AstKindPath) {
         <Attribute as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5277,6 +5412,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_attribute_token(
         &mut self,
         node: &mut AttributeToken,
@@ -5289,6 +5425,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_attribute_tokens(
         &mut self,
         node: &mut Vec<AttributeToken>,
@@ -5301,6 +5438,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attributes(&mut self, node: &mut Vec<Attribute>, __ast_path: &mut AstKindPath) {
         <Vec<Attribute> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5309,6 +5447,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_child(&mut self, node: &mut Child, __ast_path: &mut AstKindPath) {
         <Child as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5317,6 +5456,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_childs(&mut self, node: &mut Vec<Child>, __ast_path: &mut AstKindPath) {
         <Vec<Child> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5325,6 +5465,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_comment(&mut self, node: &mut Comment, __ast_path: &mut AstKindPath) {
         <Comment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5333,6 +5474,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_document(&mut self, node: &mut Document, __ast_path: &mut AstKindPath) {
         <Document as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5341,6 +5483,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_document_fragment(
         &mut self,
         node: &mut DocumentFragment,
@@ -5353,6 +5496,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_document_mode(&mut self, node: &mut DocumentMode, __ast_path: &mut AstKindPath) {
         <DocumentMode as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5361,6 +5505,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_document_type(&mut self, node: &mut DocumentType, __ast_path: &mut AstKindPath) {
         <DocumentType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5369,6 +5514,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_element(&mut self, node: &mut Element, __ast_path: &mut AstKindPath) {
         <Element as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5377,6 +5523,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5385,6 +5532,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_atom(
         &mut self,
         node: &mut Option<swc_atoms::Atom>,
@@ -5397,6 +5545,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
              [`Option < DocumentFragment >::visit_mut_children_with_ast_path`]. If you want to \
              recurse, you need to call it manually."]
+    #[inline]
     fn visit_mut_opt_document_fragment(
         &mut self,
         node: &mut Option<DocumentFragment>,
@@ -5409,6 +5558,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_namespace(
         &mut self,
         node: &mut Option<Namespace>,
@@ -5421,6 +5571,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Option < Raw >`.\n\nBy default, this method calls [`Option < \
              Raw >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_opt_raw(&mut self, node: &mut Option<Raw>, __ast_path: &mut AstKindPath) {
         <Option<Raw> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5429,12 +5580,14 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_raw(&mut self, node: &mut Raw, __ast_path: &mut AstKindPath) {
         <Raw 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::visit_mut_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, __ast_path: &mut AstKindPath) {
         <swc_common::Span as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5443,6 +5596,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_text(&mut self, node: &mut Text, __ast_path: &mut AstKindPath) {
         <Text as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5451,6 +5605,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5459,6 +5614,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -7083,10 +7239,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TokenAndSpan {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -7095,10 +7253,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<AttributeToken> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_tokens`] 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_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <AttributeToken as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -7111,10 +7271,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<AttributeToken>
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Attribute> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_attributes`] 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_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Attribute as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -7127,10 +7289,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Attribute> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Child> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_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_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Child as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -7141,10 +7305,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Child> {
 #[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 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 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(
@@ -7158,10 +7324,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::A
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<DocumentFragment> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_document_fragment`] 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_document_fragment(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => <DocumentFragment as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -7175,10 +7343,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<DocumentFrag
 #[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 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 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(
@@ -7192,10 +7362,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Namespace> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Raw> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_opt_raw`] 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_raw(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         match self {
             Some(inner) => {
@@ -7209,10 +7381,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Raw> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -7224,6 +7398,7 @@ where
     V: ?Sized + VisitMutAstPath,
     T: VisitMutWithAstPath<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,
@@ -7233,6 +7408,7 @@ where
         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,
@@ -7247,92 +7423,108 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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 `Attribute`.\n\nBy default, this method calls \
              [`Attribute::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute(&mut self, node: Attribute) -> Attribute {
         <Attribute as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute_token(&mut self, node: AttributeToken) -> AttributeToken {
         <AttributeToken as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute_tokens(&mut self, node: Vec<AttributeToken>) -> Vec<AttributeToken> {
         <Vec<AttributeToken> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attributes(&mut self, node: Vec<Attribute>) -> Vec<Attribute> {
         <Vec<Attribute> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_child(&mut self, node: Child) -> Child {
         <Child as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_childs(&mut self, node: Vec<Child>) -> Vec<Child> {
         <Vec<Child> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_comment(&mut self, node: Comment) -> Comment {
         <Comment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document(&mut self, node: Document) -> Document {
         <Document as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_fragment(&mut self, node: DocumentFragment) -> DocumentFragment {
         <DocumentFragment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_mode(&mut self, node: DocumentMode) -> DocumentMode {
         <DocumentMode as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_type(&mut self, node: DocumentType) -> DocumentType {
         <DocumentType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_element(&mut self, node: Element) -> Element {
         <Element 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
              [`Option < DocumentFragment >::fold_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_opt_document_fragment(
         &mut self,
         node: Option<DocumentFragment>,
@@ -7342,38 +7534,45 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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 < Raw >`.\n\nBy default, this method calls [`Option < \
              Raw >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_opt_raw(&mut self, node: Option<Raw>) -> Option<Raw> {
         <Option<Raw> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_raw(&mut self, node: Raw) -> Raw {
         <Raw 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`]. 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)
     }
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_text(&mut self, node: Text) -> Text {
         <Text 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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
         <TokenAndSpan as FoldWith<Self>>::fold_children_with(node, self)
     }
@@ -8425,20 +8624,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for TokenAndSpan {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
     #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<AttributeToken> {
     #[doc = "Calls [Fold`::fold_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <AttributeToken as FoldWith<V>>::fold_with(item, visitor)
@@ -8447,10 +8650,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<AttributeToken> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Attribute> {
     #[doc = "Calls [Fold`::fold_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_attributes(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Attribute as FoldWith<V>>::fold_with(item, visitor)
@@ -8459,10 +8664,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Attribute> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Child> {
     #[doc = "Calls [Fold`::fold_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_childs(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Child as FoldWith<V>>::fold_with(item, visitor)
@@ -8471,50 +8678,60 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Child> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<DocumentFragment> {
     #[doc = "Calls [Fold`::fold_opt_document_fragment`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_document_fragment(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <DocumentFragment as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Namespace> {
     #[doc = "Calls [Fold`::fold_opt_namespace`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Namespace as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Raw> {
     #[doc = "Calls [Fold`::fold_opt_raw`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_raw(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Raw as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
     #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_span(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
@@ -8524,10 +8741,12 @@ where
     V: ?Sized + Fold,
     T: FoldWith<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))
     }
 
+    #[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)
@@ -8541,6 +8760,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_atom(
         &mut self,
         node: swc_atoms::Atom,
@@ -8553,12 +8773,14 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_attribute(&mut self, node: Attribute, __ast_path: &mut AstKindPath) -> Attribute {
         <Attribute as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_attribute_token(
         &mut self,
         node: AttributeToken,
@@ -8571,6 +8793,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::fold_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_attribute_tokens(
         &mut self,
         node: Vec<AttributeToken>,
@@ -8583,6 +8806,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_attributes(
         &mut self,
         node: Vec<Attribute>,
@@ -8595,30 +8819,35 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child {
         <Child as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_childs(&mut self, node: Vec<Child>, __ast_path: &mut AstKindPath) -> Vec<Child> {
         <Vec<Child> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_comment(&mut self, node: Comment, __ast_path: &mut AstKindPath) -> Comment {
         <Comment as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_document(&mut self, node: Document, __ast_path: &mut AstKindPath) -> Document {
         <Document as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DocumentFragment`.\n\nBy default, this method calls \
              [`DocumentFragment::fold_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_document_fragment(
         &mut self,
         node: DocumentFragment,
@@ -8631,6 +8860,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_document_mode(
         &mut self,
         node: DocumentMode,
@@ -8641,6 +8871,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_document_type(
         &mut self,
         node: DocumentType,
@@ -8651,18 +8882,21 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_element(&mut self, node: Element, __ast_path: &mut AstKindPath) -> Element {
         <Element 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::fold_children_with_ast_path`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_atom(
         &mut self,
         node: Option<swc_atoms::Atom>,
@@ -8675,6 +8909,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Option < DocumentFragment >`.\n\nBy default, this method calls \
              [`Option < DocumentFragment >::fold_children_with_ast_path`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn fold_opt_document_fragment(
         &mut self,
         node: Option<DocumentFragment>,
@@ -8687,6 +8922,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_namespace(
         &mut self,
         node: Option<Namespace>,
@@ -8699,18 +8935,21 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Option < Raw >`.\n\nBy default, this method calls [`Option < \
              Raw >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_opt_raw(&mut self, node: Option<Raw>, __ast_path: &mut AstKindPath) -> Option<Raw> {
         <Option<Raw> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Raw`.\n\nBy default, this method calls \
              [`Raw::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw {
         <Raw 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::fold_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,
@@ -8723,18 +8962,21 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text {
         <Text 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::fold_children_with_ast_path`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_token_and_span(
         &mut self,
         node: TokenAndSpan,
@@ -10517,10 +10759,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TokenAndSpan {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -10529,10 +10773,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<AttributeToken> {
     #[doc = "Calls [FoldAstPath`::fold_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <AttributeToken as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10543,10 +10789,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<AttributeToken> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Attribute> {
     #[doc = "Calls [FoldAstPath`::fold_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Attribute as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10557,10 +10805,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Attribute> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Child> {
     #[doc = "Calls [FoldAstPath`::fold_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Child as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10571,10 +10821,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Child> {
 #[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 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 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)
@@ -10585,10 +10837,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<DocumentFragment> {
     #[doc = "Calls [FoldAstPath`::fold_opt_document_fragment`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_opt_document_fragment(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self.map(|inner| {
             <DocumentFragment as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
@@ -10599,10 +10853,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<DocumentFragment> {
 #[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 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 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)
@@ -10613,10 +10869,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Namespace> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Raw> {
     #[doc = "Calls [FoldAstPath`::fold_opt_raw`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_opt_raw(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self.map(|inner| {
             <Raw as FoldWithAstPath<V>>::fold_with_ast_path(inner, visitor, __ast_path)
@@ -10627,10 +10885,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Raw> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -10642,12 +10902,14 @@ where
     V: ?Sized + FoldAstPath,
     T: FoldWithAstPath<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)
         })
     }
 
+    #[inline]
     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)
@@ -10659,84 +10921,98 @@ 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)
     }
@@ -10744,6 +11020,7 @@ pub trait VisitAll {
              [`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)
     }
@@ -10751,48 +11028,56 @@ pub trait VisitAll {
              [`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)
     }
@@ -11828,20 +12113,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TokenAndSpan {
 }
 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))
@@ -11849,10 +12138,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [AttributeToken] {
 }
 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))
@@ -11860,10 +12151,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Attribute] {
 }
 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))
@@ -11871,10 +12164,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Child] {
 }
 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),
@@ -11884,10 +12179,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
 }
 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),
@@ -11897,10 +12194,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<DocumentFragment> {
 }
 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),
@@ -11910,10 +12209,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
 }
 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),
@@ -11923,10 +12224,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Raw> {
 }
 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) {
         {}
     }
@@ -11936,11 +12239,13 @@ 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
@@ -11951,11 +12256,13 @@ 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
diff --git a/crates/swc_xml_visit/src/generated.rs b/crates/swc_xml_visit/src/generated.rs
index b69bb436c331..e78227baf94e 100644
--- a/crates/swc_xml_visit/src/generated.rs
+++ b/crates/swc_xml_visit/src/generated.rs
@@ -8,122 +8,143 @@ pub trait Visit {
     #[doc = "Visit a node of type `swc_atoms :: Atom`.\n\nBy default, this method calls \
              [`swc_atoms :: Atom::visit_children_with`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attribute(&mut self, node: &Attribute) {
         <Attribute as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attribute_token(&mut self, node: &AttributeToken) {
         <AttributeToken as VisitWith<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`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attribute_tokens(&mut self, node: &[AttributeToken]) {
         <[AttributeToken] as VisitWith<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`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_attributes(&mut self, node: &[Attribute]) {
         <[Attribute] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_cdata_section(&mut self, node: &CdataSection) {
         <CdataSection as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_child(&mut self, node: &Child) {
         <Child as VisitWith<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`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_childs(&mut self, node: &[Child]) {
         <[Child] as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_comment(&mut self, node: &Comment) {
         <Comment as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document(&mut self, node: &Document) {
         <Document as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document_mode(&mut self, node: &DocumentMode) {
         <DocumentMode as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_document_type(&mut self, node: &DocumentType) {
         <DocumentType as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_element(&mut self, node: &Element) {
         <Element as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Namespace`.\n\nBy default, this method calls \
              [`Namespace::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_namespace(&mut self, node: &Namespace) {
         <Namespace as VisitWith<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`]. 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 VisitWith<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`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_opt_namespace(&mut self, node: &Option<Namespace>) {
         <Option<Namespace> as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::visit_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_processing_instruction(&mut self, node: &ProcessingInstruction) {
         <ProcessingInstruction as VisitWith<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`]. 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 VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_text(&mut self, node: &Text) {
         <Text as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `Token`.\n\nBy default, this method calls \
              [`Token::visit_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_token(&mut self, node: &Token) {
         <Token as VisitWith<Self>>::visit_children_with(node, self)
     }
     #[doc = "Visit a node of type `TokenAndSpan`.\n\nBy default, this method calls \
              [`TokenAndSpan::visit_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_token_and_span(&mut self, node: &TokenAndSpan) {
         <TokenAndSpan as VisitWith<Self>>::visit_children_with(node, self)
     }
@@ -1249,20 +1270,24 @@ impl<V: ?Sized + Visit> VisitWith<V> for TokenAndSpan {
 }
 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 [AttributeToken] {
     #[doc = "Calls [Visit`::visit_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <AttributeToken as VisitWith<V>>::visit_with(item, visitor))
@@ -1270,10 +1295,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [AttributeToken] {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for [Attribute] {
     #[doc = "Calls [Visit`::visit_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_attributes(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Attribute as VisitWith<V>>::visit_with(item, visitor))
@@ -1281,10 +1308,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Attribute] {
 }
 impl<V: ?Sized + Visit> VisitWith<V> for [Child] {
     #[doc = "Calls [Visit`::visit_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with(&self, visitor: &mut V) {
         <V as Visit>::visit_childs(visitor, self)
     }
 
+    #[inline]
     fn visit_children_with(&self, visitor: &mut V) {
         self.iter()
             .for_each(|item| <Child as VisitWith<V>>::visit_with(item, visitor))
@@ -1292,10 +1321,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for [Child] {
 }
 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),
@@ -1305,10 +1336,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<swc_atoms::Atom> {
 }
 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),
@@ -1318,10 +1351,12 @@ impl<V: ?Sized + Visit> VisitWith<V> for Option<Namespace> {
 }
 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) {
         {}
     }
@@ -1331,11 +1366,13 @@ 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
@@ -1346,11 +1383,13 @@ 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
@@ -1363,6 +1402,7 @@ pub trait VisitAstPath {
     #[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,
@@ -1375,6 +1415,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attribute<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Attribute,
@@ -1385,6 +1426,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_attribute_token<'ast: 'r, 'r>(
         &mut self,
         node: &'ast AttributeToken,
@@ -1397,6 +1439,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_attribute_tokens<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [AttributeToken],
@@ -1409,6 +1452,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_attributes<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [Attribute],
@@ -1421,6 +1465,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_cdata_section<'ast: 'r, 'r>(
         &mut self,
         node: &'ast CdataSection,
@@ -1433,12 +1478,14 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_child<'ast: 'r, 'r>(&mut self, node: &'ast Child, __ast_path: &mut AstNodePath<'r>) {
         <Child as VisitWithAstPath<Self>>::visit_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_childs<'ast: 'r, 'r>(
         &mut self,
         node: &'ast [Child],
@@ -1449,6 +1496,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_comment<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Comment,
@@ -1459,6 +1507,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_document<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Document,
@@ -1469,6 +1518,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_document_mode<'ast: 'r, 'r>(
         &mut self,
         node: &'ast DocumentMode,
@@ -1481,6 +1531,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_document_type<'ast: 'r, 'r>(
         &mut self,
         node: &'ast DocumentType,
@@ -1493,6 +1544,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_element<'ast: 'r, 'r>(
         &mut self,
         node: &'ast Element,
@@ -1503,6 +1555,7 @@ pub trait VisitAstPath {
     #[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,
@@ -1513,6 +1566,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -1525,6 +1579,7 @@ pub trait VisitAstPath {
     #[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>,
@@ -1537,6 +1592,7 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::visit_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_processing_instruction<'ast: 'r, 'r>(
         &mut self,
         node: &'ast ProcessingInstruction,
@@ -1549,6 +1605,7 @@ pub trait VisitAstPath {
     #[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,
@@ -1561,18 +1618,21 @@ pub trait VisitAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_text<'ast: 'r, 'r>(&mut self, node: &'ast Text, __ast_path: &mut AstNodePath<'r>) {
         <Text 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,
@@ -3604,6 +3664,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for TokenAndSpan {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3612,6 +3673,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
         <V as VisitAstPath>::visit_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3624,6 +3686,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
     #[doc = "Calls [VisitAstPath`::visit_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3632,6 +3695,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
         <V as VisitAstPath>::visit_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3646,6 +3710,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [AttributeToken] {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
     #[doc = "Calls [VisitAstPath`::visit_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3654,6 +3719,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
         <V as VisitAstPath>::visit_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3668,6 +3734,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Attribute] {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
     #[doc = "Calls [VisitAstPath`::visit_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3676,6 +3743,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
         <V as VisitAstPath>::visit_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3690,6 +3758,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for [Child] {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3698,6 +3767,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
         <V as VisitAstPath>::visit_opt_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3715,6 +3785,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3723,6 +3794,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
         <V as VisitAstPath>::visit_opt_namespace(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3740,6 +3812,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for Option<Namespace> {
 #[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,
@@ -3748,6 +3821,7 @@ impl<V: ?Sized + VisitAstPath> VisitWithAstPath<V> for swc_common::Span {
         <V as VisitAstPath>::visit_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3763,6 +3837,7 @@ where
     V: ?Sized + VisitAstPath,
     T: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3772,6 +3847,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3789,6 +3865,7 @@ where
     V: ?Sized + VisitAstPath,
     [T]: VisitWithAstPath<V>,
 {
+    #[inline]
     fn visit_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3798,6 +3875,7 @@ where
         v
     }
 
+    #[inline]
     fn visit_children_with_ast_path<'ast: 'r, 'r>(
         &'ast self,
         visitor: &mut V,
@@ -3813,125 +3891,146 @@ pub trait VisitMut {
     #[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."]
+    #[inline]
     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 `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_attribute(&mut self, node: &mut Attribute) {
         <Attribute as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_attribute_token(&mut self, node: &mut AttributeToken) {
         <AttributeToken as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_mut_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attribute_tokens(&mut self, node: &mut Vec<AttributeToken>) {
         <Vec<AttributeToken> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_attributes(&mut self, node: &mut Vec<Attribute>) {
         <Vec<Attribute> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_cdata_section(&mut self, node: &mut CdataSection) {
         <CdataSection as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_child(&mut self, node: &mut Child) {
         <Child as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_mut_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn visit_mut_childs(&mut self, node: &mut Vec<Child>) {
         <Vec<Child> as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_comment(&mut self, node: &mut Comment) {
         <Comment as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_document(&mut self, node: &mut Document) {
         <Document as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_document_mode(&mut self, node: &mut DocumentMode) {
         <DocumentMode as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_mut_children_with`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_document_type(&mut self, node: &mut DocumentType) {
         <DocumentType as VisitMutWith<Self>>::visit_mut_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_element(&mut self, node: &mut Element) {
         <Element 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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 `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::visit_mut_children_with`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_processing_instruction(&mut self, node: &mut ProcessingInstruction) {
         <ProcessingInstruction 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`]. 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)
     }
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_mut_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_text(&mut self, node: &mut Text) {
         <Text 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`]. 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)
     }
     #[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)
     }
@@ -4933,20 +5032,24 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for TokenAndSpan {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<AttributeToken> {
     #[doc = "Calls [VisitMut`::visit_mut_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <AttributeToken as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -4954,10 +5057,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<AttributeToken> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Attribute> {
     #[doc = "Calls [VisitMut`::visit_mut_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_attributes(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <Attribute as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -4965,10 +5070,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Attribute> {
 }
 impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Child> {
     #[doc = "Calls [VisitMut`::visit_mut_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn visit_mut_with(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_childs(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         self.iter_mut()
             .for_each(|item| <Child as VisitMutWith<V>>::visit_mut_with(item, visitor))
@@ -4976,10 +5083,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Vec<Child> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <swc_atoms::Atom as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -4989,10 +5098,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<swc_atoms::Atom> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         match self {
             Some(inner) => <Namespace as VisitMutWith<V>>::visit_mut_with(inner, visitor),
@@ -5002,10 +5113,12 @@ impl<V: ?Sized + VisitMut> VisitMutWith<V> for Option<Namespace> {
 }
 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(&mut self, visitor: &mut V) {
         <V as VisitMut>::visit_mut_span(visitor, self)
     }
 
+    #[inline]
     fn visit_mut_children_with(&mut self, visitor: &mut V) {
         {}
     }
@@ -5015,11 +5128,13 @@ where
     V: ?Sized + VisitMut,
     T: VisitMutWith<V>,
 {
+    #[inline]
     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(&mut self, visitor: &mut V) {
         let v = <T as VisitMutWith<V>>::visit_mut_children_with(&mut **self, visitor);
         v
@@ -5032,6 +5147,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5040,6 +5156,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attribute(&mut self, node: &mut Attribute, __ast_path: &mut AstKindPath) {
         <Attribute as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5048,6 +5165,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_attribute_token(
         &mut self,
         node: &mut AttributeToken,
@@ -5060,6 +5178,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::visit_mut_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn visit_mut_attribute_tokens(
         &mut self,
         node: &mut Vec<AttributeToken>,
@@ -5072,6 +5191,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_attributes(&mut self, node: &mut Vec<Attribute>, __ast_path: &mut AstKindPath) {
         <Vec<Attribute> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5080,6 +5200,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_cdata_section(&mut self, node: &mut CdataSection, __ast_path: &mut AstKindPath) {
         <CdataSection as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5088,6 +5209,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_child(&mut self, node: &mut Child, __ast_path: &mut AstKindPath) {
         <Child as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5096,6 +5218,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn visit_mut_childs(&mut self, node: &mut Vec<Child>, __ast_path: &mut AstKindPath) {
         <Vec<Child> as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5104,6 +5227,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_comment(&mut self, node: &mut Comment, __ast_path: &mut AstKindPath) {
         <Comment as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5112,6 +5236,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_document(&mut self, node: &mut Document, __ast_path: &mut AstKindPath) {
         <Document as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5120,6 +5245,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_document_mode(&mut self, node: &mut DocumentMode, __ast_path: &mut AstKindPath) {
         <DocumentMode as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5128,6 +5254,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::visit_mut_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn visit_mut_document_type(&mut self, node: &mut DocumentType, __ast_path: &mut AstKindPath) {
         <DocumentType as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5136,6 +5263,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::visit_mut_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn visit_mut_element(&mut self, node: &mut Element, __ast_path: &mut AstKindPath) {
         <Element as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5144,6 +5272,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5152,6 +5281,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_atom(
         &mut self,
         node: &mut Option<swc_atoms::Atom>,
@@ -5164,6 +5294,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[inline]
     fn visit_mut_opt_namespace(
         &mut self,
         node: &mut Option<Namespace>,
@@ -5176,6 +5307,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::visit_mut_children_with_ast_path`]. If you want to recurse, \
              you need to call it manually."]
+    #[inline]
     fn visit_mut_processing_instruction(
         &mut self,
         node: &mut ProcessingInstruction,
@@ -5188,6 +5320,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5196,6 +5329,7 @@ pub trait VisitMutAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::visit_mut_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn visit_mut_text(&mut self, node: &mut Text, __ast_path: &mut AstKindPath) {
         <Text as VisitMutWithAstPath<Self>>::visit_mut_children_with_ast_path(
             node, self, __ast_path,
@@ -5204,6 +5338,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -5212,6 +5347,7 @@ pub trait VisitMutAstPath {
     #[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."]
+    #[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,
@@ -6827,10 +6963,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for TokenAndSpan {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -6839,10 +6977,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<AttributeToken> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_attribute_tokens`] 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_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <AttributeToken as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -6855,10 +6995,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<AttributeToken>
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Attribute> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_attributes`] 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_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Attribute as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(
@@ -6871,10 +7013,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Attribute> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Child> {
     #[doc = "Calls [VisitMutAstPath`::visit_mut_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_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         self.iter_mut().for_each(|item| {
             <Child as VisitMutWithAstPath<V>>::visit_mut_with_ast_path(item, visitor, __ast_path)
@@ -6885,10 +7029,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Vec<Child> {
 #[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 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 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(
@@ -6902,10 +7048,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<swc_atoms::A
 #[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 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 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(
@@ -6919,10 +7067,12 @@ impl<V: ?Sized + VisitMutAstPath> VisitMutWithAstPath<V> for Option<Namespace> {
 #[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 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 visit_mut_children_with_ast_path(&mut self, visitor: &mut V, __ast_path: &mut AstKindPath) {
         {}
     }
@@ -6934,6 +7084,7 @@ where
     V: ?Sized + VisitMutAstPath,
     T: VisitMutWithAstPath<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,
@@ -6943,6 +7094,7 @@ where
         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,
@@ -6957,98 +7109,115 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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 `Attribute`.\n\nBy default, this method calls \
              [`Attribute::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute(&mut self, node: Attribute) -> Attribute {
         <Attribute as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute_token(&mut self, node: AttributeToken) -> AttributeToken {
         <AttributeToken as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attribute_tokens(&mut self, node: Vec<AttributeToken>) -> Vec<AttributeToken> {
         <Vec<AttributeToken> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_attributes(&mut self, node: Vec<Attribute>) -> Vec<Attribute> {
         <Vec<Attribute> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_cdata_section(&mut self, node: CdataSection) -> CdataSection {
         <CdataSection as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_child(&mut self, node: Child) -> Child {
         <Child as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_childs(&mut self, node: Vec<Child>) -> Vec<Child> {
         <Vec<Child> as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_comment(&mut self, node: Comment) -> Comment {
         <Comment as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document(&mut self, node: Document) -> Document {
         <Document as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_mode(&mut self, node: DocumentMode) -> DocumentMode {
         <DocumentMode as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::fold_children_with`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_document_type(&mut self, node: DocumentType) -> DocumentType {
         <DocumentType as FoldWith<Self>>::fold_children_with(node, self)
     }
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_element(&mut self, node: Element) -> Element {
         <Element 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`]. 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)
     }
     #[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."]
+    #[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)
     }
     #[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."]
+    #[inline]
     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 `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::fold_children_with`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_processing_instruction(
         &mut self,
         node: ProcessingInstruction,
@@ -7058,22 +7227,26 @@ pub trait Fold {
     #[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."]
+    #[inline]
     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 `Text`.\n\nBy default, this method calls \
              [`Text::fold_children_with`]. If you want to recurse, you need to call it manually."]
+    #[inline]
     fn fold_text(&mut self, node: Text) -> Text {
         <Text 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`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_token_and_span(&mut self, node: TokenAndSpan) -> TokenAndSpan {
         <TokenAndSpan as FoldWith<Self>>::fold_children_with(node, self)
     }
@@ -8071,20 +8244,24 @@ impl<V: ?Sized + Fold> FoldWith<V> for TokenAndSpan {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_atoms::Atom {
     #[doc = "Calls [Fold`::fold_atom`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<AttributeToken> {
     #[doc = "Calls [Fold`::fold_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_attribute_tokens(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <AttributeToken as FoldWith<V>>::fold_with(item, visitor)
@@ -8093,10 +8270,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<AttributeToken> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Attribute> {
     #[doc = "Calls [Fold`::fold_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_attributes(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Attribute as FoldWith<V>>::fold_with(item, visitor)
@@ -8105,10 +8284,12 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Attribute> {
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Vec<Child> {
     #[doc = "Calls [Fold`::fold_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_childs(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Child as FoldWith<V>>::fold_with(item, visitor)
@@ -8117,30 +8298,36 @@ impl<V: ?Sized + Fold> FoldWith<V> for Vec<Child> {
 }
 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(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_atom(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <swc_atoms::Atom as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for Option<Namespace> {
     #[doc = "Calls [Fold`::fold_opt_namespace`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_opt_namespace(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self.map(|inner| <Namespace as FoldWith<V>>::fold_with(inner, visitor))
     }
 }
 impl<V: ?Sized + Fold> FoldWith<V> for swc_common::Span {
     #[doc = "Calls [Fold`::fold_span`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with(self, visitor: &mut V) -> Self {
         <V as Fold>::fold_span(visitor, self)
     }
 
+    #[inline]
     fn fold_children_with(self, visitor: &mut V) -> Self {
         self
     }
@@ -8150,10 +8337,12 @@ where
     V: ?Sized + Fold,
     T: FoldWith<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))
     }
 
+    #[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)
@@ -8167,6 +8356,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_atom(
         &mut self,
         node: swc_atoms::Atom,
@@ -8179,12 +8369,14 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Attribute`.\n\nBy default, this method calls \
              [`Attribute::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_attribute(&mut self, node: Attribute, __ast_path: &mut AstKindPath) -> Attribute {
         <Attribute as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `AttributeToken`.\n\nBy default, this method calls \
              [`AttributeToken::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_attribute_token(
         &mut self,
         node: AttributeToken,
@@ -8197,6 +8389,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Vec < AttributeToken >`.\n\nBy default, this method calls [`Vec \
              < AttributeToken >::fold_children_with_ast_path`]. If you want to recurse, you need \
              to call it manually."]
+    #[inline]
     fn fold_attribute_tokens(
         &mut self,
         node: Vec<AttributeToken>,
@@ -8209,6 +8402,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Vec < Attribute >`.\n\nBy default, this method calls [`Vec < \
              Attribute >::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_attributes(
         &mut self,
         node: Vec<Attribute>,
@@ -8221,6 +8415,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `CdataSection`.\n\nBy default, this method calls \
              [`CdataSection::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_cdata_section(
         &mut self,
         node: CdataSection,
@@ -8231,30 +8426,35 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Child`.\n\nBy default, this method calls \
              [`Child::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child {
         <Child as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Vec < Child >`.\n\nBy default, this method calls [`Vec < Child \
              >::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_childs(&mut self, node: Vec<Child>, __ast_path: &mut AstKindPath) -> Vec<Child> {
         <Vec<Child> as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Comment`.\n\nBy default, this method calls \
              [`Comment::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_comment(&mut self, node: Comment, __ast_path: &mut AstKindPath) -> Comment {
         <Comment as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `Document`.\n\nBy default, this method calls \
              [`Document::fold_children_with_ast_path`]. If you want to recurse, you need to call \
              it manually."]
+    #[inline]
     fn fold_document(&mut self, node: Document, __ast_path: &mut AstKindPath) -> Document {
         <Document as FoldWithAstPath<Self>>::fold_children_with_ast_path(node, self, __ast_path)
     }
     #[doc = "Visit a node of type `DocumentMode`.\n\nBy default, this method calls \
              [`DocumentMode::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_document_mode(
         &mut self,
         node: DocumentMode,
@@ -8265,6 +8465,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `DocumentType`.\n\nBy default, this method calls \
              [`DocumentType::fold_children_with_ast_path`]. If you want to recurse, you need to \
              call it manually."]
+    #[inline]
     fn fold_document_type(
         &mut self,
         node: DocumentType,
@@ -8275,18 +8476,21 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Element`.\n\nBy default, this method calls \
              [`Element::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_element(&mut self, node: Element, __ast_path: &mut AstKindPath) -> Element {
         <Element 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::fold_children_with_ast_path`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_opt_atom(
         &mut self,
         node: Option<swc_atoms::Atom>,
@@ -8299,6 +8503,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_opt_namespace(
         &mut self,
         node: Option<Namespace>,
@@ -8311,6 +8516,7 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `ProcessingInstruction`.\n\nBy default, this method calls \
              [`ProcessingInstruction::fold_children_with_ast_path`]. If you want to recurse, you \
              need to call it manually."]
+    #[inline]
     fn fold_processing_instruction(
         &mut self,
         node: ProcessingInstruction,
@@ -8323,6 +8529,7 @@ pub trait FoldAstPath {
     #[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."]
+    #[inline]
     fn fold_span(
         &mut self,
         node: swc_common::Span,
@@ -8335,18 +8542,21 @@ pub trait FoldAstPath {
     #[doc = "Visit a node of type `Text`.\n\nBy default, this method calls \
              [`Text::fold_children_with_ast_path`]. If you want to recurse, you need to call it \
              manually."]
+    #[inline]
     fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text {
         <Text 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::fold_children_with_ast_path`]. 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)
     }
     #[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."]
+    #[inline]
     fn fold_token_and_span(
         &mut self,
         node: TokenAndSpan,
@@ -10134,10 +10344,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for TokenAndSpan {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_atom(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -10146,10 +10358,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for swc_atoms::Atom {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<AttributeToken> {
     #[doc = "Calls [FoldAstPath`::fold_attribute_tokens`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_attribute_tokens(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <AttributeToken as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10160,10 +10374,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<AttributeToken> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Attribute> {
     #[doc = "Calls [FoldAstPath`::fold_attributes`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_attributes(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Attribute as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10174,10 +10390,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Attribute> {
 #[cfg_attr(docsrs, doc(cfg(feature = "path")))]
 impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Child> {
     #[doc = "Calls [FoldAstPath`::fold_childs`] with `self`. (Extra impl)"]
+    #[inline]
     fn fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_childs(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         swc_visit::util::move_map::MoveMap::move_map(self, |item| {
             <Child as FoldWithAstPath<V>>::fold_with_ast_path(item, visitor, __ast_path)
@@ -10188,10 +10406,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Vec<Child> {
 #[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 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 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)
@@ -10202,10 +10422,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<swc_atoms::Atom> {
 #[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 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 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)
@@ -10216,10 +10438,12 @@ impl<V: ?Sized + FoldAstPath> FoldWithAstPath<V> for Option<Namespace> {
 #[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 fold_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         <V as FoldAstPath>::fold_span(visitor, self, __ast_path)
     }
 
+    #[inline]
     fn fold_children_with_ast_path(self, visitor: &mut V, __ast_path: &mut AstKindPath) -> Self {
         self
     }
@@ -10231,12 +10455,14 @@ where
     V: ?Sized + FoldAstPath,
     T: FoldWithAstPath<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)
         })
     }
 
+    #[inline]
     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)
@@ -10248,84 +10474,98 @@ 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)
     }
@@ -10333,42 +10573,49 @@ pub trait VisitAll {
              [`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)
     }
@@ -11368,20 +11615,24 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for TokenAndSpan {
 }
 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))
@@ -11389,10 +11640,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [AttributeToken] {
 }
 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))
@@ -11400,10 +11653,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Attribute] {
 }
 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))
@@ -11411,10 +11666,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for [Child] {
 }
 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),
@@ -11424,10 +11681,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<swc_atoms::Atom> {
 }
 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),
@@ -11437,10 +11696,12 @@ impl<V: ?Sized + VisitAll> VisitAllWith<V> for Option<Namespace> {
 }
 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) {
         {}
     }
@@ -11450,11 +11711,13 @@ 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
@@ -11465,11 +11728,13 @@ 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