antlr/com.strumenta.kolasu.antlr.mapping/ParseTreeToASTTransformer

ParseTreeToASTTransformer

open class ParseTreeToASTTransformer(issues: MutableList<Issue> = mutableListOf(), allowGenericNode: Boolean = true, val source: Source? = null) : ASTTransformer

Implements a transformation from an ANTLR parse tree (the output of the parser) to an AST (a higher-level representation of the source code).

Constructors

constructor(issues: MutableList<Issue> = mutableListOf(), allowGenericNode: Boolean = true, source: Source? = null)

Functions

addIssue

fun addIssue(message: String, severity: IssueSeverity, range: Range?): Issue

registerIdentityTransformation

fun <T : Node> registerIdentityTransformation(nodeClass: KClass<T>): NodeTransformer<T, T>

registerNodeFactoryUnwrappingChild

inline fun <P : ParserRuleContext> registerNodeFactoryUnwrappingChild(): NodeTransformer<P, Node>

Alternative to registerNodeFactoryUnwrappingChild(KClass) which is slightly more concise.

registerNodeTransformer

inline fun <S : Any, T : Node> registerNodeTransformer(): NodeTransformer<S, T>

inline fun <S : Any, T : Node> registerNodeTransformer(crossinline transformer: S.(ASTTransformer) -> T?): NodeTransformer<S, T>

fun <S : Any, T : Node> registerNodeTransformer(kclass: KClass<S>, transformer: (S) -> T?): NodeTransformer<S, T>

fun <S : Any, T : Node> registerNodeTransformer(kclass: KClass<S>, transformer: (S, ASTTransformer) -> T?): NodeTransformer<S, T>

fun <S : Any, T : Node> registerNodeTransformer(kclass: KClass<S>, transformer: (S, ASTTransformer, NodeTransformer<S, T>) -> T?): NodeTransformer<S, T>

fun <S : Any, T : Node> registerNodeTransformer(source: KClass<S>, target: KClass<T>, parameterConverters: List<ParameterConverter>): NodeTransformer<S, T>

registerNodeTransformerUnwrappingChild

fun <P : ParserRuleContext> registerNodeTransformerUnwrappingChild(kclass: KClass<P>): NodeTransformer<P, Node>

Often in ANTLR grammar we have rules which wraps other rules and act as wrapper. When there is only a ParserRuleContext child we can transform that child and return that result.

registerTrivialPTtoASTConversion

inline fun <S : RuleContext, T : Node> ParseTreeToASTTransformer.registerTrivialPTtoASTConversion(vararg nameConversions: Pair<KCallable<*>, KCallable<*>>)

inline fun <S : RuleContext, T : Node> ASTTransformer.registerTrivialPTtoASTConversion(vararg nameConversions: Pair<String, String>)

transform

open override fun transform(source: Any?, parent: Node?): Node?

Performs the transformation of a node and, recursively, its descendants. In addition to the overridden method, it also assigns the parseTreeNode to the AST node so that it can keep track of its range. However, a node transformer can override the parseTreeNode of the nodes it creates (but not the parent).

translateCasted

fun <T> ParseTreeToASTTransformer.translateCasted(original: ParserRuleContext): T

Translate the given node and ensure a certain type will be obtained.

translateList

fun <T> ParseTreeToASTTransformer.translateList(original: Collection<out ParserRuleContext>?): ObservableList<T>

Translate a whole collection into a mutable list, translating each element and ensuring the list has the expected type.

translateOnlyChild

fun <T> ParseTreeToASTTransformer.translateOnlyChild(parent: ParserRuleContext): T

Translate the only child (of type ParseRuleContext) and ensure the resulting value as the expected type.

translateOptional

fun <T> ParseTreeToASTTransformer.translateOptional(original: ParserRuleContext?): T?

Translate the given node and ensure a certain type will be obtained, if the value is not null. If the value is null, null is returned.

unwrap

inline fun <S : RuleContext, T : Node> ParseTreeToASTTransformer.unwrap(wrappingMember: KCallable<*>)

Properties

allowGenericNode

val allowGenericNode: Boolean

issues

val issues: MutableList<Issue>

knownClasses

val knownClasses: Map<String, Set<KClass<*>>>

source

val source: Source? = null