yukigo 0.1.1 → 0.2.2

package/dist/interpreter/entities.js

@@ -0,0 +1,96 @@
+export function isLogicResult(value) {
+    return (value &&
+        typeof value === "object" &&
+        "success" in value &&
+        typeof value.success === "boolean" &&
+        "solutions" in value &&
+        value.solutions instanceof Map);
+}
+export class RuntimePredicate {
+    kind;
+    identifier;
+    equations;
+    constructor(kind, identifier, equations) {
+        this.kind = kind;
+        this.identifier = identifier;
+        this.equations = equations;
+    }
+    pushEquation(eq) {
+        this.equations.push(eq);
+    }
+}
+// TODO: Replace with correct polymorphism
+export const isRuntimePredicate = (prim) => {
+    return prim instanceof RuntimePredicate;
+};
+export class RuntimeEquation {
+    patterns;
+    body;
+    constructor(patterns, body) {
+        this.patterns = patterns;
+        this.body = body;
+    }
+}
+export class RuntimeFunction {
+    arity;
+    identifier;
+    equations;
+    pendingArgs;
+    closure;
+    constructor(arity, identifier, equations, pendingArgs, closure) {
+        this.arity = arity;
+        this.identifier = identifier;
+        this.equations = equations;
+        this.pendingArgs = pendingArgs;
+        this.closure = closure;
+    }
+    setPendingArgs(args) {
+        this.pendingArgs = args;
+    }
+}
+// TODO: Replace with correct polymorphism
+export function isRuntimeFunction(val) {
+    return val instanceof RuntimeFunction;
+}
+export class RuntimeClass {
+    identifier;
+    fields;
+    methods;
+    mixins;
+    superclass;
+    constructor(identifier, fields, methods, mixins, superclass) {
+        this.identifier = identifier;
+        this.fields = fields;
+        this.methods = methods;
+        this.mixins = mixins;
+        this.superclass = superclass;
+    }
+}
+// TODO: prev as before
+export function isRuntimeClass(val) {
+    return val instanceof RuntimeClass;
+}
+export class RuntimeObject {
+    identifier;
+    className;
+    fields;
+    methods;
+    constructor(identifier, className, fields, methods) {
+        this.identifier = identifier;
+        this.className = className;
+        this.fields = fields;
+        this.methods = methods;
+    }
+}
+export function isRuntimeObject(val) {
+    return val instanceof RuntimeObject;
+}
+export class LazyList {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+}
+export function isLazyList(prim) {
+    return prim instanceof LazyList;
+}

package/dist/src/analyzer/GraphBuilder.d.ts

@@ -0,0 +1,30 @@
+import { Application, AST, ASTNode, Call, Class, Fact, Function, Interface, Method, New, Object as YuObject, Procedure, Rule, TraverseVisitor, TypeAlias, TypeSignature, Exist } from "yukigo-ast";
+type DefinitionMap = Map<string, ASTNode[]>;
+type CallsMap = Map<string, string[]>;
+export type SymbolGraph = {
+    defs: DefinitionMap;
+    calls: CallsMap;
+};
+export declare class GraphBuilder extends TraverseVisitor {
+    private defs;
+    private calls;
+    private scope;
+    build(ast: AST): SymbolGraph;
+    private addDefinition;
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitRule(node: Rule): void;
+    visitFact(node: Fact): void;
+    visitClass(node: Class): void;
+    visitObject(node: YuObject): void;
+    visitInterface(node: Interface): void;
+    visitTypeAlias(node: TypeAlias): void;
+    visitTypeSignature(node: TypeSignature): void;
+    visitCall(node: Call): void;
+    visitApplication(node: Application): void;
+    visitNew(node: New): void;
+    visitExist(node: Exist): void;
+    fallback(node: ASTNode): void;
+}
+export {};

package/dist/src/analyzer/GraphBuilder.js

@@ -0,0 +1,100 @@
+import { SymbolPrimitive, TraverseVisitor, } from "yukigo-ast";
+export class GraphBuilder extends TraverseVisitor {
+    defs = new Map();
+    calls = new Map();
+    scope = "";
+    build(ast) {
+        ast.forEach((node) => node.accept(this));
+        return { defs: this.defs, calls: this.calls };
+    }
+    addDefinition(name, node) {
+        const existing = this.defs.get(name) || [];
+        this.defs.set(name, [...existing, node]);
+    }
+    visitFunction(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitMethod(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitProcedure(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitRule(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitFact(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.patterns);
+        this.scope = "";
+    }
+    visitClass(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitObject(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitInterface(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitTypeAlias(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.scope = "";
+    }
+    visitTypeSignature(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.scope = "";
+    }
+    visitCall(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.callee.value, ...arr]);
+    }
+    visitApplication(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        if (node.functionExpr instanceof SymbolPrimitive)
+            this.calls.set(this.scope, [node.functionExpr.value, ...arr]);
+        else
+            node.functionExpr.accept(this);
+    }
+    visitNew(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.identifier.value, ...arr]);
+    }
+    visitExist(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.identifier.value, ...arr]);
+    }
+    fallback(node) { }
+}

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

