add: inheritance, complete part 2

Author: ananthvk

GRAMMAR.md

@@ -4,7 +4,10 @@ declaration          = const_declaration
                       | function_declaration
                       | class_declaration
                       | statement
-class_declaration    = "class" IDENTIFIER "{" function* "}" 
+class_declaration    = "class" IDENTIFIER (":" IDENTIFIER)? "{" method* "}" 
+method               = function
+                      | "static" function
+                      | IDENTIFIER block
 function_declaration = "fun" function
 function             = IDENTIFIER "(" parameters? ")" block
 parameters           = IDENTIFIER ( "," IDENTIFIER ) * 

README.md

@@ -235,4 +235,31 @@ class Circle {
 
 const c = Circle(10);
 println c.area; // 314.15
+```
+
+20) Implemented inheritance with a similar style to Python. Derived class must call `super.init` to initialize parent class properties.
+```
+class Animal {
+    init(name) {
+        this.name = name;
+    }
+
+    speak {
+        return this.name + " makes a sound.";
+    }
+}
+
+class Dog : Animal {
+    init(name, breed) {
+        super.init(name);
+        this.breed = breed;
+    }
+
+    speak {
+        return this.name + " barks.";
+    }
+}
+
+const dog = Dog("Fido", "Golden Retriever");
+println dog.speak;
 ```

samples/inheritance.lox

@@ -0,0 +1,38 @@
+class Animal {
+    init(name) {
+        this.name = name;
+    }
+
+    speak {
+        return this.name + " makes a sound.";
+    }
+}
+
+class Dog : Animal {
+    init(name, breed) {
+        super.init(name);
+        this.breed = breed;
+    }
+
+    speak {
+        return this.name + " barks.";
+    }
+}
+
+class FriendlyDog: Dog {
+    init(name, breed) {
+        super.init(name, breed);
+    }
+    
+    speak {
+        return this.name + ", a friendly " + this.breed + " barks";
+    }
+    
+    static getMood() {
+        return "Friendly";
+    }
+}
+
+const dog = FriendlyDog("Fido", "Golden Retriever");
+println dog.speak;
+println "Currently the dog is " + dog.getMood(); 

src/python_lox/ast/expr.py

@@ -63,6 +63,10 @@ def visit_set_expr(self, expr: "Set") -> T:
     def visit_this_expr(self, expr: "This") -> T:
         pass
 
+    @abstractmethod
+    def visit_super_expr(self, expr: "Super") -> T:
+        pass
+
 
 class Expr(ABC):
     @abstractmethod
@@ -186,3 +190,11 @@ class This(Expr):
 
     def accept(self, visitor: Visitor[T]) -> T:
         return visitor.visit_this_expr(self)
+
+
+@dataclass
+class Super(Expr):
+    keyword: Token
+
+    def accept(self, visitor: Visitor[T]) -> T:
+        return visitor.visit_super_expr(self)

src/python_lox/ast/stmt.py

@@ -3,7 +3,7 @@
 from typing import Generic, List, TypeVar
 
 from ..token import Token
-from .expr import Expr
+from .expr import Expr, Variable
 
 T = TypeVar("T")
 
@@ -206,6 +206,7 @@ class Class(Stmt):
     methods: List[Function]
     static_methods: List[Function]
     getters: List[Function]
+    base_class: Variable | None = None
 
     def accept(self, visitor: Visitor[T]) -> T:
         return visitor.visit_class_stmt(self)

src/python_lox/callable.py

@@ -72,6 +72,8 @@ def call(self, interpreter: "Interpreter", args: List[object]) -> object:
     def bind(self, instance: "LoxInstance") -> "LoxFunction":
         environment = Environment(parent=self.closure)
         environment.define("this", instance)
+        if instance.base_class_instance is not None:
+            environment.define("super", instance.base_class_instance)
         return LoxFunction(
             declaration=self.declaration,
             closure=environment,

src/python_lox/extras/ast_printer.py

@@ -71,3 +71,7 @@ def visit_set_expr(self, expr: Expr.Set) -> str:
     @override
     def visit_this_expr(self, expr: Expr.This) -> str:
         return "(this)"
+
+    @override
+    def visit_super_expr(self, expr: Expr.Super) -> str:
+        return "(super)"

src/python_lox/interpreter.py

@@ -377,6 +377,16 @@ def visit_class_stmt(self, stmt: Stmt.Class) -> None:
         methods: Dict[str, LoxFunction] = {}
         static_methods: Dict[str, LoxFunction] = {}
         getters: Dict[str, LoxFunction] = {}
+        base_class: LoxClass | None = None
+
+        if stmt.base_class is not None:
+            cls = self.evaluate(stmt.base_class)
+            if not isinstance(cls, LoxClass):
+                raise RuntimeException(
+                    f'Error: class "{stmt.name.string_repr}" cannot derive from "{stmt.base_class.name.string_repr}" since "{stmt.base_class.name.string_repr}" is not a class',
+                    token=stmt.name,
+                )
+            base_class = cls
 
         for method in stmt.methods:
             function = LoxFunction(
@@ -402,7 +412,9 @@ def visit_class_stmt(self, stmt: Stmt.Class) -> None:
             )
             getters[getter.name.string_repr] = function
 
-        classobj = LoxClass(stmt.name.string_repr, methods, getters=getters)
+        classobj = LoxClass(
+            stmt.name.string_repr, methods, getters=getters, base_class=base_class
+        )
         classobj.class_.methods = static_methods
         self.environment.define(stmt.name, classobj)
 
@@ -431,6 +443,10 @@ def visit_set_expr(self, expr: Expr.Set) -> object:
     def visit_this_expr(self, expr: Expr.This) -> object:
         return self.lookup_variable(expr.keyword, expr)
 
+    @override
+    def visit_super_expr(self, expr: Expr.Super) -> object:
+        return self.lookup_variable(expr.keyword, expr)
+
     def execute(self, statement: Stmt.Stmt) -> None:
         statement.accept(self)
 

src/python_lox/lox_class.py

@@ -9,9 +9,12 @@
 
 
 class LoxInstance:
-    def __init__(self, class_: "LoxClass") -> None:
+    def __init__(
+        self, class_: "LoxClass", base_class_instance: "LoxInstance | None" = None
+    ) -> None:
         self.class_ = class_
         self.fields: Dict[str, object] = {}
+        self.base_class_instance: LoxInstance | None = base_class_instance
 
     def __str__(self) -> str:
         return f"<{self.class_.name()} instance at 0x{id(self):x}>"
@@ -34,6 +37,18 @@ def get(self, name: Token, interpreter: "Interpreter") -> object:
         if name.string_repr in self.class_.class_.methods:
             return self.class_.class_.methods[name.string_repr]
 
+        if self.base_class_instance is not None:
+            try:
+                return self.base_class_instance.get(name, interpreter)
+            except RuntimeException as r:
+                if str(r).startswith("Error: There is no attribute"):
+                    raise RuntimeException(
+                        f'Error: There is no attribute "{name.string_repr}" on an instance of class "{self.class_.name()}"',
+                        token=name,
+                    )
+                else:
+                    raise r
+
         raise RuntimeException(
             f'Error: There is no attribute "{name.string_repr}" on an instance of class "{self.class_.name()}"',
             token=name,
@@ -49,12 +64,14 @@ def __init__(
         name_: str,
         methods: Dict[str, LoxFunction],
         getters: Dict[str, LoxFunction] = {},
+        base_class: "LoxClass | None" = None,
     ) -> None:
         LoxInstance.__init__(self, Meta())
         Callable.__init__(self)
         self.name_ = name_
         self.methods = methods
         self.getters = getters
+        self.base_class = base_class
 
     def __str__(self) -> str:
         return f"<class {self.name_}>"
@@ -71,11 +88,21 @@ def arity(self) -> int:
         return constructor.arity()
 
     @override
-    def call(self, interpreter: "Interpreter", args: List[object]) -> object:
-        instance = LoxInstance(class_=self)
-        constructor = self.methods.get("init")
-        if constructor is not None:
-            constructor.bind(instance).call(interpreter, args)
+    def call(
+        self,
+        interpreter: "Interpreter",
+        args: List[object],
+        do_not_call_init: bool = False,
+    ) -> object:
+        base_class_instance: LoxInstance | None = None
+        if self.base_class:
+            base_class_instance = self.base_class.call(interpreter, [], True)  # type: ignore
+
+        instance = LoxInstance(class_=self, base_class_instance=base_class_instance)
+        if not do_not_call_init:
+            constructor = self.methods.get("init")
+            if constructor is not None:
+                constructor.bind(instance).call(interpreter, args)
         return instance
 
 
@@ -86,6 +113,7 @@ def __init__(self) -> None:
         self.name_ = "Meta"
         self.methods: Dict[str, LoxFunction] = {}
         self.getters: Dict[str, LoxFunction] = {}
+        self.base_class = None
 
     def __str__(self) -> str:
         return f"<meta {self.name_}>"
@@ -102,9 +130,15 @@ def arity(self) -> int:
         return constructor.arity()
 
     @override
-    def call(self, interpreter: "Interpreter", args: List[object]) -> object:
+    def call(
+        self,
+        interpreter: "Interpreter",
+        args: List[object],
+        do_not_call_init: bool = False,
+    ) -> object:
         instance = LoxInstance(class_=self)
-        constructor = self.methods.get("init")
-        if constructor is not None:
-            constructor.bind(instance).call(interpreter, args)
+        if not do_not_call_init:
+            constructor = self.methods.get("init")
+            if constructor is not None:
+                constructor.bind(instance).call(interpreter, args)
         return instance

src/python_lox/parser.py

@@ -348,6 +348,9 @@ def primary(self) -> expr.Expr:
         if self.match([TokenType.THIS]):
             return expr.This(keyword=self.previous())
 
+        if self.match([TokenType.SUPER]):
+            return expr.Super(keyword=self.previous())
+
         if self.match([TokenType.NIL]):
             return expr.Literal(value=None)
 
@@ -396,7 +399,10 @@ def primary(self) -> expr.Expr:
             self.factor()
             raise ParserException("Left hand operand missing", token=err_token)
 
-        raise ParserException("Expected expression", token=self.previous())
+        tok = self.peek()
+        if tok.token_type == TokenType.EOF:
+            tok = self.previous()
+        raise ParserException("Expected expression", token=tok)
 
     def arrow_function(self) -> None | expr.Arrow:
         prev_current: int = self.current
@@ -474,7 +480,7 @@ def if_statement(self) -> stmt.If:
         except ParserException as e:
             if str(e) == "Expected expression":
                 raise ParserException(
-                    "Expected valid expression after if", token=self.previous()
+                    "Expected valid expression after if", token=e.token
                 )
             else:
                 raise e
@@ -498,7 +504,7 @@ def while_statement(self) -> stmt.Stmt:
         except ParserException as e:
             if str(e) == "Expected expression":
                 raise ParserException(
-                    "Expected valid expression after while", token=self.previous()
+                    "Expected valid expression after while", token=e.token
                 )
             else:
                 raise e
@@ -644,6 +650,14 @@ def const_declaration(self) -> stmt.Const:
     def class_declaration(self) -> stmt.Class:
         self.consume([TokenType.IDENTIFIER], message="Expected class name")
         name = self.previous()
+
+        base_class: expr.Variable | None = None
+        if self.match([TokenType.COLON]):
+            self.consume(
+                [TokenType.IDENTIFIER], message='Expected base class name after ":"'
+            )
+            base_class = expr.Variable(name=self.previous())
+
         self.consume([TokenType.LEFT_BRACE], message='Expected "{" after class name')
 
         methods: List[stmt.Function] = []
@@ -673,7 +687,11 @@ def class_declaration(self) -> stmt.Class:
 
         self.consume([TokenType.RIGHT_BRACE], message='Expected "}" after class body')
         return stmt.Class(
-            name=name, methods=methods, static_methods=static_methods, getters=getters
+            name=name,
+            methods=methods,
+            static_methods=static_methods,
+            getters=getters,
+            base_class=base_class,
         )
 
     def declaration(self) -> stmt.Stmt:
@@ -692,7 +710,11 @@ def parse(self, repl: bool = False) -> List[stmt.Stmt] | None:
         while not self.is_at_end():
             prev_current = self.current
             try:
-                statements.append(self.declaration())
+                # Ignore empty statements
+                while self.check(TokenType.SEMICOLON):
+                    self.advance()
+                if not self.is_at_end():
+                    statements.append(self.declaration())
             except ParserException as e:
                 if not repl:
                     if self.error_reporter is None: