Variable RNode

Type declaration

• collectAllIds:function

  • collectAllIds<OtherInfo>(
        this: void,
        nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>,
    ): Set<NodeId>

    Collects all node ids within a tree given by a respective root node

    Type Parameters

    • OtherInfo

    Parameters

    • this: void
    • nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>

      The root id nodes to start collecting from

    Returns Set<NodeId>

    See

    • collectAllIdsWithStop - to stop collecting at certain nodes
    • RProject.collectAllIds - to collect all ids within a project

• collectAllIdsWithStop:function

  • collectAllIdsWithStop<OtherInfo>(
        this: void,
        nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>,
        stop: (node: RNode<OtherInfo & ParentInformation>) => boolean,
    ): Set<NodeId>

    Collects all node ids within a tree given by a respective root node, but stops collecting at nodes where the given stop function returns true.

    This can be used to exclude certain subtrees from the collection, for example to exclude function bodies when collecting ids on the root level.

    Type Parameters

    • OtherInfo

    Parameters

    • this: void
    • nodes: SingleOrArrayOrNothing<RNode<OtherInfo & ParentInformation>>

      The root id nodes to start collecting from
    • stop: (node: RNode<OtherInfo & ParentInformation>) => boolean

      A function that determines whether to stop collecting at a given node, does not stop by default

    Returns Set<NodeId>

    See

    • collectAllIds - to collect all ids without stopping
    • RProject.collectAllIdsWithStop - to collect all ids within a project with stopping

• depth:function

  • depth(this: void, node: RNode, idMap: Map<NodeId, RNode<object>>): number

    In contrast to the nesting stored in the RNode structure, this function calculates the depth of a node by counting the number of parents until the root node is reached.

    Parameters

    • this: void
    • node: RNode
    • idMap: Map<NodeId, RNode<object>>

    Returns number

• directChildren:function

  • directChildren<OtherInfo>(
        this: void,
        node: RNode<OtherInfo>,
    ): readonly ("<>" | RNode<OtherInfo>)[]

    Collects all direct children of a given node, i.e. all nodes that are directly reachable via a property of the given node.

    Type Parameters

    • OtherInfo

    Parameters

    • this: void
    • node: RNode<OtherInfo>

    Returns readonly ("<>" | RNode<OtherInfo>)[]

• directParent:function

  • directParent<OtherInfo>(
        this: void,
        node: RNode<OtherInfo & ParentInformation>,
        idMap: Map<NodeId, RNode<OtherInfo>>,
    ): undefined | RNode<OtherInfo>

    Returns the direct parent of a node. Usually, only root nodes do not have a parent, and you can assume that there is a linear chain of parents leading to the root node.

    Type Parameters

    • OtherInfo

    Parameters

    • this: void
    • node: RNode<OtherInfo & ParentInformation>
    • idMap: Map<NodeId, RNode<OtherInfo>>

    Returns undefined | RNode<OtherInfo>

• getId:function

  • getId(this: void, node: RNode<ParentInformation>): NodeId

    A helper function to retrieve the id of a given node, if available.

    Parameters

    • this: void
    • node: RNode<ParentInformation>

    Returns NodeId

• getLocation:function

  • getLocation(
        this: void,
        node: RNode,
    ):
        | undefined
        | [
            startLine: number,
            startColumn: number,
            endLine: number,
            endColumn: number,
            f?: string,
        ]

    A helper function to retrieve the location of a given node, if available.

    Parameters

    • this: void
    • node: RNode

    Returns
        | undefined
        | [
            startLine: number,
            startColumn: number,
            endLine: number,
            endColumn: number,
            f?: string,
        ]

    See

    SourceLocation.fromNode

• getType:function

  • getType(this: void, node: RNode): RType

    A helper function to retrieve the type of a given node.

    Parameters

    • this: void
    • node: RNode

    Returns RType

• lexeme:function

  • lexeme<R extends RNode<ParentInformation>>(
        this: void,
        node: undefined | R,
    ): R extends { lexeme: string } ? string : undefined | string

    A helper function to retrieve the lexeme of a given node, if available. If the fullLexeme is available, it will be returned, otherwise the lexeme will be returned.

    Type Parameters

    • R extends RNode<ParentInformation>

    Parameters

    • this: void
    • node: undefined | R

    Returns R extends { lexeme: string } ? string : undefined | string

• Readonlyname: "RNode"

• visitAst:function

  • visitAst<OtherInfo = object>(
        this: void,
        nodes: SingleOrArrayOrNothing<RNode<OtherInfo>>,
        onVisit?: OnEnter<OtherInfo>,
        onExit?: OnExit<OtherInfo>,
    ): void

    Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.

    Type Parameters

    • OtherInfo = object

    Parameters

    • this: void
    • nodes: SingleOrArrayOrNothing<RNode<OtherInfo>>

      The root id nodes to start collecting from
    • OptionalonVisit: OnEnter<OtherInfo>

      Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return true stop)
    • OptionalonExit: OnExit<OtherInfo>

      Called after the subtree of a node has been visited, called for leafs too (even though their subtree is empty)

    Returns void

    See

    RProject.visitAst - to visit all nodes in a project