@@ -0,0 +1,59 @@
+import { AST } from "yukigo-ast";
+import { InspectionMap, VisitorConstructor } from "./utils.js";
+export type AnalysisResult = {
+    rule: InspectionRule;
+    passed: boolean;
+    actual: boolean;
+    error?: string;
+};
+export type InspectionRule = {
+    inspection: string;
+    binding?: string;
+    args?: string[];
+    expected: boolean;
+};
+export declare const DefaultInspectionSet: InspectionMap;
+export declare const DefaultSmellsSet: InspectionMap;
+/**
+ * The Analyzer class.
+ * @remarks
+ * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
+ */
+export declare class Analyzer {
+    /**
+     * The set of inspections that are available for the Analyzer.
+     * You can load your set of inspections or leave the default one.
+     * @defaultValue a default set of inspections for each supported paradigm
+     */
+    private inspectionConstructors;
+    private smellsConstructors;
+    constructor(inspectionSet?: InspectionMap, smellsSet?: InspectionMap);
+    /**
+     * Registers a new custom inspection handler after Analyzer was instantiated.
+     * @param name The name of the inspection (e.g., "HasArithmetic").
+     * @param visitorConstructor The constructor for the TraverseVisitor class.
+     */
+    registerInspection(name: string, visitorConstructor: VisitorConstructor): void;
+    /**
+     * Runs a list of inspection rules against the AST.
+     * @param ast The parsed AST.
+     * @param rules The array of inspection rules to run.
+     * @returns An array of analysis results.
+     * @example
+     * const rules: InspectionRule[] = [
+     *  {
+     *    inspection: "HasBinding",
+     *    args: { name: "minimoEntre" },
+     *    expected: false,
+     *  },
+     *  {
+     *    inspection: "HasBinding",
+     *    args: { name: "squareList" },
+     *    expected: true,
+     *  }
+     * ]
+     * const analyzer = new ASTAnalyzer(ast);
+     * const analysisResults = analyzer.analyze(expectations);
+     */
+    analyze(ast: AST, rules: InspectionRule[]): AnalysisResult[];
+}

package/dist/src/analyzer/index.js

