Class NodeAbstract

The Abstract Syntax Tree will be constituted by instances of Node.

It implements Origin as it could be the source of a AST-to-AST transformation, so the node itself can be the Origin of another node.

Hierarchy (view full)

Implements

Constructors

constructor

Properties

destination? origin? parent? parseTree? positionOverride?

Accessors

children features nodeDefinition position source sourceText

Methods

addChild containment contains doGetAttributeValue doGetChildOrChildren doGetReference doSetAttributeValue find findAncestorOfType findByPosition getAllChildren getAttributeValue getChild getChildNames getChildren getChildrenWithRole getReference hasValidParents invalidPositions notAContainment overlaps searchByPosition setAttributeValue setChild walk walkAncestors walkChildren walkDescendants walkWithin withOrigin withParent withParseTreeNode

Constructors

constructor

Properties

Optional destination

destination?: Destination

Optional origin

origin?: Origin

Optional parent

parent?: Node

Optional parseTree

parseTree?: ParseTree

Protected Optional positionOverride

positionOverride?: Position

Accessors

children

features

nodeDefinition

position

source

sourceText

  • get sourceText(): undefined | string

  • Returns undefined | string

Methods

addChild

  • addChild(name, child): void

  • Parameters

    • name: string | symbol
    • child: Node

    Returns void

containment

contains

  • contains(position?): boolean

  • Tests whether the given position is contained in the interval represented by this object.

    Parameters

    • Optional position: Position

      the position

    Returns boolean

Protected doGetAttributeValue

  • doGetAttributeValue(name): any

  • Parameters

    • name: string | symbol

    Returns any

Protected doGetChildOrChildren

Protected doGetReference

  • doGetReference(name): any

  • Parameters

    • name: string | symbol

    Returns any

Protected doSetAttributeValue

  • doSetAttributeValue(name, value): void

  • Parameters

    • name: string | symbol
    • value: any

    Returns void

find

  • find(predicate, walker?): undefined | Node

  • Finds the first node that satisfies a condition among this node's descendants.

    Parameters

    • predicate: ((n, index) => boolean)

      the function expressing the condition that the node must satisfy.

        • (n, index): boolean

        • Parameters

          • n: Node
          • index: number

          Returns boolean

    • Optional walker: ((node) => Generator<Node>)

      the function that generates the nodes to operate on in the desired sequence. By default, this is a depth-first traversal that includes the node on which find() has been called.

        • (node): Generator<Node>

        • A generator that walks the whole AST starting from the provided node, depth-first.

          Parameters

          • node: Node

            the starting node.

          Returns Generator<Node>

    Returns undefined | Node

    the first node in the AST for which the predicate is true. Returns undefined if none are found.

findAncestorOfType

  • findAncestorOfType(type): undefined | Node

  • Note that the type is not strictly forced to be a subclass of Node. This is intended to support interfaces like Statement or Expression. However, being an ancestor the returned value is guaranteed to be a Node, as only Node instances can be part of the hierarchy.

    Parameters

    • type: any

    Returns undefined | Node

    ancestor the nearest ancestor of this node that is of type type.

findByPosition

  • findByPosition(position, selfContained?): undefined | Node

  • Parameters

    • position: Position

      the position where to search for nodes

    • Optional selfContained: boolean

      whether the starting node position contains the positions of all its children. If true no further search will be performed in subtrees where the root node falls outside the given position. If false (default) the research will cover all nodes from the starting node to the leaves.

    Returns undefined | Node

    the node most closely containing the given [position]. undefined if none is found.

    See

    searchByPosition

getAllChildren

getAttributeValue

  • getAttributeValue(name): any

  • Parameters

    • name: string | symbol

    Returns any

getChild

  • getChild(name, index?): undefined | Node

  • Parameters

    • name: string | symbol
    • Optional index: number

    Returns undefined | Node

getChildNames

getChildren

getChildrenWithRole

getReference

hasValidParents

invalidPositions

Private notAContainment

  • notAContainment(name): Error

  • Parameters

    • name: string | symbol

    Returns Error

overlaps

  • overlaps(position?): boolean

  • Tests whether the given position overlaps the interval represented by this object.

    Parameters

    • Optional position: Position

      the position

    Returns boolean

searchByPosition

  • searchByPosition(position, selfContained?): Generator<Node, any, unknown>

  • Parameters

    • position: Position

      the position where to search for nodes

    • Optional selfContained: boolean

      whether the starting node position contains the positions of all its children. If true: no further search will be performed in subtrees where the root node falls outside the given position.

      • If false (default): the search will cover all nodes from the starting node to the leaves. In any case, the search stops at the first subtree found to be containing the position.

    Returns Generator<Node, any, unknown>

    all nodes containing the given [position] using depth-first search. Empty list if none are found.

setAttributeValue

  • setAttributeValue(name, value): void

  • Parameters

    • name: string | symbol
    • value: any

    Returns void

setChild

  • setChild(name, child): void

  • Parameters

    • name: string | symbol
    • child: Node

    Returns void

walk

  • walk(): Generator<Node, any, unknown>

  • A generator that walks over the whole AST starting from this node, depth-first.

    Returns Generator<Node, any, unknown>

walkAncestors

  • walkAncestors(): Generator<Node, any, unknown>

  • Returns Generator<Node, any, unknown>

    nodes the sequence of nodes from the parent all the way up to the root node. For this to work, the nodes' parents must have been set.

walkChildren

walkDescendants

  • walkDescendants(walker?): Generator<Node, any, unknown>

  • A generator that walks over the whole AST starting from the children of this node.

    Parameters

    • Optional walker: ((node) => Generator<Node>)

      a function that generates a sequence of nodes. By default, this is the depth-first "walk" function. For post-order traversal, use "walkLeavesFirst".

        • (node): Generator<Node>

        • A generator that walks the whole AST starting from the provided node, depth-first.

          Parameters

          • node: Node

            the starting node.

          Returns Generator<Node>

    Returns Generator<Node, any, unknown>

walkWithin

  • walkWithin(position): Generator<Node, any, unknown>

  • Parameters

    • position: Position

      the position within which the walk should remain

    Returns Generator<Node, any, unknown>

    walks the AST within the given [position] starting from this node, depth-first.

withOrigin

withParent

withParseTreeNode

  • withParseTreeNode(parseTree?, source?): this

  • Parameters

    • Optional parseTree: null | ParseTree
    • Optional source: Source

    Returns this

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc