yukigo 0.1.0 → 0.2.0

package/src/interpreter/components/RuntimeContext.ts

@@ -0,0 +1,119 @@
+import { Environment, EnvStack, PrimitiveValue } from "yukigo-ast";
+import { FunctionRuntime } from "./runtimes/FunctionRuntime.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+import { ObjectRuntime } from "./runtimes/ObjectRuntime.js";
+import { createGlobalEnv } from "../utils.js";
+import { UnboundVariable } from "../errors.js";
+
+export const DefaultConfiguration: Required<InterpreterConfig> = {
+  lazyLoading: false,
+  debug: false,
+  outputMode: "first",
+  mutability: true,
+};
+
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface InterpreterConfig {
+  lazyLoading?: boolean;
+  debug?: boolean;
+  outputMode?: LogicSearchMode;
+  mutability?: boolean;
+}
+
+export class UninitializedConfig extends Error {
+  constructor() {
+    super(
+      "GlobalConfig was not initialized. You must call initialize() first.",
+    );
+  }
+}
+export class ReinitializedConfig extends Error {
+  constructor() {
+    super(
+      "GlobalConfig is already initialized. You cannot change it at execution.",
+    );
+  }
+}
+
+export class RuntimeContext {
+  public readonly config: InterpreterConfig | null = null;
+  public env: EnvStack;
+  public lazyRuntime: LazyRuntime;
+  public funcRuntime: FunctionRuntime;
+  public objRuntime: ObjectRuntime;
+  constructor(config?: InterpreterConfig) {
+    this.config = Object.freeze({ ...DefaultConfiguration, ...config });
+    this.lazyRuntime = new LazyRuntime(this);
+    this.funcRuntime = new FunctionRuntime(this);
+    this.objRuntime = new ObjectRuntime(this);
+    this.env = createGlobalEnv();
+  }
+
+  public setEnv(env: EnvStack) {
+    this.env = env;
+  }
+  public isDefined(name: string): boolean {
+    let current: EnvStack | null = this.env;
+
+    while (current !== null) {
+      if (current.head.has(name)) return true;
+      current = current.tail;
+    }
+
+    return false;
+  }
+  public pushEnv(frame: Environment = new Map()) {
+    this.env = {
+      head: frame,
+      tail: this.env,
+    };
+  }
+  public replace(
+    name: string,
+    value: PrimitiveValue,
+    onReplace?: (env: Environment) => void,
+  ): boolean {
+    let current: EnvStack | null = this.env;
+
+    while (current !== null) {
+      if (current.head.has(name)) {
+        current.head.set(name, value);
+        if (onReplace) onReplace(current.head);
+        return true;
+      }
+      current = current.tail;
+    }
+
+    return false;
+  }
+  public popEnv() {
+    if (!this.env.tail)
+      throw new Error(
+        "Runtime Error: Cannot pop the global environment scope.",
+      );
+    this.env = this.env.tail;
+  }
+  public lookup(name: string): PrimitiveValue {
+    let current: EnvStack | null = this.env;
+
+    while (current !== null) {
+      if (current.head.has(name)) return current.head.get(name);
+      current = current.tail;
+    }
+
+    throw new UnboundVariable(name);
+  }
+  public remove(name: string): void {
+    this.env.head.delete(name);
+  }
+  public define(name: string, value: PrimitiveValue): void {
+    this.env.head.set(name, value);
+  }
+  public clone(env?: EnvStack): EnvStack {
+    const target = env ?? this.env;
+    return {
+      head: new Map(target.head),
+      tail: this.env.tail,
+    };
+  }
+}

package/src/interpreter/components/TestRunner.ts

