yukigo 0.1.0 → 0.2.0

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

@@ -0,0 +1,365 @@
+import {
+  Application,
+  ASTNode,
+  BooleanPrimitive,
+  Call,
+  Catch,
+  Equation,
+  Expression,
+  Function,
+  If,
+  LogicalBinaryOperation,
+  NilPrimitive,
+  Print,
+  Return,
+  Sequence,
+  StopTraversalException,
+  SymbolPrimitive,
+  Variable,
+  VariablePattern,
+} from "yukigo-ast";
+import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
+
+function isSequenceEmpty(node: Expression): boolean {
+  return node instanceof Sequence && node.statements.length === 0;
+}
+
+/**
+ * Basic Levenshtein distance for typo detection
+ */
+function getLevenshteinDistance(a: string, b: string): number {
+  const matrix: number[][] = [];
+  for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+  for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+@AutoScoped
+export class DiscardsExceptions extends ScopedVisitor {
+  visitCatch(node: Catch): void {
+    if (
+      !node.body ||
+      node.body instanceof NilPrimitive ||
+      isSequenceEmpty(node.body)
+    ) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class DoesConsolePrint extends ScopedVisitor {
+  visitPrint(node: Print): void {
+    throw new StopTraversalException();
+  }
+
+  visitCall(node: Call): void {
+    const name = node.callee.value;
+    if (this.isPrintFunc(name)) throw new StopTraversalException();
+  }
+
+  visitApplication(node: Application): void {
+    const func = node.functionExpr;
+    if (!(func instanceof SymbolPrimitive)) return func.accept(this);
+    const name = func.value;
+    if (this.isPrintFunc(name)) throw new StopTraversalException();
+  }
+  private isPrintFunc(name: string): boolean {
+    const printFuncs = [
+      "print",
+      "println",
+      "puts",
+      "log",
+      "console.log",
+      "System.out.println",
+      "fmt.Println",
+    ];
+    if (printFuncs.includes(name)) return true;
+    return false;
+  }
+}
+
+@AutoScoped
+export class HasDeclarationTypos extends ScopedVisitor {
+  /*
+   * Checks if two variables declared in the same scope are suspiciously similar
+   * (Levenshtein distance <= 2), indicating a possible typo (e.g., 'count' vs 'conut').
+   */
+  visitSequence(node: Sequence): void {
+    const declaredNames: string[] = [];
+
+    for (const stmt of node.statements) {
+      if (stmt instanceof Variable) declaredNames.push(stmt.identifier.value);
+    }
+
+    for (let i = 0; i < declaredNames.length; i++) {
+      for (let j = i + 1; j < declaredNames.length; j++) {
+        const a = declaredNames[i];
+        const b = declaredNames[j];
+        if (a.length > 3 && b.length > 3) {
+          if (getLevenshteinDistance(a, b) <= 2) {
+            throw new StopTraversalException();
+          }
+        }
+      }
+    }
+  }
+}
+
+@AutoScoped
+export class HasEmptyIfBranches extends ScopedVisitor {
+  visitIf(node: If): void {
+    const isThenEmpty = !node.then || isSequenceEmpty(node.then);
+    const isElseEmpty = node.elseExpr && isSequenceEmpty(node.elseExpr);
+    if (isThenEmpty || isElseEmpty) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasLongParameterList extends ScopedVisitor {
+  private readonly maxParams: number;
+
+  constructor(maxParams: number = 5, scope?: string) {
+    super(scope);
+    this.maxParams = Number(maxParams);
+  }
+
+  visitEquation(node: Equation): void {
+    const params = node.patterns;
+    if (params.length > this.maxParams) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasMisspelledIdentifiers extends ScopedVisitor {
+  private readonly dictionary: Set<string>;
+
+  constructor(dictionaryWords: string[] = [], scope?: string) {
+    super(scope);
+    // In a real app, load a standard dictionary + jargon here
+    this.dictionary = new Set(dictionaryWords.map((w) => w.toLowerCase()));
+  }
+
+  visitVariable(node: Variable): void {
+    this.checkSpelling(node.identifier.value);
+  }
+
+  visitFunction(node: Function): void {
+    this.checkSpelling(node.identifier.value);
+  }
+
+  private checkSpelling(word: string): void {
+    // Skip if no dictionary provided or word is very short
+    if (this.dictionary.size === 0 || word.length < 3) return;
+
+    // Naive camelCase splitter
+    const parts = word.split(/(?=[A-Z])|[-_]/);
+
+    for (const part of parts) {
+      if (!this.dictionary.has(part.toLowerCase()))
+        throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class HasRedundantBooleanComparison extends ScopedVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    const isLeftBool = node.left instanceof BooleanPrimitive;
+    const isRightBool = node.right instanceof BooleanPrimitive;
+    if (isLeftBool || isRightBool) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasRedundantIf extends ScopedVisitor {
+  visitIf(node: If): void {
+    if (node.elseExpr) {
+      const thenStmt = node.then;
+      const elseStmt = node.elseExpr;
+
+      if (thenStmt instanceof Sequence && elseStmt instanceof Sequence) {
+        // Check if returning booleans
+        if (
+          thenStmt.statements.some(
+            (stmt) => stmt instanceof BooleanPrimitive
+          ) &&
+          elseStmt.statements.some((stmt) => stmt instanceof BooleanPrimitive)
+        ) {
+          throw new StopTraversalException();
+        }
+      }
+    }
+  }
+}
+
+@AutoScoped
+export class HasRedundantLocalVariableReturn extends ScopedVisitor {
+  /*
+   * Detects:
+   * var x = something;
+   * return x;
+   */
+  visitSequence(node: Sequence): void {
+    const stmts = node.statements;
+    for (let i = 0; i < stmts.length - 1; i++) {
+      const stmt = stmts[i];
+      const nextStmt = stmts[i + 1];
+
+      if (stmt instanceof Variable && nextStmt instanceof Return) {
+        if (
+          nextStmt.body instanceof SymbolPrimitive &&
+          nextStmt.body.value === stmt.identifier.value
+        ) {
+          throw new StopTraversalException();
+        }
+      }
+    }
+  }
+}
+
+@AutoScoped
+export class HasTooShortIdentifiers extends ScopedVisitor {
+  private readonly minLength: number;
+
+  constructor(minLength: number = 3, scope?: string) {
+    super(scope);
+    this.minLength = Number(minLength);
+  }
+
+  visitVariable(node: Variable): void {
+    // exclude common counters
+    const allowed = ["i", "j", "k", "x", "y", "z", "id"];
+    const name = node.identifier.value;
+
+    if (name.length < this.minLength && !allowed.includes(name)) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class HasUsageTypos extends ScopedVisitor {
+  visitSequence(node: Sequence): void {
+    const declaredNames = new Set<string>();
+    const usedNames = new Set<string>();
+
+    for (const stmt of node.statements) {
+      if (stmt instanceof Function || stmt instanceof Variable) {
+        declaredNames.add(stmt.identifier.value);
+      }
+    }
+
+    for (const stmt of node.statements) {
+      if (stmt instanceof Call) usedNames.add(stmt.callee.value);
+    }
+
+    for (const usage of usedNames) {
+      if (!declaredNames.has(usage)) {
+        for (const decl of declaredNames) {
+          if (usage.length > 3 && getLevenshteinDistance(usage, decl) <= 1) {
+            throw new StopTraversalException();
+          }
+        }
+      }
+    }
+  }
+}
+
+@AutoScoped
+export class UsesWrongCaseBindings extends ScopedVisitor {
+  private readonly caseType: "camel" | "snake" | "pascal";
+
+  constructor(caseType: string = "camel", scopeName?: string) {
+    super(scopeName);
+    this.caseType = caseType as any;
+  }
+
+  visitSymbolPrimitive(node: SymbolPrimitive): void {
+    this.checkCase(node.value);
+  }
+
+  private checkCase(name: string): void {
+    // Ignore operators (names not starting with a letter or underscore)
+    if (!/^[a-zA-Z_]/.test(name)) return;
+
+    let regex: RegExp;
+
+    switch (this.caseType) {
+      case "snake":
+        regex = /^[a-z][a-z0-9_]*$/;
+        break;
+      case "pascal":
+        regex = /^[A-Z][a-zA-Z0-9]*$/;
+        break;
+      case "camel":
+      default:
+        regex = /^[a-z][a-zA-Z0-9]*$/;
+        break;
+    }
+
+    if (!regex.test(name)) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class IsLongCode extends ScopedVisitor {
+  private readonly maxStatements: number;
+
+  constructor(maxStatements: number = 50, scopeName?: string) {
+    super(scopeName);
+    this.maxStatements = Number(maxStatements);
+  }
+
+  visitSequence(node: Sequence): void {
+    if (node.statements.length > this.maxStatements) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class ShouldInvertIfCondition extends ScopedVisitor {
+  visitIf(node: If): void {
+    const thenEmpty = !node.then || isSequenceEmpty(node.then);
+    const elseNonEmpty = node.elseExpr && !isSequenceEmpty(node.elseExpr);
+
+    if (thenEmpty && elseNonEmpty) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+export const genericSmells: Record<string, VisitorConstructor> = {
+  DiscardsExceptions: DiscardsExceptions,
+  DoesConsolePrint: DoesConsolePrint,
+  HasDeclarationTypos: HasDeclarationTypos,
+  HasEmptyIfBranches: HasEmptyIfBranches,
+  HasLongParameterList: HasLongParameterList,
+  HasMisspelledIdentifiers: HasMisspelledIdentifiers,
+  HasRedundantBooleanComparison: HasRedundantBooleanComparison,
+  HasRedundantIf: HasRedundantIf,
+  HasRedundantLocalVariableReturn: HasRedundantLocalVariableReturn,
+  HasTooShortIdentifiers: HasTooShortIdentifiers,
+  HasUsageTypos: HasUsageTypos,
+  HasWrongCaseIdentifiers: UsesWrongCaseBindings,
+  UsesWrongCaseBindings: UsesWrongCaseBindings,
+  IsLongCode: IsLongCode,
+  ShouldInvertIfCondition: ShouldInvertIfCondition,
+};

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

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

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

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

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

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

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

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