core/com.strumenta.kolasu.model/GenericErrorNode

GenericErrorNode

class GenericErrorNode(error: Exception? = null, message: String? = null) : Node, ErrorNode

Generic implementation of ErrorNode.

Constructors

GenericErrorNode

constructor(error: Exception? = null, message: String? = null)

Functions

addSeveralAfter

fun Node.addSeveralAfter(newNodes: List<Node>)

Inserts the newNodes after this node if it is in a MutableList. For this to work, Node.assignParents must have been called.

fun Node.addSeveralAfter(targetNode: Node, newNodes: List<Node>)

Looks for targetNode in the lists of nodes in this node. When found, newNodes are inserted after it. When not found, an IllegalStateException is thrown.

addSeveralBefore

fun Node.addSeveralBefore(newNodes: List<Node>)

Inserts the newNodes before this node if it is in a MutableList. For this to work, Node.assignParents must have been called.

fun Node.addSeveralBefore(targetNode: Node, newNodes: List<Node>)

Looks for targetNode in the lists of nodes in this node. When found, newNodes are inserted before it. When not found, an IllegalStateException is thrown.

assertAllReferencesResolved

fun Node.assertAllReferencesResolved()

assignParents

fun Node.assignParents()

Sets or corrects the parent of all AST nodes. Kolasu does not see set/add/delete operations on the AST nodes, so this function should be called manually after modifying the AST.

collectByType

fun <T> Node.collectByType(klass: Class<T>, walker: (Node) -> Sequence<Node> = Node::walk): List<T>

T is not forced to be a subtype of Node to support using interfaces.

computeIds

fun Node.computeIds(walker: (Node) -> Sequence<Node> = Node::walk, idProvider: IdProvider = SequentialIdProvider()): IdentityHashMap<Node, String>

computeIdsForReferencedNodes

fun Node.computeIdsForReferencedNodes(walker: (Node) -> Sequence<Node> = Node::walk, idProvider: IdProvider = OnlyReferencedIdProvider(this)): IdentityHashMap<Node, String>

containingProperty

fun Node.containingProperty(): PropertyDescription?

Return the property containing this Node, if any. Null should be returned for root nodes.

contains

fun contains(range: Range?): Boolean

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

debugPrint

@JvmOverloads

fun Node.debugPrint(indent: String = "", configuration: DebugPrintConfiguration = DebugPrintConfiguration()): String

detach

fun detach(keepRange: Boolean = true, keepSourceText: Boolean = false)

errors

fun Node.errors(): Sequence<ErrorNode>

find

fun Node.find(predicate: (Node) -> Boolean, walker: (Node) -> Sequence<Node> = Node::walk): Node?

findAncestorOfType

fun <T> Node.findAncestorOfType(klass: Class<T>): T?

Note that type T is not strictly forced to be a 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.

findByRange

@JvmOverloads

fun Node.findByRange(range: Range, selfContained: Boolean = false): Node?

findError

fun Node.findError(): ErrorNode?

findGenericNode

fun Node.findGenericNode(): GenericNode?

findInvalidRange

fun Node.findInvalidRange(): Node?

hasValidParents

fun Node.hasValidParents(parent: Node? = this.parent): Boolean

indexInContainingProperty

fun Node.indexInContainingProperty(): Int?

Return the index of this Node within the containing property. The return value is null for root nodes. The index is always 0 for Nodes in singular containment properties.

invalidRanges

fun Node.invalidRanges(): Sequence<Node>

isBefore

fun Node.isBefore(other: Node): Boolean

mapChildren

fun Node.mapChildren(operation: (Node) -> Node): Node

overlaps

fun overlaps(range: Range?): Boolean

Tests whether the given range overlaps the interval represented by this object.

processConsideringDirectParent

fun Node.processConsideringDirectParent(operation: (Node, Node?) -> Unit, parent: Node? = null)

