yukigo 0.2.0 → 0.2.3

package/dist/src/interpreter/index.js

@@ -0,0 +1,41 @@
+import { InterpreterVisitor } from "./components/Visitor.js";
+import { EnvBuilderVisitor } from "./components/EnvBuilder.js";
+import { InterpreterError } from "./errors.js";
+import { idContinuation, trampoline } from "./trampoline.js";
+import { RuntimeContext, } from "./components/RuntimeContext.js";
+/**
+ * The Interpreter class is responsible for evaluating the Abstract Syntax Tree (AST)
+ * generated by the parsers.
+ *
+ * It manages the global execution environment and delegates the actual evaluation
+ * of Expression nodes to a dedicated visitor.
+ */
+export class Interpreter {
+    context;
+    /**
+     * @param ast The Abstract Syntax Tree (AST) of the program to be interpreted.
+     */
+    constructor(ast, config = {}) {
+        this.context = new RuntimeContext(config);
+        const builder = new EnvBuilderVisitor(this.context);
+        builder.build(ast);
+    }
+    /**
+     * Evaluates a single Expression node within the context of the global environment.
+     *
+     * @param expr The root Expression node to be evaluated.
+     * @returns The resulting primitive value (number, string, boolean, etc.) after evaluation.
+     */
+    evaluate(expr) {
+        try {
+            const visitor = new InterpreterVisitor(this.context);
+            const evaluatedCPS = expr.accept(visitor);
+            return trampoline(evaluatedCPS(idContinuation));
+        }
+        catch (error) {
+            if (error instanceof InterpreterError)
+                console.log(error.formatStack());
+            throw error;
+        }
+    }
+}

package/dist/src/interpreter/trampoline.d.ts

@@ -0,0 +1,17 @@
+import { PrimitiveValue } from "yukigo-ast";
+export type CallableThunk<T> = () => Thunk<T>;
+export type Thunk<T> = T | CallableThunk<T>;
+export type Continuation<T, R = any> = (value: T) => Thunk<R>;
+export declare const idContinuation: Continuation<PrimitiveValue>;
+export declare function trampoline<T>(thunk: Thunk<T>): T;
+/**
+ * A specialized Thunk type for our CPS visitor.
+ * This is a function that, when called, takes the continuation for the current node's evaluation
+ * and returns the actual Thunk chain for that node.
+ * This effectively injects the continuation *after* the `visit` method has returned.
+ */
+export type CPSThunk<T, R = any> = (k: Continuation<T, R>) => Thunk<R>;
+export declare function makeCPSThunk<T>(fn: (k: Continuation<T>) => Thunk<T>): CPSThunk<T>;
+export declare function bindCPS<A, B, R>(cpsA: CPSThunk<A, R>, f: (valueA: A) => CPSThunk<B, R>): CPSThunk<B, R>;
+export declare function valueToCPS<T, R>(value: T): CPSThunk<T, R>;
+export declare function thunkToCPS<T>(thunk: Thunk<T>): CPSThunk<T>;

package/dist/src/interpreter/trampoline.js

@@ -0,0 +1,38 @@
+const isCallableThunk = (thunk) => typeof thunk === "function";
+// The identity continuation: simply returns the value as a resolved Thunk.
+// This is used for the very last step of a computation or when a value is final.
+export const idContinuation = (value) => value;
+// The trampoline function executes a chain of Thunks until a final non-function value is reached.
+export function trampoline(thunk) {
+    let result = thunk;
+    while (isCallableThunk(result))
+        result = result();
+    return result;
+}
+// Helper to create a CPSThunk for visitor methods.
+// Visitor methods will call this, providing a function that knows how to use 'k'.
+export function makeCPSThunk(fn) {
+    return fn;
+}
+// Helper to compose asynchronous/CPS operations.
+// `cpsA` is a CPSThunk that eventually produces a value A.
+// `f` is a function that takes A and returns a CPSThunk that eventually produces B.
+export function bindCPS(cpsA, f) {
+    return (k) => {
+        return () => cpsA((valueA) => {
+            // f(valueA) returns a CPSThunk<B, R>
+            // calling that with 'k' returns Thunk<R>
+            return f(valueA)(k);
+        });
+    };
+}
+// Helper to lift a direct value into a CPSThunk
+export function valueToCPS(value) {
+    return (k) => () => k(value);
+}
+// Helper to lift a regular Thunk into a CPSThunk (if it resolves a simple Thunk)
+export function thunkToCPS(thunk) {
+    return (k) => {
+        return () => k(trampoline(thunk)); // Trampoline the simple thunk and pass its result to k
+    };
+}