@@ -0,0 +1,152 @@
+import { StopTraversalException } from "yukigo-ast";
+import { genericInspections } from "./inspections/generic/generic.js";
+import { functionalInspections } from "./inspections/functional/functional.js";
+import { logicInspections } from "./inspections/logic/logic.js";
+import { objectInspections } from "./inspections/object/object.js";
+import { imperativeInspections } from "./inspections/imperative/imperative.js";
+import { functionalSmells } from "./inspections/functional/smells.js";
+import { logicSmells } from "./inspections/logic/smells.js";
+import { objectSmells } from "./inspections/object/smells.js";
+import { imperativeSmells } from "./inspections/imperative/smells.js";
+import { genericSmells } from "./inspections/generic/smells.js";
+import { GraphBuilder } from "./GraphBuilder.js";
+export const DefaultInspectionSet = {
+    ...genericInspections,
+    ...functionalInspections,
+    ...logicInspections,
+    ...objectInspections,
+    ...imperativeInspections,
+};
+export const DefaultSmellsSet = {
+    ...genericSmells,
+    ...functionalSmells,
+    ...logicSmells,
+    ...objectSmells,
+    ...imperativeSmells,
+};
+/**
+ * The Analyzer class.
+ * @remarks
+ * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
+ */
+export class Analyzer {
+    /**
+     * The set of inspections that are available for the Analyzer.
+     * You can load your set of inspections or leave the default one.
+     * @defaultValue a default set of inspections for each supported paradigm
+     */
+    inspectionConstructors = {};
+    smellsConstructors = {};
+    constructor(inspectionSet, smellsSet) {
+        this.inspectionConstructors = inspectionSet ?? DefaultInspectionSet;
+        this.smellsConstructors = smellsSet ?? DefaultSmellsSet;
+    }
+    /**
+     * Registers a new custom inspection handler after Analyzer was instantiated.
+     * @param name The name of the inspection (e.g., "HasArithmetic").
+     * @param visitorConstructor The constructor for the TraverseVisitor class.
+     */
+    registerInspection(name, visitorConstructor) {
+        this.inspectionConstructors[name] = visitorConstructor;
+    }
+    /**
+     * Runs a list of inspection rules against the AST.
+     * @param ast The parsed AST.
+     * @param rules The array of inspection rules to run.
+     * @returns An array of analysis results.
+     * @example
+     * const rules: InspectionRule[] = [
+     *  {
+     *    inspection: "HasBinding",
+     *    args: { name: "minimoEntre" },
+     *    expected: false,
+     *  },
+     *  {
+     *    inspection: "HasBinding",
+     *    args: { name: "squareList" },
+     *    expected: true,
+     *  }
+     * ]
+     * const analyzer = new ASTAnalyzer(ast);
+     * const analysisResults = analyzer.analyze(expectations);
+     */
+    analyze(ast, rules) {
+        const ruleResults = new Map();
+        const graphBuilder = new GraphBuilder();
+        const { defs, calls } = graphBuilder.build(ast);
+        for (const rule of rules) {
+            let inspectionName = rule.inspection;
+            let isTransitive = true;
+            if (inspectionName.startsWith("Intransitive:")) {
+                isTransitive = false;
+                inspectionName = inspectionName.replace("Intransitive:", "");
+            }
+            const InspectionClass = this.inspectionConstructors[inspectionName];
+            if (!InspectionClass) {
+                ruleResults.set(rule, {
+                    rule,
+                    passed: false,
+                    actual: false,
+                    error: "Unknown inspection: " + inspectionName,
+                });
+                continue;
+            }
+            if (InspectionClass.IS_INTRANSITIVE)
+                isTransitive = false;
+            let targets = [];
+            // Case 1: Global Inspection (No binding or wildcard)
+            if (!rule.binding || rule.binding === "*") {
+                targets = ast.map((n) => ({ node: n, binding: undefined }));
+            }
+            // Case 2: Directed Inspection (Specific binding)
+            else {
+                const workList = [rule.binding];
+                const visited = new Set();
+                while (workList.length > 0) {
+                    const currentBinding = workList.shift();
+                    if (!currentBinding || visited.has(currentBinding))
+                        continue;
+                    visited.add(currentBinding);
+                    const node = defs.get(currentBinding);
+                    if (node)
+                        node.forEach((n) => targets.push({ node: n, binding: currentBinding }));
+                    if (isTransitive) {
+                        const deps = calls.get(currentBinding) || [];
+                        workList.push(...deps);
+                    }
+                }
+            }
+            let actual = false;
+            let error = undefined;
+            // Execution Loop
+            const isGlobalVisitor = !rule.binding || rule.binding === "*";
+            const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
+            const args = rule.args ?? [];
+            const visitor = new InspectionClass(...args, normalizedBinding);
+            for (const { node, binding } of targets) {
+                try {
+                    if (!isGlobalVisitor && visitor.setBinding && binding) {
+                        visitor.setBinding(binding);
+                    }
+                    node.accept(visitor);
+                }
+                catch (e) {
+                    if (e instanceof StopTraversalException) {
+                        actual = true;
+                        break; // Short-circuit: Rule passed
+                    }
+                    else {
+                        error = e.message;
+                    }
+                }
+            }
+            ruleResults.set(rule, {
+                rule,
+                passed: actual === rule.expected,
+                actual,
+                error,
+            });
+        }
+        return [...ruleResults.values()];
+    }
+}

package/dist/src/analyzer/inspections/functional/functional.d.ts