Recursively execute operation on this node, and all nodes below this node. Every node is informed about its parent node. (But not about the parent's parent!)

processNodes

fun Node.processNodes(operation: (Node) -> Unit, walker: (Node) -> Sequence<Node> = Node::walk)

Recursively execute operation on this node, and all nodes below this node.

processNodesOfType

fun <T> Node.processNodesOfType(klass: Class<T>, operation: (T) -> Unit, walker: (Node) -> Sequence<Node> = Node::walk)

Recursively execute operation on this node, and all nodes below this node that extend klass.

processProperties

@JvmOverloads

fun Node.processProperties(propertiesToIgnore: Set<String> = emptySet(), propertyOperation: (PropertyDescription) -> Unit)

Executes an operation on the properties of a node.

referenceByNameProperties

fun Node.referenceByNameProperties(): Collection<ReferenceByNameProperty>

registerObserver

fun registerObserver(observer: Observer<*>)

removeFromList

fun Node.removeFromList()

Removes this node from the parent if it is in a MutableList. For this to work, Node.assignParents must have been called.

fun Node.removeFromList(targetNode: Node)

Looks for targetNode in the lists of nodes in this node. When found, it is removed. When not found, an IllegalStateException is thrown.

replaceWith

fun Node.replaceWith(other: Node)

Replace this node with other (by modifying the children of the parent node.) For this to work, Node.assignParents must have been called.

replaceWithSeveral

fun Node.replaceWithSeveral(newNodes: List<Node>)

Replaces this node with any amount of other nodes if it is in a MutableList.

fun Node.replaceWithSeveral(oldNode: Node, newNodes: List<Node>)

Looks for oldNode in the lists of nodes in this node. When found, it is removed, and in its place the newNodes are inserted. When not found, an IllegalStateException is thrown.

searchByRange

@JvmOverloads

fun Node.searchByRange(range: Range, selfContained: Boolean = false): Sequence<Node>

searchByType

@JvmOverloads

fun <T> Node.searchByType(klass: Class<T>, walker: (Node) -> Sequence<Node> = Node::walk): Sequence<T>

toString

override fun toString(): String

This must be final because otherwise data classes extending this will automatically generate their own implementation. If Link properties are present it could lead to stack overflows in case of circular graphs.

transformChildren

fun Node.transformChildren(operation: (Node) -> Node)

transformTree

fun Node.transformTree(operation: (Node) -> Node, inPlace: Boolean = false, mutationsCache: IdentityHashMap<Node, Node> = IdentityHashMap<Node, Node>()): Node

unregisterObserver

fun unregisterObserver(observer: Observer<in Node>)

walk

fun Node.walk(): Sequence<Node>

Traverse the entire tree, deep first, starting from this Node.

walkAncestors

fun Node.walkAncestors(): Sequence<Node>

walkChildren

fun Node.walkChildren(): Sequence<Node>

walkDescendants

@JvmOverloads

fun Node.walkDescendants(walker: (Node) -> Sequence<Node> = Node::walk): Sequence<Node>

@JvmOverloads

fun <N : Any> Node.walkDescendants(type: KClass<N>, walker: (Node) -> Sequence<Node> = Node::walk): Sequence<N>

walkLeavesFirst

fun Node.walkLeavesFirst(): Sequence<Node>

Performs a post-order (or leaves-first) node traversal starting with a given node.

walkWithin

fun Node.walkWithin(range: Range): Sequence<Node>

Properties

children

val Node.children: List<Node>

destination

var destination: Destination?

endLine

val Node.endLine: Int?

message

open override val message: String

nextSamePropertySibling

val Node.nextSamePropertySibling: Node?

nextSibling

val Node.nextSibling: Node?

nodeType

open val nodeType: String

observers

val observers: MutableList<Observer<in Node>>

origin

var origin: Origin?

The node from which this AST Node has been generated, if any.

parent

var parent: Node?

The parent node, if any.

previousSamePropertySibling

val Node.previousSamePropertySibling: Node?

previousSibling

val Node.previousSibling: Node?

properties

open val properties: List<PropertyDescription>

The properties of this AST nodes, including attributes, children, and references.

range

open override var range: Range?

The range of this node in the source text. If a range has been provided when creating this node, it is returned. Otherwise, the value of this property is the range of the origin, if any.

source

open override val source: Source?

sourceText

open override val sourceText: String?

The source text for this node

startLine

val Node.startLine: Int?