Merge pull request #10 from quephird/implement_inheritance_post_stati…

…c_methods

Implement inheritance

README.md

@@ -20,6 +20,10 @@ So far, the following have been implemented in `slox`:
 - Lambda expressions
 - Class declaration and instantiation
 - Instance properties and methods
+- Referencing the scoped instance via `this`
+- Class-level properties and methods
+- Single inheritance
+- Invoking superclass methods via `super`
 
 # Design
 
@@ -60,7 +64,7 @@ Instead of maintaining set of native functions in `Interpreter`'s constructor, t
 
 # Unit testing
 
-This repository contains a fairly comprehensive suite of unit tests that exercise the scanner, parser, resolver, and interpreter; to run them, hit ⌘-U.
+This repository contains a fairly comprehensive suite of unit tests that exercise the scanner, parser, resolver, and interpreter; to run them, hit ⌘-U from within Xcode.
 
 # Relevant links
 

slox/Environment.swift

@@ -6,7 +6,7 @@
 //
 
 class Environment: Equatable {
-    private var enclosingEnvironment: Environment?
+    var enclosingEnvironment: Environment?
     private var values: [String: LoxValue] = [:]
 
     init(enclosingEnvironment: Environment? = nil) {

slox/Expression.swift

@@ -18,4 +18,5 @@ indirect enum Expression: Equatable {
     case get(Expression, Token)
     case set(Expression, Token, Expression)
     case this(Token)
+    case `super`(Token, Token)
 }

slox/Interpreter.swift

@@ -56,8 +56,11 @@ class Interpreter {
                             environment: Environment(enclosingEnvironment: environment))
         case .while(let expr, let stmt):
             try handleWhileStatement(expr: expr, stmt: stmt)
-        case .class(let nameToken, let methods, let staticMethods):
-            try handleClassDeclaration(nameToken: nameToken, methods: methods, staticMethods: staticMethods)
+        case .class(let nameToken, let superclassExpr, let methods, let staticMethods):
+            try handleClassDeclaration(nameToken: nameToken,
+                                       superclassExpr: superclassExpr,
+                                       methods: methods,
+                                       staticMethods: staticMethods)
         case .function(let name, let lambda):
             try handleFunctionDeclaration(name: name, lambda: lambda)
         case .return(let returnToken, let expr):
@@ -81,13 +84,25 @@ class Interpreter {
     }
 
     private func handleClassDeclaration(nameToken: Token,
+                                        superclassExpr: ResolvedExpression?,
                                         methods: [ResolvedStatement],
                                         staticMethods: [ResolvedStatement]) throws {
         // NOTA BENE: We temporarily set the initial value associated with
         // the class name to `.nil` so that, according to the book,
         // "allows references to the class inside its own methods".
         environment.define(name: nameToken.lexeme, value: .nil)
 
+        let superclass = try superclassExpr.map { superclassExpr in
+            guard case .instance(let superclass as LoxClass) = try evaluate(expr: superclassExpr) else {
+                throw RuntimeError.superclassMustBeAClass
+            }
+
+            environment = Environment(enclosingEnvironment: environment);
+            environment.define(name: "super", value: .instance(superclass));
+
+            return superclass
+        }
+
         var methodImpls: [String: UserDefinedFunction] = [:]
         for method in methods {
             guard case .function(let nameToken, let lambdaExpr) = method else {
@@ -125,13 +140,21 @@ class Interpreter {
             staticMethodImpls[nameToken.lexeme] = staticMethodImpl
         }
 
-        let newClass = LoxClass(name: nameToken.lexeme, methods: methodImpls)
+        let newClass = LoxClass(name: nameToken.lexeme,
+                                superclass: superclass,
+                                methods: methodImpls)
         if !staticMethodImpls.isEmpty {
             // NOTA BENE: This assigns the static methods to the metaclass,
             // which is lazily created in `LoxInstance`
             newClass.klass.methods = staticMethodImpls
         }
 
+        // Note that we can't accomplish this via a defer block because we need
+        // to assign the class to the _outermost_ environment, not the enclosing one.
+        if superclassExpr != nil {
+            environment = environment.enclosingEnvironment!
+        }
+
         try environment.assignAtDepth(name: nameToken.lexeme, value: .instance(newClass), depth: 0)
     }
 
@@ -217,6 +240,8 @@ class Interpreter {
             return try handleThis(thisToken: thisToken, depth: depth)
         case .lambda(let params, let statements):
             return try handleLambdaExpression(params: params, statements: statements)
+        case .super(let superToken, let methodToken, let depth):
+            return try handleSuperExpression(superToken: superToken, methodToken: methodToken, depth: depth)
         }
     }
 
@@ -386,6 +411,23 @@ class Interpreter {
         return .userDefinedFunction(function)
     }
 
+    private func handleSuperExpression(superToken: Token, methodToken: Token, depth: Int) throws -> LoxValue {
+        guard case .instance(let superclass as LoxClass) = try environment.getValueAtDepth(name: "super", depth: depth) else {
+            throw RuntimeError.superclassMustBeAClass
+        }
+
+        guard case .instance(let thisInstance) = try environment.getValueAtDepth(name: "this", depth: depth - 1) else {
+            throw RuntimeError.notAnInstance
+        }
+
+        if let method = superclass.findMethod(name: methodToken.lexeme) {
+            return .userDefinedFunction(method.bind(instance: thisInstance))
+        }
+
+        throw RuntimeError.undefinedProperty(methodToken.lexeme)
+    }
+
+    // Utility functions below
     private func isEqual(leftValue: LoxValue, rightValue: LoxValue) -> Bool {
         switch (leftValue, rightValue) {
         case (.nil, .nil):

slox/LoxClass.swift

@@ -7,6 +7,7 @@
 
 class LoxClass: LoxInstance, LoxCallable {
     var name: String
+    var superclass: LoxClass?
     var arity: Int {
         if let initializer = methods["init"] {
             return initializer.params.count
@@ -16,8 +17,9 @@ class LoxClass: LoxInstance, LoxCallable {
     }
     var methods: [String: UserDefinedFunction]
 
-    init(name: String, methods: [String: UserDefinedFunction]) {
+    init(name: String, superclass: LoxClass?, methods: [String: UserDefinedFunction]) {
         self.name = name
+        self.superclass = superclass
         self.methods = methods
 
         super.init(klass: nil)
@@ -27,6 +29,14 @@ class LoxClass: LoxInstance, LoxCallable {
         return lhs === rhs
     }
 
+    func findMethod(name: String) -> UserDefinedFunction? {
+        if let method = methods[name] {
+            return method
+        }
+
+        return superclass?.findMethod(name: name)
+    }
+
     func call(interpreter: Interpreter, args: [LoxValue]) throws -> LoxValue {
         let newInstance = LoxInstance(klass: self)
 

slox/LoxInstance.swift

@@ -19,7 +19,7 @@ class LoxInstance: Equatable {
         if _klass == nil {
             // Only metaclasses should ever have a `nil` value for `_klass`
             let selfClass = self as! LoxClass
-            _klass = LoxClass(name: "\(selfClass.name) metaclass", methods: [:])
+            _klass = LoxClass(name: "\(selfClass.name) metaclass", superclass: nil, methods: [:])
         }
         return _klass!
     }
@@ -37,7 +37,7 @@ class LoxInstance: Equatable {
             return propertyValue
         }
 
-        if let method = klass.methods[propertyName] {
+        if let method = klass.findMethod(name: propertyName) {
             let boundMethod = method.bind(instance: self)
             return .userDefinedFunction(boundMethod)
         }

slox/ParseError.swift

@@ -29,6 +29,9 @@ enum ParseError: CustomStringConvertible, Equatable, LocalizedError {
     case missingOpenBraceBeforeFunctionBody(Token)
     case missingCloseParenAfterArguments(Token)
     case missingIdentifierAfterDot(Token)
+    case missingSuperclassName(Token)
+    case missingDotAfterSuper(Token)
+    case expectedSuperclassMethodName(Token)
 
     var description: String {
         switch self {
@@ -74,6 +77,12 @@ enum ParseError: CustomStringConvertible, Equatable, LocalizedError {
             return "[Line \(token.line)] Error: expected right parenthesis after arguments"
         case .missingIdentifierAfterDot(let token):
             return "[Line \(token.line)] Error: expected identifer after dot"
+        case .missingSuperclassName(let token):
+            return "[Line \(token.line)] Error: expected superclass name"
+        case .missingDotAfterSuper(let token):
+            return "[Line \(token.line)] Error: expected dot after super"
+        case .expectedSuperclassMethodName(let token):
+            return "[Line \(token.line)] Error: expected superclass method name"
         }
     }
 }

slox/Parser.swift

@@ -36,7 +36,8 @@ struct Parser {
     //                   | funDecl
     //                   | varDecl
     //                   | statement ;
-    //    classDecl      → "class" IDENTIFIER "{" function* "}" ;
+    //    classDecl      → "class" IDENTIFIER ( "<" IDENTIFIER )?
+    //                     "{" function* "}" ;
     //    funDecl        → "fun" function ;
     //    function       → IDENTIFIER "(" parameters? ")" block ;
     //    varDecl        → "var" IDENTIFIER ( "=" expression )? ";" ;
@@ -85,6 +86,16 @@ struct Parser {
         let className = currentToken
         advanceCursor()
 
+        var superclassExpr: Expression? = nil
+        if currentTokenMatchesAny(types: [.less]) {
+            guard case .identifier = currentToken.type else {
+                throw ParseError.missingSuperclassName(currentToken)
+            }
+
+            superclassExpr = .variable(currentToken)
+            advanceCursor()
+        }
+
         if !currentTokenMatchesAny(types: [.leftBrace]) {
             throw ParseError.missingOpenBraceBeforeClassBody(currentToken)
         }
@@ -105,7 +116,7 @@ struct Parser {
         }
 
         if currentTokenMatchesAny(types: [.rightBrace]) {
-            return .class(className, methodStatements, staticMethodStatements)
+            return .class(className, superclassExpr, methodStatements, staticMethodStatements)
         }
 
         throw ParseError.missingClosingBrace(previousToken)
@@ -340,7 +351,8 @@ struct Parser {
     //                   | "(" expression ")"
     //                   | "this"
     //                   | IDENTIFIER
-    //                   | lambda ;
+    //                   | lambda
+    //                   | "super" "." IDENTIFIER ;
     //    lambda         → "fun" "(" parameters? ")" block ;
     //
     mutating private func parseExpression() throws -> Expression {
@@ -508,6 +520,21 @@ struct Parser {
             throw ParseError.missingClosingParenthesis(currentToken)
         }
 
+        if currentTokenMatchesAny(types: [.super]) {
+            let superToken = previousToken
+            if !currentTokenMatchesAny(types: [.dot]) {
+                throw ParseError.missingDotAfterSuper(currentToken)
+            }
+
+            guard case .identifier = currentToken.type else {
+                throw ParseError.expectedSuperclassMethodName(currentToken)
+            }
+            let methodToken = currentToken
+            advanceCursor()
+
+            return .super(superToken, methodToken)
+        }
+
         if currentTokenMatchesAny(types: [.this]) {
             return .this(previousToken)
         }

slox/ResolvedExpression.swift

@@ -18,4 +18,5 @@ indirect enum ResolvedExpression: Equatable {
     case get(ResolvedExpression, Token)
     case set(ResolvedExpression, Token, ResolvedExpression)
     case this(Token, Int)
+    case `super`(Token, Token, Int)
 }

slox/ResolvedStatement.swift

@@ -14,5 +14,5 @@ indirect enum ResolvedStatement: Equatable {
     case `while`(ResolvedExpression, ResolvedStatement)
     case function(Token, ResolvedExpression)
     case `return`(Token, ResolvedExpression?)
-    case `class`(Token, [ResolvedStatement], [ResolvedStatement])
+    case `class`(Token, ResolvedExpression?, [ResolvedStatement], [ResolvedStatement])
 }