pork/ast/src/main/kotlin/gay/pizza/pork/ast/gen/NodeVisitorExtensions.kt

// GENERATED CODE FROM PORK AST CODEGEN
package gay.pizza.pork.ast.gen

fun <T> NodeVisitor<T>.visit(node: Node): T =
  when (node) {
    is Symbol -> visitSymbol(node)
    is Block -> visitBlock(node)
    is CompilationUnit -> visitCompilationUnit(node)
    is LetAssignment -> visitLetAssignment(node)
    is VarAssignment -> visitVarAssignment(node)
    is SetAssignment -> visitSetAssignment(node)
    is InfixOperation -> visitInfixOperation(node)
    is BooleanLiteral -> visitBooleanLiteral(node)
    is FunctionCall -> visitFunctionCall(node)
    is ArgumentSpec -> visitArgumentSpec(node)
    is FunctionDefinition -> visitFunctionDefinition(node)
    is LetDefinition -> visitLetDefinition(node)
    is If -> visitIf(node)
    is ImportPath -> visitImportPath(node)
    is ImportDeclaration -> visitImportDeclaration(node)
    is IntegerLiteral -> visitIntegerLiteral(node)
    is LongLiteral -> visitLongLiteral(node)
    is DoubleLiteral -> visitDoubleLiteral(node)
    is ListLiteral -> visitListLiteral(node)
    is Parentheses -> visitParentheses(node)
    is PrefixOperation -> visitPrefixOperation(node)
    is SuffixOperation -> visitSuffixOperation(node)
    is StringLiteral -> visitStringLiteral(node)
    is SymbolReference -> visitSymbolReference(node)
    is While -> visitWhile(node)
    is ForInItem -> visitForInItem(node)
    is ForIn -> visitForIn(node)
    is Break -> visitBreak(node)
    is Continue -> visitContinue(node)
    is NoneLiteral -> visitNoneLiteral(node)
    is Native -> visitNative(node)
    is IndexedBy -> visitIndexedBy(node)
  }

fun <T> NodeVisitor<T>.visitNodes(vararg nodes: Node?): List<T> =
  nodes.asSequence().filterNotNull().map { visit(it) }.toList()

fun <T> NodeVisitor<T>.visitAll(vararg nodeLists: List<Node?>): List<T> =
  nodeLists.asSequence().flatten().filterNotNull().map { visit(it) }.toList()
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`// GENERATED CODE FROM PORK AST CODEGEN`
ast: move gay.pizza.pork.ast to gay.pizza.pork.ast.gen 2023-10-06 15:39:13 -07:00			`package gay.pizza.pork.ast.gen`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00
			`fun <T> NodeVisitor<T>.visit(node: Node): T =`
			`when (node) {`
			`is Symbol -> visitSymbol(node)`
			`is Block -> visitBlock(node)`
			`is CompilationUnit -> visitCompilationUnit(node)`
			`is LetAssignment -> visitLetAssignment(node)`
language: var, reassign, comparison operators 2023-09-10 04:34:50 -04:00			`is VarAssignment -> visitVarAssignment(node)`
			`is SetAssignment -> visitSetAssignment(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is InfixOperation -> visitInfixOperation(node)`
			`is BooleanLiteral -> visitBooleanLiteral(node)`
			`is FunctionCall -> visitFunctionCall(node)`
idea: proper scoping support, completion now works 2023-09-21 23:07:22 -07:00			`is ArgumentSpec -> visitArgumentSpec(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is FunctionDefinition -> visitFunctionDefinition(node)`
language: implement let definitions 2023-09-11 04:57:13 -04:00			`is LetDefinition -> visitLetDefinition(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is If -> visitIf(node)`
pork: it's got it all, ffi, state machine tokenizer, and better IDE support 2023-10-13 01:04:35 -07:00			`is ImportPath -> visitImportPath(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is ImportDeclaration -> visitImportDeclaration(node)`
language: floating point support 2023-09-09 00:08:30 -04:00			`is IntegerLiteral -> visitIntegerLiteral(node)`
parser: implement long literal and handle overflow 2023-09-12 00:25:13 -04:00			`is LongLiteral -> visitLongLiteral(node)`
language: floating point support 2023-09-09 00:08:30 -04:00			`is DoubleLiteral -> visitDoubleLiteral(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is ListLiteral -> visitListLiteral(node)`
			`is Parentheses -> visitParentheses(node)`
			`is PrefixOperation -> visitPrefixOperation(node)`
language: add unary plus & minus, post increment & decrement operators, non-newline print builtin. fix block comments (#4) 2023-09-11 14:34:10 +10:00			`is SuffixOperation -> visitSuffixOperation(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`is StringLiteral -> visitStringLiteral(node)`
			`is SymbolReference -> visitSymbolReference(node)`
while loop support, and native functions (including ffi!) 2023-09-06 19:07:28 -07:00			`is While -> visitWhile(node)`
idea: proper scoping support, completion now works 2023-09-21 23:07:22 -07:00			`is ForInItem -> visitForInItem(node)`
language: implement for in 2023-09-11 05:34:09 -04:00			`is ForIn -> visitForIn(node)`
while loop support, and native functions (including ffi!) 2023-09-06 19:07:28 -07:00			`is Break -> visitBreak(node)`
			`is Continue -> visitContinue(node)`
language: none support 2023-09-12 02:03:41 -04:00			`is NoneLiteral -> visitNoneLiteral(node)`
while loop support, and native functions (including ffi!) 2023-09-06 19:07:28 -07:00			`is Native -> visitNative(node)`
language: implement list indexing 2023-09-17 08:38:11 -07:00			`is IndexedBy -> visitIndexedBy(node)`
ast: utilize extension functions to prevent larger stack frames from default interface methods 2023-09-05 14:04:39 -07:00			`}`

			`fun <T> NodeVisitor<T>.visitNodes(vararg nodes: Node?): List<T> =`
			`nodes.asSequence().filterNotNull().map { visit(it) }.toList()`

while loop support, and native functions (including ffi!) 2023-09-06 19:07:28 -07:00			`fun <T> NodeVisitor<T>.visitAll(vararg nodeLists: List<Node?>): List<T> =`
			`nodeLists.asSequence().flatten().filterNotNull().map { visit(it) }.toList()`