bartek/smnp-kt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor parsers

Browse Source
This commit is contained in:
Bartłomiej Przemysław Pluta
2020-03-13 18:10:25 +01:00
parent 764c607a69
commit 7eb543f2bc
15 changed files with 89 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
app/src/main/kotlin/io/smnp/dsl/ast/parser/AbstractIterableParser.kt
View File

@@ -16,7 +16,7 @@ abstract class AbstractIterableParser(
val emptyIterableParser = allOf(
terminal(beginTokenType),
terminal(endTokenType)
) { createNode(listOf(), it[0].position) }
) { (beginToken) -> createNode(listOf(), beginToken.position) }
val nonEmptyIterableParser = allOf(
terminal(beginTokenType),
@@ -25,12 +25,12 @@ abstract class AbstractIterableParser(
optional(repeat(allOf(
terminal(TokenType.COMMA),
itemParser
) { it[1] }) { list, position -> object : Node(list, position) {} }
)) { list ->
object : Node(listOf(list[0]) + list[1].children, TokenPosition.NONE) {}
) { (_, item) -> item }) { list, position -> object : Node(list, position) {} }
)) { (firstItem, otherAggregatedItems) ->
object : Node(listOf(firstItem) + otherAggregatedItems.children, TokenPosition.NONE) {}
},
terminal(endTokenType)
) { createNode(it[1].children.toList(), it[0].position) }
) { (beginToken, aggregatedItems) -> createNode(aggregatedItems.children.toList(), beginToken.position) }
return oneOf(
emptyIterableParser,

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/AssignmentOperatorParser.kt
View File

@@ -11,8 +11,6 @@ class AssignmentOperatorParser : Parser() {
SimpleIdentifierParser(),
terminal(TokenType.ASSIGN),
assert(ExpressionParser(), "expression")
) {
AssignmentOperatorNode(it[0], it[1], it[2])
}.parse(input)
) { (target, assignToken, value) -> AssignmentOperatorNode(target, assignToken, value) }.parse(input)
}
}

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/AtomParser.kt
View File

@@ -10,9 +10,7 @@ class AtomParser : Parser() {
terminal(TokenType.OPEN_PAREN),
ExpressionParser(),
terminal(TokenType.CLOSE_PAREN)
) {
it[1]
}
) { (_, expression) -> expression }
val literalParser = oneOf(
parenthesesParser,

8
app/src/main/kotlin/io/smnp/dsl/ast/parser/ExtendParser.kt
View File

@@ -16,8 +16,8 @@ class ExtendParser : Parser() {
assert(SimpleIdentifierParser(), "identifier"),
terminal(TokenType.WITH),
assert(mapNode(FunctionDefinitionParser()) { BlockNode(Node.NONE, listOf(it), Node.NONE) }, "method definition")
) {
ExtendNode(it[1], it[3], it[5], it[0].position)
) { (extendToken, targetType, identifier, method) ->
ExtendNode(targetType, identifier, method, extendToken.position)
}
val complexExtendParser = allOf(
@@ -28,8 +28,8 @@ class ExtendParser : Parser() {
assert(loop(terminal(TokenType.OPEN_CURLY), assert(FunctionDefinitionParser(), "method definition or }"), terminal(TokenType.CLOSE_CURLY)) {
begin, methods, end -> BlockNode(begin, methods, end)
}, "block with methods' definitions or 'with' keyword with single method definition")
) {
ExtendNode(it[1], it[3], it[4], it[0].position)
) { (extendToken, targetType, identifier, methods) ->
ExtendNode(targetType, identifier, methods, extendToken.position)
}
return oneOf(

8
app/src/main/kotlin/io/smnp/dsl/ast/parser/FactorParser.kt
View File

@@ -12,16 +12,12 @@ class FactorParser : Parser() {
UnitParser(),
listOf(TokenType.DOUBLE_ASTERISK),
assert(UnitParser(), "expression")
) { lhs, operator, rhs ->
PowerOperatorNode(lhs, operator, rhs)
}
) { lhs, operator, rhs -> PowerOperatorNode(lhs, operator, rhs) }
val notOperatorParser = allOf(
terminal(TokenType.NOT),
assert(factorParser, "expression")
) {
NotOperatorNode(it[0], it[1])
}
) { (notToken, expression) -> NotOperatorNode(notToken, expression) }
return oneOf(
notOperatorParser,

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionCallParser.kt
View File

@@ -9,8 +9,6 @@ class FunctionCallParser : Parser() {
return allOf(
SimpleIdentifierParser(),
FunctionCallArgumentsParser()
) {
FunctionCallNode(it[0], it[1])
}.parse(input)
) { (identifier, arguments) -> FunctionCallNode(identifier, arguments) }.parse(input)
}
}

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionDefinitionParser.kt
View File

@@ -12,8 +12,8 @@ class FunctionDefinitionParser : Parser() {
assert(SimpleIdentifierParser(), "function/method name"),
assert(FunctionDefinitionArgumentsParser(), "function/method arguments list"),
assert(BlockParser(), "function/method body")
) {
FunctionDefinitionNode(it[1], it[2], it[3], it[0].position)
) { (functionToken, identifier, arguments, body) ->
FunctionDefinitionNode(identifier, arguments, body, functionToken.position)
}.parse(input)
}
}

