@fraczak/k 7.0.1 → 7.1.0

package/backends/arm64/tests/integration.sh

@@ -1,112 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-K_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-TMP_DIR=$(mktemp -d)
-trap 'rm -rf "$TMP_DIR"' EXIT
-
-echo "Running './backends/arm64/tests/integration.sh' ..."
-
-compare_json_envelope() {
-  local name=$1
-  local input=$2
-  local program=$3
-  printf '%s\n' "$input" |
-    node "$K_ROOT/codecs/json.mjs" --parse |
-    node "$K_ROOT/k.mjs" "$program" > "$TMP_DIR/native.kv"
-  printf '%s\n' "$input" |
-    node "$K_ROOT/codecs/json.mjs" --parse |
-    node "$K_ROOT/kvm.mjs" "$program" > "$TMP_DIR/kvm.kv"
-  printf '%s\n' "$input" |
-    node "$K_ROOT/codecs/json.mjs" --parse |
-    node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" "$program" > "$TMP_DIR/arm64.kv"
-
-  if ! cmp -s "$TMP_DIR/native.kv" "$TMP_DIR/kvm.kv" ||
-     ! cmp -s "$TMP_DIR/native.kv" "$TMP_DIR/arm64.kv"; then
-    echo "output envelope mismatch for $name" >&2
-    exit 1
-  fi
-}
-
-echo "Testing basic tag injection..."
-node "$K_ROOT/codecs/unit.mjs" --parse |
-  node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" '|ok' |
-  node "$K_ROOT/codecs/k-print.mjs" |
-  grep -qx '"ok"'
-
-echo "Testing record wrapping..."
-printf '{"a": {}, "b": {}}\n' |
-  node "$K_ROOT/codecs/k-parse.mjs" |
-  node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" '|ok' |
-  node "$K_ROOT/codecs/k-print.mjs" |
-  grep -qx '{"ok":{"a":{},"b":{}}}'
-
-echo "Testing field projection with JSON codec..."
-printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
-  node "$K_ROOT/codecs/json.mjs" --parse |
-  node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" '.c' |
-  node "$K_ROOT/codecs/json.mjs" --print |
-  grep -qx '\[1,2,"alsk"\]'
-
-echo "Testing nested array projection..."
-compare_json_envelope "nested array string projection" \
-  '{"a":[1,2,"kupa"], "b": 123}' \
-  '.a.2'
-
-echo "Testing JSON number projection..."
-compare_json_envelope "projected JSON number" \
-  '{"a":[1,2,"kupa"], "b": 123}' \
-  '.b'
-
-echo "Testing closed product filter..."
-compare_json_envelope "closed product filter" \
-  '{"a":[1,2,"kupa"], "b": 123}' \
-  '?{X a, Y b}'
-
-echo "Testing record construction..."
-printf '{"a":[1,2,"kupa"], "b": 123}\n' |
-  node "$K_ROOT/codecs/json.mjs" --parse |
-  node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" '{ .a.2 word, .b number }' |
-  node "$K_ROOT/codecs/json.mjs" --print |
-  grep -qx '{"number":123,"word":"kupa"}'
-
-echo "Testing standalone executable compilation and execution..."
-node "$K_ROOT/backends/arm64/bin/k-arm64-compile.mjs" -o "$TMP_DIR/dot-c" '.c'
-printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
-  node "$K_ROOT/codecs/json.mjs" --parse |
-  node "$K_ROOT/backends/arm64/bin/k-arm64-run.mjs" "$TMP_DIR/dot-c" |
-  node "$K_ROOT/codecs/json.mjs" --print |
-  grep -qx '\[1,2,"alsk"\]'
-
-echo "Testing direct execution of compiled executable with --json..."
-printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
-  node "$K_ROOT/codecs/json.mjs" --parse |
-  "$TMP_DIR/dot-c" --json |
-  grep -q 'exponent'
-
-echo "Testing compilation from .ko object..."
-node "$K_ROOT/objects/compile.mjs" '.c' "$TMP_DIR/dot-c.ko"
-printf '{"a":123,"b":true,"c":[1,2,"alsk"]}\n' |
-  node "$K_ROOT/codecs/json.mjs" --parse |
-  node "$K_ROOT/backends/arm64/bin/k-arm64.mjs" "$TMP_DIR/dot-c.ko" |
-  node "$K_ROOT/codecs/json.mjs" --print |
-  grep -qx '\[1,2,"alsk"\]'
-
-echo "Testing compilation to assembly (-S)..."
-node "$K_ROOT/backends/arm64/bin/k-arm64-compile.mjs" -S '.c' "$TMP_DIR/dot-c.s"
-test -s "$TMP_DIR/dot-c.s"
-grep -q "rel___main__" "$TMP_DIR/dot-c.s"
-
-echo "Testing library dependencies (--lib and --export)..."
-node "$K_ROOT/backends/arm64/bin/k-arm64-compile.mjs" \
-  --lib "$K_ROOT/Examples/arithmetics.k" \
-  --export plus:+ --export succ --export int \
-  '{succ int x,int y}+' \
-  -o "$TMP_DIR/lib-add"
-
-node "$K_ROOT/codecs/k-parse.mjs" <<< '{"x":{"0":"_"},"y":{"+":{"0":"_"}}}' |
-  "$TMP_DIR/lib-add" --json |
-  grep -Fxq '{"+":{"1":"_"}}'
-
-echo "==> ARM64 Integration Tests Completed Successfully!"

