feat: Implement Chapter 13, Inheritance

baselines/chapter13/boston-creme-super.txt

@@ -0,0 +1,2 @@
+Fry until golden brown.
+Pipe full of custard and coat with chocolate.

baselines/chapter13/boston-creme.txt

@@ -0,0 +1 @@
+Fry until golden brown.

baselines/chapter13/inheritance-loop.errors.txt

@@ -0,0 +1,2 @@
+Undefined variable 'B'.
+[line 1]

baselines/chapter13/invalid-super-in-class.errors.txt

@@ -0,0 +1 @@
+[line 3] Error at 'super': Can't use 'super' in a class with no superclass.

baselines/chapter13/invalid-super-top-level.errors.txt

@@ -0,0 +1 @@
+[line 1] Error at 'super': Can't use 'super' outside of a class.

baselines/chapter13/non-class-parent.errors.txt

@@ -0,0 +1,2 @@
+Superclass must be a class.
+[line 3]

baselines/chapter13/non-existent-method-on-super.errors.txt

@@ -0,0 +1,2 @@
+Undefined property bar.
+[line 12]

baselines/chapter13/non-existent-method-on-super.txt

@@ -0,0 +1 @@
+Parent.foo

baselines/chapter13/self-inheritance.errors.txt

@@ -0,0 +1 @@
+[line 1] Error at 'Oops': A class can't inherit from itself.

baselines/chapter13/super-without-parent.errors.txt

@@ -0,0 +1 @@
+[line 9] Error at 'super': Can't use 'super' in a class with no superclass.

baselines/chapter13/which-super.txt

@@ -0,0 +1 @@
+A method

cspell.json

@@ -30,6 +30,8 @@
 		"quickfix",
 		"Nystrom",
 		"unshadow",
-		"klass"
+		"klass",
+		"crème",
+		"pâtissière"
 	]
 }

examples/chapter13/boston-creme-super.lox

@@ -0,0 +1,14 @@
+class Doughnut {
+  cook() {
+    print "Fry until golden brown.";
+  }
+}
+
+class BostonCream < Doughnut {
+  cook() {
+    super.cook();
+    print "Pipe full of custard and coat with chocolate.";
+  }
+}
+
+BostonCream().cook();

examples/chapter13/boston-creme.lox

@@ -0,0 +1,9 @@
+class Doughnut {
+  cook() {
+    print "Fry until golden brown.";
+  }
+}
+
+class BostonCream < Doughnut {}
+
+BostonCream().cook();

examples/chapter13/inheritance-loop.lox

@@ -0,0 +1,13 @@
+class A < B {
+    foo() {
+        super.foo();
+    }
+}
+class B < A {
+    foo() {
+        super.foo();
+    }
+}
+
+var a = A();
+a.foo();

examples/chapter13/invalid-super-in-class.lox

@@ -0,0 +1,6 @@
+class Eclair {
+  cook() {
+    super.cook();
+    print "Pipe full of crème pâtissière.";
+  }
+}

examples/chapter13/invalid-super-top-level.lox

@@ -0,0 +1 @@
+super.notEvenInAClass();

examples/chapter13/non-class-parent.lox

@@ -0,0 +1,3 @@
+fun Parent() {}
+
+class Child < Parent {}

examples/chapter13/non-existent-method-on-super.lox

@@ -0,0 +1,18 @@
+class Parent {
+    foo() {
+        print "Parent.foo";
+    }
+}
+
+class Child < Parent {
+    foo() {
+        super.foo();
+    }
+    bar() {
+        super.bar();
+    }
+}
+
+var c = Child();
+c.foo();
+c.bar();

examples/chapter13/self-inheritance.lox

@@ -0,0 +1 @@
+class Oops < Oops {}

examples/chapter13/super-without-parent.lox

@@ -0,0 +1,14 @@
+class Parent {
+    foo() {
+        print "Parent.foo";
+    }
+}
+
+class Child {
+    foo() {
+        super.foo();
+    }
+}
+
+var c = Child();
+c.foo();

examples/chapter13/which-super.lox