package/dist/src/interpreter/utils.d.ts

@@ -0,0 +1,11 @@
+import { LazyList, PrimitiveValue, Environment, EnvStack, ASTNode } from "yukigo-ast";
+import { Continuation, Thunk } from "./trampoline.js";
+export interface ExpressionEvaluator {
+    evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
+}
+export declare function createStream(generator: () => Generator<PrimitiveValue, void, unknown>): LazyList;
+export declare function isArrayOfNumbers(arr: PrimitiveValue[]): arr is number[];
+export declare function generateRange(start: number, end: number, step: number): number[];
+export declare function createEnv(bindings: [string, PrimitiveValue][]): Environment;
+export declare function createGlobalEnv(): EnvStack;
+export declare function getYukigoType(val: PrimitiveValue): string;

package/dist/src/interpreter/utils.js

@@ -0,0 +1,65 @@
+import { isRuntimeFunction, isRuntimeObject, isLazyList, isRuntimeClass, isRuntimePredicate, } from "yukigo-ast";
+export function createStream(generator) {
+    return {
+        type: "LazyList",
+        generator,
+    };
+}
+export function isArrayOfNumbers(arr) {
+    for (const item of arr)
+        if (typeof item !== "number")
+            return false;
+    return true;
+}
+export function generateRange(start, end, step) {
+    if (step === 0)
+        throw new Error("Step cannot be zero in range expression");
+    const result = [];
+    let current = start;
+    if (step > 0) {
+        while (current <= end) {
+            result.push(current);
+            current += step;
+        }
+    }
+    else {
+        while (current >= end) {
+            result.push(current);
+            current += step;
+        }
+    }
+    return result;
+}
+export function createEnv(bindings) {
+    const env = new Map();
+    for (const [name, value] of bindings)
+        env.set(name, value);
+    return env;
+}
+export function createGlobalEnv() {
+    return {
+        head: new Map(),
+        tail: null,
+    };
+}
+export function getYukigoType(val) {
+    if (val === null || val === undefined)
+        return "YuNil";
+    if (typeof val === "number")
+        return "YuNumber";
+    if (typeof val === "boolean")
+        return "YuBoolean";
+    if (typeof val === "string")
+        return val.length === 1 ? "YuChar" : "YuString";
+    if (Array.isArray(val) || isLazyList(val))
+        return "YuList";
+    if (isRuntimeFunction(val))
+        return "YuFunction";
+    if (isRuntimeObject(val))
+        return "YuObject";
+    if (isRuntimeClass(val))
+        return "YuClass";
+    if (isRuntimePredicate(val))
+        return "YuPredicate";
+    return "YuUnknown";
+}

package/dist/src/tester/index.d.ts

@@ -0,0 +1,25 @@
+import { AST } from "yukigo-ast";
+import { InterpreterConfig } from "../interpreter/components/RuntimeContext.js";
+export type TestStatus = "passed" | "failed" | "error";
+export interface TestReport {
+    name: string;
+    status: TestStatus;
+    message?: string;
+    duration?: number;
+    children?: TestReport[];
+}
+/**
+ * The Tester class provides a high-level API for executing test nodes
+ * (Tests and TestGroups) within an AST and generating a detailed report.
+ */
+export declare class Tester {
+    private ast;
+    private config?;
+    constructor(ast: AST, config?: InterpreterConfig | undefined);
+    /**
+     * Executes all Test and TestGroup nodes found at the top level of the provided AST.
+     * @param nodes The AST (or subset of nodes) to scan for tests.
+     * @returns An array of TestReport objects for each top-level test/group.
+     */
+    test(nodes: AST): TestReport[];
+}

package/dist/src/tester/index.js

