yukigo 0.1.0

package/src/analyzer/inspections/generic.ts

@@ -0,0 +1,499 @@
+import {
+  ArithmeticBinaryOperation,
+  ArithmeticUnaryOperation,
+  Assignment,
+  AST,
+  ASTNode,
+  Attribute,
+  Call,
+  Catch,
+  ConstructorPattern,
+  EntryPoint,
+  Fact,
+  Function,
+  If,
+  ListType,
+  LogicalBinaryOperation,
+  LogicalUnaryOperation,
+  Method,
+  ParameterizedType,
+  Print,
+  Procedure,
+  Raise,
+  Record as RecordNode,
+  Rule,
+  SimpleType,
+  StopTraversalException,
+  SymbolPrimitive,
+  TraverseVisitor,
+  Try,
+  TupleType,
+  Type,
+  TypeAlias,
+  TypeApplication,
+  TypeSignature,
+  TypeVar,
+  Variable,
+  VariablePattern,
+} from "yukigo-ast";
+import { InspectionMap, executeVisitor } from "../utils.js";
+
+export class Assigns extends TraverseVisitor {
+  private readonly targetIdentifier: string;
+  constructor(targetIdentifier: string) {
+    super();
+    this.targetIdentifier = targetIdentifier;
+  }
+  visitVariable(node: Variable): void {
+    if (node.identifier.value === this.targetIdentifier)
+      throw new StopTraversalException();
+  }
+  visitAttribute(node: Attribute): void {
+    if (node.identifier.value === this.targetIdentifier)
+      throw new StopTraversalException();
+  }
+  visitAssignment(node: Assignment): void {
+    if (node.identifier.value === this.targetIdentifier)
+      throw new StopTraversalException();
+  }
+}
+export class Calls extends TraverseVisitor {
+  private readonly targetCallee: string;
+  constructor(targetCallee: string) {
+    super();
+    this.targetCallee = targetCallee;
+  }
+  visitCall(node: Call): void {
+    if (node.callee.value === this.targetCallee)
+      throw new StopTraversalException();
+  }
+}
+export class Declares extends TraverseVisitor {
+  private readonly targetIdentifier: string;
+  constructor(targetIdentifier: string) {
+    super();
+    this.targetIdentifier = targetIdentifier;
+  }
+  visit(node: ASTNode): void {
+    if (
+      "identifier" in node &&
+      node.identifier instanceof SymbolPrimitive &&
+      node.identifier.value === this.targetIdentifier
+    )
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresComputation extends TraverseVisitor {
+  private readonly callName: string;
+  constructor(callName: string) {
+    super();
+    this.callName = callName;
+  }
+  visitFunction(node: Function): void {
+    if (node.identifier.value === this.callName)
+      throw new StopTraversalException();
+  }
+  visitMethod(node: Method): void {
+    if (node.identifier.value === this.callName)
+      throw new StopTraversalException();
+  }
+  visitProcedure(node: Procedure): void {
+    if (node.identifier.value === this.callName)
+      throw new StopTraversalException();
+  }
+  visitFact(node: Fact): void {
+    if (node.identifier.value === this.callName)
+      throw new StopTraversalException();
+  }
+  visitRule(node: Rule): void {
+    if (node.identifier.value === this.callName)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresComputationWithArity extends TraverseVisitor {
+  private readonly targetBinding: string;
+  private readonly targetArity: number;
+  constructor(targetBinding: string, targetArity: number) {
+    super();
+    this.targetBinding = targetBinding;
+    this.targetArity = targetArity;
+  }
+  visitFunction(node: Function): void {
+    if (
+      node.identifier.value === this.targetBinding &&
+      node.equations.some((eq) => eq.patterns.length === this.targetArity)
+    )
+      throw new StopTraversalException();
+  }
+  visitMethod(node: Method): void {
+    if (
+      node.identifier.value === this.targetBinding &&
+      node.equations.some((eq) => eq.patterns.length === this.targetArity)
+    )
+      throw new StopTraversalException();
+  }
+  visitProcedure(node: Procedure): void {
+    if (
+      node.identifier.value === this.targetBinding &&
+      node.equations.some((eq) => eq.patterns.length === this.targetArity)
+    )
+      throw new StopTraversalException();
+  }
+  visitFact(node: Fact): void {
+    if (
+      node.identifier.value === this.targetBinding &&
+      node.patterns.length === this.targetArity
+    )
+      throw new StopTraversalException();
+  }
+  visitRule(node: Rule): void {
+    if (
+      node.identifier.value === this.targetBinding &&
+      node.patterns.length === this.targetArity
+    )
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresEntryPoint extends TraverseVisitor {
+  visitEntryPoint(node: EntryPoint): void {
+    throw new StopTraversalException();
+  }
+}
+export class DeclaresFunction extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitFunction(node: Function): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+
+export class DeclaresRecursively extends DeclaresComputation {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super(targetBinding);
+    this.targetBinding = targetBinding;
+  }
+  visitFunction(node: Function): void {
+    super.visitFunction(node);
+    this.visitNested(node);
+  }
+  visitMethod(node: Method): void {
+    super.visitMethod(node);
+    this.visitNested(node);
+  }
+  visitProcedure(node: Procedure): void {
+    super.visitProcedure(node);
+    this.visitNested(node);
+  }
+  visitFact(node: Fact): void {
+    super.visitFact(node);
+    this.visitNested(node);
+  }
+  visitRule(node: Rule): void {
+    super.visitRule(node);
+    this.visitNested(node);
+  }
+  visitNested(node: ASTNode): void {
+    if (
+      "identifier" in node &&
+      node.identifier instanceof SymbolPrimitive &&
+      node.identifier.value === this.targetBinding
+    )
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresTypeAlias extends TraverseVisitor {
+  private readonly typeAliasName: string;
+  constructor(typeAliasName: string) {
+    super();
+    this.typeAliasName = typeAliasName;
+  }
+  visitTypeAlias(node: TypeAlias): void {
+    if (node.identifier.value === this.typeAliasName)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresTypeSignature extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitTypeSignature(node: TypeSignature): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresVariable extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitVariable(node: Variable): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+export class Raises extends TraverseVisitor {
+  visitRaise(node: Raise): void {
+    throw new StopTraversalException();
+  }
+}
+export class Uses extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitSymbolPrimitive(node: SymbolPrimitive): void {
+    if (node.value === this.targetBinding) throw new StopTraversalException();
+  }
+}
+export class UsesArithmetic extends TraverseVisitor {
+  visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void {
+    throw new StopTraversalException();
+  }
+  visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesConditional extends TraverseVisitor {
+  visitIf(node: If): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesLogic extends TraverseVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    throw new StopTraversalException();
+  }
+  visitLogicalUnaryOperation(node: LogicalUnaryOperation): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesPrint extends TraverseVisitor {
+  visitPrint(node: Print): void {
+    throw new StopTraversalException();
+  }
+}
+export class UsesType extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitTypeSignature(node: TypeSignature): void {
+    node.body.accept(this);
+  }
+  visitSimpleType(node: SimpleType): void {
+    if (node.value === this.targetBinding) throw new StopTraversalException();
+  }
+  visitTypeVar(node: TypeVar): void {
+    if (node.value === this.targetBinding) throw new StopTraversalException();
+  }
+}
+export class HasBinding extends TraverseVisitor {
+  private readonly targetBinding: string;
+  constructor(targetBinding: string) {
+    super();
+    this.targetBinding = targetBinding;
+  }
+  visitFunction(node: Function): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+  visitTypeAlias(node: TypeAlias): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+  visitTypeSignature(node: TypeSignature): void {
+    if (node.identifier.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+  visitRecord(node: RecordNode): void {
+    if (node.name.value === this.targetBinding)
+      throw new StopTraversalException();
+  }
+}
+
+export class SubordinatesDeclarationsTo extends TraverseVisitor {
+  constructor(private childName: string, private parentName: string) {
+    super();
+  }
+
+  visitFunction(node: Function): void {
+    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 {
+  constructor(private childName: string) {
+    super();
+  }
+
+  visitEntryPoint(node: EntryPoint): void {
+    const childFinder = new Declares(this.childName);
+    node.expression.statements.forEach((stmt) => stmt.accept(childFinder));
+  }
+}
+
+export class TypesAs extends TraverseVisitor {
+  constructor(private bindingName: string, private typeName: string) {
+    super();
+  }
+
+  visitTypeSignature(node: TypeSignature): void {
+    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 {
+  constructor(
+    private bindingName: string,
+    private paramIndex: number,
+    private typeName: string
+  ) {
+    super();
+  }
+
+  visitTypeSignature(node: TypeSignature): void {
+    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 {
+  constructor(private bindingName: string, private typeName: string) {
+    super();
+  }
+
+  visitTypeSignature(node: TypeSignature): void {
+    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 {
+  constructor(private exceptionName: string) {
+    super();
+  }
+  visitCatch(node: Catch): void {
+    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: Try): void {
+    throw new StopTraversalException();
+  }
+}
+
+export class UsesExceptions extends TraverseVisitor {
+  visitTry(node: Try): void {
+    throw new StopTraversalException();
+  }
+  visitRaise(node: Raise): void {
+    throw new StopTraversalException();
+  }
+}
+
+export const genericInspections: InspectionMap = {
+  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/src/analyzer/inspections/imperative.ts

@@ -0,0 +1,129 @@
+import {
+  Enumeration,
+  ForLoop,
+  Function,
+  Procedure,
+  Repeat,
+  StopTraversalException,
+  Switch,
+  TraverseVisitor,
+  While,
+} from "yukigo-ast";
+import { InspectionMap, executeVisitor } from "../utils.js";
+
+export class BindingVisitor extends TraverseVisitor {
+  private readonly targetBinding: string;
+  protected isInsideTargetScope: boolean = false; // this flag helps to check nested functions inside the targetBinding scope
+  constructor(binding: string) {
+    super();
+    this.targetBinding = binding;
+  }
+  visitProcedure(node: Procedure): void {
+    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: Function): void {
+    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 {
+  private readonly enumName: string;
+  constructor(enumName: string) {
+    super();
+    this.enumName = enumName;
+  }
+  visitEnumeration(node: Enumeration): void {
+    if (node.identifier.value === this.enumName) throw StopTraversalException;
+  }
+}
+export class DeclaresProcedure extends TraverseVisitor {
+  private readonly procedureName: string;
+  constructor(procedureName: string) {
+    super();
+    this.procedureName = procedureName;
+  }
+  visitProcedure(node: Procedure): void {
+    if (node.identifier.value === this.procedureName)
+      throw StopTraversalException;
+  }
+}
+export class UsesForLoop extends BindingVisitor {
+  visitForLoop(node: ForLoop): void {
+    throw StopTraversalException;
+  }
+}
+export class UsesWhile extends BindingVisitor {
+  visitWhile(node: While): void {
+    throw StopTraversalException;
+  }
+}
+export class UsesRepeat extends BindingVisitor {
+  visitRepeat(node: Repeat): void {
+    throw StopTraversalException;
+  }
+}
+export class UsesLoop extends BindingVisitor {
+  visitForLoop(node: ForLoop): void {
+    throw StopTraversalException;
+  }
+  visitWhile(node: While): void {
+    throw StopTraversalException;
+  }
+  visitRepeat(node: Repeat): void {
+    throw StopTraversalException;
+  }
+  // visitForEach(node: ForEach): void {
+  //   throw StopTraversalException;
+  // }
+}
+export class UsesSwitch extends BindingVisitor {
+  visitSwitch(node: Switch): void {
+    throw StopTraversalException;
+  }
+}
+
+export const imperativeInspections: InspectionMap = {
+  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)),
+};