yukigo 0.2.3 → 0.3.2

package/src/analyzer/inspections/imperative/imperative.ts

@@ -1,101 +1,104 @@
-import {
-  Enumeration,
-  ForLoop,
-  Function,
-  Procedure,
-  Repeat,
-  StopTraversalException,
-  Switch,
-  TraverseVisitor,
-  While,
-} from "yukigo-ast";
-import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
-
-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 new StopTraversalException();
-  }
-}
-@AutoScoped
-export class DeclaresProcedure extends ScopedVisitor {
-  private readonly procedureName: string;
-  constructor(procedureName: string, scope?: string) {
-    super(scope);
-    this.procedureName = procedureName;
-  }
-  visitProcedure(node: Procedure): void {
-    if (node.identifier.value === this.procedureName)
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class UsesForLoop extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitForLoop(node: ForLoop): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesWhile extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitWhile(node: While): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesRepeat extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitRepeat(node: Repeat): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesLoop extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitForLoop(node: ForLoop): void {
-    throw new StopTraversalException();
-  }
-  visitWhile(node: While): void {
-    throw new StopTraversalException();
-  }
-  visitRepeat(node: Repeat): void {
-    throw new StopTraversalException();
-  }
-  // visitForEach(node: ForEach): void {
-  //   throw StopTraversalException;
-  // }
-}
-@AutoScoped
-export class UsesSwitch extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitSwitch(node: Switch): void {
-    throw new StopTraversalException();
-  }
-}
-
-export const imperativeInspections: Record<string, VisitorConstructor> = {
-  DeclaresEnumeration: DeclaresEnumeration,
-  DeclaresProcedure: DeclaresProcedure,
-  UsesForLoop: UsesForLoop,
-  UsesRepeat: UsesRepeat,
-  UsesWhile: UsesWhile,
-  UsesLoop: UsesLoop,
-  UsesSwitch: UsesSwitch,
-};
+import {
+  Enumeration,
+  ForLoop,
+  Procedure,
+  Repeat,
+  StopTraversalException,
+  Switch,
+  While,
+} from "yukigo-ast";
+import {
+  AutoScoped,
+  ScopedVisitor,
+  VisitorConstructor,
+  InspectionVisitor,
+} from "../../utils.js";
+
+export class DeclaresEnumeration extends InspectionVisitor {
+  private readonly enumName: string;
+  constructor(enumName: string) {
+    super();
+    this.enumName = enumName;
+  }
+  visitEnumeration(node: Enumeration): void {
+    if (node.identifier.value === this.enumName)
+      throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class DeclaresProcedure extends ScopedVisitor {
+  private readonly procedureName: string;
+  constructor(procedureName: string, scope?: string) {
+    super(scope);
+    this.procedureName = procedureName;
+  }
+  visitProcedure(node: Procedure): void {
+    if (node.identifier.value === this.procedureName)
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class UsesForLoop extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitForLoop(node: ForLoop): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesWhile extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitWhile(node: While): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesRepeat extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitRepeat(node: Repeat): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesLoop extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitForLoop(node: ForLoop): void {
+    throw new StopTraversalException();
+  }
+  visitWhile(node: While): void {
+    throw new StopTraversalException();
+  }
+  visitRepeat(node: Repeat): void {
+    throw new StopTraversalException();
+  }
+  // visitForEach(node: ForEach): void {
+  //   throw StopTraversalException;
+  // }
+}
+@AutoScoped
+export class UsesSwitch extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitSwitch(node: Switch): void {
+    throw new StopTraversalException();
+  }
+}
+
+export const imperativeInspections: Record<string, VisitorConstructor> = {
+  DeclaresEnumeration: DeclaresEnumeration,
+  DeclaresProcedure: DeclaresProcedure,
+  UsesForLoop: UsesForLoop,
+  UsesRepeat: UsesRepeat,
+  UsesWhile: UsesWhile,
+  UsesLoop: UsesLoop,
+  UsesSwitch: UsesSwitch,
+};

package/src/analyzer/inspections/imperative/smells.ts

@@ -1,54 +1,58 @@
-import {
-  Assignment,
-  If,
-  NumberPrimitive,
-  Repeat,
-  Return,
-  Sequence,
-  StopTraversalException,
-  While,
-} from "yukigo-ast";
-import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
-
-@AutoScoped
-export class HasAssignmentCondition extends ScopedVisitor {
-  visitIf(node: If): void {
-    if (node.condition instanceof Assignment)
-      throw new StopTraversalException();
-  }
-  visitWhile(node: While): void {
-    if (node.condition instanceof Assignment)
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class HasAssignmentReturn extends ScopedVisitor {
-  visitReturn(node: Return): void {
-    if (node.body && node.body instanceof Assignment)
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class HasEmptyRepeat extends ScopedVisitor {
-  visitRepeat(node: Repeat): void {
-    if (node.body instanceof Sequence && node.body.statements.length === 0)
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class HasRedundantRepeat extends ScopedVisitor {
-  visitRepeat(node: Repeat): void {
-    if (node.count instanceof NumberPrimitive && node.count.value === 1)
-      throw new StopTraversalException();
-  }
-}
-
-export const imperativeSmells: Record<string, VisitorConstructor> = {
-  HasAssignmentCondition: HasAssignmentCondition,
-  HasAssignmentReturn: HasAssignmentReturn,
-  HasEmptyRepeat: HasEmptyRepeat,
-  HasRedundantRepeat: HasRedundantRepeat,
-};
+import {
+  Assignment,
+  Expression,
+  If,
+  NumberPrimitive,
+  Repeat,
+  Return,
+  Sequence,
+  StopTraversalException,
+  While,
+} from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
+
+@AutoScoped
+export class HasAssignmentCondition extends ScopedVisitor {
+  visitIf(node: If): void {
+    if (this.isConditionAssignment(node.condition))
+      throw new StopTraversalException();
+  }
+  visitWhile(node: While): void {
+    if (this.isConditionAssignment(node.condition))
+      throw new StopTraversalException();
+  }
+  private isConditionAssignment(node: Expression) {
+    return node.is(Assignment);
+  }
+}
+
+@AutoScoped
+export class HasAssignmentReturn extends ScopedVisitor {
+  visitReturn(node: Return): void {
+    if (node.body && node.body.is(Assignment))
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasEmptyRepeat extends ScopedVisitor {
+  visitRepeat(node: Repeat): void {
+    if (node.body.is(Sequence) && node.body.statements.length === 0)
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasRedundantRepeat extends ScopedVisitor {
+  visitRepeat(node: Repeat): void {
+    if (node.count.is(NumberPrimitive) && node.count.value === 1)
+      throw new StopTraversalException();
+  }
+}
+
+export const imperativeSmells: Record<string, VisitorConstructor> = {
+  HasAssignmentCondition: HasAssignmentCondition,
+  HasAssignmentReturn: HasAssignmentReturn,
+  HasEmptyRepeat: HasEmptyRepeat,
+  HasRedundantRepeat: HasRedundantRepeat,
+};

package/src/analyzer/inspections/logic/logic.ts

@@ -1,90 +1,84 @@
-import {
-  Assignment,
-  AssignOperation,
-  Exist,
-  Fact,
-  Findall,
-  Forall,
-  Not,
-  Rule,
-  StopTraversalException,
-  SymbolPrimitive,
-  TraverseVisitor,
-  UnifyOperation,
-} from "yukigo-ast";
-import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
-import { isYukigoPrimitive } from "yukigo-ast";
-
-export class DeclaresFact extends TraverseVisitor {
-  constructor(private readonly target?: string) {
-    super();
-  }
-  visitFact(node: Fact): void {
-    const bindingName = node.identifier.value;
-    if (!this.target || bindingName === this.target)
-      throw new StopTraversalException();
-  }
-}
-export class DeclaresRule extends TraverseVisitor {
-  constructor(private readonly target?: string) {
-    super();
-  }
-  visitRule(node: Rule): void {
-    const bindingName = node.identifier.value;
-    if (!this.target || bindingName === this.target)
-      throw new StopTraversalException();
-  }
-}
-export class DeclaresPredicate extends TraverseVisitor {
-  constructor(private readonly target?: string) {
-    super();
-  }
-  visitFact(node: Fact): void {
-    new DeclaresFact(this.target).visitFact(node);
-  }
-  visitRule(node: Rule): void {
-    new DeclaresRule(this.target).visitRule(node);
-  }
-}
-@AutoScoped
-export class UsesFindall extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitFindall(node: Findall): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesForall extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitForall(node: Forall): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesNot extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitNot(node: Not): void {
-    throw new StopTraversalException();
-  }
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "not") throw new StopTraversalException();
-  }
-}
-
-export const logicInspections: Record<string, VisitorConstructor> = {
-  DeclaresFact: DeclaresFact,
-  DeclaresRule: DeclaresRule,
-  DeclaresPredicate: DeclaresPredicate,
-  UsesFindall: UsesFindall,
-  HasFindall: UsesFindall,
-  UsesForall: UsesForall,
-  HasForall: UsesForall,
-  UsesNot: UsesNot,
-  HasNot: UsesNot,
-};
+import {
+  Exist,
+  Fact,
+  Findall,
+  Forall,
+  Not,
+  Rule,
+  StopTraversalException,
+} from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, VisitorConstructor, InspectionVisitor } from "../../utils.js";
+
+export class DeclaresFact extends InspectionVisitor {
+  constructor(private readonly target?: string) {
+    super();
+  }
+  visitFact(node: Fact): void {
+    const bindingName = node.identifier.value;
+    if (!this.target || bindingName === this.target)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresRule extends InspectionVisitor {
+  constructor(private readonly target?: string) {
+    super();
+  }
+  visitRule(node: Rule): void {
+    const bindingName = node.identifier.value;
+    if (!this.target || bindingName === this.target)
+      throw new StopTraversalException();
+  }
+}
+export class DeclaresPredicate extends InspectionVisitor {
+  constructor(private readonly target?: string) {
+    super();
+  }
+  visitFact(node: Fact): void {
+    new DeclaresFact(this.target).visitFact(node);
+  }
+  visitRule(node: Rule): void {
+    new DeclaresRule(this.target).visitRule(node);
+  }
+}
+@AutoScoped
+export class UsesFindall extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitFindall(node: Findall): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesForall extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitForall(node: Forall): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesNot extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitNot(node: Not): void {
+    throw new StopTraversalException();
+  }
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "not") throw new StopTraversalException();
+  }
+}
+
+export const logicInspections: Record<string, VisitorConstructor> = {
+  DeclaresFact: DeclaresFact,
+  DeclaresRule: DeclaresRule,
+  DeclaresPredicate: DeclaresPredicate,
+  UsesFindall: UsesFindall,
+  HasFindall: UsesFindall,
+  UsesForall: UsesForall,
+  HasForall: UsesForall,
+  UsesNot: UsesNot,
+  HasNot: UsesNot,
+};

package/src/analyzer/inspections/logic/smells.ts

@@ -1,54 +1,54 @@
-import {
-  AssignOperation,
-  Exist,
-  isYukigoPrimitive,
-  Rule,
-  StopTraversalException,
-  SymbolPrimitive,
-  UnifyOperation,
-} from "yukigo-ast";
-import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
-
-@AutoScoped
-export class HasRedundantReduction extends ScopedVisitor {
-  visitAssignOperation(node: AssignOperation): void {
-    const left = node.left;
-    const right = node.right;
-
-    if (!(left instanceof SymbolPrimitive)) return;
-
-    const redundantReductionParameters = isYukigoPrimitive(right);
-    const redundantReductionFunctors = right instanceof Exist;
-
-    const isRedundant =
-      redundantReductionParameters || redundantReductionFunctors;
-
-    if (isRedundant) throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class UsesUnificationOperator extends ScopedVisitor {
-  visitUnifyOperation(node: UnifyOperation): void {
-    throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesCut extends ScopedVisitor {
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "!") throw new StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesFail extends ScopedVisitor {
-  visitExist(node: Exist): void {
-    if (node.identifier.value === "fail") throw new StopTraversalException();
-  }
-}
-
-export const logicSmells: Record<string, VisitorConstructor> = {
-  HasRedundantReduction: HasRedundantReduction,
-  UsesCut: UsesCut,
-  UsesFail: UsesFail,
-  UsesUnificationOperator: UsesUnificationOperator,
-};
+import {
+  AssignOperation,
+  Exist,
+  isYukigoPrimitive,
+  Rule,
+  StopTraversalException,
+  SymbolPrimitive,
+  UnifyOperation,
+} from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
+
+@AutoScoped
+export class HasRedundantReduction extends ScopedVisitor {
+  visitAssignOperation(node: AssignOperation): void {
+    const left = node.left;
+    const right = node.right;
+
+    if (!left.is(SymbolPrimitive)) return;
+
+    const redundantReductionParameters = isYukigoPrimitive(right);
+    const redundantReductionFunctors = right.is(Exist);
+
+    const isRedundant =
+      redundantReductionParameters || redundantReductionFunctors;
+
+    if (isRedundant) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class UsesUnificationOperator extends ScopedVisitor {
+  visitUnifyOperation(node: UnifyOperation): void {
+    throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesCut extends ScopedVisitor {
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "!") throw new StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesFail extends ScopedVisitor {
+  visitExist(node: Exist): void {
+    if (node.identifier.value === "fail") throw new StopTraversalException();
+  }
+}
+
+export const logicSmells: Record<string, VisitorConstructor> = {
+  HasRedundantReduction: HasRedundantReduction,
+  UsesCut: UsesCut,
+  UsesFail: UsesFail,
+  UsesUnificationOperator: UsesUnificationOperator,
+};