Migrate import evaluator to Kotlin

app/src/main/kotlin/io/smnp/dsl/ast/parser/ImportParser.kt

@@ -9,8 +9,7 @@ class ImportParser : Parser() {
     override fun tryToParse(input: TokenList): ParserOutput {
         val pathParser = oneOf(
             UnitParser(),
-            SimpleIdentifierParser(),
-            StringLiteralParser()
+            SimpleIdentifierParser()
         )
 
         return allOf(

app/src/main/kotlin/io/smnp/dsl/ast/parser/RootParser.kt

@@ -3,12 +3,13 @@ package io.smnp.dsl.ast.parser
 import io.smnp.dsl.ast.model.entity.ParserOutput
 import io.smnp.dsl.ast.model.node.RootNode
 import io.smnp.dsl.token.model.entity.TokenList
+import io.smnp.dsl.token.model.enumeration.TokenType
 
 class RootParser : Parser() {
     override fun tryToParse(input: TokenList): ParserOutput {
         return repeat(
             oneOf(
-                ImportParser(),
+                allOf(ImportParser(), optional(terminal(TokenType.SEMICOLON))) { (import, _) -> import },
                 FunctionDefinitionParser(),
                 ExtendParser(),
                 StatementParser()

app/src/main/kotlin/io/smnp/evaluation/evaluator/ImportEvaluator.kt

@@ -0,0 +1,39 @@
+package io.smnp.evaluation.evaluator
+
+import io.smnp.dsl.ast.model.node.AccessOperatorNode
+import io.smnp.dsl.ast.model.node.IdentifierNode
+import io.smnp.dsl.ast.model.node.ImportNode
+import io.smnp.dsl.ast.model.node.Node
+import io.smnp.environment.Environment
+import io.smnp.error.ShouldNeverReachThisLineException
+import io.smnp.evaluation.model.entity.EvaluatorOutput
+
+class ImportEvaluator : Evaluator() {
+    override fun supportedNodes() = listOf(ImportNode::class)
+
+    override fun tryToEvaluate(node: Node, environment: Environment): EvaluatorOutput {
+        val path = when (val pathNode = (node as ImportNode).path) {
+            is AccessOperatorNode -> complexPath(pathNode).joinToString(".")
+            is IdentifierNode -> pathNode.token.rawValue
+            else -> throw ShouldNeverReachThisLineException()
+        }
+
+        environment.loadModule(path)
+
+        return EvaluatorOutput.ok()
+    }
+
+    private fun complexPath(segment: AccessOperatorNode): List<String> {
+        val segments  = mutableListOf<String>()
+        val (lhs, _, rhs) = segment
+
+        segments.add((rhs as IdentifierNode).token.rawValue)
+
+        when(lhs) {
+            is AccessOperatorNode -> segments.addAll(complexPath(lhs))
+            is IdentifierNode -> segments.add(lhs.token.rawValue)
+        }
+
+        return segments.reversed()
+    }
+}

app/src/main/kotlin/io/smnp/evaluation/evaluator/RootEvaluator.kt

@@ -11,8 +11,10 @@ class RootEvaluator : Evaluator() {
 
     override fun tryToEvaluate(node: Node, environment: Environment): EvaluatorOutput {
         val evaluator = oneOf(
+            ImportEvaluator(),
             ExpressionEvaluator(),
-            FunctionDefinitionEvaluator()
+            FunctionDefinitionEvaluator(),
+            DefaultEvaluator()
         )
 
         for(child in node.children) {

app/src/main/kotlin/io/smnp/interpreter/Interpreter.kt

@@ -2,30 +2,38 @@ package io.smnp.interpreter
 
 import io.smnp.dsl.ast.parser.RootParser
 import io.smnp.dsl.token.tokenizer.DefaultTokenizer
+import io.smnp.environment.DefaultEnvironment
+import io.smnp.environment.Environment
+import io.smnp.evaluation.evaluator.RootEvaluator
 import java.io.File
 
 class Interpreter {
-    fun run(code: String) {
-        val tokenizer = DefaultTokenizer()
-        val parser = RootParser()
+    private val tokenizer = DefaultTokenizer()
+    private val parser = RootParser()
+    private val evaluator = RootEvaluator()
 
+    fun run(code: String) {
         val lines = code.split("\n")
         val tokens = tokenizer.tokenize(lines)
         val ast = parser.parse(tokens)
 
-        ast.node.pretty()
-        println(tokens)
+        val environment = createEnvironment()
+        evaluator.evaluate(ast.node, environment)
+    }
+
+    private fun createEnvironment(): Environment {
+        val environment = DefaultEnvironment()
+        environment.loadModule("smnp.lang")
+
+        return environment
     }
 
     fun run(file: File) {
-        val tokenizer = DefaultTokenizer()
-        val parser = RootParser()
-
         val lines = file.readLines()
         val tokens = tokenizer.tokenize(lines)
         val ast = parser.parse(tokens)
 
-        ast.node.pretty()
-        println(tokens)
+        val environment = createEnvironment()
+        evaluator.evaluate(ast.node, environment)
     }
 }