@@ -0,0 +1,151 @@
+import {
+  Assert,
+  Equality,
+  Failure,
+  isLazyList,
+  PrimitiveValue,
+  Test,
+  TestGroup,
+  TraverseVisitor,
+  Truth,
+} from "yukigo-ast";
+import { InterpreterVisitor } from "./Visitor.js";
+import {
+  CPSThunk,
+  idContinuation,
+  trampoline,
+  Continuation,
+  Thunk,
+} from "../trampoline.js";
+import { LazyRuntime } from "./runtimes/LazyRuntime.js";
+
+export class FailedAssert extends Error {
+  constructor(
+    public actual?: PrimitiveValue,
+    public expected?: PrimitiveValue,
+    message?: string,
+  ) {
+    super(message || `Assertion failed: expected ${expected}, got ${actual}`);
+    this.name = "FailedAssert";
+  }
+}
+
+class AssertionVisitor extends TraverseVisitor {
+  constructor(
+    private interpreter: InterpreterVisitor,
+    private negated: boolean,
+    private lazyRuntime: LazyRuntime,
+  ) {
+    super();
+  }
+
+  visitFailure(node: Failure): CPSThunk<void> {
+    return (k) => () => {
+      let threw = false;
+      let actualError: string | undefined;
+
+      try {
+        // We use trampoline here to execute the function under test.
+        // While this is a nested trampoline, it's necessary to capture the error
+        // and isolate the test execution from the test runner's CPS flow.
+        trampoline(this.interpreter.evaluate(node.func, idContinuation));
+      } catch (error) {
+        threw = true;
+        actualError = (error as Error).message;
+      }
+
+      return this.interpreter.evaluate(node.message, (expectedError) => {
+        const passed =
+          threw &&
+          (expectedError === undefined ||
+            actualError?.includes(expectedError as string));
+
+        if (this.negated === passed) {
+          if (!threw) {
+            throw new FailedAssert(
+              undefined,
+              expectedError,
+              "Expected code to fail, but it succeeded",
+            );
+          } else {
+            throw new FailedAssert(
+              actualError,
+              expectedError,
+              `Expected error message to contain "${expectedError}", but got "${actualError}"`,
+            );
+          }
+        }
+        return k(undefined);
+      });
+    };
+  }
+
+  visitEquality(node: Equality): CPSThunk<void> {
+    return (k) =>
+      this.interpreter.evaluate(node.value, (value) => {
+        return () =>
+          this.interpreter.evaluate(node.expected, (expected) => {
+            this.lazyRuntime.deepEqual(value, expected, (passed) => {
+              if (this.negated === passed) {
+                throw new FailedAssert(
+                  value, expected,
+                  this.negated
+                    ? `Expected ${JSON.stringify(value)} NOT to be equal to ${JSON.stringify(expected)}`
+                    : `Expected ${JSON.stringify(expected)}, but got ${JSON.stringify(value)}`,
+                );
+              }
+              return k(undefined);
+            })
+          });
+      });
+  }
+
+  visitTruth(node: Truth): CPSThunk<void> {
+    return (k) =>
+      this.interpreter.evaluate(node.body, (value) => {
+        const isTruthy = Boolean(value);
+        if (this.negated === isTruthy) {
+          throw new FailedAssert(
+            value,
+            !this.negated,
+            this.negated
+              ? `Expected value to be falsy, but got ${JSON.stringify(value)}`
+              : `Expected value to be truthy, but got ${JSON.stringify(value)}`,
+          );
+        }
+        return k(undefined);
+      });
+  }
+}
+
+export class TestRunner extends TraverseVisitor {
+  constructor(
+    public interpreter: InterpreterVisitor,
+    private lazyRuntime: LazyRuntime,
+  ) {
+    super();
+  }
+
+  public run(node: TestGroup | Test | Assert): CPSThunk<void> {
+    return node.accept(this) as any;
+  }
+
+  visitTestGroup(node: TestGroup): CPSThunk<void> {
+    return (k) => this.interpreter.evaluate(node.group, () => k(undefined));
+  }
+  visitTest(node: Test): CPSThunk<void> {
+    return (k) => this.interpreter.evaluate(node.body, () => k(undefined));
+  }
+  visitAssert(node: Assert): CPSThunk<void> {
+    return (k) =>
+      this.interpreter.evaluate(node.negated, (negatedVal) => {
+        const isNegated = Boolean(negatedVal);
+        const visitor = new AssertionVisitor(
+          this.interpreter,
+          isNegated,
+          this.lazyRuntime,
+        );
+        return (node.body.accept(visitor) as any)(k);
+      });
+  }
+}