@@ -0,0 +1,113 @@
+import { Test, TestGroup, TraverseVisitor, } from "yukigo-ast";
+import { Interpreter } from "../interpreter/index.js";
+import { FailedAssert } from "../interpreter/components/TestRunner.js";
+import { UnexpectedNode } from "../utils/helpers.js";
+class TestExecutor extends TraverseVisitor {
+    interpreter;
+    report = null;
+    constructor(interpreter) {
+        super();
+        this.interpreter = interpreter;
+    }
+    visitTest(node) {
+        const name = this.evaluateName(node.name);
+        const start = Date.now();
+        try {
+            //this.bindParameters(node);
+            this.interpreter.evaluate(node);
+            this.report = {
+                name,
+                status: "passed",
+                duration: Date.now() - start,
+            };
+        }
+        catch (error) {
+            this.report = this.handleError(name, start, error);
+        }
+    }
+    /*   private bindParameters(node: Test): void {
+      if (!node.args || node.args.length === 0) return;
+  
+      for (const pattern of node.args) {
+        if (pattern instanceof VariablePattern) {
+          this.interpreter.define(pattern.name.value, null);
+        }
+      }
+    } */
+    visitTestGroup(node) {
+        const name = this.evaluateName(node.name);
+        const start = Date.now();
+        try {
+            const children = [];
+            for (const stmt of node.group.statements) {
+                if (stmt instanceof Test || stmt instanceof TestGroup) {
+                    const visitor = new TestExecutor(this.interpreter);
+                    stmt.accept(visitor);
+                    if (visitor.report)
+                        children.push(visitor.report);
+                }
+                else {
+                    this.interpreter.evaluate(stmt);
+                }
+            }
+            const anyFailed = children.some((c) => c.status !== "passed");
+            this.report = {
+                name,
+                status: anyFailed ? "failed" : "passed",
+                duration: Date.now() - start,
+                children,
+            };
+        }
+        catch (error) {
+            this.report = this.handleError(name, start, error);
+        }
+    }
+    evaluateName(nameExpr) {
+        try {
+            return String(this.interpreter.evaluate(nameExpr));
+        }
+        catch {
+            return "Unknown Test";
+        }
+    }
+    handleError(name, start, error) {
+        const duration = Date.now() - start;
+        if (error instanceof FailedAssert)
+            return { name, status: "failed", message: error.message, duration };
+        const message = error instanceof Error ? error.message : String(error);
+        return { name, status: "error", message, duration };
+    }
+    fallback(node) {
+        throw new UnexpectedNode(node.constructor.name, "TestExecutor");
+    }
+}
+/**
+ * The Tester class provides a high-level API for executing test nodes
+ * (Tests and TestGroups) within an AST and generating a detailed report.
+ */
+export class Tester {
+    ast;
+    config;
+    constructor(ast, config) {
+        this.ast = ast;
+        this.config = config;
+    }
+    /**
+     * Executes all Test and TestGroup nodes found at the top level of the provided AST.
+     * @param nodes The AST (or subset of nodes) to scan for tests.
+     * @returns An array of TestReport objects for each top-level test/group.
+     */
+    test(nodes) {
+        const reports = [];
+        for (const node of nodes) {
+            if (node instanceof Test || node instanceof TestGroup) {
+                const interpreter = new Interpreter(this.ast, this.config);
+                const visitor = new TestExecutor(interpreter);
+                node.accept(visitor);
+                if (visitor.report)
+                    reports.push(visitor.report);
+            }
+        }
+        return reports;
+    }
+}

package/dist/src/utils/helpers.d.ts

@@ -0,0 +1,13 @@
+import { InspectionRule } from "../analyzer/index.js";
+export declare class UnexpectedNode extends Error {
+    constructor(nodeCons: string, context: string);
+}
+/**
+ * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
+ * @param mulangYamlString The Mulang inspection syntax as a YAML string.
+ * @returns An array of InspectionRule objects.
+ */
+export declare class MulangAdapter {
+    translateMulangInspection(mulangInspection: any): InspectionRule;
+    translateMulangExpectations(mulangYamlString: string): InspectionRule[];
+}

package/dist/src/utils/helpers.js

