yukigo-haskell-parser 0.1.0 → 0.1.2

package/src/utils/helpers.ts

@@ -1,29 +1,29 @@
-import { inspect } from "util";
-import { AST } from "yukigo-ast";
-import { Function } from "yukigo-ast";
-
-export function groupFunctionDeclarations(ast: AST): AST {
-  const groups: Record<string, Function[]> = {};
-  const others: AST = [];
-
-  for (const node of ast) {
-    if (node instanceof Function) {
-      const name = node.identifier.value;
-      if (!groups[name]) {
-        groups[name] = [];
-      }
-      groups[name].push(node);
-    } else {
-      others.push(node);
-    }
-  }
-
-  // Merge equations for each function name
-  const functionGroups: Function[] = Object.values(groups).map((functions) => {
-    const identifier = functions[0].identifier;
-    const allEquations = functions.flatMap((f) => f.equations);
-    return new Function(identifier, allEquations, identifier.loc);
-  });
-
-  return [...others, ...functionGroups];
-}
+import { inspect } from "util";
+import { AST } from "yukigo-ast";
+import { Function } from "yukigo-ast";
+
+export function groupFunctionDeclarations(ast: AST): AST {
+  const groups: Record<string, Function[]> = {};
+  const others: AST = [];
+
+  for (const node of ast) {
+    if (node instanceof Function) {
+      const name = node.identifier.value;
+      if (!groups[name]) {
+        groups[name] = [];
+      }
+      groups[name].push(node);
+    } else {
+      others.push(node);
+    }
+  }
+
+  // Merge equations for each function name
+  const functionGroups: Function[] = Object.values(groups).map((functions) => {
+    const identifier = functions[0].identifier;
+    const allEquations = functions.flatMap((f) => f.equations);
+    return new Function(identifier, allEquations, identifier.loc);
+  });
+
+  return [...others, ...functionGroups];
+}

package/src/utils/types.ts

@@ -1,56 +1,63 @@
-import { YukigoPrimitive } from "yukigo-ast";
-
-export const keywords = [
-  "type",
-  "where",
-  "in",
-  "if",
-  "else",
-  "then",
-  "data",
-  "case",
-  "class",
-  "do",
-  "default",
-  "deriving",
-  "import",
-  "infix",
-  "infixl",
-  "infixr",
-  "instance",
-  "let",
-  "module",
-  "newtype",
-  "of",
-  "qualified",
-  "hiding",
-  "foreign",
-];
-
-export const typeMappings: { [key: string]: YukigoPrimitive } = {
-  Float: "YuNumber",
-  Double: "YuNumber",
-  Int: "YuNumber",
-  Integer: "YuNumber",
-  String: "YuString",
-  Char: "YuChar",
-  Boolean: "YuBoolean",
-  Bool: "YuBoolean",
-};
-
-export const typeClasses: Map<string, string[]> = new Map([
-  ["Bounded", ["YuChar", "YuNumber"]],
-  ["Enum", ["YuChar", "YuNumber"]],
-  ["Ord", ["YuNumber", "YuString", "YuChar"]],
-  ["Eq", ["YuNumber", "YuString", "YuChar", "YuBoolean"]],
-  ["Floating", ["YuNumber"]],
-  ["Fractional", ["YuNumber"]],
-  ["Integral", ["YuNumber"]],
-  ["Num", ["YuNumber"]],
-  ["Random", ["YuBoolean", "YuChar", "YuNumber"]],
-  ["Read", ["YuList", "YuChar", "YuNumber"]],
-  ["Real", ["YuNumber"]],
-  ["RealFloat", ["YuNumber"]],
-  ["RealFrac", ["YuNumber"]],
-  ["Show", ["YuNumber", "YuString", "YuChar", "YuList"]],
-]);
+import { YukigoPrimitive } from "yukigo-ast";
+
+export const keywords = [
+  "type",
+  "where",
+  "in",
+  "if",
+  "else",
+  "then",
+  "data",
+  "case",
+  "error",
+  "class",
+  "do",
+  "default",
+  "deriving",
+  "import",
+  "infix",
+  "infixl",
+  "infixr",
+  "instance",
+  "let",
+  "module",
+  "newtype",
+  "of",
+  "qualified",
+  "hiding",
+  "foreign",
+  "describe",
+  "it",
+  "shouldBe",
+  "shouldNotBe",
+  "shouldSatisfy",
+  "shouldThrow"
+];
+
+export const typeMappings: { [key: string]: YukigoPrimitive } = {
+  Float: "YuNumber",
+  Double: "YuNumber",
+  Int: "YuNumber",
+  Integer: "YuNumber",
+  String: "YuString",
+  Char: "YuChar",
+  Boolean: "YuBoolean",
+  Bool: "YuBoolean",
+};
+
+export const typeClasses: Map<string, string[]> = new Map([
+  ["Bounded", ["YuChar", "YuNumber"]],
+  ["Enum", ["YuChar", "YuNumber"]],
+  ["Ord", ["YuNumber", "YuString", "YuChar"]],
+  ["Eq", ["YuNumber", "YuString", "YuChar", "YuBoolean"]],
+  ["Floating", ["YuNumber"]],
+  ["Fractional", ["YuNumber"]],
+  ["Integral", ["YuNumber"]],
+  ["Num", ["YuNumber"]],
+  ["Random", ["YuBoolean", "YuChar", "YuNumber"]],
+  ["Read", ["YuList", "YuChar", "YuNumber"]],
+  ["Real", ["YuNumber"]],
+  ["RealFloat", ["YuNumber"]],
+  ["RealFrac", ["YuNumber"]],
+  ["Show", ["YuNumber", "YuString", "YuChar", "YuList"]],
+]);