@@ -0,0 +1,44 @@
+import * as Yu from "yukigo-ast";
+import { VisitorConstructor, ScopedVisitor } from "../../utils.js";
+export declare class UsesComposition extends ScopedVisitor {
+    constructor(scope?: string);
+    visitCompositionExpression(node: Yu.CompositionExpression): void;
+}
+export declare class UsesAnonymousVariable extends ScopedVisitor {
+    constructor(scope?: string);
+    visitWildcardPattern(node: Yu.WildcardPattern): void;
+}
+export declare class UsesComprehension extends ScopedVisitor {
+    constructor(scope?: string);
+    visitListComprehension(node: Yu.ListComprehension): void;
+}
+export declare class UsesGuards extends ScopedVisitor {
+    constructor(scope?: string);
+    visitGuardedBody(node: Yu.GuardedBody): void;
+}
+export declare class UsesOtherwise extends ScopedVisitor {
+    constructor(scope?: string);
+    visitOtherwise(node: Yu.Otherwise): void;
+}
+export declare class UsesLambda extends ScopedVisitor {
+    constructor(scope?: string);
+    visitLambda(node: Yu.Lambda): void;
+}
+export declare class UsesYield extends ScopedVisitor {
+    constructor(scope?: string);
+    visitYield(node: Yu.Yield): void;
+}
+export declare class UsesPatternMatching extends ScopedVisitor {
+    constructor(scope?: string);
+    visitConsPattern(node: Yu.ConsPattern): void;
+    visitAsPattern(node: Yu.AsPattern): void;
+    visitListPattern(node: Yu.ListPattern): void;
+    visitTuplePattern(node: Yu.TuplePattern): void;
+    visitLiteralPattern(node: Yu.LiteralPattern): void;
+    visitApplicationPattern(node: Yu.ApplicationPattern): void;
+    visitConstructorPattern(node: Yu.ConstructorPattern): void;
+    visitUnionPattern(node: Yu.UnionPattern): void;
+    visitFunctorPattern(node: Yu.FunctorPattern): void;
+    visitWildcardPattern(node: Yu.WildcardPattern): void;
+}
+export declare const functionalInspections: Record<string, VisitorConstructor>;

package/dist/src/analyzer/inspections/functional/functional.js

@@ -0,0 +1,149 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as Yu from "yukigo-ast";
+import { ScopedVisitor, AutoScoped } from "../../utils.js";
+let UsesComposition = class UsesComposition extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitCompositionExpression(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesComposition = __decorate([
+    AutoScoped
+], UsesComposition);
+export { UsesComposition };
+let UsesAnonymousVariable = class UsesAnonymousVariable extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitWildcardPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesAnonymousVariable = __decorate([
+    AutoScoped
+], UsesAnonymousVariable);
+export { UsesAnonymousVariable };
+let UsesComprehension = class UsesComprehension extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitListComprehension(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesComprehension = __decorate([
+    AutoScoped
+], UsesComprehension);
+export { UsesComprehension };
+let UsesGuards = class UsesGuards extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitGuardedBody(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesGuards = __decorate([
+    AutoScoped
+], UsesGuards);
+export { UsesGuards };
+let UsesOtherwise = class UsesOtherwise extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitOtherwise(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesOtherwise = __decorate([
+    AutoScoped
+], UsesOtherwise);
+export { UsesOtherwise };
+let UsesLambda = class UsesLambda extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitLambda(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesLambda = __decorate([
+    AutoScoped
+], UsesLambda);
+export { UsesLambda };
+let UsesYield = class UsesYield extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitYield(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesYield = __decorate([
+    AutoScoped
+], UsesYield);
+export { UsesYield };
+let UsesPatternMatching = class UsesPatternMatching extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitConsPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitAsPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitListPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitTuplePattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitLiteralPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitApplicationPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitConstructorPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitUnionPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitFunctorPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitWildcardPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesPatternMatching = __decorate([
+    AutoScoped
+], UsesPatternMatching);
+export { UsesPatternMatching };
+export const functionalInspections = {
+    UsesComposition: UsesComposition,
+    HasComposition: UsesComposition,
+    UsesAnonymousVariable: UsesAnonymousVariable,
+    HasAnonymousVariable: UsesAnonymousVariable,
+    UsesComprehension: UsesComprehension,
+    HasComprehension: UsesComprehension,
+    UsesGuards: UsesGuards,
+    HasGuards: UsesGuards,
+    UsesOtherwise: UsesOtherwise,
+    HasOtherwise: UsesOtherwise,
+    UsesLambda: UsesLambda,
+    HasLambda: UsesLambda,
+    UsesYield: UsesYield,
+    HasYield: UsesYield,
+    UsesPatternMatching: UsesPatternMatching,
+    HasPatternMatching: UsesPatternMatching,
+};

package/dist/src/analyzer/inspections/functional/smells.d.ts

@@ -0,0 +1,16 @@
+import { Lambda, Equation, GuardedBody } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class HasRedundantLambda extends ScopedVisitor {
+    visitLambda(node: Lambda): void;
+}
+export declare class HasRedundantGuards extends ScopedVisitor {
+    visitEquation(node: Equation): void;
+    private isAlwaysTrue;
+}
+export declare class ShouldUseOtherwise extends ScopedVisitor {
+    visitGuardedBody(node: GuardedBody): void;
+}
+export declare class HasRedundantParameter extends ScopedVisitor {
+    visitEquation(node: Equation): void;
+}
+export declare const functionalSmells: Record<string, VisitorConstructor>;