Migrate function call and assignment operator parsers to Kotlin

src/main/kotlin/SMNP.kt

@@ -2,5 +2,5 @@ import interpreter.Interpreter
 
 fun main(args: Array<String>) {
     val interpreter = Interpreter()
-    interpreter.run("{ [2, 3, 4] as (i, j, k) ^ { x y z } % i == 2 [1, xyz, [true, { 1 -> false, 2 -> { @c -> @d, @e -> false } }, [@c], 4, \"h\"]] 2 @c @d * 3.14 }")
+    interpreter.run("{ a = b = c = [2, 3, 4] as (i, j, k) ^ { x y z(1, 2, c(), {a  -> b() }) } % i == 2 [1, xyz, [true, { 1 -> false, 2 -> { @c -> @d, @e -> false } }, [@c], 4, \"h\"]] 2 @c @d * 3.14 }")
 }

src/main/kotlin/dsl/ast/model/node/AssignmentOperatorNode.kt

@@ -0,0 +1,3 @@
+package dsl.ast.model.node
+
+class AssignmentOperatorNode(lhs: Node, operator: Node, rhs: Node) : BinaryOperatorAbstractNode(lhs, operator, rhs)

src/main/kotlin/dsl/ast/model/node/FunctionCallArgumentsNode.kt

@@ -0,0 +1,5 @@
+package dsl.ast.model.node
+
+import dsl.token.model.entity.TokenPosition
+
+class FunctionCallArgumentsNode(items: List<Node>, position: TokenPosition) : AbstractIterableNode(items, position)

src/main/kotlin/dsl/ast/model/node/FunctionCallNode.kt

@@ -0,0 +1,14 @@
+package dsl.ast.model.node
+
+class FunctionCallNode(identifier: Node, arguments: Node) : Node(2, identifier.position) {
+    val identifier: Node
+    get() = children[0]
+
+    val arguments: Node
+    get() = children[1]
+
+    init {
+        children[0] = identifier
+        children[1] = arguments
+    }
+}

src/main/kotlin/dsl/ast/parser/AssignmentOperatorParser.kt

@@ -0,0 +1,18 @@
+package dsl.ast.parser
+
+import dsl.ast.model.entity.ParserOutput
+import dsl.ast.model.node.AssignmentOperatorNode
+import dsl.token.model.entity.TokenList
+import dsl.token.model.enumeration.TokenType
+
+class AssignmentOperatorParser : Parser() {
+    override fun tryToParse(input: TokenList): ParserOutput {
+        return allOf(listOf(
+            SimpleIdentifierParser(),
+            terminal(TokenType.ASSIGN),
+            assert(ExpressionParser(), "expression")
+        )) {
+            AssignmentOperatorNode(it[0], it[1], it[2])
+        }.parse(input)
+    }
+}

src/main/kotlin/dsl/ast/parser/AtomParser.kt

@@ -19,7 +19,7 @@ class AtomParser : Parser() {
         val literalParser = oneOf(
             listOf(
                 parenthesesParser,
-                IdentifierParser(),
+                ComplexIdentifierParser(),
                 ListParser(),
                 LiteralParser(),
                 MapParser()

src/main/kotlin/dsl/ast/parser/ComplexIdentifierParser.kt

@@ -0,0 +1,14 @@
+package dsl.ast.parser
+
+import dsl.ast.model.entity.ParserOutput
+import dsl.token.model.entity.TokenList
+
+class ComplexIdentifierParser : Parser() {
+    override fun tryToParse(input: TokenList): ParserOutput {
+        return oneOf(listOf(
+            AssignmentOperatorParser(),
+            FunctionCallParser(),
+            SimpleIdentifierParser()
+        )).parse(input)
+    }
+}

src/main/kotlin/dsl/ast/parser/FunctionCallArgumentsParser.kt

@@ -0,0 +1,8 @@
+package dsl.ast.parser
+
+import dsl.ast.model.node.FunctionCallArgumentsNode
+import dsl.token.model.enumeration.TokenType
+
+class FunctionCallArgumentsParser : AbstractIterableParser(TokenType.OPEN_PAREN, ExpressionParser(), TokenType.CLOSE_PAREN, {
+    list, tokenPosition -> FunctionCallArgumentsNode(list, tokenPosition)
+})

src/main/kotlin/dsl/ast/parser/FunctionCallParser.kt

@@ -0,0 +1,16 @@
+package dsl.ast.parser
+
+import dsl.ast.model.entity.ParserOutput
+import dsl.ast.model.node.FunctionCallNode
+import dsl.token.model.entity.TokenList
+
+class FunctionCallParser : Parser() {
+    override fun tryToParse(input: TokenList): ParserOutput {
+        return allOf(listOf(
+            SimpleIdentifierParser(),
+            FunctionCallArgumentsParser()
+        )) {
+            FunctionCallNode(it[0], it[1])
+        }.parse(input)
+    }
+}

src/main/kotlin/dsl/ast/parser/LoopParametersParser.kt

@@ -3,6 +3,6 @@ package dsl.ast.parser
 import dsl.ast.model.node.LoopParametersNode
 import dsl.token.model.enumeration.TokenType
 
-class LoopParametersParser : AbstractIterableParser(TokenType.OPEN_PAREN, IdentifierParser(), TokenType.CLOSE_PAREN, {
+class LoopParametersParser : AbstractIterableParser(TokenType.OPEN_PAREN, SimpleIdentifierParser(), TokenType.CLOSE_PAREN, {
     list, tokenPosition -> LoopParametersNode(list, tokenPosition)
 })

src/main/kotlin/dsl/ast/parser/LoopParser.kt

@@ -11,7 +11,7 @@ class LoopParser : Parser() {
         val loopParametersParser = allOf(listOf(
             terminal(TokenType.AS),
             oneOf(listOf(
-                mapNode(IdentifierParser()) { LoopParametersNode(listOf(it), it.position) },
+                mapNode(SimpleIdentifierParser()) { LoopParametersNode(listOf(it), it.position) },
                 LoopParametersParser()
             ))
         )) { it[1] }

src/main/kotlin/dsl/ast/parser/MapEntryParser.kt

@@ -9,7 +9,7 @@ class MapEntryParser : Parser() {
     override fun tryToParse(input: TokenList): ParserOutput {
         val keyParser = oneOf(listOf(
             LiteralParser(),
-            IdentifierParser()
+            SimpleIdentifierParser()
         ))
 
         return allOf(listOf(

src/main/kotlin/dsl/ast/parser/SimpleIdentifierParser.kt

@@ -5,7 +5,7 @@ import dsl.ast.model.node.IdentifierNode
 import dsl.token.model.entity.TokenList
 import dsl.token.model.enumeration.TokenType
 
-class IdentifierParser : Parser() {
+class SimpleIdentifierParser : Parser() {
     override fun tryToParse(input: TokenList): ParserOutput {
         val identifierParser = terminal(TokenType.IDENTIFIER) { IdentifierNode(it) }