package/tests/hspec.spec.ts

@@ -0,0 +1,92 @@
+import { expect } from "chai";
+import { YukigoHaskellParser } from "../src/index.js";
+import {
+  TestGroup,
+  Test,
+  Assert,
+  Equality,
+  Truth,
+  Failure,
+  Raise,
+  NumberPrimitive,
+  SymbolPrimitive,
+  Application,
+  StringPrimitive,
+  BooleanPrimitive
+} from "yukigo-ast";
+
+describe("HSpec Parsing", () => {
+  const parser = new YukigoHaskellParser("", { typecheck: true, includePrims: false });
+
+  it("should parse describe and it blocks", () => {
+    const code = `
+describe "Math" do
+  it "adds 1 and 1" do
+    (1 + 1) shouldBe 2
+`;
+    const ast = parser.parse(code);
+    expect(ast).to.have.lengthOf(1);
+    expect(ast[0]).to.be.instanceOf(TestGroup);
+    
+    const group = ast[0] as TestGroup;
+    expect(group.name).to.be.instanceOf(StringPrimitive);
+    expect((group.name as StringPrimitive).value).to.equal("Math");
+    
+    expect(group.group.statements).to.have.lengthOf(1);
+    expect(group.group.statements[0]).to.be.instanceOf(Test);
+    
+    const test = group.group.statements[0] as Test;
+    expect(test.name).to.be.instanceOf(StringPrimitive);
+    expect((test.name as StringPrimitive).value).to.equal("adds 1 and 1");
+    
+    expect(test.body.statements).to.have.lengthOf(1);
+    expect(test.body.statements[0]).to.be.instanceOf(Assert);
+    
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.negated).to.be.instanceOf(BooleanPrimitive);
+    expect((assert.negated as BooleanPrimitive).value).to.be.false;
+    expect(assert.body).to.be.instanceOf(Equality);
+    
+    const equality = assert.body as Equality;
+    expect(equality.expected).to.be.instanceOf(NumberPrimitive);
+    expect((equality.expected as NumberPrimitive).value).to.equal(2);
+  });
+
+  it("should parse shouldNotBe", () => {
+    const code = `it "negation" do 1 shouldNotBe 2`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect((assert.negated as BooleanPrimitive).value).to.be.true;
+    expect(assert.body).to.be.instanceOf(Equality);
+  });
+
+  it("should parse shouldSatisfy", () => {
+    const code = `it "satisfy" do 5 shouldSatisfy odd`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.body).to.be.instanceOf(Truth);
+    
+    const truth = assert.body as Truth;
+    expect(truth.body).to.be.instanceOf(Application);
+    const app = truth.body as Application;
+    expect(app.functionExpr).to.be.instanceOf(SymbolPrimitive);
+    expect((app.functionExpr as SymbolPrimitive).value).to.equal("odd");
+    expect(app.parameter).to.be.instanceOf(NumberPrimitive);
+    expect((app.parameter as NumberPrimitive).value).to.equal(5);
+  });
+
+  it("should parse shouldThrow", () => {
+    const code = `it "throws" do error "fail" shouldThrow anyException`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.body).to.be.instanceOf(Failure);
+    
+    const failure = assert.body as Failure;
+    expect(failure.func).to.be.instanceOf(Raise);
+    expect(failure.message).to.be.instanceOf(SymbolPrimitive);
+    expect((failure.message as SymbolPrimitive).value).to.equal("anyException");
+  });
+});

package/tests/lexer.spec.ts

