yukigo 0.1.0

package/dist/analyzer/inspections/imperative.js

@@ -0,0 +1,105 @@
+import { StopTraversalException, TraverseVisitor, } from "@yukigo/ast";
+import { executeVisitor } from "../utils.js";
+export class BindingVisitor extends TraverseVisitor {
+    targetBinding;
+    isInsideTargetScope = false; // this flag helps to check nested functions inside the targetBinding scope
+    constructor(binding) {
+        super();
+        this.targetBinding = binding;
+    }
+    visitProcedure(node) {
+        const currentFunctionName = node.identifier.value;
+        // if not inside scope then is top-level
+        if (!this.isInsideTargetScope) {
+            if (!this.targetBinding || currentFunctionName === this.targetBinding) {
+                this.isInsideTargetScope = true;
+                this.traverseCollection(node.equations);
+                this.isInsideTargetScope = false;
+                return;
+            }
+            return;
+        }
+        // if inside the scope of targetBinding then traverse
+        this.traverseCollection(node.equations);
+    }
+    visitFunction(node) {
+        const currentFunctionName = node.identifier.value;
+        // if not inside scope then is top-level
+        if (!this.isInsideTargetScope) {
+            if (!this.targetBinding || currentFunctionName === this.targetBinding) {
+                this.isInsideTargetScope = true;
+                this.traverseCollection(node.equations);
+                this.isInsideTargetScope = false;
+                return;
+            }
+            return;
+        }
+        // if inside the scope of targetBinding then traverse
+        this.traverseCollection(node.equations);
+    }
+}
+export class DeclaresEnumeration extends TraverseVisitor {
+    enumName;
+    constructor(enumName) {
+        super();
+        this.enumName = enumName;
+    }
+    visitEnumeration(node) {
+        if (node.identifier.value === this.enumName)
+            throw StopTraversalException;
+    }
+}
+export class DeclaresProcedure extends TraverseVisitor {
+    procedureName;
+    constructor(procedureName) {
+        super();
+        this.procedureName = procedureName;
+    }
+    visitProcedure(node) {
+        if (node.identifier.value === this.procedureName)
+            throw StopTraversalException;
+    }
+}
+export class UsesForLoop extends BindingVisitor {
+    visitForLoop(node) {
+        throw StopTraversalException;
+    }
+}
+export class UsesWhile extends BindingVisitor {
+    visitWhile(node) {
+        throw StopTraversalException;
+    }
+}
+export class UsesRepeat extends BindingVisitor {
+    visitRepeat(node) {
+        throw StopTraversalException;
+    }
+}
+export class UsesLoop extends BindingVisitor {
+    visitForLoop(node) {
+        throw StopTraversalException;
+    }
+    visitWhile(node) {
+        throw StopTraversalException;
+    }
+    visitRepeat(node) {
+        throw StopTraversalException;
+    }
+}
+export class UsesSwitch extends BindingVisitor {
+    visitSwitch(node) {
+        throw StopTraversalException;
+    }
+}
+export const imperativeInspections = {
+    DeclaresEnumeration: (node, args) => executeVisitor(node, new DeclaresEnumeration(args[0])),
+    DeclaresProcedure: (node, args) => executeVisitor(node, new DeclaresProcedure(args[0])),
+    UsesForEach: (node, args) => {
+        throw Error("Inspection not implemented");
+    },
+    UsesForLoop: (node, args, binding) => executeVisitor(node, new UsesForLoop(binding)),
+    UsesRepeat: (node, args, binding) => executeVisitor(node, new UsesRepeat(binding)),
+    UsesWhile: (node, args, binding) => executeVisitor(node, new UsesWhile(binding)),
+    UsesLoop: (node, args, binding) => executeVisitor(node, new UsesLoop(binding)),
+    UsesSwitch: (node, args, binding) => executeVisitor(node, new UsesSwitch(binding)),
+};

package/dist/analyzer/inspections/logic.d.ts

