feat: implement super and finish the jlox yeo!!!!

Author: aymaneelmaini

src/main/kotlin/com/aymanetech/Expr.kt

@@ -40,6 +40,10 @@ sealed class Expr : ExprVisitable {
         override fun <T> accept(visitor: Visitor<T>) = visitor.visit(this)
     }
 
+    data class Super(val keyword: Token, val method: Token): Expr() {
+        override fun <T> accept(visitor: Visitor<T>) = visitor.visit(this)
+    }
+
     data class This(val keyword: Token) : Expr() {
         override fun <T> accept(visitor: Visitor<T>) = visitor.visit(this)
     }
@@ -69,5 +73,6 @@ sealed class Expr : ExprVisitable {
         fun visit(expr: Get): T
         fun visit(expr: Set): T
         fun visit(expr: This): T
+        fun visit(expr: Super): T
     }
 }

src/main/kotlin/com/aymanetech/Interpreter.kt

@@ -145,6 +145,16 @@ class Interpreter : Expr.Visitor<Any?>, Stmt.Visitor<Unit> {
         return value
     }
 
+    override fun visit(expr: Super): Any? {
+        val distance = locals[expr]
+        val superClass = environment.getAt(distance!!, "super") as LoxClass
+        val obj = environment.getAt(distance - 1, "this") as LoxInstance
+        val method = superClass.findMethod(expr.method.lexeme)
+            ?: throw RuntimeError(expr.method, "Undefined property '${expr.method.lexeme}'")
+
+        return method.bind(obj)
+    }
+
     override fun visit(expr: This): Any? = lookUpVariable(expr.keyword, expr)
 
     override fun visit(stmt: Expression) {
@@ -198,6 +208,12 @@ class Interpreter : Expr.Visitor<Any?>, Stmt.Visitor<Unit> {
         }
 
         environment.define(stmt.name.lexeme to null)
+
+        if (stmt.superClass != null) {
+            environment = Environment(environment)
+            environment.define("super" to superClass)
+        }
+
         val methods: Map<String, LoxFunction> = stmt.methods.associate {
             val method = it.name.lexeme
             method to LoxFunction(it, environment, method == "init")
@@ -208,6 +224,8 @@ class Interpreter : Expr.Visitor<Any?>, Stmt.Visitor<Unit> {
             method to LoxFunction(it, environment, false)
         }
         val klass = LoxClass(stmt.name.lexeme, superClass as LoxClass?, methods, staticMethods)
+        if (stmt.superClass != null) environment = environment.enclosing!!
+
         environment.assign(stmt.name to klass)
     }
 

src/main/kotlin/com/aymanetech/Parser.kt

@@ -293,6 +293,7 @@ class Parser(private val tokens: List<Token>) {
             match(TRUE) -> Literal(true)
             match(NIL) -> Literal(null)
             match(NUMBER, STRING) -> Literal(previous().literal)
+            match(SUPER) -> superKeyword()
             match(THIS) -> This(previous())
             match(IDENTIFIER) -> Variable(previous())
             match(FN) -> anonymousFunction()
@@ -305,6 +306,13 @@ class Parser(private val tokens: List<Token>) {
             else -> throw error(peek(), "Expect expression.")
         }
 
+    private fun superKeyword(): Expr {
+        val keyword = previous()
+        consume(DOT, "Expect '.' after keyword")
+        val name = consume(IDENTIFIER, "Expect superclass method name")
+        return Super(keyword, name)
+    }
+
     private fun match(vararg types: TokenType): Boolean {
         for (type in types) {
             if (check(type)) {

src/main/kotlin/com/aymanetech/Resolver.kt

@@ -55,6 +55,15 @@ class Resolver(private val interpreter: Interpreter) : Expr.Visitor<Unit>, Stmt.
         resolve(expr.obj)
     }
 
+    override fun visit(expr: Super) {
+        if(currentClass == ClassType.NONE)
+            error(expr.keyword, "Can't use 'super' outside of a class.")
+        else if (currentClass != ClassType.SUBCLASS)
+            error(expr.keyword, "Can't use 'super' in a class without a superclass.")
+
+        resolveLocal(expr, expr.keyword)
+    }
+
     override fun visit(expr: This) {
         if (currentClass == ClassType.NONE) {
             error(expr.keyword, "Can't use 'this' outside of a method")
@@ -132,8 +141,15 @@ class Resolver(private val interpreter: Interpreter) : Expr.Visitor<Unit>, Stmt.
         if(stmt.superClass != null && stmt.name.lexeme.equals(stmt.superClass.name.lexeme))
             error(stmt.superClass.name, "A class can't inherit from itself")
 
-        if (stmt.superClass != null)
+        if (stmt.superClass != null){
+            currentClass = ClassType.SUBCLASS
             resolve(stmt.superClass)
+        }
+
+        if(stmt.superClass != null){
+            beginScope()
+            scopes.peek()["super"] = true
+        }
 
         beginScope()
         scopes.peek()["this"] = true
@@ -142,6 +158,7 @@ class Resolver(private val interpreter: Interpreter) : Expr.Visitor<Unit>, Stmt.
             resolveFunction(it, declaration)
         }
         endScope()
+        if(stmt.superClass != null) endScope()
         currentClass = enclosingClass
     }
 
@@ -210,7 +227,7 @@ class Resolver(private val interpreter: Interpreter) : Expr.Visitor<Unit>, Stmt.
     }
 
     enum class ClassType {
-        NONE, CLASS
+        NONE, CLASS, SUBCLASS
     }
 }