Trait FoldAstPath

pub trait FoldAstPath {
    // Provided methods
    fn fold_alternative(
        &mut self,
        node: Alternative,
        __ast_path: &mut AstKindPath,
    ) -> Alternative { ... }
    fn fold_alternatives(
        &mut self,
        node: Vec<Alternative>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Alternative> { ... }
    fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom { ... }
    fn fold_boundary_assertion(
        &mut self,
        node: BoundaryAssertion,
        __ast_path: &mut AstKindPath,
    ) -> BoundaryAssertion { ... }
    fn fold_boundary_assertion_kind(
        &mut self,
        node: BoundaryAssertionKind,
        __ast_path: &mut AstKindPath,
    ) -> BoundaryAssertionKind { ... }
    fn fold_capturing_group(
        &mut self,
        node: CapturingGroup,
        __ast_path: &mut AstKindPath,
    ) -> CapturingGroup { ... }
    fn fold_character(
        &mut self,
        node: Character,
        __ast_path: &mut AstKindPath,
    ) -> Character { ... }
    fn fold_character_class(
        &mut self,
        node: CharacterClass,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClass { ... }
    fn fold_character_class_contents(
        &mut self,
        node: CharacterClassContents,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClassContents { ... }
    fn fold_character_class_contents_kind(
        &mut self,
        node: CharacterClassContentsKind,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClassContentsKind { ... }
    fn fold_character_class_contentss(
        &mut self,
        node: Vec<CharacterClassContents>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<CharacterClassContents> { ... }
    fn fold_character_class_escape(
        &mut self,
        node: CharacterClassEscape,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClassEscape { ... }
    fn fold_character_class_escape_kind(
        &mut self,
        node: CharacterClassEscapeKind,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClassEscapeKind { ... }
    fn fold_character_class_range(
        &mut self,
        node: CharacterClassRange,
        __ast_path: &mut AstKindPath,
    ) -> CharacterClassRange { ... }
    fn fold_character_kind(
        &mut self,
        node: CharacterKind,
        __ast_path: &mut AstKindPath,
    ) -> CharacterKind { ... }
    fn fold_characters(
        &mut self,
        node: Vec<Character>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Character> { ... }
    fn fold_class_string(
        &mut self,
        node: ClassString,
        __ast_path: &mut AstKindPath,
    ) -> ClassString { ... }
    fn fold_class_string_disjunction(
        &mut self,
        node: ClassStringDisjunction,
        __ast_path: &mut AstKindPath,
    ) -> ClassStringDisjunction { ... }
    fn fold_class_strings(
        &mut self,
        node: Vec<ClassString>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<ClassString> { ... }
    fn fold_disjunction(
        &mut self,
        node: Disjunction,
        __ast_path: &mut AstKindPath,
    ) -> Disjunction { ... }
    fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot { ... }
    fn fold_ignore_group(
        &mut self,
        node: IgnoreGroup,
        __ast_path: &mut AstKindPath,
    ) -> IgnoreGroup { ... }
    fn fold_indexed_reference(
        &mut self,
        node: IndexedReference,
        __ast_path: &mut AstKindPath,
    ) -> IndexedReference { ... }
    fn fold_look_around_assertion(
        &mut self,
        node: LookAroundAssertion,
        __ast_path: &mut AstKindPath,
    ) -> LookAroundAssertion { ... }
    fn fold_look_around_assertion_kind(
        &mut self,
        node: LookAroundAssertionKind,
        __ast_path: &mut AstKindPath,
    ) -> LookAroundAssertionKind { ... }
    fn fold_modifier(
        &mut self,
        node: Modifier,
        __ast_path: &mut AstKindPath,
    ) -> Modifier { ... }
    fn fold_modifiers(
        &mut self,
        node: Modifiers,
        __ast_path: &mut AstKindPath,
    ) -> Modifiers { ... }
    fn fold_named_reference(
        &mut self,
        node: NamedReference,
        __ast_path: &mut AstKindPath,
    ) -> NamedReference { ... }
    fn fold_opt_atom(
        &mut self,
        node: Option<Atom>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Atom> { ... }
    fn fold_opt_modifiers(
        &mut self,
        node: Option<Modifiers>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Modifiers> { ... }
    fn fold_pattern(
        &mut self,
        node: Pattern,
        __ast_path: &mut AstKindPath,
    ) -> Pattern { ... }
    fn fold_quantifier(
        &mut self,
        node: Quantifier,
        __ast_path: &mut AstKindPath,
    ) -> Quantifier { ... }
    fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span { ... }
    fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term { ... }
    fn fold_terms(
        &mut self,
        node: Vec<Term>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Term> { ... }
    fn fold_unicode_property_escape(
        &mut self,
        node: UnicodePropertyEscape,
        __ast_path: &mut AstKindPath,
    ) -> UnicodePropertyEscape { ... }
}

Available on crate feature path only.

A visitor trait for traversing the AST.

Provided Methods

fn fold_alternative( &mut self, node: Alternative, __ast_path: &mut AstKindPath, ) -> Alternative

Visit a node of type Alternative.

By default, this method calls [Alternative::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_alternatives( &mut self, node: Vec<Alternative>, __ast_path: &mut AstKindPath, ) -> Vec<Alternative>

Visit a node of type Vec < Alternative >.

By default, this method calls [Vec < Alternative >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

Visit a node of type swc_atoms :: Atom.

By default, this method calls [swc_atoms :: Atom::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_boundary_assertion( &mut self, node: BoundaryAssertion, __ast_path: &mut AstKindPath, ) -> BoundaryAssertion

Visit a node of type BoundaryAssertion.

By default, this method calls [BoundaryAssertion::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_boundary_assertion_kind( &mut self, node: BoundaryAssertionKind, __ast_path: &mut AstKindPath, ) -> BoundaryAssertionKind

Visit a node of type BoundaryAssertionKind.

By default, this method calls [BoundaryAssertionKind::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_capturing_group( &mut self, node: CapturingGroup, __ast_path: &mut AstKindPath, ) -> CapturingGroup

Visit a node of type CapturingGroup.

By default, this method calls [CapturingGroup::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character( &mut self, node: Character, __ast_path: &mut AstKindPath, ) -> Character

Visit a node of type Character.

By default, this method calls [Character::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class( &mut self, node: CharacterClass, __ast_path: &mut AstKindPath, ) -> CharacterClass

Visit a node of type CharacterClass.

By default, this method calls [CharacterClass::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_contents( &mut self, node: CharacterClassContents, __ast_path: &mut AstKindPath, ) -> CharacterClassContents

Visit a node of type CharacterClassContents.

By default, this method calls [CharacterClassContents::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_contents_kind( &mut self, node: CharacterClassContentsKind, __ast_path: &mut AstKindPath, ) -> CharacterClassContentsKind

Visit a node of type CharacterClassContentsKind.

By default, this method calls [CharacterClassContentsKind::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_contentss( &mut self, node: Vec<CharacterClassContents>, __ast_path: &mut AstKindPath, ) -> Vec<CharacterClassContents>

Visit a node of type Vec < CharacterClassContents >.

By default, this method calls [Vec < CharacterClassContents >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_escape( &mut self, node: CharacterClassEscape, __ast_path: &mut AstKindPath, ) -> CharacterClassEscape

Visit a node of type CharacterClassEscape.

By default, this method calls [CharacterClassEscape::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_escape_kind( &mut self, node: CharacterClassEscapeKind, __ast_path: &mut AstKindPath, ) -> CharacterClassEscapeKind

Visit a node of type CharacterClassEscapeKind.

By default, this method calls [CharacterClassEscapeKind::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_class_range( &mut self, node: CharacterClassRange, __ast_path: &mut AstKindPath, ) -> CharacterClassRange

Visit a node of type CharacterClassRange.

By default, this method calls [CharacterClassRange::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_character_kind( &mut self, node: CharacterKind, __ast_path: &mut AstKindPath, ) -> CharacterKind

Visit a node of type CharacterKind.

By default, this method calls [CharacterKind::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_characters( &mut self, node: Vec<Character>, __ast_path: &mut AstKindPath, ) -> Vec<Character>

Visit a node of type Vec < Character >.

By default, this method calls [Vec < Character >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_class_string( &mut self, node: ClassString, __ast_path: &mut AstKindPath, ) -> ClassString

Visit a node of type ClassString.

By default, this method calls [ClassString::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_class_string_disjunction( &mut self, node: ClassStringDisjunction, __ast_path: &mut AstKindPath, ) -> ClassStringDisjunction

Visit a node of type ClassStringDisjunction.

By default, this method calls [ClassStringDisjunction::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_class_strings( &mut self, node: Vec<ClassString>, __ast_path: &mut AstKindPath, ) -> Vec<ClassString>

Visit a node of type Vec < ClassString >.

By default, this method calls [Vec < ClassString >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_disjunction( &mut self, node: Disjunction, __ast_path: &mut AstKindPath, ) -> Disjunction

Visit a node of type Disjunction.

By default, this method calls [Disjunction::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot

Visit a node of type Dot.

By default, this method calls [Dot::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_ignore_group( &mut self, node: IgnoreGroup, __ast_path: &mut AstKindPath, ) -> IgnoreGroup

Visit a node of type IgnoreGroup.

By default, this method calls [IgnoreGroup::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_indexed_reference( &mut self, node: IndexedReference, __ast_path: &mut AstKindPath, ) -> IndexedReference

Visit a node of type IndexedReference.

By default, this method calls [IndexedReference::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_look_around_assertion( &mut self, node: LookAroundAssertion, __ast_path: &mut AstKindPath, ) -> LookAroundAssertion

Visit a node of type LookAroundAssertion.

By default, this method calls [LookAroundAssertion::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_look_around_assertion_kind( &mut self, node: LookAroundAssertionKind, __ast_path: &mut AstKindPath, ) -> LookAroundAssertionKind

Visit a node of type LookAroundAssertionKind.

By default, this method calls [LookAroundAssertionKind::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_modifier( &mut self, node: Modifier, __ast_path: &mut AstKindPath, ) -> Modifier

Visit a node of type Modifier.

By default, this method calls [Modifier::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_modifiers( &mut self, node: Modifiers, __ast_path: &mut AstKindPath, ) -> Modifiers

Visit a node of type Modifiers.

By default, this method calls [Modifiers::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_named_reference( &mut self, node: NamedReference, __ast_path: &mut AstKindPath, ) -> NamedReference

Visit a node of type NamedReference.

By default, this method calls [NamedReference::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

Visit a node of type Option < swc_atoms :: Atom >.

By default, this method calls [Option < swc_atoms :: Atom >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_opt_modifiers( &mut self, node: Option<Modifiers>, __ast_path: &mut AstKindPath, ) -> Option<Modifiers>

Visit a node of type Option < Modifiers >.

By default, this method calls [Option < Modifiers >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_pattern( &mut self, node: Pattern, __ast_path: &mut AstKindPath, ) -> Pattern

Visit a node of type Pattern.

By default, this method calls [Pattern::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_quantifier( &mut self, node: Quantifier, __ast_path: &mut AstKindPath, ) -> Quantifier

Visit a node of type Quantifier.

By default, this method calls [Quantifier::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

Visit a node of type swc_common :: Span.

By default, this method calls [swc_common :: Span::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term

Visit a node of type Term.

By default, this method calls [Term::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_terms( &mut self, node: Vec<Term>, __ast_path: &mut AstKindPath, ) -> Vec<Term>

Visit a node of type Vec < Term >.

By default, this method calls [Vec < Term >::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

fn fold_unicode_property_escape( &mut self, node: UnicodePropertyEscape, __ast_path: &mut AstKindPath, ) -> UnicodePropertyEscape

Visit a node of type UnicodePropertyEscape.

By default, this method calls [UnicodePropertyEscape::fold_children_with_ast_path]. If you want to recurse, you need to call it manually.

Implementations on Foreign Types

impl<A, B> FoldAstPath for Either<A, B>

where A: FoldAstPath, B: FoldAstPath,

fn fold_alternative( &mut self, node: Alternative, __ast_path: &mut AstKindPath, ) -> Alternative

fn fold_alternatives( &mut self, node: Vec<Alternative>, __ast_path: &mut AstKindPath, ) -> Vec<Alternative>

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_boundary_assertion( &mut self, node: BoundaryAssertion, __ast_path: &mut AstKindPath, ) -> BoundaryAssertion

fn fold_boundary_assertion_kind( &mut self, node: BoundaryAssertionKind, __ast_path: &mut AstKindPath, ) -> BoundaryAssertionKind

fn fold_capturing_group( &mut self, node: CapturingGroup, __ast_path: &mut AstKindPath, ) -> CapturingGroup

fn fold_character( &mut self, node: Character, __ast_path: &mut AstKindPath, ) -> Character

fn fold_character_class( &mut self, node: CharacterClass, __ast_path: &mut AstKindPath, ) -> CharacterClass

fn fold_character_class_contents( &mut self, node: CharacterClassContents, __ast_path: &mut AstKindPath, ) -> CharacterClassContents

fn fold_character_class_contents_kind( &mut self, node: CharacterClassContentsKind, __ast_path: &mut AstKindPath, ) -> CharacterClassContentsKind

fn fold_character_class_contentss( &mut self, node: Vec<CharacterClassContents>, __ast_path: &mut AstKindPath, ) -> Vec<CharacterClassContents>

fn fold_character_class_escape( &mut self, node: CharacterClassEscape, __ast_path: &mut AstKindPath, ) -> CharacterClassEscape

fn fold_character_class_escape_kind( &mut self, node: CharacterClassEscapeKind, __ast_path: &mut AstKindPath, ) -> CharacterClassEscapeKind

fn fold_character_class_range( &mut self, node: CharacterClassRange, __ast_path: &mut AstKindPath, ) -> CharacterClassRange

fn fold_character_kind( &mut self, node: CharacterKind, __ast_path: &mut AstKindPath, ) -> CharacterKind

fn fold_characters( &mut self, node: Vec<Character>, __ast_path: &mut AstKindPath, ) -> Vec<Character>

fn fold_class_string( &mut self, node: ClassString, __ast_path: &mut AstKindPath, ) -> ClassString

fn fold_class_string_disjunction( &mut self, node: ClassStringDisjunction, __ast_path: &mut AstKindPath, ) -> ClassStringDisjunction

fn fold_class_strings( &mut self, node: Vec<ClassString>, __ast_path: &mut AstKindPath, ) -> Vec<ClassString>

fn fold_disjunction( &mut self, node: Disjunction, __ast_path: &mut AstKindPath, ) -> Disjunction

fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot

fn fold_ignore_group( &mut self, node: IgnoreGroup, __ast_path: &mut AstKindPath, ) -> IgnoreGroup

fn fold_indexed_reference( &mut self, node: IndexedReference, __ast_path: &mut AstKindPath, ) -> IndexedReference

fn fold_look_around_assertion( &mut self, node: LookAroundAssertion, __ast_path: &mut AstKindPath, ) -> LookAroundAssertion

fn fold_look_around_assertion_kind( &mut self, node: LookAroundAssertionKind, __ast_path: &mut AstKindPath, ) -> LookAroundAssertionKind

fn fold_modifier( &mut self, node: Modifier, __ast_path: &mut AstKindPath, ) -> Modifier

fn fold_modifiers( &mut self, node: Modifiers, __ast_path: &mut AstKindPath, ) -> Modifiers

fn fold_named_reference( &mut self, node: NamedReference, __ast_path: &mut AstKindPath, ) -> NamedReference

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_modifiers( &mut self, node: Option<Modifiers>, __ast_path: &mut AstKindPath, ) -> Option<Modifiers>

fn fold_pattern( &mut self, node: Pattern, __ast_path: &mut AstKindPath, ) -> Pattern

fn fold_quantifier( &mut self, node: Quantifier, __ast_path: &mut AstKindPath, ) -> Quantifier

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term

fn fold_terms( &mut self, node: Vec<Term>, __ast_path: &mut AstKindPath, ) -> Vec<Term>

fn fold_unicode_property_escape( &mut self, node: UnicodePropertyEscape, __ast_path: &mut AstKindPath, ) -> UnicodePropertyEscape

impl<V> FoldAstPath for &mut V

where V: ?Sized + FoldAstPath,

fn fold_alternative( &mut self, node: Alternative, __ast_path: &mut AstKindPath, ) -> Alternative

fn fold_alternatives( &mut self, node: Vec<Alternative>, __ast_path: &mut AstKindPath, ) -> Vec<Alternative>

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_boundary_assertion( &mut self, node: BoundaryAssertion, __ast_path: &mut AstKindPath, ) -> BoundaryAssertion

fn fold_boundary_assertion_kind( &mut self, node: BoundaryAssertionKind, __ast_path: &mut AstKindPath, ) -> BoundaryAssertionKind

fn fold_capturing_group( &mut self, node: CapturingGroup, __ast_path: &mut AstKindPath, ) -> CapturingGroup

fn fold_character( &mut self, node: Character, __ast_path: &mut AstKindPath, ) -> Character

fn fold_character_class( &mut self, node: CharacterClass, __ast_path: &mut AstKindPath, ) -> CharacterClass

fn fold_character_class_contents( &mut self, node: CharacterClassContents, __ast_path: &mut AstKindPath, ) -> CharacterClassContents

fn fold_character_class_contents_kind( &mut self, node: CharacterClassContentsKind, __ast_path: &mut AstKindPath, ) -> CharacterClassContentsKind

fn fold_character_class_contentss( &mut self, node: Vec<CharacterClassContents>, __ast_path: &mut AstKindPath, ) -> Vec<CharacterClassContents>

fn fold_character_class_escape( &mut self, node: CharacterClassEscape, __ast_path: &mut AstKindPath, ) -> CharacterClassEscape

fn fold_character_class_escape_kind( &mut self, node: CharacterClassEscapeKind, __ast_path: &mut AstKindPath, ) -> CharacterClassEscapeKind

fn fold_character_class_range( &mut self, node: CharacterClassRange, __ast_path: &mut AstKindPath, ) -> CharacterClassRange

fn fold_character_kind( &mut self, node: CharacterKind, __ast_path: &mut AstKindPath, ) -> CharacterKind

fn fold_characters( &mut self, node: Vec<Character>, __ast_path: &mut AstKindPath, ) -> Vec<Character>

fn fold_class_string( &mut self, node: ClassString, __ast_path: &mut AstKindPath, ) -> ClassString

fn fold_class_string_disjunction( &mut self, node: ClassStringDisjunction, __ast_path: &mut AstKindPath, ) -> ClassStringDisjunction

fn fold_class_strings( &mut self, node: Vec<ClassString>, __ast_path: &mut AstKindPath, ) -> Vec<ClassString>

fn fold_disjunction( &mut self, node: Disjunction, __ast_path: &mut AstKindPath, ) -> Disjunction

fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot

fn fold_ignore_group( &mut self, node: IgnoreGroup, __ast_path: &mut AstKindPath, ) -> IgnoreGroup

fn fold_indexed_reference( &mut self, node: IndexedReference, __ast_path: &mut AstKindPath, ) -> IndexedReference

fn fold_look_around_assertion( &mut self, node: LookAroundAssertion, __ast_path: &mut AstKindPath, ) -> LookAroundAssertion

fn fold_look_around_assertion_kind( &mut self, node: LookAroundAssertionKind, __ast_path: &mut AstKindPath, ) -> LookAroundAssertionKind

fn fold_modifier( &mut self, node: Modifier, __ast_path: &mut AstKindPath, ) -> Modifier

fn fold_modifiers( &mut self, node: Modifiers, __ast_path: &mut AstKindPath, ) -> Modifiers

fn fold_named_reference( &mut self, node: NamedReference, __ast_path: &mut AstKindPath, ) -> NamedReference

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_modifiers( &mut self, node: Option<Modifiers>, __ast_path: &mut AstKindPath, ) -> Option<Modifiers>

fn fold_pattern( &mut self, node: Pattern, __ast_path: &mut AstKindPath, ) -> Pattern

fn fold_quantifier( &mut self, node: Quantifier, __ast_path: &mut AstKindPath, ) -> Quantifier

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term

fn fold_terms( &mut self, node: Vec<Term>, __ast_path: &mut AstKindPath, ) -> Vec<Term>

fn fold_unicode_property_escape( &mut self, node: UnicodePropertyEscape, __ast_path: &mut AstKindPath, ) -> UnicodePropertyEscape

impl<V> FoldAstPath for Box<V>

where V: ?Sized + FoldAstPath,

fn fold_alternative( &mut self, node: Alternative, __ast_path: &mut AstKindPath, ) -> Alternative

fn fold_alternatives( &mut self, node: Vec<Alternative>, __ast_path: &mut AstKindPath, ) -> Vec<Alternative>

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_boundary_assertion( &mut self, node: BoundaryAssertion, __ast_path: &mut AstKindPath, ) -> BoundaryAssertion

fn fold_boundary_assertion_kind( &mut self, node: BoundaryAssertionKind, __ast_path: &mut AstKindPath, ) -> BoundaryAssertionKind

fn fold_capturing_group( &mut self, node: CapturingGroup, __ast_path: &mut AstKindPath, ) -> CapturingGroup

fn fold_character( &mut self, node: Character, __ast_path: &mut AstKindPath, ) -> Character

fn fold_character_class( &mut self, node: CharacterClass, __ast_path: &mut AstKindPath, ) -> CharacterClass

fn fold_character_class_contents( &mut self, node: CharacterClassContents, __ast_path: &mut AstKindPath, ) -> CharacterClassContents

fn fold_character_class_contents_kind( &mut self, node: CharacterClassContentsKind, __ast_path: &mut AstKindPath, ) -> CharacterClassContentsKind

fn fold_character_class_contentss( &mut self, node: Vec<CharacterClassContents>, __ast_path: &mut AstKindPath, ) -> Vec<CharacterClassContents>

fn fold_character_class_escape( &mut self, node: CharacterClassEscape, __ast_path: &mut AstKindPath, ) -> CharacterClassEscape

fn fold_character_class_escape_kind( &mut self, node: CharacterClassEscapeKind, __ast_path: &mut AstKindPath, ) -> CharacterClassEscapeKind

fn fold_character_class_range( &mut self, node: CharacterClassRange, __ast_path: &mut AstKindPath, ) -> CharacterClassRange

fn fold_character_kind( &mut self, node: CharacterKind, __ast_path: &mut AstKindPath, ) -> CharacterKind

fn fold_characters( &mut self, node: Vec<Character>, __ast_path: &mut AstKindPath, ) -> Vec<Character>

fn fold_class_string( &mut self, node: ClassString, __ast_path: &mut AstKindPath, ) -> ClassString

fn fold_class_string_disjunction( &mut self, node: ClassStringDisjunction, __ast_path: &mut AstKindPath, ) -> ClassStringDisjunction

fn fold_class_strings( &mut self, node: Vec<ClassString>, __ast_path: &mut AstKindPath, ) -> Vec<ClassString>

fn fold_disjunction( &mut self, node: Disjunction, __ast_path: &mut AstKindPath, ) -> Disjunction

fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot

fn fold_ignore_group( &mut self, node: IgnoreGroup, __ast_path: &mut AstKindPath, ) -> IgnoreGroup

fn fold_indexed_reference( &mut self, node: IndexedReference, __ast_path: &mut AstKindPath, ) -> IndexedReference

fn fold_look_around_assertion( &mut self, node: LookAroundAssertion, __ast_path: &mut AstKindPath, ) -> LookAroundAssertion

fn fold_look_around_assertion_kind( &mut self, node: LookAroundAssertionKind, __ast_path: &mut AstKindPath, ) -> LookAroundAssertionKind

fn fold_modifier( &mut self, node: Modifier, __ast_path: &mut AstKindPath, ) -> Modifier

fn fold_modifiers( &mut self, node: Modifiers, __ast_path: &mut AstKindPath, ) -> Modifiers

fn fold_named_reference( &mut self, node: NamedReference, __ast_path: &mut AstKindPath, ) -> NamedReference

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_modifiers( &mut self, node: Option<Modifiers>, __ast_path: &mut AstKindPath, ) -> Option<Modifiers>

fn fold_pattern( &mut self, node: Pattern, __ast_path: &mut AstKindPath, ) -> Pattern

fn fold_quantifier( &mut self, node: Quantifier, __ast_path: &mut AstKindPath, ) -> Quantifier

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term

fn fold_terms( &mut self, node: Vec<Term>, __ast_path: &mut AstKindPath, ) -> Vec<Term>

fn fold_unicode_property_escape( &mut self, node: UnicodePropertyEscape, __ast_path: &mut AstKindPath, ) -> UnicodePropertyEscape

impl<V> FoldAstPath for Optional<V>

where V: FoldAstPath,

fn fold_alternative( &mut self, node: Alternative, __ast_path: &mut AstKindPath, ) -> Alternative

fn fold_alternatives( &mut self, node: Vec<Alternative>, __ast_path: &mut AstKindPath, ) -> Vec<Alternative>

fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_boundary_assertion( &mut self, node: BoundaryAssertion, __ast_path: &mut AstKindPath, ) -> BoundaryAssertion

fn fold_boundary_assertion_kind( &mut self, node: BoundaryAssertionKind, __ast_path: &mut AstKindPath, ) -> BoundaryAssertionKind

fn fold_capturing_group( &mut self, node: CapturingGroup, __ast_path: &mut AstKindPath, ) -> CapturingGroup

fn fold_character( &mut self, node: Character, __ast_path: &mut AstKindPath, ) -> Character

fn fold_character_class( &mut self, node: CharacterClass, __ast_path: &mut AstKindPath, ) -> CharacterClass

fn fold_character_class_contents( &mut self, node: CharacterClassContents, __ast_path: &mut AstKindPath, ) -> CharacterClassContents

fn fold_character_class_contents_kind( &mut self, node: CharacterClassContentsKind, __ast_path: &mut AstKindPath, ) -> CharacterClassContentsKind

fn fold_character_class_contentss( &mut self, node: Vec<CharacterClassContents>, __ast_path: &mut AstKindPath, ) -> Vec<CharacterClassContents>

fn fold_character_class_escape( &mut self, node: CharacterClassEscape, __ast_path: &mut AstKindPath, ) -> CharacterClassEscape

fn fold_character_class_escape_kind( &mut self, node: CharacterClassEscapeKind, __ast_path: &mut AstKindPath, ) -> CharacterClassEscapeKind

fn fold_character_class_range( &mut self, node: CharacterClassRange, __ast_path: &mut AstKindPath, ) -> CharacterClassRange

fn fold_character_kind( &mut self, node: CharacterKind, __ast_path: &mut AstKindPath, ) -> CharacterKind

fn fold_characters( &mut self, node: Vec<Character>, __ast_path: &mut AstKindPath, ) -> Vec<Character>

fn fold_class_string( &mut self, node: ClassString, __ast_path: &mut AstKindPath, ) -> ClassString

fn fold_class_string_disjunction( &mut self, node: ClassStringDisjunction, __ast_path: &mut AstKindPath, ) -> ClassStringDisjunction

fn fold_class_strings( &mut self, node: Vec<ClassString>, __ast_path: &mut AstKindPath, ) -> Vec<ClassString>

fn fold_disjunction( &mut self, node: Disjunction, __ast_path: &mut AstKindPath, ) -> Disjunction

fn fold_dot(&mut self, node: Dot, __ast_path: &mut AstKindPath) -> Dot

fn fold_ignore_group( &mut self, node: IgnoreGroup, __ast_path: &mut AstKindPath, ) -> IgnoreGroup

fn fold_indexed_reference( &mut self, node: IndexedReference, __ast_path: &mut AstKindPath, ) -> IndexedReference

fn fold_look_around_assertion( &mut self, node: LookAroundAssertion, __ast_path: &mut AstKindPath, ) -> LookAroundAssertion

fn fold_look_around_assertion_kind( &mut self, node: LookAroundAssertionKind, __ast_path: &mut AstKindPath, ) -> LookAroundAssertionKind

fn fold_modifier( &mut self, node: Modifier, __ast_path: &mut AstKindPath, ) -> Modifier

fn fold_modifiers( &mut self, node: Modifiers, __ast_path: &mut AstKindPath, ) -> Modifiers

fn fold_named_reference( &mut self, node: NamedReference, __ast_path: &mut AstKindPath, ) -> NamedReference

fn fold_opt_atom( &mut self, node: Option<Atom>, __ast_path: &mut AstKindPath, ) -> Option<Atom>

fn fold_opt_modifiers( &mut self, node: Option<Modifiers>, __ast_path: &mut AstKindPath, ) -> Option<Modifiers>

fn fold_pattern( &mut self, node: Pattern, __ast_path: &mut AstKindPath, ) -> Pattern

fn fold_quantifier( &mut self, node: Quantifier, __ast_path: &mut AstKindPath, ) -> Quantifier

fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span

fn fold_term(&mut self, node: Term, __ast_path: &mut AstKindPath) -> Term

fn fold_terms( &mut self, node: Vec<Term>, __ast_path: &mut AstKindPath, ) -> Vec<Term>

fn fold_unicode_property_escape( &mut self, node: UnicodePropertyEscape, __ast_path: &mut AstKindPath, ) -> UnicodePropertyEscape

Implementors