package/backends/arm64/tests/test-arm64.mjs

@@ -1,240 +0,0 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { execFileSync, execSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-
-import {
-  compileARM64Artifact,
-  compileARM64ArtifactFromKVM,
-  compileARM64ArtifactFromObject,
-  runARM64Artifact
-} from "../src/arm64.mjs";
-import {
-  compileKVMModuleToARM64,
-  emitMetadataC,
-  getTagEntries,
-  resetTagIds
-} from "../src/kvm2arm64.mjs";
-import { compileObjectBuffer, decodeObject } from "../../../object.mjs";
-import { objectToKVMArtifact } from "../../../kvm.mjs";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(__dirname, "../../..");
-
-console.log("==> Running ARM64 Backend Test Suite");
-
-// Helper to convert JSON value to wire buffer via codecs/k-parse.mjs
-function jsonToWire(jsonObj) {
-  const jsonStr = typeof jsonObj === "string" ? jsonObj : JSON.stringify(jsonObj);
-  return execFileSync("node", [path.join(ROOT, "codecs/k-parse.mjs")], {
-    input: jsonStr
-  });
-}
-
-// Helper to convert wire buffer to JSON value via codecs/k-print.mjs
-function wireToJSON(wireBuf) {
-  const outputStr = execFileSync("node", [path.join(ROOT, "codecs/k-print.mjs")], {
-    input: wireBuf,
-    encoding: "utf8"
-  });
-  return JSON.parse(outputStr.trim());
-}
-
-// 1. Identity / Unit Relation
-console.log("==> Test 1: Identity / Unit Relation");
-{
-  const source = `()`;
-  const artifact = compileARM64Artifact(source);
-  const inputWire = jsonToWire({});
-  const outWire = runARM64Artifact(artifact, inputWire);
-  const outJSON = wireToJSON(outWire);
-  assert.deepEqual(outJSON, {}, "Unit relation must return empty object {}");
-
-  // Test --json mode
-  const outJsonStr = runARM64Artifact(artifact, inputWire, { json: true });
-  assert.equal(outJsonStr.trim(), "{}", "--json mode must return {}");
-  console.log("  Passed!");
-}
-
-// 2. Boolean Negation (Variant Projection & Creation)
-console.log("==> Test 2: Boolean Negation (Variants)");
-{
-  const source = `
-    true = {} | true;
-    false = {} | false;
-    neg = < /true false, /false true >;
-    neg
-  `;
-  const artifact = compileARM64Artifact(source);
-
-  // Test neg(true) -> false
-  const trueWire = jsonToWire({ true: {} });
-  const falseWireOut = runARM64Artifact(artifact, trueWire);
-  assert.deepEqual(wireToJSON(falseWireOut), "false");
-
-  // Test neg(false) -> true
-  const falseWire = jsonToWire({ false: {} });
-  const trueWireOut = runARM64Artifact(artifact, falseWire);
-  assert.deepEqual(wireToJSON(trueWireOut), "true");
-
-  // Test --json mode
-  const jsonOut = runARM64Artifact(artifact, trueWire, { json: true });
-  assert.equal(jsonOut.trim(), '"false"');
-  console.log("  Passed!");
-}
-
-// 3. Product Projection and Field Swapping
-console.log("==> Test 3: Product Projection and Record Construction");
-{
-  const source = `
-    swap = { .y x, .x y };
-    swap
-  `;
-  const artifact = compileARM64Artifact(source);
-  const inWire = jsonToWire({ x: "a", y: "b" });
-  const outWire = runARM64Artifact(artifact, inWire);
-  assert.deepEqual(wireToJSON(outWire), { x: "b", y: "a" });
-  console.log("  Passed!");
-}
-
-// 4. Multi-branch Union with Backtracking
-console.log("==> Test 4: Multi-branch Union with Backtracking");
-{
-  const source = `
-    $ t = < {} a, {} b, {} c >;
-    classify = <
-      /a ({} | first),
-      /b ({} | second),
-      /c ({} | third)
-    >;
-    classify
-  `;
-  const artifact = compileARM64Artifact(source);
-
-  assert.deepEqual(wireToJSON(runARM64Artifact(artifact, jsonToWire({ a: {} }))), "first");
-  assert.deepEqual(wireToJSON(runARM64Artifact(artifact, jsonToWire({ b: {} }))), "second");
-  assert.deepEqual(wireToJSON(runARM64Artifact(artifact, jsonToWire({ c: {} }))), "third");
-  console.log("  Passed!");
-}
-
-// 5. Peano Addition with Tail-Call Optimization
-console.log("==> Test 5: Peano Addition with Tail Recursion Optimization");
-{
-  const source = `
-    $ nat = < {} 0, nat +1 >;
-    0 = {} | 0 $ nat;
-    inc = | +1 $ nat;
-    dec = $ nat / +1;
-    add = $ { nat x, nat y } <
-      { . x dec x, . y inc y } add,
-      . y
-    >;
-    add
-  `;
-  const artifact = compileARM64Artifact(source);
-
-  // 3 + 2 = 5
-  const n0 = "0";
-  const n1 = { "+1": n0 };
-  const n2 = { "+1": n1 };
-  const n3 = { "+1": n2 };
-  const n5 = { "+1": { "+1": n3 } };
-
-  const inWire = jsonToWire({ x: n3, y: n2 });
-  const outWire = runARM64Artifact(artifact, inWire);
-  assert.deepEqual(wireToJSON(outWire), n5);
-
-  // Test 0 + 2 = 2
-  const inWireZero = jsonToWire({ x: n0, y: n2 });
-  const outWireZero = runARM64Artifact(artifact, inWireZero);
-  assert.deepEqual(wireToJSON(outWireZero), n2);
-  console.log("  Passed!");
-}
-
-// 6. Deep Tail Recursion (testing stack safety with loop)
-console.log("==> Test 6: Deep Tail Recursion Loop");
-{
-  const source = `
-    $ nat = < {} 0, nat +1 >;
-    0 = {} | 0 $ nat;
-    inc = | +1 $ nat;
-    dec = $ nat / +1;
-    add = $ { nat x, nat y } <
-      { . x dec x, . y inc y } add,
-      . y
-    >;
-    add
-  `;
-  const artifact = compileARM64Artifact(source);
-
-  // Compute 50 + 1 = 51
-  let cur = "0";
-  for (let i = 0; i < 50; i++) cur = { "+1": cur };
-  const one = { "+1": "0" };
-
-  const inWire = jsonToWire({ x: cur, y: one });
-  const outWire = runARM64Artifact(artifact, inWire);
-  const outJSON = wireToJSON(outWire);
-
-  // Count the +1 depth
-  let count = 0;
-  let p = outJSON;
-  while (p && typeof p === "object" && "+1" in p) {
-    count++;
-    p = p["+1"];
-  }
-  assert.equal(count, 51, "50 + 1 must yield depth 51");
-  console.log("  Passed!");
-}
-
-// 7. Compilation to Assembly Text (-S)
-console.log("==> Test 7: Assembly Text Generation");
-{
-  const source = `true = {} | true; true`;
-  const { assembly, entryName } = compileARM64Artifact(source, { emit: "assembly" });
-  assert.ok(typeof assembly === "string", "Assembly output must be a string");
-  assert.ok(assembly.includes(".arch armv8-a"), "Assembly must target armv8-a");
-  assert.ok(assembly.includes(`.global ${entryName}`), "Assembly must export entry symbol");
-  assert.ok(assembly.includes("ret"), "Assembly must contain return instructions");
-  console.log("  Passed!");
-}
-
-// 8. Compilation from .kvm Artifact
-console.log("==> Test 8: Compilation from .kvm Artifact");
-{
-  const script = `
-    $ bool = < {} true, {} false >;
-    not = $ bool < /true ({} | false), /false ({} | true) >;
-    not
-  `;
-  const obj = decodeObject(compileObjectBuffer(script));
-  const kvm = objectToKVMArtifact(obj);
-
-  const artifact = compileARM64ArtifactFromKVM(kvm);
-  const inWire = jsonToWire({ true: {} });
-  const outWire = runARM64Artifact(artifact, inWire);
-  assert.deepEqual(wireToJSON(outWire), "false");
-  console.log("  Passed!");
-}
-
-// 9. Failure Case (Partial Relation Non-Match)
-console.log("==> Test 9: Failure Case (Relation Rejection)");
-{
-  const source = `
-    onlyA = /a ({} | success);
-    onlyA
-  `;
-  const artifact = compileARM64Artifact(source);
-  const inWireFail = jsonToWire({ b: {} });
-
-  assert.throws(
-    () => runARM64Artifact(artifact, inWireFail),
-    /failed with exit status 1/,
-    "Executable must exit with status 1 on partial relation failure"
-  );
-  console.log("  Passed!");
-}
-
-console.log("==> All ARM64 Backend Unit Tests Passed Successfully!");

package/backends/llvm/bin/k-llvm-jit.mjs

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-import crypto from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { spawn } from "node:child_process";
-import { argv, exit, stdin, stdout } from "node:process";
-import { fileURLToPath } from "node:url";
-import { decodeObject } from "@fraczak/k/object.mjs";
-import { decodeWire } from "@fraczak/k/codecs/runtime/prefix-codec.mjs";
-import { compileObjectToExecutable } from "../src/executable.mjs";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-function usage(stream = console.error) {
-  const prog = argv[1] || "k-llvm-jit.mjs";
-  stream(`Usage: node ${prog} [options] object-file`);
-  stream("Compile and execute a k .ko/.klib object against the stdin binary envelope.");
-  stream("");
-  stream("The runner reads a binary k pattern+value envelope from stdin, specializes");
-  stream("the object with that envelope pattern, then writes a binary envelope to stdout.");
-  stream("");
-  stream("Options:");
-  stream("  --retype rel            Relation to specialize. Defaults to object main.");
-  stream("  --cache-dir path        Directory for compiled native executables.");
-  stream("  --no-cache              Compile in a temporary directory and remove it after execution.");
-  stream("  -h, --help              Show this help.");
-}
-
-async function readStdinBuffer() {
-  const chunks = [];
-  for await (const chunk of stdin) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
-}
-
-let cachedBackendFingerprint = null;
-
-function backendFingerprint() {
-  if (cachedBackendFingerprint != null) return cachedBackendFingerprint;
-  const hash = crypto.createHash("sha256");
-  for (const relPath of ["src/llvm.mjs", "src/kvm2llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
-    hash.update(relPath);
-    hash.update("\0");
-    hash.update(fs.readFileSync(path.join(root, relPath)));
-    hash.update("\0");
-  }
-  cachedBackendFingerprint = hash.digest("hex").slice(0, 16);
-  return cachedBackendFingerprint;
-}
-
-function cacheKey({ objectBuffer, relation, inputPattern }) {
-  const hash = crypto.createHash("sha256");
-  hash.update("k-llvm-jit-v2\0");
-  hash.update(backendFingerprint());
-  hash.update("\0");
-  hash.update(relation);
-  hash.update("\0");
-  hash.update(JSON.stringify(inputPattern));
-  hash.update("\0");
-  hash.update(objectBuffer);
-  return hash.digest("hex");
-}
-
-function runExecutable(exePath, inputBuffer) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(exePath, [], { stdio: ["pipe", "pipe", "pipe"] });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-
-    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-    child.on("error", reject);
-    child.on("close", (status) => {
-      if (status !== 0) {
-        const stderr = Buffer.concat(stderrChunks).toString("utf8");
-        reject(new Error(`${exePath} failed with status ${status}${stderr ? `\n${stderr}` : ""}`));
-        return;
-      }
-      resolve(Buffer.concat(stdoutChunks));
-    });
-
-    child.stdin.end(inputBuffer);
-  });
-}
-
-function compileCached({ object, objectBuffer, relation, inputPattern, cacheDir }) {
-  fs.mkdirSync(cacheDir, { recursive: true });
-  const key = cacheKey({ objectBuffer, relation, inputPattern });
-  const exePath = path.join(cacheDir, `${key}.exe`);
-  if (!fs.existsSync(exePath)) {
-    const tmpPath = path.join(cacheDir, `${key}.${process.pid}.tmp`);
-    compileObjectToExecutable(object, tmpPath, { relation, inputPattern });
-    fs.renameSync(tmpPath, exePath);
-  }
-  return exePath;
-}
-
-function compileTemporary({ object, relation, inputPattern }) {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-llvm-jit-"));
-  const exePath = path.join(tmpDir, "program");
-  compileObjectToExecutable(object, exePath, { relation, inputPattern });
-  return { exePath, tmpDir };
-}
-
-try {
-  const args = argv.slice(2);
-  if (args.includes("-h") || args.includes("--help")) {
-    usage(console.log);
-    exit(0);
-  }
-
-  let relation = null;
-  let cacheDir = path.join(os.tmpdir(), "k-llvm-jit-cache");
-  let useCache = true;
-  while (args.length > 0 && args[0].startsWith("--")) {
-    const option = args.shift();
-    if (option === "--retype") {
-      relation = args.shift();
-      if (!relation) throw new Error("--retype requires a relation name");
-    } else if (option === "--cache-dir") {
-      cacheDir = args.shift();
-      if (!cacheDir) throw new Error("--cache-dir requires a path");
-    } else if (option === "--no-cache") {
-      useCache = false;
-    } else {
-      throw new Error(`Unknown option: ${option}`);
-    }
-  }
-
-  const objectPath = args.shift() || null;
-  if (objectPath == null) throw new Error("object-file is required");
-  if (args.length > 0) throw new Error(`Unexpected argument: ${args[0]}`);
-
-  const objectBuffer = fs.readFileSync(objectPath);
-  const object = decodeObject(objectBuffer);
-  const relationName = relation || object.main;
-  const inputBuffer = await readStdinBuffer();
-  const { pattern: inputPattern } = decodeWire(inputBuffer);
-
-  let tmpDir = null;
-  try {
-    const exePath = useCache
-      ? compileCached({ object, objectBuffer, relation: relationName, inputPattern, cacheDir })
-      : (() => {
-          const compiled = compileTemporary({ object, relation: relationName, inputPattern });
-          tmpDir = compiled.tmpDir;
-          return compiled.exePath;
-        })();
-    stdout.write(await runExecutable(exePath, inputBuffer));
-  } finally {
-    if (tmpDir != null) fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-} catch (error) {
-  console.error(error.stack || error.message || String(error));
-  usage();
-  exit(1);
-}

package/harness/adapters/arm64.mjs

@@ -1,105 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { BackendAdapter, BackendRunner } from "../backend.mjs";
-import { PersistentExecutable } from "../persistent.mjs";
-import { compileARM64ArtifactFromObject } from "../../backends/arm64/src/arm64.mjs";
-import { decodeWire } from "../../backend-api.mjs";
-
-class ARM64Runner extends BackendRunner {
-  constructor(backendId, servers = new Map()) {
-    super(backendId);
-    this.servers = servers;
-  }
-
-  getServer(exePath) {
-    let server = this.servers.get(exePath);
-    if (!server) {
-      server = new PersistentExecutable(exePath);
-      this.servers.set(exePath, server);
-    }
-    return server;
-  }
-
-  async runSingle(testCase, options = {}) {
-    const server = this.getServer(testCase.exePath);
-    if (options.trace) {
-      const res = await server.requestWithTrace(testCase.inputWire);
-      const decoded = decodeWire(res.payload);
-      return {
-        outputWire: res.payload,
-        outputVal: decoded.value,
-        outputPattern: decoded.pattern,
-        trace: res.trace,
-        profile: res.trace?.profile
-      };
-    } else {
-      const payload = await server.request(testCase.inputWire);
-      const decoded = decodeWire(payload);
-      return {
-        outputWire: payload,
-        outputVal: decoded.value,
-        outputPattern: decoded.pattern
-      };
-    }
-  }
-
-  async runBatch(compiledCases) {
-    for (const c of compiledCases) {
-      const server = this.getServer(c.exePath);
-      await server.request(c.inputWire);
-    }
-  }
-
-  async close() {
-    for (const server of this.servers.values()) {
-      server.close();
-    }
-    this.servers.clear();
-  }
-}
-
-export class ARM64Adapter extends BackendAdapter {
-  constructor(options = {}) {
-    const optLevel = options.optLevel || "-O2";
-    super("arm64", `Linux ARM64 ${optLevel} (persistent)`, options);
-    this.optLevel = optLevel;
-  }
-
-  isAvailable() {
-    return process.arch === "arm64" && process.platform === "linux";
-  }
-
-  async compile(testCase, options = {}) {
-    const cacheDir = options.cacheDir || path.join(process.cwd(), ".cache");
-    fs.mkdirSync(cacheDir, { recursive: true });
-    const exePath = path.join(cacheDir, `harness_arm64_${testCase.op || testCase.relName || "case"}`);
-
-    try {
-      compileARM64ArtifactFromObject(testCase.object, {
-        entry: testCase.relName || testCase.op || testCase.relationName,
-        inputPattern: testCase.inputPattern,
-        outputPattern: testCase.outputPattern,
-        outputPath: exePath,
-        optLevel: this.optLevel,
-        profile: Boolean(options.profile)
-      });
-
-      return {
-        status: "ok",
-        exePath,
-        inputWire: testCase.inputWire,
-        inputVal: testCase.inputVal,
-        outputPattern: testCase.outputPattern
-      };
-    } catch (error) {
-      return {
-        status: "failed",
-        error: error.stack || error.message || String(error)
-      };
-    }
-  }
-
-  async createRunner(compiledCases) {
-    return new ARM64Runner(this.id);
-  }
-}