@@ -0,0 +1,52 @@
+import { parseDocument } from "yaml";
+export class UnexpectedNode extends Error {
+    constructor(nodeCons, context) {
+        super(`${nodeCons} not expected in ${context}.`);
+    }
+}
+const isValidFormat = (inspection) => typeof inspection === "object" &&
+    "inspection" in inspection &&
+    "binding" in inspection;
+/**
+ * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
+ * @param mulangYamlString The Mulang inspection syntax as a YAML string.
+ * @returns An array of InspectionRule objects.
+ */
+export class MulangAdapter {
+    translateMulangInspection(mulangInspection) {
+        if (!isValidFormat(mulangInspection))
+            throw new Error(`Skipping malformed Mulang inspection entry: ${mulangInspection}`);
+        const inspection = mulangInspection.inspection.split(":");
+        const expected = inspection[0] !== "Not" && inspection[0] !== "Except";
+        const args = inspection.slice(expected ? 1 : 2);
+        return {
+            inspection: expected ? inspection[0] : inspection[1],
+            expected,
+            args,
+            binding: mulangInspection.binding,
+        };
+    }
+    translateMulangExpectations(mulangYamlString) {
+        if (!mulangYamlString)
+            return [];
+        const parsedYaml = parseDocument(mulangYamlString).toJS();
+        if (!parsedYaml)
+            return [];
+        let expectations = [];
+        if (Array.isArray(parsedYaml)) {
+            expectations = parsedYaml;
+        }
+        else if (Array.isArray(parsedYaml.expectations)) {
+            expectations = parsedYaml.expectations;
+        }
+        else {
+            throw new Error("Invalid Mulang YAML structure. Expected 'expectations' to be an array.");
+        }
+        const inspectionRules = [];
+        for (const mulangInspection of expectations) {
+            const inspection = this.translateMulangInspection(mulangInspection);
+            inspectionRules.push(inspection);
+        }
+        return inspectionRules;
+    }
+}

package/dist/utils/helpers.d.ts

@@ -5,6 +5,10 @@ import { InspectionRule } from "../analyzer/index.js";
  * @returns An array of InspectionRule objects.
  */
 export declare class MulangAdapter {
-    translateMulangInspection(mulangInspection: any): InspectionRule;
+    translateMulangInspection(mulangInspection: unknown): InspectionRule;
     translateMulangExpectations(mulangYamlString: string): InspectionRule[];
+    private transformToV2;
+    private parseNegation;
+    private applyV0ToV2;
+    private retrieveArguments;
 }

package/dist/utils/helpers.js

@@ -1,4 +1,19 @@
 import { parseDocument } from "yaml";
+const declareMap = {
+    HasBinding: "Declares",
+    HasTypeDeclaration: "DeclaresTypeAlias",
+    HasTypeSignature: "DeclaresTypeSignature",
+    HasVariable: "DeclaresVariable",
+};
+const V0_HAS_INSPECTIONS = new Set([
+    "HasBinding", "HasTypeDeclaration", "HasTypeSignature", "HasVariable",
+    "HasArity", "HasDirectRecursion", "HasComposition", "HasComprehension",
+    "HasForeach", "HasIf", "HasGuards", "HasConditional", "HasLambda",
+    "HasRepeat", "HasWhile", "HasUsage", "HasAnonymousVariable",
+    "HasNot", "HasForall", "HasFindall",
+]);
+const NEGATION_PREFIXES = new Set(["Not", "Except"]);
+const SUFFIX_ARGS = new Set(["like", "except"]);
 const isValidFormat = (inspection) => typeof inspection === "object" &&
     "inspection" in inspection &&
     "binding" in inspection;
