yukigo 0.1.0

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

@@ -0,0 +1,151 @@
+import { ArithmeticBinaryOperation, ArithmeticUnaryOperation, Assignment, ASTNode, Attribute, Call, Catch, EntryPoint, Fact, Function, If, LogicalBinaryOperation, LogicalUnaryOperation, Method, Print, Procedure, Raise, Record as RecordNode, Rule, SimpleType, SymbolPrimitive, TraverseVisitor, Try, TypeAlias, TypeSignature, TypeVar, Variable } from "@yukigo/ast";
+import { InspectionMap } from "../utils.js";
+export declare class Assigns extends TraverseVisitor {
+    private readonly targetIdentifier;
+    constructor(targetIdentifier: string);
+    visitVariable(node: Variable): void;
+    visitAttribute(node: Attribute): void;
+    visitAssignment(node: Assignment): void;
+}
+export declare class Calls extends TraverseVisitor {
+    private readonly targetCallee;
+    constructor(targetCallee: string);
+    visitCall(node: Call): void;
+}
+export declare class Declares extends TraverseVisitor {
+    private readonly targetIdentifier;
+    constructor(targetIdentifier: string);
+    visit(node: ASTNode): void;
+}
+export declare class DeclaresComputation extends TraverseVisitor {
+    private readonly callName;
+    constructor(callName: string);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresComputationWithArity extends TraverseVisitor {
+    private readonly targetBinding;
+    private readonly targetArity;
+    constructor(targetBinding: string, targetArity: number);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+}
+export declare class DeclaresEntryPoint extends TraverseVisitor {
+    visitEntryPoint(node: EntryPoint): void;
+}
+export declare class DeclaresFunction extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitFunction(node: Function): void;
+}
+export declare class DeclaresRecursively extends DeclaresComputation {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitFact(node: Fact): void;
+    visitRule(node: Rule): void;
+    visitNested(node: ASTNode): void;
+}
+export declare class DeclaresTypeAlias extends TraverseVisitor {
+    private readonly typeAliasName;
+    constructor(typeAliasName: string);
+    visitTypeAlias(node: TypeAlias): void;
+}
+export declare class DeclaresTypeSignature extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class DeclaresVariable extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitVariable(node: Variable): void;
+}
+export declare class Raises extends TraverseVisitor {
+    visitRaise(node: Raise): void;
+}
+export declare class Uses extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitSymbolPrimitive(node: SymbolPrimitive): void;
+}
+export declare class UsesArithmetic extends TraverseVisitor {
+    visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void;
+    visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void;
+}
+export declare class UsesConditional extends TraverseVisitor {
+    visitIf(node: If): void;
+}
+export declare class UsesLogic extends TraverseVisitor {
+    visitLogicalBinaryOperation(node: LogicalBinaryOperation): void;
+    visitLogicalUnaryOperation(node: LogicalUnaryOperation): void;
+}
+export declare class UsesPrint extends TraverseVisitor {
+    visitPrint(node: Print): void;
+}
+export declare class UsesType extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitTypeSignature(node: TypeSignature): void;
+    visitSimpleType(node: SimpleType): void;
+    visitTypeVar(node: TypeVar): void;
+}
+export declare class HasBinding extends TraverseVisitor {
+    private readonly targetBinding;
+    constructor(targetBinding: string);
+    visitFunction(node: Function): void;
+    visitTypeAlias(node: TypeAlias): void;
+    visitTypeSignature(node: TypeSignature): void;
+    visitRecord(node: RecordNode): void;
+}
+export declare class SubordinatesDeclarationsTo extends TraverseVisitor {
+    private childName;
+    private parentName;
+    constructor(childName: string, parentName: string);
+    visitFunction(node: Function): void;
+}
+export declare class SubordinatesDeclarationsToEntryPoint extends TraverseVisitor {
+    private childName;
+    constructor(childName: string);
+    visitEntryPoint(node: EntryPoint): void;
+}
+export declare class TypesAs extends TraverseVisitor {
+    private bindingName;
+    private typeName;
+    constructor(bindingName: string, typeName: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class TypesParameterAs extends TraverseVisitor {
+    private bindingName;
+    private paramIndex;
+    private typeName;
+    constructor(bindingName: string, paramIndex: number, typeName: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class TypesReturnAs extends TraverseVisitor {
+    private bindingName;
+    private typeName;
+    constructor(bindingName: string, typeName: string);
+    visitTypeSignature(node: TypeSignature): void;
+}
+export declare class Rescues extends TraverseVisitor {
+    private exceptionName;
+    constructor(exceptionName: string);
+    visitCatch(node: Catch): void;
+}
+export declare class UsesExceptionHandling extends TraverseVisitor {
+    visitTry(node: Try): void;
+}
+export declare class UsesExceptions extends TraverseVisitor {
+    visitTry(node: Try): void;
+    visitRaise(node: Raise): void;
+}
+export declare const genericInspections: InspectionMap;

package/dist/analyzer/inspections/generic.js

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

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