8
app/src/main/kotlin/io/smnp/dsl/ast/parser/LoopParser.kt
View File

@@ -14,12 +14,12 @@ class LoopParser : Parser() {
mapNode(SimpleIdentifierParser()) { LoopParametersNode(listOf(it), it.position) },
LoopParametersParser()
), "loop parameters")
) { it[1] }
) { (_, parameters) -> parameters }
val loopFilterParser = allOf(
terminal(TokenType.PERCENT),
assert(SubexpressionParser(), "filter as bool expression")
) { it[1] }
) { (_, filter) -> filter }
return allOf(
SubexpressionParser(),
@@ -27,8 +27,8 @@ class LoopParser : Parser() {
terminal(TokenType.CARET),
assert(StatementParser(), "statement"),
optional(loopFilterParser)
) {
LoopNode(it[0], it[1], it[2], it[3], it[4])
) { (iterator, parameters, caretToken, statement, filter) ->
LoopNode(iterator, parameters, caretToken, statement, filter)
}.parse(input)
}
}

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/MapEntryParser.kt
View File

@@ -16,8 +16,6 @@ class MapEntryParser : Parser() {
keyParser,
terminal(TokenType.ARROW),
assert(SubexpressionParser(), "expression")
) {
MapEntryNode(it[0], it[1], it[2])
}.parse(input)
) { (key, arrowToken, value) -> MapEntryNode(key, arrowToken, value) }.parse(input)
}
}

6
app/src/main/kotlin/io/smnp/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt
View File

@@ -14,11 +14,11 @@ class OptionalFunctionDefinitionArgumentParser : Parser() {
optional(allOf(
terminal(TokenType.COLON),
assert(TypeParser(), "type name")
) { it[1] }) { UnionTypeNode(emptyList(), TokenPosition.NONE) },
) { (_, type) -> type }) { UnionTypeNode(emptyList(), TokenPosition.NONE) },
terminal(TokenType.ASSIGN),
assert(ExpressionParser(), "expression")
) {
OptionalFunctionDefinitionArgumentNode(it[0], it[1], it[3])
) { (identifier, type, defaultValue) ->
OptionalFunctionDefinitionArgumentNode(identifier, type, defaultValue)
}.parse(input)
}
}

2
app/src/main/kotlin/io/smnp/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt
View File

@@ -15,7 +15,7 @@ class RegularFunctionDefinitionArgumentParser : Parser() {
optional(allOf(
terminal(TokenType.COLON),
assert(TypeParser(), "type name")
) { it[1] }) { UnionTypeNode(emptyList(), TokenPosition.NONE) }
) { (_, type) -> type }) { UnionTypeNode(emptyList(), TokenPosition.NONE) }
) { (vararg, identifier, type) ->
RegularFunctionDefinitionArgumentNode(identifier, type, vararg)
}.parse(input)

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/SingleTypeParser.kt
View File

@@ -10,8 +10,6 @@ class SingleTypeParser : Parser() {
return allOf(
SimpleIdentifierParser(),
optional(repeat(TypeSpecifierParser()) { list, tokenPosition -> TypeSpecifiersNode(list, tokenPosition) })
) {
SingleTypeNode(it[0], it[1])
}.parse(input)
) { (identifier, specifiers) -> SingleTypeNode(identifier, specifiers) }.parse(input)
}
}

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/StatementParser.kt
View File

@@ -15,8 +15,6 @@ class StatementParser : Parser() {
ThrowParser()
),
optional(terminal(TokenType.SEMICOLON))
) {
it[0]
}.parse(input)
) { (statement) -> statement }.parse(input)
}
}

4
app/src/main/kotlin/io/smnp/dsl/ast/parser/ThrowParser.kt
View File

@@ -10,8 +10,6 @@ class ThrowParser : Parser() {
return allOf(
terminal(TokenType.THROW),
optional(SubexpressionParser())
) {
ThrowNode(it[1])
}.parse(input)
) { (_, value) -> ThrowNode(value) }.parse(input)
}
}

12
app/src/main/kotlin/io/smnp/dsl/ast/parser/UnitParser.kt
View File

@@ -11,17 +11,17 @@ class UnitParser : Parser() {
val minusOperatorParser = allOf(
terminal(TokenType.MINUS),
assert(AtomParser(), "expression")
) {
MinusOperatorNode(it[0], it[1])
}
) { (minusToken, expression) -> MinusOperatorNode(minusToken, expression) }
val atom2 = oneOf(
minusOperatorParser,
AtomParser()
)
return leftAssociativeOperator(atom2, listOf(TokenType.DOT), assert(atom2, "property or method call")) { lhs, operator, rhs ->
AccessOperatorNode(lhs, operator, rhs)
}.parse(input)
return leftAssociativeOperator(
atom2,
listOf(TokenType.DOT),
assert(atom2, "property or method call")
) { lhs, operator, rhs -> AccessOperatorNode(lhs, operator, rhs) }.parse(input)
}
}