Update to KtLox v1.1.0

Author: HallofFamer

README.md

@@ -0,0 +1,77 @@
+# KtLox
+Kotlin Treewalk Interpreter for Lox
+
+## Introduction
+KtLox is an implementation of the programming language Lox in Kotlin. Currently it uses naive treewalk interpreter, and is not optimized for speed. The initial version of KtLox has only features already present in the original JLox/CLox, but subsequent versions will continue to add new features to make it a powerful language. This is an experiment on the design and implementation of language features.
+
+The original version of Lox programming language can be found at Bob Nystrom's repository:
+
+https://github.com/munificent/craftinginterpreters
+
+## Features
+- Lexer, Parser and Treewalk Interpreter
+- Unary and Binary Expression/Operators
+- If and Else Statement
+- While and For Loop
+- Break Statement(challenge from the book)
+- Scope and Environment
+- Functions and Closures
+- Resolver and Semantic Analysis
+- Anonymous Functions(challenge from the book)
+- Classes and Objects
+- Methods and Property Getters
+- Inheritance and this/super keywords
+- Metaclasses(challenge from the book)
+- Traits(challenge from the book)
+
+## Roadmap
+
+### KtLox v1.1.0(current version)
+- Improved object model - Everything is an object, including nil, true, false, number, string, etc.
+- Framework for writing Native functions and classes.
+- root class Object which serves as superclass of every class.
+
+### KtLox v1.2.0(next version)
+- Full Fledged Standard Library: Boolean, Number, String, Array, Dictionary, DateTime, etc.
+- Mechanism for efficiently loading standard library at interpreter startup.
+- (maybe) Split the Number class, which will distinguish between integers and floating numbers.
+
+### KtLox v1.3.0
+- Syntactic Sugar for Array/Dictionary Literals.
+- Short closures/lambda expression.
+- (maybe) Null-safe operator (?.).
+
+### KtLox v1.4.0
+- Immutable variable declaration with **val**.
+- Function/method parameters are immutable by default(unless var keyword is used).
+- (maybe) Allow properties/instance variables to be defined inside the class statements, instead of initializers.
+
+### KtLox v1.5.0
+- Refinement of metaclass system to match smalltalk's metaobject protocol.
+- Improvement of trait system in KtLox.
+- Add some Metaclasses and traits to the standard library.
+
+### KtLox v1.6.0
+- Introduction of Namespace for KtLox's module system.
+- Allow importing namespaces and aliasing of imported classes/functions.
+- Redesign the existing standard library with namespaces(KtLox.Standard package).
+
+### KtLox v1.7.0
+- Exception handling: throw statement, try/catch/finally statement, etc.
+- Add class Exception as well as a few more exception subclasses to the standard library.
+- (maybe) Pattern Matching
+
+### Ktlox v1.8.0
+- Operator Overloading: enable user defined classes to overload operators, these operators are treated as method calls.
+- Method interception when an undefined method call is invoked on an object/class, similar to Smalltalk's doesNotUnderstand: message.
+- (maybe) Semicolon inference that allows semicolons to be omitted when its obvious that the statement is finished at the end of the line.
+
+### KtLox v1.9.0
+- Introduction of async and await keywords, which allows C#/JS style of concurrency.
+- Add class Promise(or Future) to the standard library, which represents an async task to be completed in future.
+- (maybe) Continuation and Context, similar to smalltalk style stack manipulation.
+
+### KtLox v2.0.0
+- Optional static typing support for instance variables and function/method parameters.
+- (maybe) Type inference for immutable variables, as well as possible optimization for typed variables.
+- (maybe) Slot as refied variables, similar to Pharo Smalltalk and Self's implementation. 

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.mysidia"
-version = "1.0.0"
+version = "1.1.0"
 
 repositories {
     mavenCentral()

src/main/kotlin/Ast.kt

@@ -34,7 +34,7 @@ object Ast {
         val grammarStmts = listOf(
             "Block      : List<Stmt> statements",
             "Break      : Token token",
-            "Class      : Token name, Expr.Variable? superclass, List<Expr.Variable> traits, List<Stmt.Function> methods, List<Stmt.Function> classMethods",
+            "Class      : Token name, Expr.Variable superclass, List<Expr.Variable> traits, List<Stmt.Function> methods, List<Stmt.Function> classMethods",
             "Function   : Token name, Expr.Function functionBody",
             "Expression : Expr expression",
             "If         : Expr condition, Stmt thenBranch, Stmt? elseBranch",

src/main/kotlin/ast/Stmt.kt

@@ -26,7 +26,7 @@ abstract class Stmt {
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitBreakStmt(this)
     }
 
-    data class Class(val name: Token, val superclass: Expr.Variable?, val traits: List<Expr.Variable>, val methods: List<Stmt.Function>, val classMethods: List<Stmt.Function>) : Stmt(){
+    data class Class(val name: Token, val superclass: Expr.Variable, val traits: List<Expr.Variable>, val methods: List<Function>, val classMethods: List<Function>) : Stmt(){
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitClassStmt(this)
     }
 
@@ -50,7 +50,7 @@ abstract class Stmt {
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitReturnStmt(this)
     }
 
-    data class Trait(val name: Token, val traits: List<Expr.Variable>, val methods: List<Stmt.Function>) : Stmt(){
+    data class Trait(val name: Token, val traits: List<Expr.Variable>, val methods: List<Function>) : Stmt(){
         override fun <R> accept(visitor: Visitor<R>) = visitor.visitTraitStmt(this)
     }
 

src/main/kotlin/common/LoxBooleanClass.kt

@@ -0,0 +1,13 @@
+package com.mysidia.ktlox.common
+
+import com.mysidia.ktlox.interpreter.Interpreter
+
+object LoxBooleanClass : LoxNativeClass("Boolean", LoxObjectClass){
+
+    init{
+        defineNativeMetaclass("Boolean class")
+        defineNativeMethod("isBoolean", 0, this::isBooleanDef)
+    }
+
+    private fun isBooleanDef(interpreter: Interpreter, arguments: List<Any?>?) = true
+}

src/main/kotlin/common/LoxCallable.kt

@@ -4,5 +4,8 @@ import com.mysidia.ktlox.interpreter.Interpreter
 
 interface LoxCallable {
     val arity : Int
+    val isGetter : Boolean
+
+    fun bind(instance: LoxObject) : LoxCallable = this
     fun call(interpreter: Interpreter, arguments: List<Any?>?) : Any?
 }

src/main/kotlin/common/LoxClass.kt

@@ -2,21 +2,22 @@ package com.mysidia.ktlox.common
 
 import com.mysidia.ktlox.interpreter.Interpreter
 
-class LoxClass(val name: String,
-               private val superclass: LoxClass?,
-               private val methods: MutableMap<String, LoxFunction>,
-               metaclass: LoxClass?) : LoxInstance(metaclass), LoxCallable{
+open class LoxClass(val name: String,
+                    val superclass: LoxClass?,
+                    val methods: MutableMap<String, LoxCallable>,
+                    metaclass: LoxClass?) : LoxObject(metaclass), LoxCallable{
 
     private val initializer by lazy { findMethod("init") }
     override val arity get() = initializer?.arity ?: 0
+    override val isGetter = false
 
     override fun call(interpreter: Interpreter, arguments: List<Any?>?): Any {
-        val instance = LoxInstance(this)
-        initializer?.let { it.bind(instance).call(interpreter, arguments) }
+        val instance = LoxObject(this)
+        initializer?.bind(instance)?.call(interpreter, arguments)
         return instance
     }
 
-    fun findMethod(name: String) : LoxFunction? {
+    fun findMethod(name: String) : LoxCallable? {
         if(methods.containsKey(name)) return methods[name]
         return superclass?.findMethod(name)
     }

src/main/kotlin/common/LoxClassClass.kt

@@ -0,0 +1,18 @@
+package com.mysidia.ktlox.common
+
+import com.mysidia.ktlox.interpreter.Interpreter
+
+object LoxClassClass : LoxNativeClass("Class", LoxObjectClass, null) {
+
+    init{
+        defineNativeMethod("getSuperclass", 0, this::getSuperclassDef)
+        defineNativeMethod("isClass", 0, this::isClassDef)
+        defineNativeMethod("toString", 0, this::toStringDef)
+    }
+
+    private fun getSuperclassDef(interpreter: Interpreter, arguments: List<Any?>?) = (interpreter.thisInstance as LoxClass).superclass
+
+    private fun isClassDef(interpreter: Interpreter, arguments: List<Any?>?) = true
+
+    private fun toStringDef(interpreter: Interpreter, arguments: List<Any?>?) = interpreter.thisInstance.className
+}

src/main/kotlin/common/LoxFalse.kt

@@ -0,0 +1,3 @@
+package com.mysidia.ktlox.common
+
+object LoxFalse : LoxObject(LoxFalseClass)

src/main/kotlin/common/LoxFalseClass.kt

@@ -0,0 +1,19 @@
+package com.mysidia.ktlox.common
+
+import com.mysidia.ktlox.interpreter.Interpreter
+import com.mysidia.ktlox.interpreter.RuntimeError
+
+object LoxFalseClass : LoxNativeClass("False", LoxBooleanClass) {
+
+    init{
+        defineNativeMetaclass("False class")
+        defineNativeMethod("init", 0, this::initDef)
+        defineNativeMethod("toString", 0, this::toStringDef)
+    }
+
+    private fun initDef(interpreter: Interpreter, arguments: List<Any?>?) : Any?{
+        throw RuntimeError(interpreter.tokenFalse, "Cannot create instance from class False")
+    }
+
+    private fun toStringDef(interpreter: Interpreter, arguments: List<Any?>?) = "false"
+}