@@ -0,0 +1,19 @@
+class A {
+  method() {
+    print "A method";
+  }
+}
+
+class B < A {
+  method() {
+    print "B method";
+  }
+
+  test() {
+    super.method();
+  }
+}
+
+class C < B {}
+
+C().test();

src/ast-printer.ts

@@ -38,6 +38,7 @@ export const astPrinter: ExpressionVisitor<string> & StmtVisitor<string> = {
 	print: (stmt) => parenthesize("print", stmt.expression),
 	return: (stmt) => parenthesize("return", ...(stmt.value ? [stmt.value] : [])),
 	set: (expr) => parenthesize("set", expr.object, expr.name.lexeme, expr.value),
+	super: () => "super",
 	this: () => parenthesize("this"),
 	unary: (expr) => parenthesize(expr.operator.lexeme, expr.right),
 	"var-expr": (expr) => String(expr.name.literal),

src/ast.ts

@@ -113,6 +113,7 @@ export interface Return {
 export interface Class {
 	kind: "class";
 	name: Token;
+	superclass: VarExpr | null;
 	methods: Func[];
 }
 
@@ -123,6 +124,12 @@ export interface SetExpr {
 	value: Expr;
 }
 
+export interface Super {
+	kind: "super";
+	keyword: Token;
+	method: Token;
+}
+
 export type Expr =
 	| Assign
 	| Binary
@@ -132,6 +139,7 @@ export type Expr =
 	| Literal
 	| Logical
 	| SetExpr
+	| Super
 	| This
 	| Unary
 	| VarExpr;

src/environment.ts

@@ -3,19 +3,19 @@ import { LoxValue } from "./lox-value.js";
 import { Token } from "./token.js";
 
 export class Environment {
-	#enclosing?: Environment;
 	#values: Map<string, LoxValue>;
+	enclosing?: Environment;
 
 	constructor(enclosing?: Environment) {
 		this.#values = new Map();
-		this.#enclosing = enclosing;
+		this.enclosing = enclosing;
 	}
 
 	ancestor(distance: number): Environment {
 		// eslint-disable-next-line @typescript-eslint/no-this-alias
 		let env: Environment = this;
 		for (let i = 0; i < distance; i++) {
-			const enclosing = env.#enclosing;
+			const enclosing = env.enclosing;
 			if (!enclosing) {
 				throw new Error("Tried to go past last ancestor!");
 			}

src/interpreter.ts

@@ -161,7 +161,23 @@ export class Interpreter {
 	}
 
 	class(stmt: Class): void {
+		let superclass = null;
+		if (stmt.superclass) {
+			superclass = this.evaluate(stmt.superclass);
+			if (!(superclass instanceof LoxClass)) {
+				throw new RuntimeError(
+					stmt.superclass.name,
+					"Superclass must be a class.",
+				);
+			}
+		}
+
 		this.#environment.define(stmt.name.lexeme, null);
+		if (superclass) {
+			this.#environment = new Environment(this.#environment);
+			this.#environment.define("super", superclass);
+		}
+
 		const methods = new Map<string, LoxFunction>();
 		for (const method of stmt.methods) {
 			const func = new LoxFunction(
@@ -171,7 +187,11 @@ export class Interpreter {
 			);
 			methods.set(method.name.lexeme, func);
 		}
-		const klass = new LoxClass(stmt.name.lexeme, methods);
+		const klass = new LoxClass(stmt.name.lexeme, superclass, methods);
+		if (superclass) {
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			this.#environment = this.#environment.enclosing!;
+		}
 		this.#environment.assign(stmt.name, klass);
 	}
 
@@ -231,6 +251,27 @@ export class Interpreter {
 				return value;
 			}
 
+			case "super": {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				const distance = this.#locals.get(expr)!;
+				const superclass = this.#environment.getAt(
+					distance,
+					"super",
+				) as LoxClass;
+				const object = this.#environment.getAt(
+					distance - 1,
+					"this",
+				) as LoxInstance;
+				const method = superclass.findMethod(expr.method.lexeme);
+				if (!method) {
+					throw new RuntimeError(
+						expr.method,
+						`Undefined property ${expr.method.lexeme}.`,
+					);
+				}
+				return method.bindThis(object);
+			}
+
 			case "unary":
 				const right = this.evaluate(expr.right);
 				switch (expr.operator.type) {

src/lox-class.ts

@@ -10,11 +10,17 @@ import { LoxValue } from "./lox-value.js";
 export class LoxClass extends LoxCallable {
 	#methods: Map<string, LoxFunction>;
 	name: string;
+	superclass: LoxClass | null;
 
-	constructor(name: string, methods: Map<string, LoxFunction>) {
+	constructor(
+		name: string,
+		superclass: LoxClass | null,
+		methods: Map<string, LoxFunction>,
+	) {
 		super();
 		this.name = name;
 		this.#methods = methods;
+		this.superclass = superclass;
 	}
 
 	arity(): number {
@@ -31,8 +37,9 @@ export class LoxClass extends LoxCallable {
 		return instance;
 	}
 
-	findMethod(name: string) {
-		return this.#methods.get(name);
+	findMethod(name: string): LoxFunction | undefined {
+		const meth = this.#methods.get(name);
+		return meth ?? this.superclass?.findMethod(name);
 	}
 
 	toString() {

src/parser.ts

@@ -1,7 +1,7 @@
 // Grammar:
 // program        → declaration* EOF ;
 // declaration    → classDecl | funDecl | varDecl | statement ;
-// classDecl      → "class" IDENTIFIER "{" function* "}" ;
+// classDecl      → "class" IDENTIFIER ( "<" IDENTIFIER ) "{" function* "}" ;
 // funDecl        → "fun" function ;
 // function       → IDENTIFIER "(" parameters? ")" block ;
 // varDecl        → "var" IDENTIFIER ( "=" expression )? ";" ;
@@ -24,11 +24,19 @@
 // unary          → ( "!" | "-" ) unary | call ;
 // call           → primary ( "(" arguments? ")" | "." IDENTIFIER )* ;
 // arguments      → expression ( "," expression )* ;
-// primary        → NUMBER | STRING | "true" | "false" | "nil"
+// primary        → NUMBER | STRING | "true" | "false" | "nil" | "this"
 //                | "(" expression ")" ;
-//                | IDENTIFIER ;
-
-import { Expr, Expression, Func, Print, Stmt, VarStmt } from "./ast.js";
+//                | IDENTIFIER | "super" "." IDENTIFIER;
+
+import {
+	Expr,
+	Expression,
+	Func,
+	Print,
+	Stmt,
+	VarExpr,
+	VarStmt,
+} from "./ast.js";
 import { errorOnToken } from "./main.js";
 import { Token } from "./token.js";
 import { TokenType } from "./token-type.js";
@@ -121,13 +129,20 @@ export function parse(tokens: Token[]) {
 	// classDecl      → "class" IDENTIFIER "{" function* "}" ;
 	const classDecl = (): Stmt => {
 		const name = consume("identifier", "Expect class name.");
+
+		let superclass: VarExpr | null = null;
+		if (match("<")) {
+			consume("identifier", "Expect superclass name.");
+			superclass = { kind: "var-expr", name: previous() };
+		}
+
 		consume("{", "Expect '{' before class body.");
 		const methods = [];
 		while (!check("}") && !isAtEnd()) {
 			methods.push(func("method"));
 		}
 		consume("}", "Expect '}' after class body.");
-		return { kind: "class", methods, name };
+		return { kind: "class", methods, name, superclass };
 	};
 
 	// funDecl        → "fun" function ;
@@ -368,6 +383,11 @@ export function parse(tokens: Token[]) {
 			return { keyword: previous(), kind: "this" };
 		} else if (match("identifier")) {
 			return { kind: "var-expr", name: previous() };
+		} else if (match("super")) {
+			const keyword = previous();
+			consume(".", "Expect '.' after 'super'.");
+			const method = consume("identifier", "Expect superclass method name.");
+			return { keyword, kind: "super", method };
 		}
 		throw error(peek(), "Expect expression.");
 	};