@@ -0,0 +1,175 @@
+import { assert, expect } from "chai";
+import { HaskellLayoutLexer } from "../src/parser/lexer.js";
+
+describe("HaskellLayoutLexer", () => {
+  let lexer: HaskellLayoutLexer;
+
+  beforeEach(() => {
+    lexer = new HaskellLayoutLexer();
+  });
+
+  // Helper: Returns array of objects { type, value } for better debugging
+  const getTokens = (input: string) => {
+    lexer.reset(input);
+    const tokens = [];
+    for (const token of lexer) {
+      tokens.push({ type: token.type, value: token.value });
+    }
+    return tokens;
+  };
+
+  const getTypes = (input: string) => getTokens(input).map((t) => t.type);
+
+  it("should ignore basic whitespace", () => {
+    const input = "x = 5";
+    const types = getTypes(input);
+    expect(types).to.not.include("WS");
+    expect(types).to.not.include("NL");
+    expect(types).to.include("assign");
+  });
+
+  describe("Layout Rule: 'do' blocks", () => {
+    it("should inject braces for indented 'do' block", () => {
+      const input = `
+do
+  x
+  y
+`;
+      const tokens = getTokens(input);
+      // We check values for keywords since type is now generic 'keyword' or 'variable'
+      expect(tokens[0].value).to.equal("do");
+      expect(tokens[1].type).to.equal("lbracket"); // { Injected
+      expect(tokens[2].value).to.equal("x");
+      expect(tokens[3].type).to.equal("semicolon"); // ; Injected
+      expect(tokens[4].value).to.equal("y");
+      expect(tokens[5].type).to.equal("rbracket"); // } Injected
+    });
+
+    it("should handle explicit braces (no layout injection)", () => {
+      const input = "do { x; y }";
+      const types = getTypes(input);
+      expect(types).to.include("lbracket");
+      expect(types).to.include("semicolon");
+      expect(types).to.include("rbracket");
+      // Ensure we didn't double up
+      expect(types.filter((t) => t === "lbracket").length).to.equal(1);
+    });
+  });
+
+  describe("Layout Rule: 'let' blocks", () => {
+    it("should inject braces and handle 'in' dedent", () => {
+      const input = `
+let
+  x = 1
+in x
+`;
+      const tokens = getTokens(input);
+
+      const letIndex = tokens.findIndex((t) => t.value === "let");
+      expect(tokens[letIndex + 1].type).to.equal("lbracket");
+
+      const inIndex = tokens.findIndex((t) => t.value === "in");
+      expect(tokens[inIndex - 1].type).to.equal("rbracket");
+    });
+  });
+
+  describe("Layout Rule: 'where' clauses", () => {
+    it("should handle nested blocks correctly", () => {
+      const input = `
+f = do
+  let x = 1
+  return x
+`;
+      const types = getTypes(input);
+
+      const lbrackets = types.filter((t) => t === "lbracket").length;
+      const rbrackets = types.filter((t) => t === "rbracket").length;
+      const semicolons = types.filter((t) => t === "semicolon").length;
+
+      expect(lbrackets).to.equal(2);
+      expect(rbrackets).to.equal(2);
+      expect(semicolons).to.equal(1);
+    });
+  });
+
+  describe("Layout Rule: Separators", () => {
+    it("should inject semicolons for aligned declarations", () => {
+      // NOTE: We removed the leading newline here.
+      // If we keep the newline, the lexer will insert a semicolon before 'x' too
+      // (because x is at col 1, which matches stack 1).
+      const input = "x = 1\ny = 2";
+
+      const tokens = getTokens(input);
+
+      // Expected: x, =, 1, SEMICOLON, y, =, 2
+      const semiToken = tokens.find((t) => t.type === "semicolon");
+      expect(semiToken).to.not.be.undefined;
+
+      const semiIndex = tokens.findIndex((t) => t.type === "semicolon");
+      // Should be after '1' (index 2) and before 'y' (index 4)
+      expect(semiIndex).to.equal(3);
+    });
+  });
+
+  describe("Nearley Integration Requirements", () => {
+    it("should save and restore state correctly (Backtracking)", () => {
+      const input = `
+      do
+      x
+      y
+      `;
+      lexer.reset(input);
+
+      lexer.next();
+      lexer.next();
+
+      const state = lexer.save();
+
+      const t1 = lexer.next();
+      const t2 = lexer.next();
+
+      lexer.reset(input, state);
+
+      const t1_restored = lexer.next();
+      const t2_restored = lexer.next();
+
+      expect(t1_restored?.value).to.equal(t1?.value);
+      expect(t2_restored?.type).to.equal(t2?.type);
+    });
+  });
+  describe("Layout Rule: Separators", () => {
+    it("should not inject semicolons or blocks for if-then-else", () => {
+      const input = "f x = if x < 4 then 10 else 20";
+      const input2 = "f x = \n if x < 4\nthen 10\nelse 20";
+      const inlinetokes = getTokens(input);
+      const multiTokens = getTokens(input2);
+      expect(multiTokens.length).to.eq(inlinetokes.length);
+      multiTokens.forEach((tok, i) => {
+        const inlineTok = inlinetokes[i];
+        expect(tok.type).to.eq(inlineTok.type);
+        expect(tok.value).to.eq(inlineTok.value);
+      });
+    });
+  });
+  describe("Layout Rule: 'where' clauses (Multi-line)", () => {
+    it("should handle multi-line where clause with alignment", () => {
+      const input = `
+areaOfCircle radius = pi * radius_squared
+  where pi = 3.14159
+        radius_squared = radius * radius`;
+      const tokens = getTokens(input);
+
+      const whereIndex = tokens.findIndex((t) => t.value === "where");
+      expect(whereIndex).to.not.equal(-1);
+      expect(tokens[whereIndex + 1].type).to.equal("lbracket");
+
+      const semiIndex = tokens.findIndex(
+        (t, i) => i > whereIndex && t.type === "semicolon"
+      );
+      expect(semiIndex).to.not.equal(-1);
+
+      const lastToken = tokens[tokens.length - 1];
+      expect(lastToken.type).to.equal("rbracket");
+    });
+  });
+});