yukigo 0.1.0 → 0.2.0

package/dist/analyzer/index.js

@@ -1,19 +1,33 @@
-import { genericInspections } from "./inspections/generic.js";
-import { functionalInspections } from "./inspections/functional.js";
-import { logicInspections } from "./inspections/logic.js";
-import { objectInspections } from "./inspections/object.js";
-import { imperativeInspections } from "./inspections/imperative.js";
-export const defaultInspectionSet = {
+import { StopTraversalException } from "yukigo-ast";
+import { genericInspections } from "./inspections/generic/generic.js";
+import { functionalInspections } from "./inspections/functional/functional.js";
+import { logicInspections } from "./inspections/logic/logic.js";
+import { objectInspections } from "./inspections/object/object.js";
+import { imperativeInspections } from "./inspections/imperative/imperative.js";
+import { functionalSmells } from "./inspections/functional/smells.js";
+import { logicSmells } from "./inspections/logic/smells.js";
+import { objectSmells } from "./inspections/object/smells.js";
+import { imperativeSmells } from "./inspections/imperative/smells.js";
+import { genericSmells } from "./inspections/generic/smells.js";
+import { GraphBuilder } from "./GraphBuilder.js";
+export const DefaultInspectionSet = {
     ...genericInspections,
     ...functionalInspections,
     ...logicInspections,
     ...objectInspections,
     ...imperativeInspections,
 };
+export const DefaultSmellsSet = {
+    ...genericSmells,
+    ...functionalSmells,
+    ...logicSmells,
+    ...objectSmells,
+    ...imperativeSmells,
+};
 /**
  * The Analyzer class.
  * @remarks
- * The Analyzer is the part of Yukigo which runs the inspections on the AST.
+ * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
  */
 export class Analyzer {
     /**
@@ -21,30 +35,19 @@ export class Analyzer {
      * You can load your set of inspections or leave the default one.
      * @defaultValue a default set of inspections for each supported paradigm
      */
-    inspectionHandlers = {};
-    constructor(inspectionSet) {
-        this.inspectionHandlers = inspectionSet ?? defaultInspectionSet;
+    inspectionConstructors = {};
+    smellsConstructors = {};
+    constructor(inspectionSet, smellsSet) {
+        this.inspectionConstructors = inspectionSet ?? DefaultInspectionSet;
+        this.smellsConstructors = smellsSet ?? DefaultSmellsSet;
     }
     /**
      * Registers a new custom inspection handler after Analyzer was instantiated.
      * @param name The name of the inspection (e.g., "HasArithmetic").
-     * @param handler The function that implements the inspection logic.
-     *
-     * @example
-     * // Implementation of HasArithmetic inspection
-     * export class UsesArithmetic extends TraverseVisitor {
-     *  visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void {
-     *    throw new StopTraversalException();
-     *  }
-     *  visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void {
-     *    throw new StopTraversalException();
-     *  }
-     * }
-     * const analyzer = new ASTAnalyzer(ast);
-     * analyzer.registerInspection("HasArithmetic", (node, args) => executeVisitor(node, new UsesArithmetic()));
+     * @param visitorConstructor The constructor for the TraverseVisitor class.
      */
-    registerInspection(name, handler) {
-        this.inspectionHandlers[name] = handler;
+    registerInspection(name, visitorConstructor) {
+        this.inspectionConstructors[name] = visitorConstructor;
     }
     /**
      * Runs a list of inspection rules against the AST.
@@ -68,43 +71,82 @@ export class Analyzer {
      * const analysisResults = analyzer.analyze(expectations);
      */
     analyze(ast, rules) {
-        const results = [];
+        const ruleResults = new Map();
+        const graphBuilder = new GraphBuilder();
+        const { defs, calls } = graphBuilder.build(ast);
         for (const rule of rules) {
-            results.push(this.runRule(rule, ast));
-        }
-        return results;
-    }
-    runRule(rule, ast) {
-        const inspection = this.inspectionHandlers[rule.inspection];
-        if (!inspection)
-            return {
-                rule,
-                passed: false,
-                actual: false,
-                error: "Unknown inspection",
-            };
-        try {
-            let result = false;
-            for (const node of ast) {
-                if (inspection(node, rule.args, rule.binding)) {
-                    result = true;
-                    break;
+            let inspectionName = rule.inspection;
+            let isTransitive = true;
+            if (inspectionName.startsWith("Intransitive:")) {
+                isTransitive = false;
+                inspectionName = inspectionName.replace("Intransitive:", "");
+            }
+            const InspectionClass = this.inspectionConstructors[inspectionName];
+            if (!InspectionClass) {
+                ruleResults.set(rule, {
+                    rule,
+                    passed: false,
+                    actual: false,
+                    error: "Unknown inspection: " + inspectionName,
+                });
+                continue;
+            }
+            if (InspectionClass.IS_INTRANSITIVE)
+                isTransitive = false;
+            let targets = [];
+            // Case 1: Global Inspection (No binding or wildcard)
+            if (!rule.binding || rule.binding === "*") {
+                targets = ast.map((n) => ({ node: n, binding: undefined }));
+            }
+            // Case 2: Directed Inspection (Specific binding)
+            else {
+                const workList = [rule.binding];
+                const visited = new Set();
+                while (workList.length > 0) {
+                    const currentBinding = workList.shift();
+                    if (visited.has(currentBinding))
+                        continue;
+                    visited.add(currentBinding);
+                    const node = defs.get(currentBinding);
+                    if (node)
+                        node.forEach((n) => targets.push({ node: n, binding: currentBinding }));
+                    if (isTransitive) {
+                        const deps = calls.get(currentBinding) || [];
+                        workList.push(...deps);
+                    }
                 }
             }
-            const passed = result === rule.expected;
-            return {
-                rule,
-                passed,
-                actual: result,
-            };
-        }
-        catch (error) {
-            return {
+            let actual = false;
+            let error;
+            // Execution Loop
+            const isGlobalVisitor = !rule.binding || rule.binding === "*";
+            const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
+            const args = rule.args ?? [];
+            const visitor = new InspectionClass(...args, normalizedBinding);
+            for (const { node, binding } of targets) {
+                try {
+                    if (!isGlobalVisitor && visitor.setBinding) {
+                        visitor.setBinding(binding);
+                    }
+                    node.accept(visitor);
+                }
+                catch (e) {
+                    if (e instanceof StopTraversalException) {
+                        actual = true;
+                        break; // Short-circuit: Rule passed
+                    }
+                    else {
+                        error = e.message;
+                    }
+                }
+            }
+            ruleResults.set(rule, {
                 rule,
-                passed: false,
-                actual: false,
+                passed: actual === rule.expected,
+                actual,
                 error,
-            };
+            });
         }
+        return [...ruleResults.values()];
     }
 }

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

@@ -0,0 +1,44 @@
+import * as Yu from "yukigo-ast";
+import { VisitorConstructor, ScopedVisitor } from "../../utils.js";
+export declare class UsesComposition extends ScopedVisitor {
+    constructor(scope?: string);
+    visitCompositionExpression(node: Yu.CompositionExpression): void;
+}
+export declare class UsesAnonymousVariable extends ScopedVisitor {
+    constructor(scope?: string);
+    visitWildcardPattern(node: Yu.WildcardPattern): void;
+}
+export declare class UsesComprehension extends ScopedVisitor {
+    constructor(scope?: string);
+    visitListComprehension(node: Yu.ListComprehension): void;
+}
+export declare class UsesGuards extends ScopedVisitor {
+    constructor(scope?: string);
+    visitGuardedBody(node: Yu.GuardedBody): void;
+}
+export declare class UsesOtherwise extends ScopedVisitor {
+    constructor(scope?: string);
+    visitOtherwise(node: Yu.Otherwise): void;
+}
+export declare class UsesLambda extends ScopedVisitor {
+    constructor(scope?: string);
+    visitLambda(node: Yu.Lambda): void;
+}
+export declare class UsesYield extends ScopedVisitor {
+    constructor(scope?: string);
+    visitYield(node: Yu.Yield): void;
+}
+export declare class UsesPatternMatching extends ScopedVisitor {
+    constructor(scope?: string);
+    visitConsPattern(node: Yu.ConsPattern): void;
+    visitAsPattern(node: Yu.AsPattern): void;
+    visitListPattern(node: Yu.ListPattern): void;
+    visitTuplePattern(node: Yu.TuplePattern): void;
+    visitLiteralPattern(node: Yu.LiteralPattern): void;
+    visitApplicationPattern(node: Yu.ApplicationPattern): void;
+    visitConstructorPattern(node: Yu.ConstructorPattern): void;
+    visitUnionPattern(node: Yu.UnionPattern): void;
+    visitFunctorPattern(node: Yu.FunctorPattern): void;
+    visitWildcardPattern(node: Yu.WildcardPattern): void;
+}
+export declare const functionalInspections: Record<string, VisitorConstructor>;

package/dist/analyzer/inspections/functional/functional.js

@@ -0,0 +1,149 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as Yu from "yukigo-ast";
+import { ScopedVisitor, AutoScoped } from "../../utils.js";
+let UsesComposition = class UsesComposition extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitCompositionExpression(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesComposition = __decorate([
+    AutoScoped
+], UsesComposition);
+export { UsesComposition };
+let UsesAnonymousVariable = class UsesAnonymousVariable extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitWildcardPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesAnonymousVariable = __decorate([
+    AutoScoped
+], UsesAnonymousVariable);
+export { UsesAnonymousVariable };
+let UsesComprehension = class UsesComprehension extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitListComprehension(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesComprehension = __decorate([
+    AutoScoped
+], UsesComprehension);
+export { UsesComprehension };
+let UsesGuards = class UsesGuards extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitGuardedBody(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesGuards = __decorate([
+    AutoScoped
+], UsesGuards);
+export { UsesGuards };
+let UsesOtherwise = class UsesOtherwise extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitOtherwise(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesOtherwise = __decorate([
+    AutoScoped
+], UsesOtherwise);
+export { UsesOtherwise };
+let UsesLambda = class UsesLambda extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitLambda(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesLambda = __decorate([
+    AutoScoped
+], UsesLambda);
+export { UsesLambda };
+let UsesYield = class UsesYield extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitYield(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesYield = __decorate([
+    AutoScoped
+], UsesYield);
+export { UsesYield };
+let UsesPatternMatching = class UsesPatternMatching extends ScopedVisitor {
+    constructor(scope) {
+        super(scope);
+    }
+    visitConsPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitAsPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitListPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitTuplePattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitLiteralPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitApplicationPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitConstructorPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitUnionPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitFunctorPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+    visitWildcardPattern(node) {
+        throw new Yu.StopTraversalException();
+    }
+};
+UsesPatternMatching = __decorate([
+    AutoScoped
+], UsesPatternMatching);
+export { UsesPatternMatching };
+export const functionalInspections = {
+    UsesComposition: UsesComposition,
+    HasComposition: UsesComposition,
+    UsesAnonymousVariable: UsesAnonymousVariable,
+    HasAnonymousVariable: UsesAnonymousVariable,
+    UsesComprehension: UsesComprehension,
+    HasComprehension: UsesComprehension,
+    UsesGuards: UsesGuards,
+    HasGuards: UsesGuards,
+    UsesOtherwise: UsesOtherwise,
+    HasOtherwise: UsesOtherwise,
+    UsesLambda: UsesLambda,
+    HasLambda: UsesLambda,
+    UsesYield: UsesYield,
+    HasYield: UsesYield,
+    UsesPatternMatching: UsesPatternMatching,
+    HasPatternMatching: UsesPatternMatching,
+};

package/dist/analyzer/inspections/functional/smells.d.ts

@@ -0,0 +1,16 @@
+import { Lambda, Equation, GuardedBody } from "yukigo-ast";
+import { ScopedVisitor, VisitorConstructor } from "../../utils.js";
+export declare class HasRedundantLambda extends ScopedVisitor {
+    visitLambda(node: Lambda): void;
+}
+export declare class HasRedundantGuards extends ScopedVisitor {
+    visitEquation(node: Equation): void;
+    private isAlwaysTrue;
+}
+export declare class ShouldUseOtherwise extends ScopedVisitor {
+    visitGuardedBody(node: GuardedBody): void;
+}
+export declare class HasRedundantParameter extends ScopedVisitor {
+    visitEquation(node: Equation): void;
+}
+export declare const functionalSmells: Record<string, VisitorConstructor>;

package/dist/analyzer/inspections/functional/smells.js

@@ -0,0 +1,98 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Call, VariablePattern, Variable, StopTraversalException, BooleanPrimitive, Application, isUnguardedBody, Otherwise, } from "yukigo-ast";
+import { AutoScoped, ScopedVisitor } from "../../utils.js";
+import { Uses } from "../generic/generic.js";
+let HasRedundantLambda = class HasRedundantLambda extends ScopedVisitor {
+    visitLambda(node) {
+        if (node.parameters.length !== 1)
+            return;
+        if (!(node.body instanceof Application))
+            return;
+        const param = node.parameters[0];
+        const call = node.body;
+        if (call.functionExpr instanceof Application ||
+            call.functionExpr instanceof Call)
+            return;
+        const arg = call.parameter;
+        if (param instanceof VariablePattern &&
+            arg instanceof Variable &&
+            param.name.value === arg.identifier.value)
+            throw new StopTraversalException();
+    }
+};
+HasRedundantLambda = __decorate([
+    AutoScoped
+], HasRedundantLambda);
+export { HasRedundantLambda };
+let HasRedundantGuards = class HasRedundantGuards extends ScopedVisitor {
+    visitEquation(node) {
+        if (isUnguardedBody(node.body))
+            return;
+        // If there is only 1 guard...
+        if (node.body.length === 1) {
+            const guard = node.body[0];
+            // ...and that guard is "True" or "otherwise"
+            if (this.isAlwaysTrue(guard.condition))
+                throw new StopTraversalException();
+        }
+    }
+    isAlwaysTrue(node) {
+        // check for boolean literal 'True'
+        if (node instanceof BooleanPrimitive && node.value === true)
+            return true;
+        // check for default case
+        if (node instanceof Otherwise)
+            return true;
+        return false;
+    }
+};
+HasRedundantGuards = __decorate([
+    AutoScoped
+], HasRedundantGuards);
+export { HasRedundantGuards };
+let ShouldUseOtherwise = class ShouldUseOtherwise extends ScopedVisitor {
+    visitGuardedBody(node) {
+        if (node.condition instanceof BooleanPrimitive &&
+            node.condition.value === true)
+            throw new StopTraversalException();
+    }
+};
+ShouldUseOtherwise = __decorate([
+    AutoScoped
+], ShouldUseOtherwise);
+export { ShouldUseOtherwise };
+let HasRedundantParameter = class HasRedundantParameter extends ScopedVisitor {
+    visitEquation(node) {
+        for (const pattern of node.patterns) {
+            if (pattern instanceof VariablePattern) {
+                const paramName = pattern.name.value;
+                const usageChecker = new Uses(paramName, this.binding);
+                try {
+                    node.accept(usageChecker);
+                    // uses didnt throw so the param is not being used
+                    throw new StopTraversalException();
+                }
+                catch (e) {
+                    if (e instanceof StopTraversalException)
+                        continue;
+                    throw e;
+                }
+            }
+        }
+    }
+};
+HasRedundantParameter = __decorate([
+    AutoScoped
+], HasRedundantParameter);
+export { HasRedundantParameter };
+export const functionalSmells = {
+    HasRedundantGuards: HasRedundantGuards,
+    HasRedundantLambda: HasRedundantLambda,
+    HasRedundantParameter: HasRedundantParameter,
+    ShouldUseOtherwise: ShouldUseOtherwise,
+};