evaluate call expression

src/evaluator/environment/index.test.ts

@@ -26,3 +26,24 @@ describe("get()", () => {
     expect(value).toBe(null);
   });
 });
+
+describe("linked environment", () => {
+  it("set super environment and get via sub environment", () => {
+    const superEnv = new Environment();
+    superEnv.set("foo", 42);
+    const subEnv = new Environment(superEnv);
+
+    const value = subEnv.get("foo");
+
+    expect(value).toBe(42);
+  });
+
+  it("get null if not found even in super environment", () => {
+    const superEnv = new Environment();
+    const subEnv = new Environment(superEnv);
+
+    const value = subEnv.get("foo");
+
+    expect(value).toBe(null);
+  });
+});

src/evaluator/environment/index.ts

@@ -4,14 +4,26 @@ export interface EnvironmentType {
 }
 
 export default class Environment implements EnvironmentType {
+  private readonly superEnvironment: Environment | null;
   private readonly table: Map<string, any>;
 
-  constructor() {
+  constructor(superEnvironment: Environment | null = null) {
+    this.superEnvironment = superEnvironment;
     this.table = new Map<string, any>;
   }
 
   get(name: string): unknown {
-    return this.table.get(name) ?? null;
+    // return if found in current environment
+    const fetched = this.table.get(name);
+    if (fetched !== undefined) {
+      return fetched;
+    }
+
+    // return value in super environment
+    if (this.superEnvironment === null) {
+      return null;
+    }
+    return this.superEnvironment.get(name);
   }
 
   set(name: string, value: any): unknown {

src/evaluator/index.test.ts

@@ -165,4 +165,24 @@ describe("evaluate()", () => {
       expect(evaluated).toHaveProperty("environment");
     });
   });
+
+  describe("call expressions", () => {
+    const cases = [
+      {
+        name: "function call with function literal",
+        input: "함수(바나나) { 바나나 + 1 }(42)"
+      },
+    ];
+
+    it.each(cases)("evaluate $name", ({ input }) => {
+      const lexer = new Lexer(input);
+      const parser = new Parser(lexer);
+      const program = parser.parseProgram();
+      const evaluator = new Evaluator();
+      const environment = new Environment();
+      const evaluated = evaluator.evaluate(program, environment);
+
+      expect(evaluated).toBe(43);
+    });
+  });
 });

src/evaluator/index.ts

@@ -1,4 +1,4 @@
-import type { Program, Block, BranchStatement, Node } from "../parser";
+import type { Program, Block, BranchStatement, Node, Expression } from "../parser";
 import Environment from "./environment";
 
 // TODO: fix any return type to specific ones (by implement value system)
@@ -153,6 +153,14 @@ export default class Evaluator {
       const body = node.body;
       return { parameters, body, environment: env };
     }
+    if (node.type === "call") {
+      const functionToCall = this.evaluate(node.functionToCall, env);
+
+      const callArguments = this.parseCallArguments(node.callArguments, env);
+
+      const value = this.evaluateFunctionCall(functionToCall, callArguments);
+      return value;
+    }
     if (node.type === "assignment") {
       const varValue = this.evaluate(node.right, env);
 
@@ -176,8 +184,28 @@ export default class Evaluator {
       return value;
     }
 
-    // TODO: uncomment
-    // const exhaustiveCheck: never = node;
+    const exhaustiveCheck: never = node;
+  }
+
+  private parseCallArguments(callArguments: Expression[], env: Environment): any[] {
+    const values = [];
+    for (const arg of callArguments) {
+      const value = this.evaluate(arg, env);
+      values.push(value);
+    }
+    return values;
+  }
+
+  private evaluateFunctionCall(functionToCall: any, callArguments: any[]): any {
+    const functionEnv = new Environment(functionToCall.environment);
+    for (let i = 0; i < functionToCall.parameters.length; ++i) {
+      const name = functionToCall.parameters[i].value;
+      const value = callArguments[i];
+      functionEnv.set(name, value);
+    }
+
+    const value = this.evaluate(functionToCall.body, functionEnv);
+    return value;
   }
 }
 

src/index.test.ts

@@ -44,6 +44,10 @@ it("execute 만약 1 != 1 { 2 } 아니면 { 3 }", () => {
   expect(execute("만약 1 != 1 { 2 } 아니면 { 3 }")).toBe("3");
 });
 
-it("execute assignment", () => {
-  expect(execute("변수1 = 4  변수2 = 9  (변수2 - 변수1) * 변수1")).toBe("20");
+it("execute single assignment", () => {
+  expect(execute("변수1 = 4  변수1")).toBe("4");
+});
+
+it("execute assignment and calculation", () => {
+  expect(execute("변수1 = 4  변수2 = 9  ((변수1 - 변수2) * 변수1)")).toBe("-20");
 });