yukigo 0.1.0 → 0.2.0

package/tests/analyzer/functional.spec.ts

@@ -1,221 +1,207 @@
-import { expect } from "chai";
-import {
-  Function,
-  Equation,
-  SymbolPrimitive,
-  UnguardedBody,
-  GuardedBody,
-  Sequence,
-  CompositionExpression,
-  Lambda,
-  Application,
-  ListComprehension,
-  Yield,
-  LiteralPattern,
-  ListPattern,
-  WildcardPattern,
-  BooleanPrimitive,
-  NumberPrimitive,
-  If,
-} from "yukigo-ast";
-import {
-  UsesComposition,
-  UsesAnonymousVariable,
-  UsesComprehension,
-  UsesGuards,
-  UsesLambda,
-  UsesYield,
-  UsesPatternMatching,
-} from "../../src/analyzer/inspections/functional.js";
-import { executeVisitor } from "../../src/analyzer/utils.js";
-
-describe("Functional Spec", () => {
-  const createSymbol = (name: string) => new SymbolPrimitive(name);
-  const createSequence = (expr: any) => new Sequence([expr]);
-  const createEquation = (patterns: any[], bodyExpr: any) => {
-    const body = Array.isArray(bodyExpr)
-      ? bodyExpr
-      : new UnguardedBody(createSequence(bodyExpr));
-
-    return new Equation(patterns, body, undefined);
-  };
-  const createFunction = (name: string, equations: Equation[]) => {
-    return new Function(createSymbol(name), equations);
-  };
-  const mockExpr = new NumberPrimitive(1);
-
-  describe("UsesGuards", () => {
-    it("detects guards when they are present", () => {
-      const guardedBody = new GuardedBody(mockExpr, mockExpr);
-      const equation = new Equation([], [guardedBody, guardedBody], undefined);
-      const func = createFunction("f", [equation]);
-
-      const visitor = new UsesGuards("f");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("does not detect guards when using UnguardedBody", () => {
-      const equation = createEquation([], mockExpr);
-      const func = createFunction("f", [equation]);
-
-      const visitor = new UsesGuards("f");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-
-    it("should respect binding scope", () => {
-      const guardedBody = new GuardedBody(mockExpr, mockExpr);
-      const equation = new Equation([], [guardedBody], undefined);
-      const func = createFunction("g", [equation]);
-
-      const visitor = new UsesGuards("f");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesComposition", () => {
-    const createComp = () => new CompositionExpression(mockExpr, mockExpr);
-
-    it("is True when composition is present on top level", () => {
-      const func = createFunction("x", [createEquation([], createComp())]);
-
-      const visitor = new UsesComposition("x");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True when composition is present inside lambda", () => {
-      const lambda = new Lambda([], createComp());
-      const func = createFunction("x", [createEquation([], lambda)]);
-
-      const visitor = new UsesComposition("x");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True when composition is present inside application", () => {
-      const app = new Application(mockExpr, createComp());
-      const func = createFunction("x", [createEquation([], app)]);
-
-      const visitor = new UsesComposition("x");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True when composition is present within if", () => {
-      const ifExpr = new If(new BooleanPrimitive(true), createComp(), mockExpr);
-      const func = createFunction("f", [createEquation([], ifExpr)]);
-
-      const visitor = new UsesComposition("f");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is False when composition is not present", () => {
-      const func = createFunction("x", [createEquation([], mockExpr)]);
-      const visitor = new UsesComposition("x");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesPatternMatching", () => {
-    it("is True when Pattern Matching with Literal", () => {
-      const pattern = new LiteralPattern(new NumberPrimitive(0));
-      const func = createFunction("factorial", [
-        createEquation([pattern], mockExpr),
-      ]);
-
-      const visitor = new UsesPatternMatching("factorial");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True when Pattern Matching on List", () => {
-      const pattern = new ListPattern([]);
-      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
-
-      const visitor = new UsesPatternMatching("foo");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True when Pattern Matching on anonymous variable (Wildcard)", () => {
-      const pattern = new WildcardPattern();
-      const func = createFunction("baz", [createEquation([pattern], mockExpr)]);
-
-      const visitor = new UsesPatternMatching("baz");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is False when no patterns (or ignored patterns) are used", () => {
-      const func = createFunction("foo", [createEquation([], mockExpr)]);
-      const visitor = new UsesPatternMatching("foo");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesLambda", () => {
-    it("detects lambda when is present", () => {
-      const lambda = new Lambda([], mockExpr);
-      const func = createFunction("f", [createEquation([], lambda)]);
-
-      const visitor = new UsesLambda("f");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("detects lambda when is not present", () => {
-      const func = createFunction("f", [createEquation([], mockExpr)]);
-      const visitor = new UsesLambda("f");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesAnonymousVariable", () => {
-    it("is True if _ is present in parameters", () => {
-      const pattern = new WildcardPattern();
-      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
-
-      const visitor = new UsesAnonymousVariable("foo");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is True if _ is present in nested structures (e.g. ListPattern)", () => {
-      const innerWildcard = new WildcardPattern();
-
-      const listPattern = new ListPattern([innerWildcard]);
-
-      const func = createFunction("foo", [
-        createEquation([listPattern], mockExpr),
-      ]);
-
-      const visitor = new UsesAnonymousVariable("foo");
-
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is False if _ is not present", () => {
-      const func = createFunction("foo", [createEquation([], mockExpr)]);
-      const visitor = new UsesAnonymousVariable("foo");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesComprehension", () => {
-    it("is True when list comprehension exists", () => {
-      const comp = new ListComprehension(mockExpr, []);
-      const func = createFunction("x", [createEquation([], comp)]);
-
-      const visitor = new UsesComprehension(undefined);
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-
-    it("is False when comprehension doesnt exists", () => {
-      const func = createFunction("x", [createEquation([], mockExpr)]);
-      const visitor = new UsesComprehension("x");
-      expect(executeVisitor(func, visitor)).to.eq(false);
-    });
-  });
-
-  describe("UsesYield", () => {
-    it("is True when yield exists", () => {
-      const yieldNode = new Yield(mockExpr);
-      const func = createFunction("gen", [createEquation([], yieldNode)]);
-
-      const visitor = new UsesYield("gen");
-      expect(executeVisitor(func, visitor)).to.eq(true);
-    });
-  });
-});
+import { expect } from "chai";
+import {
+  Function,
+  Equation,
+  SymbolPrimitive,
+  UnguardedBody,
+  GuardedBody,
+  Sequence,
+  CompositionExpression,
+  Lambda,
+  Application,
+  ListComprehension,
+  Yield,
+  LiteralPattern,
+  ListPattern,
+  WildcardPattern,
+  BooleanPrimitive,
+  NumberPrimitive,
+  If,
+  TypeSignature,
+  SimpleType,
+} from "yukigo-ast";
+import { Analyzer, InspectionRule } from "../../src/analyzer/index.js";
+
+describe("Functional Inspections", () => {
+  const createSymbol = (name: string) => new SymbolPrimitive(name);
+  const createSequence = (expr: any) => new Sequence([expr]);
+  const createEquation = (patterns: any[], bodyExpr: any) => {
+    const body = Array.isArray(bodyExpr)
+      ? bodyExpr
+      : new UnguardedBody(createSequence(bodyExpr));
+
+    return new Equation(patterns, body, undefined);
+  };
+  const createFunction = (name: string, equations: Equation[]) => {
+    return new Function(createSymbol(name), equations);
+  };
+  const mockExpr = new NumberPrimitive(1);
+  const analyzer = new Analyzer();
+
+  const runSingleRule = (
+    ast: any[],
+    inspection: string,
+    expected: boolean,
+    binding?: string,
+    args: string[] = []
+  ) => {
+    const rule: InspectionRule = { inspection, binding, args, expected };
+    const results = analyzer.analyze(ast, [rule]);
+    const result = results[0]; // Assuming only one rule is passed
+    return result.passed;
+  };
+
+  describe("UsesGuards", () => {
+    it("detects guards when they are present", () => {
+      const guardedBody = new GuardedBody(mockExpr, mockExpr);
+      const equation = new Equation([], [guardedBody, guardedBody], undefined);
+      const func = createFunction("f", [equation]);
+      expect(runSingleRule([func], "UsesGuards", true, "f")).to.be.true;
+    });
+
+    it("does not detect guards when using UnguardedBody", () => {
+      const equation = createEquation([], mockExpr);
+      const func = createFunction("f", [equation]);
+      expect(runSingleRule([func], "UsesGuards", false, "f")).to.be.true;
+    });
+
+    it("should respect binding scope", () => {
+      const guardedBody = new GuardedBody(mockExpr, mockExpr);
+      const equation = new Equation([], [guardedBody], undefined);
+      const func = createFunction("g", [equation]);
+      expect(runSingleRule([func], "UsesGuards", false, "f")).to.be.true;
+    });
+  });
+
+  describe("UsesComposition", () => {
+    const createComp = () => new CompositionExpression(mockExpr, mockExpr);
+
+    it("is True when composition is present on top level", () => {
+      const func = createFunction("x", [createEquation([], createComp())]);
+      expect(runSingleRule([func], "UsesComposition", true, "x")).to.be.true;
+    });
+
+    it("is True when composition is present inside lambda", () => {
+      const lambda = new Lambda([], createComp());
+      const func = createFunction("x", [createEquation([], lambda)]);
+      expect(runSingleRule([func], "UsesComposition", true, "x")).to.be.true;
+    });
+
+    it("is True when composition is present inside application", () => {
+      const app = new Application(mockExpr, createComp());
+      const func = createFunction("x", [createEquation([], app)]);
+      expect(runSingleRule([func], "UsesComposition", true, "x")).to.be.true;
+    });
+
+    it("is True when composition is present within if", () => {
+      const ifExpr = new If(new BooleanPrimitive(true), createComp(), mockExpr);
+      const func = createFunction("f", [createEquation([], ifExpr)]);
+      expect(runSingleRule([func], "UsesComposition", true, "f")).to.be.true;
+    });
+
+    it("is False when composition is not present", () => {
+      const func = createFunction("x", [createEquation([], mockExpr)]);
+      expect(runSingleRule([func], "UsesComposition", false, "x")).to.be.true;
+    });
+  });
+
+  describe("UsesPatternMatching", () => {
+    it("is True when Pattern Matching with Literal", () => {
+      const pattern = new LiteralPattern(new NumberPrimitive(0));
+      const func = createFunction("factorial", [
+        createEquation([pattern], mockExpr),
+      ]);
+      expect(runSingleRule([func], "UsesPatternMatching", true, "factorial")).to
+        .be.true;
+    });
+
+    it("is True when Pattern Matching on List", () => {
+      const pattern = new ListPattern([]);
+      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
+      expect(runSingleRule([func], "UsesPatternMatching", true, "foo")).to.be
+        .true;
+    });
+
+    it("is True when Pattern Matching on anonymous variable (Wildcard)", () => {
+      const pattern = new WildcardPattern();
+      const func = createFunction("baz", [createEquation([pattern], mockExpr)]);
+      expect(runSingleRule([func], "UsesPatternMatching", true, "baz")).to.be
+        .true;
+    });
+
+    it("is False when no patterns (or ignored patterns) are used", () => {
+      const func = createFunction("foo", [createEquation([], mockExpr)]);
+      expect(runSingleRule([func], "UsesPatternMatching", false, "foo")).to.be
+        .true;
+    });
+  });
+
+  describe("UsesLambda", () => {
+    it("detects lambda when is present", () => {
+      const lambda = new Lambda([], mockExpr);
+      const func = createFunction("f", [createEquation([], lambda)]);
+      expect(runSingleRule([func], "UsesLambda", true, "f")).to.be.true;
+    });
+
+    it("detects lambda when is not present", () => {
+      const func = createFunction("f", [createEquation([], mockExpr)]);
+      expect(runSingleRule([func], "UsesLambda", false, "f")).to.be.true;
+    });
+  });
+
+  describe("UsesAnonymousVariable", () => {
+    it("is True if _ is present in parameters", () => {
+      const pattern = new WildcardPattern();
+      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
+      expect(runSingleRule([func], "UsesAnonymousVariable", true, "foo")).to.be
+        .true;
+    });
+
+    it("is True if _ is present in nested structures (e.g. ListPattern)", () => {
+      const innerWildcard = new WildcardPattern();
+      const listPattern = new ListPattern([innerWildcard]);
+      const func = createFunction("foo", [
+        createEquation([listPattern], mockExpr),
+      ]);
+      expect(runSingleRule([func], "UsesAnonymousVariable", true, "foo")).to.be
+        .true;
+    });
+
+    it("is False if _ is not present", () => {
+      const func = createFunction("foo", [createEquation([], mockExpr)]);
+      expect(runSingleRule([func], "UsesAnonymousVariable", false, "foo")).to.be
+        .true;
+    });
+  });
+
+  describe("UsesComprehension", () => {
+    it("is True when list comprehension exists", () => {
+      const comp = new ListComprehension(mockExpr, []);
+      const func = createFunction("x", [createEquation([], comp)]);
+      expect(runSingleRule([func], "UsesComprehension", true, undefined)).to.be
+        .true;
+    });
+
+    it("is False when comprehension doesnt exists", () => {
+      const func = createFunction("x", [createEquation([], mockExpr)]);
+      expect(runSingleRule([func], "UsesComprehension", false, "x")).to.be.true;
+    });
+  });
+
+  describe("UsesYield", () => {
+    it("is True when yield exists", () => {
+      const yieldNode = new Yield(mockExpr);
+      const func = createFunction("gen", [createEquation([], yieldNode)]);
+      expect(runSingleRule([func], "UsesYield", true, "gen")).to.be.true;
+    });
+  });
+  describe("HasTypeSignature", () => {
+    it("is True when signature exists", () => {
+      const signature = new TypeSignature(
+        new SymbolPrimitive("MockType"),
+        new SimpleType("simple", [])
+      );
+      expect(runSingleRule([signature], "HasTypeSignature", true, "MockType")).to.be.true;
+    });
+  });
+});