yukigo 0.1.0 → 0.2.0

package/dist/analyzer/inspections/generic.js

@@ -1,427 +0,0 @@
-import { ParameterizedType, StopTraversalException, SymbolPrimitive, TraverseVisitor, VariablePattern, } from "@yukigo/ast";
-import { executeVisitor } from "../utils.js";
-export class Assigns extends TraverseVisitor {
-    targetIdentifier;
-    constructor(targetIdentifier) {
-        super();
-        this.targetIdentifier = targetIdentifier;
-    }
-    visitVariable(node) {
-        if (node.identifier.value === this.targetIdentifier)
-            throw new StopTraversalException();
-    }
-    visitAttribute(node) {
-        if (node.identifier.value === this.targetIdentifier)
-            throw new StopTraversalException();
-    }
-    visitAssignment(node) {
-        if (node.identifier.value === this.targetIdentifier)
-            throw new StopTraversalException();
-    }
-}
-export class Calls extends TraverseVisitor {
-    targetCallee;
-    constructor(targetCallee) {
-        super();
-        this.targetCallee = targetCallee;
-    }
-    visitCall(node) {
-        if (node.callee.value === this.targetCallee)
-            throw new StopTraversalException();
-    }
-}
-export class Declares extends TraverseVisitor {
-    targetIdentifier;
-    constructor(targetIdentifier) {
-        super();
-        this.targetIdentifier = targetIdentifier;
-    }
-    visit(node) {
-        if ("identifier" in node &&
-            node.identifier instanceof SymbolPrimitive &&
-            node.identifier.value === this.targetIdentifier)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresComputation extends TraverseVisitor {
-    callName;
-    constructor(callName) {
-        super();
-        this.callName = callName;
-    }
-    visitFunction(node) {
-        if (node.identifier.value === this.callName)
-            throw new StopTraversalException();
-    }
-    visitMethod(node) {
-        if (node.identifier.value === this.callName)
-            throw new StopTraversalException();
-    }
-    visitProcedure(node) {
-        if (node.identifier.value === this.callName)
-            throw new StopTraversalException();
-    }
-    visitFact(node) {
-        if (node.identifier.value === this.callName)
-            throw new StopTraversalException();
-    }
-    visitRule(node) {
-        if (node.identifier.value === this.callName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresComputationWithArity extends TraverseVisitor {
-    targetBinding;
-    targetArity;
-    constructor(targetBinding, targetArity) {
-        super();
-        this.targetBinding = targetBinding;
-        this.targetArity = targetArity;
-    }
-    visitFunction(node) {
-        if (node.identifier.value === this.targetBinding &&
-            node.equations.some((eq) => eq.patterns.length === this.targetArity))
-            throw new StopTraversalException();
-    }
-    visitMethod(node) {
-        if (node.identifier.value === this.targetBinding &&
-            node.equations.some((eq) => eq.patterns.length === this.targetArity))
-            throw new StopTraversalException();
-    }
-    visitProcedure(node) {
-        if (node.identifier.value === this.targetBinding &&
-            node.equations.some((eq) => eq.patterns.length === this.targetArity))
-            throw new StopTraversalException();
-    }
-    visitFact(node) {
-        if (node.identifier.value === this.targetBinding &&
-            node.patterns.length === this.targetArity)
-            throw new StopTraversalException();
-    }
-    visitRule(node) {
-        if (node.identifier.value === this.targetBinding &&
-            node.patterns.length === this.targetArity)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresEntryPoint extends TraverseVisitor {
-    visitEntryPoint(node) {
-        throw new StopTraversalException();
-    }
-}
-export class DeclaresFunction extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitFunction(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresRecursively extends DeclaresComputation {
-    targetBinding;
-    constructor(targetBinding) {
-        super(targetBinding);
-        this.targetBinding = targetBinding;
-    }
-    visitFunction(node) {
-        super.visitFunction(node);
-        this.visitNested(node);
-    }
-    visitMethod(node) {
-        super.visitMethod(node);
-        this.visitNested(node);
-    }
-    visitProcedure(node) {
-        super.visitProcedure(node);
-        this.visitNested(node);
-    }
-    visitFact(node) {
-        super.visitFact(node);
-        this.visitNested(node);
-    }
-    visitRule(node) {
-        super.visitRule(node);
-        this.visitNested(node);
-    }
-    visitNested(node) {
-        if ("identifier" in node &&
-            node.identifier instanceof SymbolPrimitive &&
-            node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresTypeAlias extends TraverseVisitor {
-    typeAliasName;
-    constructor(typeAliasName) {
-        super();
-        this.typeAliasName = typeAliasName;
-    }
-    visitTypeAlias(node) {
-        if (node.identifier.value === this.typeAliasName)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresTypeSignature extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitTypeSignature(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class DeclaresVariable extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitVariable(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class Raises extends TraverseVisitor {
-    visitRaise(node) {
-        throw new StopTraversalException();
-    }
-}
-export class Uses extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitSymbolPrimitive(node) {
-        if (node.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class UsesArithmetic extends TraverseVisitor {
-    visitArithmeticBinaryOperation(node) {
-        throw new StopTraversalException();
-    }
-    visitArithmeticUnaryOperation(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesConditional extends TraverseVisitor {
-    visitIf(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesLogic extends TraverseVisitor {
-    visitLogicalBinaryOperation(node) {
-        throw new StopTraversalException();
-    }
-    visitLogicalUnaryOperation(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesPrint extends TraverseVisitor {
-    visitPrint(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesType extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitTypeSignature(node) {
-        node.body.accept(this);
-    }
-    visitSimpleType(node) {
-        if (node.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-    visitTypeVar(node) {
-        if (node.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class HasBinding extends TraverseVisitor {
-    targetBinding;
-    constructor(targetBinding) {
-        super();
-        this.targetBinding = targetBinding;
-    }
-    visitFunction(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-    visitTypeAlias(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-    visitTypeSignature(node) {
-        if (node.identifier.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-    visitRecord(node) {
-        if (node.name.value === this.targetBinding)
-            throw new StopTraversalException();
-    }
-}
-export class SubordinatesDeclarationsTo extends TraverseVisitor {
-    childName;
-    parentName;
-    constructor(childName, parentName) {
-        super();
-        this.childName = childName;
-        this.parentName = parentName;
-    }
-    visitFunction(node) {
-        if (node.identifier.value === this.parentName) {
-            const childFinder = new Declares(this.childName);
-            node.equations.forEach((eq) => eq.accept(childFinder)); // we expect that this will throw if find the subordinated decl
-        }
-        else {
-            super.visitFunction(node);
-        }
-    }
-}
-export class SubordinatesDeclarationsToEntryPoint extends TraverseVisitor {
-    childName;
-    constructor(childName) {
-        super();
-        this.childName = childName;
-    }
-    visitEntryPoint(node) {
-        const childFinder = new Declares(this.childName);
-        node.expression.statements.forEach((stmt) => stmt.accept(childFinder));
-    }
-}
-export class TypesAs extends TraverseVisitor {
-    bindingName;
-    typeName;
-    constructor(bindingName, typeName) {
-        super();
-        this.bindingName = bindingName;
-        this.typeName = typeName;
-    }
-    visitTypeSignature(node) {
-        if (node.identifier.value === this.bindingName) {
-            const actualType = node.body.toString();
-            if (actualType.replace(/\s+/g, " ").trim() ===
-                this.typeName.replace(/\s+/g, " ").trim()) {
-                throw new StopTraversalException();
-            }
-        }
-    }
-}
-export class TypesParameterAs extends TraverseVisitor {
-    bindingName;
-    paramIndex;
-    typeName;
-    constructor(bindingName, paramIndex, typeName) {
-        super();
-        this.bindingName = bindingName;
-        this.paramIndex = paramIndex;
-        this.typeName = typeName;
-    }
-    visitTypeSignature(node) {
-        if (node.identifier.value === this.bindingName) {
-            if (node.body instanceof ParameterizedType) {
-                const paramType = node.body.inputs[this.paramIndex];
-                if (paramType) {
-                    const actualType = paramType.toString();
-                    if (actualType.replace(/\s+/g, " ").trim() ===
-                        this.typeName.replace(/\s+/g, " ").trim()) {
-                        throw new StopTraversalException();
-                    }
-                }
-            }
-        }
-    }
-}
-export class TypesReturnAs extends TraverseVisitor {
-    bindingName;
-    typeName;
-    constructor(bindingName, typeName) {
-        super();
-        this.bindingName = bindingName;
-        this.typeName = typeName;
-    }
-    visitTypeSignature(node) {
-        if (node.identifier.value === this.bindingName) {
-            if (node.body instanceof ParameterizedType) {
-                const actualType = node.body.returnType.toString();
-                if (actualType.replace(/\s+/g, " ").trim() ===
-                    this.typeName.replace(/\s+/g, " ").trim()) {
-                    throw new StopTraversalException();
-                }
-            }
-        }
-    }
-}
-export class Rescues extends TraverseVisitor {
-    exceptionName;
-    constructor(exceptionName) {
-        super();
-        this.exceptionName = exceptionName;
-    }
-    visitCatch(node) {
-        for (const pattern of node.patterns) {
-            if (pattern instanceof VariablePattern &&
-                pattern.name.value === this.exceptionName) {
-                throw new StopTraversalException();
-            }
-        }
-    }
-}
-export class UsesExceptionHandling extends TraverseVisitor {
-    visitTry(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesExceptions extends TraverseVisitor {
-    visitTry(node) {
-        throw new StopTraversalException();
-    }
-    visitRaise(node) {
-        throw new StopTraversalException();
-    }
-}
-export const genericInspections = {
-    Assigns: (node, args) => executeVisitor(node, new Assigns(args[0])),
-    Calls: (node, args) => executeVisitor(node, new Calls(args[0])),
-    Declares: (node, args) => executeVisitor(node, new Declares(args[0])),
-    DeclaresComputation: (node, args) => executeVisitor(node, new DeclaresComputation(args[0])),
-    DeclaresComputationWithArity: (node, args, binding) => executeVisitor(node, new DeclaresComputationWithArity(binding, Number(args[0]))),
-    DeclaresEntryPoint: (node, args) => executeVisitor(node, new DeclaresEntryPoint()),
-    DeclaresFunction: (node, args) => executeVisitor(node, new DeclaresFunction(args[0])),
-    DeclaresRecursively: (node, args) => executeVisitor(node, new DeclaresRecursively(args[0])),
-    DeclaresTypeAlias: (node, args) => executeVisitor(node, new DeclaresTypeAlias(args[0])),
-    DeclaresTypeSignature: (node, args) => executeVisitor(node, new DeclaresTypeSignature(args[0])),
-    DeclaresVariable: (node, args) => executeVisitor(node, new DeclaresVariable(args[0])),
-    Delegates: (ast, args) => {
-        const declares = genericInspections.Declares(ast, args);
-        const calls = genericInspections.Calls(ast, args);
-        return declares && calls;
-    },
-    Raises: (node, args) => executeVisitor(node, new Raises()),
-    Uses: (node, args) => executeVisitor(node, new Uses(args[0])),
-    UsesArithmetic: (node, args) => executeVisitor(node, new UsesArithmetic()),
-    SubordinatesDeclarationsTo: (node, args) => executeVisitor(node, new SubordinatesDeclarationsTo(args[0], args[1])),
-    SubordinatesDeclarationsToEntryPoint: (node, args) => executeVisitor(node, new SubordinatesDeclarationsToEntryPoint(args[0])),
-    TypesAs: (node, args) => executeVisitor(node, new TypesAs(args[0], args[1])),
-    TypesParameterAs: (node, args) => executeVisitor(node, new TypesParameterAs(args[0], Number(args[1]), args[2])),
-    TypesReturnAs: (node, args) => executeVisitor(node, new TypesReturnAs(args[0], args[1])),
-    UsesConditional: (node, args) => executeVisitor(node, new UsesConditional()),
-    Rescues: (node, args) => executeVisitor(node, new Rescues(args[0])),
-    UsesExceptionHandling: (node, args) => executeVisitor(node, new UsesExceptionHandling()),
-    UsesExceptions: (node, args) => executeVisitor(node, new UsesExceptions()),
-    UsesIf: (node, args) => executeVisitor(node, new UsesConditional()),
-    UsesLogic: (node, args) => executeVisitor(node, new UsesLogic()),
-    UsesMath: (node, args) => executeVisitor(node, new UsesArithmetic()),
-    UsesPrint: (node, args) => executeVisitor(node, new UsesPrint()),
-    UsesType: (node, args) => executeVisitor(node, new UsesType(args[0])),
-    HasBinding: (node, args) => executeVisitor(node, new HasBinding(args[0])),
-};

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

@@ -1,37 +0,0 @@
-import { Enumeration, ForLoop, Function, Procedure, Repeat, Switch, TraverseVisitor, While } from "@yukigo/ast";
-import { InspectionMap } from "../utils.js";
-export declare class BindingVisitor extends TraverseVisitor {
-    private readonly targetBinding;
-    protected isInsideTargetScope: boolean;
-    constructor(binding: string);
-    visitProcedure(node: Procedure): void;
-    visitFunction(node: Function): void;
-}
-export declare class DeclaresEnumeration extends TraverseVisitor {
-    private readonly enumName;
-    constructor(enumName: string);
-    visitEnumeration(node: Enumeration): void;
-}
-export declare class DeclaresProcedure extends TraverseVisitor {
-    private readonly procedureName;
-    constructor(procedureName: string);
-    visitProcedure(node: Procedure): void;
-}
-export declare class UsesForLoop extends BindingVisitor {
-    visitForLoop(node: ForLoop): void;
-}
-export declare class UsesWhile extends BindingVisitor {
-    visitWhile(node: While): void;
-}
-export declare class UsesRepeat extends BindingVisitor {
-    visitRepeat(node: Repeat): void;
-}
-export declare class UsesLoop extends BindingVisitor {
-    visitForLoop(node: ForLoop): void;
-    visitWhile(node: While): void;
-    visitRepeat(node: Repeat): void;
-}
-export declare class UsesSwitch extends BindingVisitor {
-    visitSwitch(node: Switch): void;
-}
-export declare const imperativeInspections: InspectionMap;

package/dist/analyzer/inspections/imperative.js

@@ -1,105 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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;