Variable RLogical

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<ParentInformation>,
        idMap: Map<NodeId, RNode<ParentInformation>>,
    ): 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<ParentInformation>
    • idMap: Map<NodeId, RNode<ParentInformation>>

    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 & ParentInformation>>,
    ): RNode<OtherInfo & ParentInformation> | undefined

    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 & ParentInformation>>

    Returns RNode<OtherInfo & ParentInformation> | undefined

    See

    iterateParents - to get all parents of a node

• Readonlydocumentation: (
      nodeId: NodeId,
      idMap: AstIdMap<ParentInformation & DocumentationInfo>,
  ) => Documentation | undefined

  Return the (roxygen) documentation associated with the given node, if available.

  See

  getDocumentationOf

• 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,
    ):
        | [
            startLine: number,
            startColumn: number,
            endLine: number,
            endColumn: number,
            f?: string,
        ]
        | undefined

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

    Parameters

    • this: void
    • node: RNode

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

    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

• is: function

  • is<Info = object>(
        this: void,
        node: RNode<Info> | undefined,
    ): node is RLogical<Info>

    Type guard for RLogical nodes.

    Type Parameters

    • Info = object

    Parameters

    • this: void
    • node: RNode<Info> | undefined

    Returns node is RLogical<Info>

• isFalse: function

  • isFalse<Info = object>(this: void, node: RNode<Info> | undefined): boolean

    Checks whether a node is a logical constant with value FALSE.

    Type Parameters

    • Info = object

    Parameters

    • this: void
    • node: RNode<Info> | undefined

    Returns boolean

• isTrue: function

  • isTrue<Info = object>(this: void, node: RNode<Info> | undefined): boolean

    Checks whether a node is a logical constant with value TRUE.

    Type Parameters

    • Info = object

    Parameters

    • this: void
    • node: RNode<Info> | undefined

    Returns boolean

• iterateParents: function

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

    Returns an iterable of all parents of a node, starting with the direct parent and ending with the root node.

    Type Parameters

    • OtherInfo

    Parameters

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

    Returns Generator<RNode<OtherInfo & ParentInformation>>

• lexeme: function

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

    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: R | undefined

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

• Readonlyname: "RLogical"

• 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