@@ -11,14 +26,17 @@ export class MulangAdapter {
     translateMulangInspection(mulangInspection) {
         if (!isValidFormat(mulangInspection))
             throw new Error(`Skipping malformed Mulang inspection entry: ${mulangInspection}`);
-        const inspection = mulangInspection.inspection.split(":");
-        const expected = inspection[0] !== "Not" && inspection[0] !== "Except";
-        const args = inspection.slice(expected ? 1 : 2);
+        // transforms Mulang v0 to v2
+        const { inspection, expected, binding, args } = this.transformToV2(mulangInspection);
+        const { resolvedArgs, targetSuffix, matcher } = this.retrieveArguments(args);
         return {
-            inspection: expected ? inspection[0] : inspection[1],
+            inspection,
             expected,
-            args,
-            binding: mulangInspection.binding,
+            binding,
+            args: resolvedArgs,
+            // these should not exist in the InspectionRule if they are undefined
+            ...(targetSuffix !== undefined && { targetSuffix }),
+            ...(matcher !== undefined && { matcher }),
         };
     }
     translateMulangExpectations(mulangYamlString) {
@@ -44,4 +62,62 @@ export class MulangAdapter {
         }
         return inspectionRules;
     }
+    transformToV2(mulangInspection) {
+        const parts = mulangInspection.inspection.split(":");
+        const { expected, inspection, args: parsedArgs, } = this.parseNegation(parts);
+        const args = mulangInspection.args ?? parsedArgs;
+        const v2 = this.applyV0ToV2(inspection, args, mulangInspection.binding);
+        return { expected, ...v2 };
+    }
+    parseNegation(parts) {
+        const negated = NEGATION_PREFIXES.has(parts[0]);
+        return {
+            expected: !negated,
+            inspection: parts[negated ? 1 : 0],
+            args: parts.slice(negated ? 2 : 1),
+        };
+    }
+    applyV0ToV2(inspection, args, binding) {
+        if (inspection in declareMap)
+            return {
+                inspection: declareMap[inspection],
+                ...promoteBindingToTarget(args, binding),
+            };
+        if (inspection === "HasArity")
+            return {
+                inspection: "DeclaresComputationWithArity",
+                args: [args[0], ...(binding && binding !== "*" ? [binding] : [])],
+                binding: "*",
+            };
+        if (V0_HAS_INSPECTIONS.has(inspection))
+            return { inspection: inspection === "HasUsage" ? "Uses" : inspection.replace(/^Has/, "Uses"), args, binding };
+        return { inspection, args, binding };
+    }
+    retrieveArguments(args) {
+        const targetSuffix = args.find((a) => SUFFIX_ARGS.has(a));
+        const matcherIndex = args.findIndex((a) => a.startsWith("With"));
+        const matcher = matcherIndex !== -1
+            ? {
+                type: "with_" + args[matcherIndex].slice(4).toLowerCase(),
+                value: args[matcherIndex + 1],
+            }
+            : undefined;
+        const consumed = new Set([
+            ...(targetSuffix ? [targetSuffix] : []),
+            ...(matcherIndex !== -1
+                ? [args[matcherIndex], args[matcherIndex + 1]]
+                : []),
+        ]);
+        const resolvedArgs = args.filter((a) => !consumed.has(a));
+        return {
+            targetSuffix: targetSuffix ??
+                (resolvedArgs.length > 0 ? "named" : undefined),
+            matcher,
+            resolvedArgs,
+        };
+    }
 }
+const promoteBindingToTarget = (args, binding) => ({
+    args: binding && binding !== "*" ? [binding, ...args] : args,
+    binding: "*",
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,9 @@
   },
   "dependencies": {
     "typescript": "^5.9.2",
-    "yaml": "^2.8.0",
+    "yaml": "^2.8.0"
+  },
+  "peerDependencies": {
     "yukigo-ast": "^0.2.0"
   },
   "devDependencies": {

package/src/analyzer/index.ts

@@ -19,11 +19,20 @@ export type AnalysisResult = {
   error?: string;
 };
 
+export type TargetSuffix = "named" | "like" | "except";
+
+export type InspectionMatcher = {
+  type: string;
+  value?: string;
+};
+
 export type InspectionRule = {
   inspection: string;
   binding?: string;
   args?: string[];
   expected: boolean;
+  targetSuffix?: TargetSuffix;
+  matcher?: InspectionMatcher;
 };
 
 export const DefaultInspectionSet: InspectionMap = {

package/src/analyzer/inspections/generic/generic.ts

@@ -119,10 +119,6 @@ export class Declares extends ScopedVisitor {
   visitTypeAlias(node: TypeAlias): void {
     this.check(node);
   }
-
-  visitTypeSignature(node: TypeSignature): void {
-    this.check(node);
-  }
 }
 @AutoScoped
 export class DeclaresComputation extends ScopedVisitor {
@@ -234,7 +230,7 @@ export class DeclaresRecursively extends ScopedVisitor {
       throw new StopTraversalException();
   }
 }
-export class HasDirectRecursion extends TraverseVisitor {
+export class UsesDirectRecursion extends TraverseVisitor {
   private isInsideBody: boolean = false;
   constructor(private readonly binding: string) {
     super();
@@ -553,7 +549,7 @@ export const genericInspections: Record<string, VisitorConstructor> = {
   DeclaresEntryPoint: DeclaresEntryPoint,
   DeclaresFunction: DeclaresFunction,
   DeclaresRecursively: DeclaresRecursively,
-  HasDirectRecursion: HasDirectRecursion,
+  UsesDirectRecursion: UsesDirectRecursion,
   DeclaresTypeAlias: DeclaresTypeAlias,
   DeclaresTypeSignature: DeclaresTypeSignature,
   HasTypeSignature: DeclaresTypeSignature,