yukigo 0.1.0 → 0.2.0

package/dist/interpreter/components/TestRunner.js

@@ -0,0 +1,103 @@
+import { TraverseVisitor, } from "yukigo-ast";
+import { idContinuation, trampoline, } from "../trampoline.js";
+export class FailedAssert extends Error {
+    actual;
+    expected;
+    constructor(actual, expected, message) {
+        super(message || `Assertion failed: expected ${expected}, got ${actual}`);
+        this.actual = actual;
+        this.expected = expected;
+        this.name = "FailedAssert";
+    }
+}
+class AssertionVisitor extends TraverseVisitor {
+    interpreter;
+    negated;
+    lazyRuntime;
+    constructor(interpreter, negated, lazyRuntime) {
+        super();
+        this.interpreter = interpreter;
+        this.negated = negated;
+        this.lazyRuntime = lazyRuntime;
+    }
+    visitFailure(node) {
+        return (k) => () => {
+            let threw = false;
+            let actualError;
+            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.message;
+            }
+            return this.interpreter.evaluate(node.message, (expectedError) => {
+                const passed = threw &&
+                    (expectedError === undefined ||
+                        actualError?.includes(expectedError));
+                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) {
+        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) {
+        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 {
+    interpreter;
+    lazyRuntime;
+    constructor(interpreter, lazyRuntime) {
+        super();
+        this.interpreter = interpreter;
+        this.lazyRuntime = lazyRuntime;
+    }
+    run(node) {
+        return node.accept(this);
+    }
+    visitTestGroup(node) {
+        return (k) => this.interpreter.evaluate(node.group, () => k(undefined));
+    }
+    visitTest(node) {
+        return (k) => this.interpreter.evaluate(node.body, () => k(undefined));
+    }
+    visitAssert(node) {
+        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)(k);
+        });
+    }
+}

package/dist/interpreter/components/Visitor.d.ts

@@ -1,64 +1,70 @@
-import { Visitor, PrimitiveValue, NumberPrimitive, BooleanPrimitive, StringPrimitive, ListPrimitive, NilPrimitive, SymbolPrimitive, Variable, CharPrimitive, ArithmeticUnaryOperation, ArithmeticBinaryOperation, ListUnaryOperation, ListBinaryOperation, ComparisonOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, UnifyOperation, AssignOperation, TupleExpression, FieldExpression, DataExpression, ConsExpression, LetInExpression, Call, Otherwise, CompositionExpression, Expression, Application, Lambda, Exist, Not, Findall, Forall, Goal, Send, New, Implement, Include, Self, ListComprehension, RangeExpression, Generator as YuGenerator, ASTNode, Raise, Query } from "@yukigo/ast";
-import { EnvStack, InterpreterConfig } from "../index.js";
+import { Visitor, PrimitiveValue, NumberPrimitive, BooleanPrimitive, StringPrimitive, ListPrimitive, NilPrimitive, SymbolPrimitive, Variable, CharPrimitive, ArithmeticUnaryOperation, ArithmeticBinaryOperation, ListUnaryOperation, ListBinaryOperation, ComparisonOperation, LogicalBinaryOperation, LogicalUnaryOperation, BitwiseBinaryOperation, BitwiseUnaryOperation, StringOperation, UnifyOperation, AssignOperation, Assignment, TupleExpression, FieldExpression, DataExpression, ConsExpression, LetInExpression, Call, Otherwise, CompositionExpression, Expression, Application, Lambda, Sequence, Exist, Not, Findall, Forall, Goal, Send, New, Self, ListComprehension, RangeExpression, Generator as YuGenerator, ASTNode, Raise, Query, TypeCast, Super, If, Assert, Test, TestGroup, LogicConstraint } from "yukigo-ast";
 import { ExpressionEvaluator } from "../utils.js";
 import { ErrorFrame } from "../errors.js";
-export declare class InterpreterVisitor implements Visitor<PrimitiveValue>, ExpressionEvaluator {
+import { Continuation, CPSThunk, Thunk } from "../trampoline.js";
+import { RuntimeContext } from "./RuntimeContext.js";
+export declare class InterpreterVisitor implements Visitor<CPSThunk<PrimitiveValue>>, ExpressionEvaluator {
+    private context;
     private frames;
-    private env;
-    private readonly config;
-    constructor(env: EnvStack, config: InterpreterConfig, frames?: ErrorFrame[]);
-    evaluate(node: Expression): PrimitiveValue;
-    private getLogicEngine;
-    visitNumberPrimitive(node: NumberPrimitive): PrimitiveValue;
-    visitBooleanPrimitive(node: BooleanPrimitive): PrimitiveValue;
-    visitStringPrimitive(node: StringPrimitive): PrimitiveValue;
-    visitListPrimitive(node: ListPrimitive): PrimitiveValue;
-    visitNilPrimitive(node: NilPrimitive): PrimitiveValue;
-    visitCharPrimitive(node: CharPrimitive): PrimitiveValue;
-    visitSymbolPrimitive(node: SymbolPrimitive): PrimitiveValue;
-    visitVariable(node: Variable): PrimitiveValue;
-    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): PrimitiveValue;
-    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): PrimitiveValue;
-    visitListUnaryOperation(node: ListUnaryOperation): PrimitiveValue;
-    visitListBinaryOperation(node: ListBinaryOperation): PrimitiveValue;
-    visitComparisonOperation(node: ComparisonOperation): PrimitiveValue;
-    visitLogicalBinaryOperation(node: LogicalBinaryOperation): PrimitiveValue;
-    visitLogicalUnaryOperation(node: LogicalUnaryOperation): PrimitiveValue;
-    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): PrimitiveValue;
-    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): PrimitiveValue;
-    visitStringOperation(node: StringOperation): PrimitiveValue;
-    visitUnifyOperation(node: UnifyOperation): PrimitiveValue;
-    visitAssignOperation(node: AssignOperation): PrimitiveValue;
-    visitTupleExpr(node: TupleExpression): PrimitiveValue;
-    visitFieldExpr(node: FieldExpression): PrimitiveValue;
-    visitDataExpr(node: DataExpression): PrimitiveValue;
-    visitConsExpr(node: ConsExpression): PrimitiveValue;
-    visitLetInExpr(node: LetInExpression): PrimitiveValue;
-    visitCall(node: Call): PrimitiveValue;
-    visitOtherwise(node: Otherwise): PrimitiveValue;
-    visitCompositionExpression(node: CompositionExpression): PrimitiveValue;
-    visitLambda(node: Lambda): PrimitiveValue;
-    visitApplication(node: Application): PrimitiveValue;
-    visitQuery(node: Query): PrimitiveValue;
-    visitExist(node: Exist): PrimitiveValue;
-    visitNot(node: Not): PrimitiveValue;
-    visitFindall(node: Findall): PrimitiveValue;
-    visitForall(node: Forall): PrimitiveValue;
-    visitGoal(node: Goal): PrimitiveValue;
-    visitSend(node: Send): PrimitiveValue;
-    visitNew(node: New): PrimitiveValue;
-    visitImplement(node: Implement): PrimitiveValue;
-    visitInclude(node: Include): PrimitiveValue;
-    visitSelf(node: Self): PrimitiveValue;
-    visitListComprehension(node: ListComprehension): PrimitiveValue;
-    visitGenerator(node: YuGenerator): PrimitiveValue;
-    visitRaise(node: Raise): PrimitiveValue;
-    visitRangeExpression(node: RangeExpression): PrimitiveValue;
-    visit(node: Expression): PrimitiveValue;
-    private safelyVisit;
-    private isRuntimeFunction;
-    realizeList(val: PrimitiveValue): PrimitiveValue[];
+    constructor(context: RuntimeContext, frames?: ErrorFrame[]);
+    evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
+    visitSequence(node: Sequence): CPSThunk<PrimitiveValue>;
+    visitAssert(node: Assert): CPSThunk<PrimitiveValue>;
+    visitTest(node: Test): CPSThunk<PrimitiveValue>;
+    visitTestGroup(node: TestGroup): CPSThunk<PrimitiveValue>;
+    visitNumberPrimitive(node: NumberPrimitive): CPSThunk<PrimitiveValue>;
+    visitBooleanPrimitive(node: BooleanPrimitive): CPSThunk<PrimitiveValue>;
+    visitStringPrimitive(node: StringPrimitive): CPSThunk<PrimitiveValue>;
+    visitListPrimitive(node: ListPrimitive): CPSThunk<PrimitiveValue>;
+    visitNilPrimitive(node: NilPrimitive): CPSThunk<PrimitiveValue>;
+    visitCharPrimitive(node: CharPrimitive): CPSThunk<PrimitiveValue>;
+    visitSymbolPrimitive(node: SymbolPrimitive): CPSThunk<PrimitiveValue>;
+    visitVariable(node: Variable): CPSThunk<PrimitiveValue>;
+    visitAssignment(node: Assignment): CPSThunk<PrimitiveValue>;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitListUnaryOperation(node: ListUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitListBinaryOperation(node: ListBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitComparisonOperation(node: ComparisonOperation): CPSThunk<PrimitiveValue>;
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): CPSThunk<PrimitiveValue>;
+    visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): CPSThunk<PrimitiveValue>;
+    visitStringOperation(node: StringOperation): CPSThunk<PrimitiveValue>;
+    visitUnifyOperation(node: UnifyOperation): CPSThunk<PrimitiveValue>;
+    visitAssignOperation(node: AssignOperation): CPSThunk<PrimitiveValue>;
+    visitTupleExpr(node: TupleExpression): CPSThunk<PrimitiveValue>;
+    visitFieldExpression(node: FieldExpression): CPSThunk<PrimitiveValue>;
+    visitDataExpr(node: DataExpression): CPSThunk<PrimitiveValue>;
+    visitConsExpr(node: ConsExpression): CPSThunk<PrimitiveValue>;
+    visitLetInExpr(node: LetInExpression): CPSThunk<PrimitiveValue>;
+    visitIf(node: If): CPSThunk<PrimitiveValue>;
+    visitCall(node: Call): CPSThunk<PrimitiveValue>;
+    visitOtherwise(node: Otherwise): CPSThunk<PrimitiveValue>;
+    visitCompositionExpression(node: CompositionExpression): CPSThunk<PrimitiveValue>;
+    visitLambda(node: Lambda): CPSThunk<PrimitiveValue>;
+    visitApplication(node: Application): CPSThunk<PrimitiveValue>;
+    visitQuery(node: Query): CPSThunk<PrimitiveValue>;
+    visitExist(node: Exist): CPSThunk<PrimitiveValue>;
+    visitNot(node: Not): CPSThunk<PrimitiveValue>;
+    visitFindall(node: Findall): CPSThunk<PrimitiveValue>;
+    visitForall(node: Forall): CPSThunk<PrimitiveValue>;
+    visitGoal(node: Goal): CPSThunk<PrimitiveValue>;
+    private bindLogicResults;
+    visitLogicConstraint(node: LogicConstraint): CPSThunk<PrimitiveValue>;
+    visitSuper(node: Super): CPSThunk<PrimitiveValue>;
+    visitSend(node: Send): CPSThunk<PrimitiveValue>;
+    visitNew(node: New): CPSThunk<PrimitiveValue>;
+    visitSelf(node: Self): CPSThunk<PrimitiveValue>;
+    visitListComprehension(node: ListComprehension): CPSThunk<PrimitiveValue>;
+    visitTypeCast(node: TypeCast): CPSThunk<PrimitiveValue>;
+    visitGenerator(node: YuGenerator): CPSThunk<PrimitiveValue>;
+    visitRaise(node: Raise): CPSThunk<PrimitiveValue>;
+    visitRangeExpression(node: RangeExpression): CPSThunk<PrimitiveValue>;
+    visit(node: Expression): CPSThunk<PrimitiveValue>;
+    realizeList<R = PrimitiveValue[]>(val: PrimitiveValue, k: Continuation<PrimitiveValue[], R>): Thunk<R>;
     private processBinary;
     private processUnary;
+    private getLogicEngine;
     static evaluateLiteral(node: ASTNode): PrimitiveValue;
 }