@fraczak/k 6.6.0 → 6.8.0

package/backends/llvm/src/cli.mjs

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import path from "node:path";
+import { compileLibrary, compileObjectBuffer, decodeObject, loadLibrary } from "@fraczak/k/object.mjs";
+
+export function readAll(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+
+export function parseCompileOptions(args) {
+  const libraries = [];
+  const exportSpecs = [];
+  let loadedLibrary = false;
+
+  while (args.length > 0) {
+    if (args[0] === "--") {
+      args.shift();
+      break;
+    }
+    if (args[0] === "--lib") {
+      if (loadedLibrary) throw new Error("--lib may only be specified once");
+      args.shift();
+      const libPath = args.shift();
+      if (!libPath) throw new Error("--lib requires a file argument");
+      const ext = path.extname(libPath).toLowerCase();
+      if (ext === ".k") {
+        libraries.push(loadLibrary(compileLibrary(fs.readFileSync(libPath, "utf8"), { source: libPath })));
+      } else {
+        libraries.push(loadLibrary(decodeObject(fs.readFileSync(libPath))));
+      }
+      loadedLibrary = true;
+    } else if (args[0] === "--export") {
+      args.shift();
+      const spec = args.shift();
+      if (!spec) throw new Error("--export requires a spec argument (name or libname:localname)");
+      exportSpecs.push(spec);
+    } else if (args[0].startsWith("--")) {
+      break;
+    } else {
+      break;
+    }
+  }
+
+  return { libraries, exportSpecs };
+}
+
+export function fileInputType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".ko") return "ko";
+  if (ext === ".kvm") return "kvm";
+  if (ext === ".klib") return "klib";
+  return "source-file";
+}
+
+export function resolveProgramInput(args, { allowStdinSource = false } = {}) {
+  const inputArg = args.shift() ?? null;
+  if (inputArg == null) {
+    if (!allowStdinSource) throw new Error("Missing script argument");
+    return { kind: "stdin-source", sourceName: "<stdin>" };
+  }
+
+  const ext = path.extname(inputArg).toLowerCase();
+  if (fs.existsSync(inputArg)) {
+    const kind = fileInputType(inputArg);
+    return { kind, path: inputArg, sourceName: inputArg };
+  }
+
+  if ([".k", ".ko", ".kvm", ".klib"].includes(ext)) {
+    throw new Error(`Input file not found: ${inputArg}`);
+  }
+
+  return { kind: "inline-source", source: inputArg, sourceName: "<inline>" };
+}
+
+export function buildExportPreamble(exports = [], libraries = []) {
+  if (exports.length === 0) return "";
+  const aliasMap = {};
+  for (const lib of libraries) {
+    for (const [name, hash] of Object.entries(lib.relAlias || {})) {
+      if (name !== "__main__") aliasMap[name] = hash;
+    }
+    for (const [hash, entry] of Object.entries(lib.meta || {})) {
+      if (entry?.type !== "rel") continue;
+      for (const origin of entry?.origins || []) {
+        if (origin?.name && origin.name !== "__main__") {
+          aliasMap[origin.name] = hash;
+        }
+      }
+    }
+  }
+  const lines = [];
+  for (const spec of exports) {
+    const [libName, localName] = spec.includes(":") ? spec.split(":", 2) : [spec, spec];
+    const hash = aliasMap[libName];
+    if (!hash) throw new Error(`--export: '${libName}' not found in loaded libraries`);
+    const body = hash.startsWith("@") ? hash.slice(1) : hash;
+    lines.push(`${localName} = @${body};`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+export async function compileProgramInputToObject(
+  input,
+  { libraries = [], exportSpecs = [], stdin = null } = {}
+) {
+  let object;
+  if (input.kind === "inline-source") {
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + input.source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "stdin-source") {
+    if (!stdin) throw new Error("stdin source requested without a stdin stream");
+    const source = (await readAll(stdin)).toString("utf8");
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "source-file") {
+    const source = fs.readFileSync(input.path, "utf8");
+    const preamble = buildExportPreamble(exportSpecs, libraries);
+    const objBuffer = compileObjectBuffer(preamble + source, {
+      libraries,
+      source: input.sourceName
+    });
+    object = decodeObject(objBuffer);
+  } else if (input.kind === "ko" || input.kind === "klib") {
+    object = decodeObject(fs.readFileSync(input.path));
+  } else if (input.kind === "kvm") {
+    throw new Error("Compiling directly from .kvm to LLVM is not yet supported; use .k or .ko input.");
+  } else {
+    throw new Error(`Unsupported input kind: ${input.kind}`);
+  }
+
+  return object;
+}
+
+export default {
+  buildExportPreamble,
+  compileProgramInputToObject,
+  fileInputType,
+  parseCompileOptions,
+  readAll,
+  resolveProgramInput
+};

package/backends/llvm/src/executable.mjs

@@ -531,7 +531,7 @@ export function compileLLVMToExecutable(llvm, outputPath, { driver = stdioDriver
       driverPath,
       llPath,
       "-o",
-      outputPath
+      path.resolve(outputPath)
     ]);
   } finally {
     fs.rmSync(tmpDir, { recursive: true, force: true });

package/backends/llvm/src/kvm2llvm.mjs

@@ -757,6 +757,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const fieldValues = [];
           const pSrc = getReg(inst.src);
           const pPattern = regPatterns.get(cleanReg(inst.src)) || (cleanReg(inst.src) === "in" ? regPatterns.get("in") : null);
+          let productFailed = false;
 
           for (let bIdx = 0; bIdx < N; bIdx++) {
             const branch = inst.branches[bIdx];
@@ -783,12 +784,21 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
               nextBlock: branchDone
             });
 
+            if (!branchRegValues.has(cleanReg(branchRes))) {
+              productFailed = true;
+              break;
+            }
+
             ctx.lines.push(`${branchDone}:`);
             ctx.currentBlock = branchDone;
-            const fVal = branchRegValues.get(cleanReg(branchRes)) || branchRes;
+            const fVal = branchRegValues.get(cleanReg(branchRes));
             fieldValues.push({ label: branch.label, val: fVal });
           }
 
+          if (productFailed) {
+            break;
+          }
+
           const requestedSize = K_PRODUCT_HEADER_SIZE + (K_FIELD_SIZE * N);
           const product = lowerRawAlloc(ctx, requestedSize, alignArenaSize(requestedSize));
           nullCheck(ctx, product, failTarget);

package/backends/llvm/tests/integration.sh

@@ -10,8 +10,7 @@ command -v clang >/dev/null || {
 }
 
 node ../../objects/compile.mjs '()' "$TMP_DIR/id.ko"
-printf '[["open-product",[]]]' > "$TMP_DIR/input.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/input.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/id.ko" "$TMP_DIR/id.ll"
 grep -q '@k_llvm_metadata' "$TMP_DIR/id.ll"
 grep -q 'define %k_result @k_main' "$TMP_DIR/id.ll"
 
@@ -19,32 +18,28 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/identity-driver.c "$TMP
 "$TMP_DIR/id"
 
 node ../../objects/compile.mjs '.x' "$TMP_DIR/projection.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[]]]' > "$TMP_DIR/projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/projection.pattern.json" "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/projection.ko" "$TMP_DIR/projection.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/projection.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/projection.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/projection-driver.c "$TMP_DIR/projection.ll" -o "$TMP_DIR/projection"
 "$TMP_DIR/projection"
 
 node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/product.ko"
-printf '[["closed-product",[["x",1],["y",2]]],["closed-product",[["valA",1]]],["closed-product",[["valB",2]]]]' > "$TMP_DIR/product.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/product.pattern.json" "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/product.ko" "$TMP_DIR/product.ll"
 grep -q 'store i32 1, ptr %i32_slot' "$TMP_DIR/product.ll"
 grep -q 'store ptr %product_fields' "$TMP_DIR/product.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/product-driver.c "$TMP_DIR/product.ll" -o "$TMP_DIR/product"
 "$TMP_DIR/product"
 
 node ../../objects/compile.mjs '|tag' "$TMP_DIR/variant.ko"
-printf '[["closed-product",[]]]' > "$TMP_DIR/variant.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant.pattern.json" "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant.ko" "$TMP_DIR/variant.ll"
 grep -q 'call ptr @k_rt_alloc' "$TMP_DIR/variant.ll"
 grep -q 'store i32 2, ptr %i32_slot' "$TMP_DIR/variant.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-driver.c "$TMP_DIR/variant.ll" -o "$TMP_DIR/variant"
 "$TMP_DIR/variant"
 
 node ../../objects/compile.mjs '/tag' "$TMP_DIR/variant-projection.ko"
-printf '[["closed-union",[["tag",1]]],["closed-product",[]]]' > "$TMP_DIR/variant-projection.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/variant-projection.pattern.json" "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/variant-projection.ko" "$TMP_DIR/variant-projection.ll"
 grep -q 'tag_byte_ptr' "$TMP_DIR/variant-projection.ll"
 grep -q 'payload_slot' "$TMP_DIR/variant-projection.ll"
 ! grep -q 'call i32 @k_variant_tag_matches' "$TMP_DIR/variant-projection.ll"
@@ -53,24 +48,21 @@ clang -Wno-override-module -Iruntime runtime/krt.c tests/variant-projection-driv
 "$TMP_DIR/variant-projection"
 
 node ../../objects/compile.mjs '(.x .y)' "$TMP_DIR/composition.ko"
-printf '[["closed-product",[["x",1]]],["closed-product",[["y",2]]],["closed-product",[]]]' > "$TMP_DIR/composition.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/composition.pattern.json" "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/composition.ko" "$TMP_DIR/composition.ll"
 grep -q 'product_fields_ptr' "$TMP_DIR/composition.ll"
 ! grep -q 'call ptr @k_product_get_at' "$TMP_DIR/composition.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/composition-driver.c "$TMP_DIR/composition.ll" -o "$TMP_DIR/composition"
 "$TMP_DIR/composition"
 
 node ../../objects/compile.mjs 'pick = .x; {.a pick left, .b pick right}' "$TMP_DIR/relation.ko"
-printf '[["open-product",[["a",1],["b",2]]],["open-product",[["x",3]]],["open-product",[["x",4]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/relation.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/relation.pattern.json" "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/relation.ko" "$TMP_DIR/relation.ll"
 grep -q 'define internal %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 grep -q 'call %k_result @k_rel_pick' "$TMP_DIR/relation.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/relation-driver.c "$TMP_DIR/relation.ll" -o "$TMP_DIR/relation"
 "$TMP_DIR/relation"
 
 node ../../objects/compile.mjs '< /x |left, /y |right >' "$TMP_DIR/union.ko"
-printf '[["closed-union",[["x",1],["y",2]]],["closed-product",[]],["closed-product",[]]]' > "$TMP_DIR/union.pattern.json"
-node ./bin/k-llvm-compile.mjs --input-pattern "$TMP_DIR/union.pattern.json" "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
+node ./bin/k-llvm-compile.mjs "$TMP_DIR/union.ko" "$TMP_DIR/union.ll"
 grep -q 'define internal %k_result @k_union_arm_0' "$TMP_DIR/union.ll"
 grep -q 'call %k_result @k_union_arm_1' "$TMP_DIR/union.ll"
 clang -Wno-override-module -Iruntime runtime/krt.c tests/union-driver.c "$TMP_DIR/union.ll" -o "$TMP_DIR/union"
@@ -94,8 +86,7 @@ node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/run-product.
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-product-input.kv"
 node ./bin/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
 
-printf '[["closed-product",[["x",1],["y",3]]],["open-union",[["left",2]]],["closed-product",[]],["open-union",[["right",2]]]]' > "$TMP_DIR/run-envelope.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/run-envelope.pattern.json" "$TMP_DIR/run.ko" "$TMP_DIR/run-exe"
+node ./bin/k-llvm-build.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' -o "$TMP_DIR/run-exe"
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | "$TMP_DIR/run-exe" \
@@ -104,15 +95,13 @@ printf '{"x":"left","y":"right"}' \
 
 printf '{"x":"left"}' | node ../../codecs/k-parse.mjs | "$TMP_DIR/run-exe" && exit 1 || test "$?" -eq 5
 
-printf '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]' > "$TMP_DIR/identity-variant.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-variant.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-exe"
+node ./bin/k-llvm-build.mjs '?<{} left, {} right, ...>' -o "$TMP_DIR/id-exe"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const pattern = [[\"open-union\",[[\"left\",1],[\"right\",1]]],[\"closed-product\",[]]]; stdout.write(encodeToWire(Value.variant(\"left\", Value.product({}), pattern), pattern));" \
   | "$TMP_DIR/id-exe" \
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
-printf '[["closed-union",[["+",1],["-",1]]],["closed-union",[["0",1],["1",1],["_",2]]],["closed-product",[]]]' > "$TMP_DIR/identity-int.pattern.json"
-node ./bin/k-llvm-build.mjs --input-pattern "$TMP_DIR/identity-int.pattern.json" "$TMP_DIR/id.ko" "$TMP_DIR/id-int-exe"
+node ./bin/k-llvm-build.mjs '$bits = < {} _, bits 0, bits 1 >; $int = < bits "+", bits "-" >; $int' -o "$TMP_DIR/id-int-exe"
 printf '2' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/id-int-exe" \
@@ -121,6 +110,13 @@ printf '2' \
 
 node --input-type=module -e "import assert from 'node:assert/strict'; import { spawn } from 'node:child_process'; import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; import { parse, INT_PATTERN } from '../../codecs/int.mjs'; const input = encodeToWire(parse('2'), INT_PATTERN); const header = Buffer.alloc(4); header.writeUInt32BE(input.length); const child = spawn(process.argv[1], ['--server']); const chunks = []; const stderr = []; child.stdout.on('data', (chunk) => chunks.push(chunk)); child.stderr.on('data', (chunk) => stderr.push(chunk)); child.stdin.end(Buffer.concat([header, input])); const status = await new Promise((resolve, reject) => { child.on('error', reject); child.on('close', resolve); }); assert.equal(status, 0, Buffer.concat(stderr).toString('utf8')); const output = Buffer.concat(chunks); const length = output.readUInt32BE(0); assert.equal(output.length, 4 + length); assert.deepEqual(decodeWire(output.subarray(4)).value.toJSON(), parse('2').toJSON());" "$TMP_DIR/id-int-exe"
 
+node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
+printf '987654321' \
+  | node ../../codecs/int.mjs --parse \
+  | "$TMP_DIR/square-exe" \
+  | node ../../codecs/int.mjs --print \
+  | grep -qx '975461057789971041'
+
 printf '{"x":"left","y":"right"}' \
   | node ../../codecs/k-parse.mjs \
   | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \

package/backends/wasm/bin/k-wasm-compile.mjs

@@ -20,6 +20,7 @@ function usage(stream = console.error) {
   stream("  wasm-file       Output .wasm path. Writes the binary artifact to stdout when omitted.");
   stream("");
   stream("Options:");
+  stream("  -o, --output     Specify output file path explicitly.");
   stream("  --lib file       Load one .klib dependency before compiling.");
   stream("  --export spec    Export a library alias into source scope. May be repeated.");
   stream("                   spec is 'name' or 'libname:localname'.");
@@ -33,10 +34,24 @@ try {
     exit(0);
   }
 
-  const { libraries, exportSpecs } = parseCompileOptions(args);
-  const input = resolveProgramInput(args, { allowStdinSource: true });
-  const outputPath = args.shift();
-  if (args.length > 0) throw new Error("Too many arguments");
+  let explicitOutput = null;
+  const remainingArgs = [];
+  while (args.length > 0) {
+    const arg = args[0];
+    if (arg === "-o" || arg === "--output") {
+      args.shift();
+      explicitOutput = args.shift();
+      if (!explicitOutput) throw new Error("-o/--output requires a file argument");
+    } else {
+      remainingArgs.push(args.shift());
+    }
+  }
+
+  const { libraries, exportSpecs } = parseCompileOptions(remainingArgs);
+  const input = resolveProgramInput(remainingArgs, { allowStdinSource: true });
+  const positionalOutput = remainingArgs.shift();
+  if (remainingArgs.length > 0) throw new Error("Too many arguments");
+  const outputPath = explicitOutput || positionalOutput || null;
   const artifact = await compileProgramInput(input, { libraries, exportSpecs, stdin });
   if (outputPath == null) {
     stdout.write(artifact);