@@ -0,0 +1,49 @@
+import { Exist, Fact, Findall, Forall, Not, Rule, TraverseVisitor, UnifyOperation } from "@yukigo/ast";
+import { InspectionMap } from "../utils.js";
+export declare abstract class DeclaresBinding extends TraverseVisitor {
+    protected readonly targetBinding: string;
+    constructor(binding: string);
+}
+export declare class DeclaresFact extends DeclaresBinding {
+    visitFact(node: Fact): void;
+}
+export declare class DeclaresRule extends DeclaresBinding {
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresPredicate extends DeclaresBinding {
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class PredicateVisitor extends TraverseVisitor {
+    private readonly targetBinding;
+    protected isInsideTargetScope: boolean;
+    constructor(binding: string);
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class UsesFindall extends TraverseVisitor {
+    visitFindall(node: Findall): void;
+}
+export declare class UsesForall extends TraverseVisitor {
+    visitForall(node: Forall): void;
+}
+export declare class UsesNot extends TraverseVisitor {
+    visitNot(node: Not): void;
+    visitExist(node: Exist): void;
+}
+export declare class UsesUnificationOperator extends PredicateVisitor {
+    visitUnifyOperation(node: UnifyOperation): void;
+}
+export declare class UsesCut extends PredicateVisitor {
+    visitExist(node: Exist): void;
+}
+export declare class UsesFail extends PredicateVisitor {
+    visitExist(node: Exist): void;
+}
+export declare class HasRedundantReduction extends TraverseVisitor {
+    private readonly targetBinding;
+    protected isInsideTargetScope: boolean;
+    constructor(binding: string);
+    visitRule(node: Rule): void;
+}
+export declare const logicInspections: InspectionMap;

package/dist/analyzer/inspections/logic.js

@@ -0,0 +1,140 @@
+import { AssignOperation, Exist, StopTraversalException, SymbolPrimitive, TraverseVisitor, } from "@yukigo/ast";
+import { executeVisitor } from "../utils.js";
+import { isYukigoPrimitive } from "@yukigo/ast";
+export class DeclaresBinding extends TraverseVisitor {
+    targetBinding;
+    constructor(binding) {
+        super();
+        this.targetBinding = binding;
+    }
+}
+export class DeclaresFact extends DeclaresBinding {
+    visitFact(node) {
+        const bindingName = node.identifier.value;
+        if (!this.targetBinding || bindingName === this.targetBinding)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresRule extends DeclaresBinding {
+    visitRule(node) {
+        const bindingName = node.identifier.value;
+        if (!this.targetBinding || bindingName === this.targetBinding)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresPredicate extends DeclaresBinding {
+    visitFact(node) {
+        new DeclaresFact(this.targetBinding).visitFact(node);
+    }
+    visitRule(node) {
+        new DeclaresRule(this.targetBinding).visitRule(node);
+    }
+}
+export class PredicateVisitor extends TraverseVisitor {
+    targetBinding;
+    isInsideTargetScope = false; // this flag helps to check nested functions inside the targetBinding scope
+    constructor(binding) {
+        super();
+        this.targetBinding = binding;
+    }
+    visitFact(node) {
+        const nodeName = node.identifier.value;
+        if (!this.isInsideTargetScope) {
+            if (nodeName === this.targetBinding) {
+                this.isInsideTargetScope = true;
+                this.traverseCollection(node.patterns);
+                this.isInsideTargetScope = false;
+            }
+            return;
+        }
+        this.traverseCollection(node.patterns);
+    }
+    visitRule(node) {
+        const nodeName = node.identifier.value;
+        if (!this.isInsideTargetScope) {
+            if (nodeName === this.targetBinding) {
+                this.isInsideTargetScope = true;
+                this.traverseCollection(node.expressions);
+                this.isInsideTargetScope = false;
+            }
+            return;
+        }
+        this.traverseCollection(node.expressions);
+    }
+}
+export class UsesFindall extends TraverseVisitor {
+    visitFindall(node) {
+        throw new StopTraversalException();
+    }
+}
+export class UsesForall extends TraverseVisitor {
+    visitForall(node) {
+        throw new StopTraversalException();
+    }
+}
+export class UsesNot extends TraverseVisitor {
+    visitNot(node) {
+        throw new StopTraversalException();
+    }
+    visitExist(node) {
+        if (node.identifier.value === "not")
+            throw new StopTraversalException();
+    }
+}
+export class UsesUnificationOperator extends PredicateVisitor {
+    visitUnifyOperation(node) {
+        throw new StopTraversalException();
+    }
+}
+export class UsesCut extends PredicateVisitor {
+    visitExist(node) {
+        if (node.identifier.value === "!")
+            throw new StopTraversalException();
+    }
+}
+export class UsesFail extends PredicateVisitor {
+    visitExist(node) {
+        if (node.identifier.value === "fail")
+            throw new StopTraversalException();
+    }
+}
+export class HasRedundantReduction extends TraverseVisitor {
+    targetBinding;
+    isInsideTargetScope = false;
+    constructor(binding) {
+        super();
+        this.targetBinding = binding;
+    }
+    visitRule(node) {
+        // Only inspect the specified rule if a binding is provided
+        if (this.targetBinding && node.identifier.value !== this.targetBinding)
+            return;
+        // Check each unification in the rule's body
+        for (const bodyElement of node.expressions) {
+            if (bodyElement instanceof AssignOperation) {
+                const left = bodyElement.left;
+                const right = bodyElement.right;
+                if (!(left instanceof SymbolPrimitive))
+                    continue;
+                const redundantReductionParameters = isYukigoPrimitive(right);
+                const redundantReductionFunctors = right instanceof Exist;
+                // Check if reduction is redundant
+                const isRedundant = redundantReductionParameters || redundantReductionFunctors;
+                if (isRedundant)
+                    throw new StopTraversalException();
+            }
+        }
+    }
+}
+export const logicInspections = {
+    DeclaresFact: (node, args, binding) => executeVisitor(node, new DeclaresFact(binding)),
+    DeclaresRule: (node, args, binding) => executeVisitor(node, new DeclaresRule(binding)),
+    DeclaresPredicate: (node, args, binding) => executeVisitor(node, new DeclaresPredicate(binding)),
+    UsesFindall: (node, args, binding) => executeVisitor(node, new UsesFindall()),
+    UsesForall: (node, args, binding) => executeVisitor(node, new UsesForall()),
+    UsesNot: (node, args, binding) => executeVisitor(node, new UsesNot()),
+    UsesUnificationOperator: (node, args, binding) => executeVisitor(node, new UsesUnificationOperator(binding)),
+    UsesCut: (node, args, binding) => executeVisitor(node, new UsesCut(binding)),
+    UsesFail: (node, args, binding) => executeVisitor(node, new UsesFail(binding)),
+    HasRedundantReduction: (node, args, binding) => executeVisitor(node, new HasRedundantReduction(binding)),
+};

package/dist/analyzer/inspections/object.d.ts

@@ -0,0 +1,83 @@
+import { Attribute, Class, Include, Interface, Method, New, Object, PrimitiveMethod, Send, TraverseVisitor } from "@yukigo/ast";
+import { InspectionMap } from "../utils.js";
+export declare class DeclaresAttribute extends TraverseVisitor {
+    private attributeName;
+    constructor(attributeName: string);
+    visitAttribute(node: Attribute): void;
+}
+export declare class DeclaresClass extends TraverseVisitor {
+    private className;
+    constructor(className: string);
+    visitClass(node: Class): void;
+}
+export declare class DeclaresInterface extends TraverseVisitor {
+    private interfaceName;
+    constructor(interfaceName: string);
+    visitInterface(node: Interface): void;
+}
+export declare class DeclaresMethod extends TraverseVisitor {
+    private methodName;
+    constructor(methodName: string);
+    visitMethod(node: Method): void;
+}
+export declare class DeclaresObject extends TraverseVisitor {
+    private objectName;
+    constructor(objectName: string);
+    visitObject(node: Object): void;
+}
+export declare class DeclaresPrimitive extends TraverseVisitor {
+    private operatorName;
+    constructor(operatorName: string);
+    visitPrimitiveMethod(node: PrimitiveMethod): void;
+}
+export declare class DeclaresSuperclass extends TraverseVisitor {
+    private superclassName;
+    constructor(superclassName: string);
+    visitClass(node: Class): void;
+}
+export declare class Implements extends TraverseVisitor {
+    private interfaceName;
+    constructor(interfaceName: string);
+    visitClass(node: Class): void;
+}
+export declare class IncludeMixin extends TraverseVisitor {
+    private mixinsName;
+    constructor(mixinsName: string);
+    visitInclude(node: Include): void;
+}
+export declare class Instantiates extends TraverseVisitor {
+    private className;
+    constructor(className: string);
+    visitNew(node: New): void;
+}
+export declare class UsesDynamicPolymorphism extends TraverseVisitor {
+    private selectorName;
+    private count;
+    constructor(selectorName: string);
+    visitMethod(node: Method): void;
+}
+export declare class UsesInheritance extends TraverseVisitor {
+    visitClass(node: Class): void;
+    visitInterface(node: Interface): void;
+}
+export declare class UsesMixins extends TraverseVisitor {
+    visitInclude(node: Include): void;
+}
+export declare class UsesObjectComposition extends TraverseVisitor {
+    visitAttribute(node: Attribute): void;
+}
+export declare class UsesStaticMethodOverload extends TraverseVisitor {
+    private scopes;
+    visitClass(node: Class): void;
+    visitObject(node: Object): void;
+    visitMethod(node: Method): void;
+}
+export declare class UsesDynamicMethodOverload extends TraverseVisitor {
+    visitMethod(node: Method): void;
+}
+export declare class UsesTemplateMethod extends TraverseVisitor {
+    private abstractMethodsStack;
+    visitClass(node: Class): void;
+    visitSend(node: Send): void;
+}
+export declare const objectInspections: InspectionMap;

package/dist/analyzer/inspections/object.js

@@ -0,0 +1,235 @@
+import { New, Self, StopTraversalException, SymbolPrimitive, TraverseVisitor, } from "@yukigo/ast";
+import { executeVisitor } from "../utils.js";
+export class DeclaresAttribute extends TraverseVisitor {
+    attributeName;
+    constructor(attributeName) {
+        super();
+        this.attributeName = attributeName;
+    }
+    visitAttribute(node) {
+        if (node.identifier.value === this.attributeName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresClass extends TraverseVisitor {
+    className;
+    constructor(className) {
+        super();
+        this.className = className;
+    }
+    visitClass(node) {
+        if (node.identifier.value === this.className)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresInterface extends TraverseVisitor {
+    interfaceName;
+    constructor(interfaceName) {
+        super();
+        this.interfaceName = interfaceName;
+    }
+    visitInterface(node) {
+        if (node.identifier.value === this.interfaceName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresMethod extends TraverseVisitor {
+    methodName;
+    constructor(methodName) {
+        super();
+        this.methodName = methodName;
+    }
+    visitMethod(node) {
+        if (node.identifier.value === this.methodName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresObject extends TraverseVisitor {
+    objectName;
+    constructor(objectName) {
+        super();
+        this.objectName = objectName;
+    }
+    visitObject(node) {
+        if (node.identifier.value === this.objectName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresPrimitive extends TraverseVisitor {
+    operatorName;
+    constructor(operatorName) {
+        super();
+        this.operatorName = operatorName;
+    }
+    visitPrimitiveMethod(node) {
+        if (node.operator === this.operatorName)
+            throw new StopTraversalException();
+    }
+}
+export class DeclaresSuperclass extends TraverseVisitor {
+    superclassName;
+    constructor(superclassName) {
+        super();
+        this.superclassName = superclassName;
+    }
+    visitClass(node) {
+        if (node.extendsSymbol && node.extendsSymbol.value === this.superclassName)
+            throw new StopTraversalException();
+    }
+}
+export class Implements extends TraverseVisitor {
+    interfaceName;
+    constructor(interfaceName) {
+        super();
+        this.interfaceName = interfaceName;
+    }
+    visitClass(node) {
+        if (node.implementsNode &&
+            node.implementsNode.identifier.value === this.interfaceName)
+            throw new StopTraversalException();
+    }
+}
+export class IncludeMixin extends TraverseVisitor {
+    mixinsName;
+    constructor(mixinsName) {
+        super();
+        this.mixinsName = mixinsName;
+    }
+    visitInclude(node) {
+        if (node.identifier.value === this.mixinsName)
+            throw new StopTraversalException();
+    }
+}
+export class Instantiates extends TraverseVisitor {
+    className;
+    constructor(className) {
+        super();
+        this.className = className;
+    }
+    visitNew(node) {
+        if (node.identifier.value === this.className)
+            throw new StopTraversalException();
+    }
+}
+export class UsesDynamicPolymorphism extends TraverseVisitor {
+    selectorName;
+    count = 0;
+    constructor(selectorName) {
+        super();
+        this.selectorName = selectorName;
+    }
+    visitMethod(node) {
+        if (node.identifier.value === this.selectorName) {
+            this.count++;
+            if (this.count >= 2)
+                throw new StopTraversalException();
+        }
+    }
+}
+export class UsesInheritance extends TraverseVisitor {
+    visitClass(node) {
+        if (node.extendsSymbol)
+            throw new StopTraversalException();
+    }
+    visitInterface(node) {
+        if (node.extendsSymbol && node.extendsSymbol.length > 0)
+            throw new StopTraversalException();
+    }
+}
+export class UsesMixins extends TraverseVisitor {
+    visitInclude(node) {
+        throw new StopTraversalException();
+    }
+}
+export class UsesObjectComposition extends TraverseVisitor {
+    visitAttribute(node) {
+        if (node.expression instanceof New)
+            throw new StopTraversalException();
+    }
+}
+export class UsesStaticMethodOverload extends TraverseVisitor {
+    scopes = [];
+    visitClass(node) {
+        this.scopes.push(new Set());
+        node.expression.accept(this);
+        this.scopes.pop();
+    }
+    visitObject(node) {
+        this.scopes.push(new Set());
+        node.expression.accept(this);
+        this.scopes.pop();
+    }
+    visitMethod(node) {
+        const currentScope = this.scopes[0];
+        const methodName = node.identifier.value;
+        if (currentScope.has(methodName))
+            throw new StopTraversalException();
+        currentScope.add(methodName);
+    }
+}
+export class UsesDynamicMethodOverload extends TraverseVisitor {
+    visitMethod(node) {
+        if (node.equations.length > 1)
+            throw new StopTraversalException();
+    }
+}
+class AbstractMethodCollector extends TraverseVisitor {
+    abstractMethods = new Set();
+    visitMethod(node) {
+        if (node.getMetadata("isAbstract") === true)
+            this.abstractMethods.add(node.identifier.value);
+    }
+    // stop propagation to not mix scopes
+    visitClass(node) {
+        return;
+    }
+    visitObject(node) {
+        return;
+    }
+}
+export class UsesTemplateMethod extends TraverseVisitor {
+    abstractMethodsStack = [];
+    visitClass(node) {
+        const collector = new AbstractMethodCollector();
+        if (node.expression)
+            executeVisitor(node.expression, collector);
+        this.abstractMethodsStack.push(collector.abstractMethods);
+        node.expression.accept(this);
+        this.abstractMethodsStack.pop();
+    }
+    visitSend(node) {
+        if (node.receiver instanceof Self) {
+            if (this.abstractMethodsStack.length === 0)
+                return;
+            const currentAbstractMethods = this.abstractMethodsStack[0];
+            // This doesnt match if message is complex expression
+            if (!(node.selector instanceof SymbolPrimitive))
+                return;
+            const selectorName = node.selector.value;
+            const isMessageAbstract = currentAbstractMethods.has(selectorName);
+            if (isMessageAbstract)
+                throw new StopTraversalException();
+        }
+    }
+}
+export const objectInspections = {
+    DeclaresAttribute: (node, args) => executeVisitor(node, new DeclaresAttribute(args[0])),
+    DeclaresClass: (node, args) => executeVisitor(node, new DeclaresClass(args[0])),
+    DeclaresInterface: (node, args) => executeVisitor(node, new DeclaresInterface(args[0])),
+    DeclaresMethod: (node, args) => executeVisitor(node, new DeclaresMethod(args[0])),
+    DeclaresObject: (node, args) => executeVisitor(node, new DeclaresObject(args[0])),
+    DeclaresPrimitive: (node, args) => executeVisitor(node, new DeclaresPrimitive(args[0])),
+    DeclaresSuperclass: (node, args) => executeVisitor(node, new DeclaresSuperclass(args[0])),
+    Implements: (node, args) => executeVisitor(node, new Implements(args[0])),
+    Include: (node, args) => executeVisitor(node, new IncludeMixin(args[0])),
+    Inherits: (node, args) => executeVisitor(node, new DeclaresSuperclass(args[0])),
+    Instantiates: (node, args) => executeVisitor(node, new Instantiates(args[0])),
+    UsesDynamicPolymorphism: (node, args) => executeVisitor(node, new UsesDynamicPolymorphism(args[0])),
+    UsesInheritance: (node, args) => executeVisitor(node, new UsesInheritance()),
+    UsesMixins: (node, args) => executeVisitor(node, new UsesMixins()),
+    UsesObjectComposition: (node, args) => executeVisitor(node, new UsesObjectComposition()),
+    UsesStaticMethodOverload: (node, args) => executeVisitor(node, new UsesStaticMethodOverload()),
+    UsesDynamicMethodOverload: (node, args) => executeVisitor(node, new UsesDynamicMethodOverload()),
+    UsesTemplateMethod: (node, args) => executeVisitor(node, new UsesTemplateMethod()),
+    UsesStaticPolymorphism: (node, args) => executeVisitor(node, new UsesStaticMethodOverload()),
+};

package/dist/analyzer/utils.d.ts

@@ -0,0 +1,4 @@
+import { ASTNode, TraverseVisitor } from "@yukigo/ast";
+export type InspectionHandler = (node: ASTNode, args: string[], binding?: string) => boolean;
+export type InspectionMap = Record<string, InspectionHandler>;
+export declare function executeVisitor(node: ASTNode, visitor: TraverseVisitor): boolean;

package/dist/analyzer/utils.js

@@ -0,0 +1,16 @@
+import { StopTraversalException } from "@yukigo/ast";
+export function executeVisitor(node, visitor) {
+    let passes = false;
+    try {
+        node.accept(visitor);
+    }
+    catch (e) {
+        if (e instanceof StopTraversalException) {
+            passes = true;
+        }
+        else {
+            throw e;
+        }
+    }
+    return passes;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./interpreter/index.js";
+export * from "./analyzer/index.js";
+export * from "./utils/helpers.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./interpreter/index.js";
+export * from "./analyzer/index.js";
+export * from "./utils/helpers.js";

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

@@ -0,0 +1,16 @@
+import { AST, ASTNode, Fact, Function, Rule, TraverseVisitor } from "@yukigo/ast";
+import { EnvStack } from "../index.js";
+/**
+ * Builds the initial environment by collecting all top-level function declarations.
+ * Each function captures a closure of the environment at its definition time,
+ * allowing recursion by including itself in the closure.
+ */
+export declare class EnvBuilderVisitor extends TraverseVisitor {
+    private env;
+    constructor(baseEnv?: EnvStack);
+    build(ast: AST): EnvStack;
+    visitFunction(node: Function): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+    visit(node: ASTNode): void;
+}