Trait FoldAstPath

pub trait FoldAstPath {
    // Provided methods
    fn fold_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom { ... }
    fn fold_attribute(
        &mut self,
        node: Attribute,
        __ast_path: &mut AstKindPath,
    ) -> Attribute { ... }
    fn fold_attribute_token(
        &mut self,
        node: AttributeToken,
        __ast_path: &mut AstKindPath,
    ) -> AttributeToken { ... }
    fn fold_attribute_tokens(
        &mut self,
        node: Vec<AttributeToken>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<AttributeToken> { ... }
    fn fold_attributes(
        &mut self,
        node: Vec<Attribute>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Attribute> { ... }
    fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child { ... }
    fn fold_childs(
        &mut self,
        node: Vec<Child>,
        __ast_path: &mut AstKindPath,
    ) -> Vec<Child> { ... }
    fn fold_comment(
        &mut self,
        node: Comment,
        __ast_path: &mut AstKindPath,
    ) -> Comment { ... }
    fn fold_document(
        &mut self,
        node: Document,
        __ast_path: &mut AstKindPath,
    ) -> Document { ... }
    fn fold_document_fragment(
        &mut self,
        node: DocumentFragment,
        __ast_path: &mut AstKindPath,
    ) -> DocumentFragment { ... }
    fn fold_document_mode(
        &mut self,
        node: DocumentMode,
        __ast_path: &mut AstKindPath,
    ) -> DocumentMode { ... }
    fn fold_document_type(
        &mut self,
        node: DocumentType,
        __ast_path: &mut AstKindPath,
    ) -> DocumentType { ... }
    fn fold_element(
        &mut self,
        node: Element,
        __ast_path: &mut AstKindPath,
    ) -> Element { ... }
    fn fold_namespace(
        &mut self,
        node: Namespace,
        __ast_path: &mut AstKindPath,
    ) -> Namespace { ... }
    fn fold_opt_atom(
        &mut self,
        node: Option<Atom>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Atom> { ... }
    fn fold_opt_document_fragment(
        &mut self,
        node: Option<DocumentFragment>,
        __ast_path: &mut AstKindPath,
    ) -> Option<DocumentFragment> { ... }
    fn fold_opt_namespace(
        &mut self,
        node: Option<Namespace>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Namespace> { ... }
    fn fold_opt_raw(
        &mut self,
        node: Option<Raw>,
        __ast_path: &mut AstKindPath,
    ) -> Option<Raw> { ... }
    fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw { ... }
    fn fold_span(&mut self, node: Span, __ast_path: &mut AstKindPath) -> Span { ... }
    fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text { ... }
    fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token { ... }
    fn fold_token_and_span(
        &mut self,
        node: TokenAndSpan,
        __ast_path: &mut AstKindPath,
    ) -> TokenAndSpan { ... }
}

Available on crate feature path only.

A visitor trait for traversing the AST.

Provided Methods

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_attribute( &mut self, node: Attribute, __ast_path: &mut AstKindPath, ) -> Attribute

Visit a node of type Attribute.

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

fn fold_attribute_token( &mut self, node: AttributeToken, __ast_path: &mut AstKindPath, ) -> AttributeToken

Visit a node of type AttributeToken.

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

fn fold_attribute_tokens( &mut self, node: Vec<AttributeToken>, __ast_path: &mut AstKindPath, ) -> Vec<AttributeToken>

Visit a node of type Vec < AttributeToken >.

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

fn fold_attributes( &mut self, node: Vec<Attribute>, __ast_path: &mut AstKindPath, ) -> Vec<Attribute>

Visit a node of type Vec < Attribute >.

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

fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child

Visit a node of type Child.

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

fn fold_childs( &mut self, node: Vec<Child>, __ast_path: &mut AstKindPath, ) -> Vec<Child>

Visit a node of type Vec < Child >.

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

fn fold_comment( &mut self, node: Comment, __ast_path: &mut AstKindPath, ) -> Comment

Visit a node of type Comment.

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

fn fold_document( &mut self, node: Document, __ast_path: &mut AstKindPath, ) -> Document

Visit a node of type Document.

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

fn fold_document_fragment( &mut self, node: DocumentFragment, __ast_path: &mut AstKindPath, ) -> DocumentFragment

Visit a node of type DocumentFragment.

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

fn fold_document_mode( &mut self, node: DocumentMode, __ast_path: &mut AstKindPath, ) -> DocumentMode

Visit a node of type DocumentMode.

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

fn fold_document_type( &mut self, node: DocumentType, __ast_path: &mut AstKindPath, ) -> DocumentType

Visit a node of type DocumentType.

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

fn fold_element( &mut self, node: Element, __ast_path: &mut AstKindPath, ) -> Element

Visit a node of type Element.

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

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

Visit a node of type Namespace.

By default, this method calls [Namespace::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_document_fragment( &mut self, node: Option<DocumentFragment>, __ast_path: &mut AstKindPath, ) -> Option<DocumentFragment>

Visit a node of type Option < DocumentFragment >.

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

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

Visit a node of type Option < Namespace >.

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

fn fold_opt_raw( &mut self, node: Option<Raw>, __ast_path: &mut AstKindPath, ) -> Option<Raw>

Visit a node of type Option < Raw >.

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

fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw

Visit a node of type Raw.

By default, this method calls [Raw::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_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text

Visit a node of type Text.

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

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

Visit a node of type Token.

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

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

Visit a node of type TokenAndSpan.

By default, this method calls [TokenAndSpan::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_atom(&mut self, node: Atom, __ast_path: &mut AstKindPath) -> Atom

fn fold_attribute( &mut self, node: Attribute, __ast_path: &mut AstKindPath, ) -> Attribute

fn fold_attribute_token( &mut self, node: AttributeToken, __ast_path: &mut AstKindPath, ) -> AttributeToken

fn fold_attribute_tokens( &mut self, node: Vec<AttributeToken>, __ast_path: &mut AstKindPath, ) -> Vec<AttributeToken>

fn fold_attributes( &mut self, node: Vec<Attribute>, __ast_path: &mut AstKindPath, ) -> Vec<Attribute>

fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child

fn fold_childs( &mut self, node: Vec<Child>, __ast_path: &mut AstKindPath, ) -> Vec<Child>

fn fold_comment( &mut self, node: Comment, __ast_path: &mut AstKindPath, ) -> Comment

fn fold_document( &mut self, node: Document, __ast_path: &mut AstKindPath, ) -> Document

fn fold_document_fragment( &mut self, node: DocumentFragment, __ast_path: &mut AstKindPath, ) -> DocumentFragment

fn fold_document_mode( &mut self, node: DocumentMode, __ast_path: &mut AstKindPath, ) -> DocumentMode

fn fold_document_type( &mut self, node: DocumentType, __ast_path: &mut AstKindPath, ) -> DocumentType

fn fold_element( &mut self, node: Element, __ast_path: &mut AstKindPath, ) -> Element

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

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

fn fold_opt_document_fragment( &mut self, node: Option<DocumentFragment>, __ast_path: &mut AstKindPath, ) -> Option<DocumentFragment>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_raw( &mut self, node: Option<Raw>, __ast_path: &mut AstKindPath, ) -> Option<Raw>

fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw

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

fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

impl<V> FoldAstPath for &mut V

where V: ?Sized + FoldAstPath,

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

fn fold_attribute( &mut self, node: Attribute, __ast_path: &mut AstKindPath, ) -> Attribute

fn fold_attribute_token( &mut self, node: AttributeToken, __ast_path: &mut AstKindPath, ) -> AttributeToken

fn fold_attribute_tokens( &mut self, node: Vec<AttributeToken>, __ast_path: &mut AstKindPath, ) -> Vec<AttributeToken>

fn fold_attributes( &mut self, node: Vec<Attribute>, __ast_path: &mut AstKindPath, ) -> Vec<Attribute>

fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child

fn fold_childs( &mut self, node: Vec<Child>, __ast_path: &mut AstKindPath, ) -> Vec<Child>

fn fold_comment( &mut self, node: Comment, __ast_path: &mut AstKindPath, ) -> Comment

fn fold_document( &mut self, node: Document, __ast_path: &mut AstKindPath, ) -> Document

fn fold_document_fragment( &mut self, node: DocumentFragment, __ast_path: &mut AstKindPath, ) -> DocumentFragment

fn fold_document_mode( &mut self, node: DocumentMode, __ast_path: &mut AstKindPath, ) -> DocumentMode

fn fold_document_type( &mut self, node: DocumentType, __ast_path: &mut AstKindPath, ) -> DocumentType

fn fold_element( &mut self, node: Element, __ast_path: &mut AstKindPath, ) -> Element

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

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

fn fold_opt_document_fragment( &mut self, node: Option<DocumentFragment>, __ast_path: &mut AstKindPath, ) -> Option<DocumentFragment>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_raw( &mut self, node: Option<Raw>, __ast_path: &mut AstKindPath, ) -> Option<Raw>

fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw

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

fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

impl<V> FoldAstPath for Box<V>

where V: ?Sized + FoldAstPath,

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

fn fold_attribute( &mut self, node: Attribute, __ast_path: &mut AstKindPath, ) -> Attribute

fn fold_attribute_token( &mut self, node: AttributeToken, __ast_path: &mut AstKindPath, ) -> AttributeToken

fn fold_attribute_tokens( &mut self, node: Vec<AttributeToken>, __ast_path: &mut AstKindPath, ) -> Vec<AttributeToken>

fn fold_attributes( &mut self, node: Vec<Attribute>, __ast_path: &mut AstKindPath, ) -> Vec<Attribute>

fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child

fn fold_childs( &mut self, node: Vec<Child>, __ast_path: &mut AstKindPath, ) -> Vec<Child>

fn fold_comment( &mut self, node: Comment, __ast_path: &mut AstKindPath, ) -> Comment

fn fold_document( &mut self, node: Document, __ast_path: &mut AstKindPath, ) -> Document

fn fold_document_fragment( &mut self, node: DocumentFragment, __ast_path: &mut AstKindPath, ) -> DocumentFragment

fn fold_document_mode( &mut self, node: DocumentMode, __ast_path: &mut AstKindPath, ) -> DocumentMode

fn fold_document_type( &mut self, node: DocumentType, __ast_path: &mut AstKindPath, ) -> DocumentType

fn fold_element( &mut self, node: Element, __ast_path: &mut AstKindPath, ) -> Element

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

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

fn fold_opt_document_fragment( &mut self, node: Option<DocumentFragment>, __ast_path: &mut AstKindPath, ) -> Option<DocumentFragment>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_raw( &mut self, node: Option<Raw>, __ast_path: &mut AstKindPath, ) -> Option<Raw>

fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw

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

fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

impl<V> FoldAstPath for Optional<V>

where V: FoldAstPath,

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

fn fold_attribute( &mut self, node: Attribute, __ast_path: &mut AstKindPath, ) -> Attribute

fn fold_attribute_token( &mut self, node: AttributeToken, __ast_path: &mut AstKindPath, ) -> AttributeToken

fn fold_attribute_tokens( &mut self, node: Vec<AttributeToken>, __ast_path: &mut AstKindPath, ) -> Vec<AttributeToken>

fn fold_attributes( &mut self, node: Vec<Attribute>, __ast_path: &mut AstKindPath, ) -> Vec<Attribute>

fn fold_child(&mut self, node: Child, __ast_path: &mut AstKindPath) -> Child

fn fold_childs( &mut self, node: Vec<Child>, __ast_path: &mut AstKindPath, ) -> Vec<Child>

fn fold_comment( &mut self, node: Comment, __ast_path: &mut AstKindPath, ) -> Comment

fn fold_document( &mut self, node: Document, __ast_path: &mut AstKindPath, ) -> Document

fn fold_document_fragment( &mut self, node: DocumentFragment, __ast_path: &mut AstKindPath, ) -> DocumentFragment

fn fold_document_mode( &mut self, node: DocumentMode, __ast_path: &mut AstKindPath, ) -> DocumentMode

fn fold_document_type( &mut self, node: DocumentType, __ast_path: &mut AstKindPath, ) -> DocumentType

fn fold_element( &mut self, node: Element, __ast_path: &mut AstKindPath, ) -> Element

fn fold_namespace( &mut self, node: Namespace, __ast_path: &mut AstKindPath, ) -> Namespace

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

fn fold_opt_document_fragment( &mut self, node: Option<DocumentFragment>, __ast_path: &mut AstKindPath, ) -> Option<DocumentFragment>

fn fold_opt_namespace( &mut self, node: Option<Namespace>, __ast_path: &mut AstKindPath, ) -> Option<Namespace>

fn fold_opt_raw( &mut self, node: Option<Raw>, __ast_path: &mut AstKindPath, ) -> Option<Raw>

fn fold_raw(&mut self, node: Raw, __ast_path: &mut AstKindPath) -> Raw

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

fn fold_text(&mut self, node: Text, __ast_path: &mut AstKindPath) -> Text

fn fold_token(&mut self, node: Token, __ast_path: &mut AstKindPath) -> Token

fn fold_token_and_span( &mut self, node: TokenAndSpan, __ast_path: &mut AstKindPath, ) -> TokenAndSpan

Implementors