@fraczak/k 7.0.1 → 7.1.0

package/backends/llvm/src/executable.mjs

@@ -7,7 +7,8 @@ import { isProduct, isVariant } from "@fraczak/k/Value.mjs";
 import { exportPatternGraph } from "@fraczak/k/codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "@fraczak/k/codecs/runtime/pattern-json.mjs";
 import { specializeKVM } from "@fraczak/k/kvm.mjs";
-import { compileObjectToLLVM } from "./llvm.mjs";
+import { lowerPKIRToKVM } from "@fraczak/k/backend-api.mjs";
+import { compileObjectToLLVM, compileLLVMArtifactFromPKIR } from "./llvm.mjs";
 import { compileKVMModuleToLLVM } from "./kvm2llvm.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -263,6 +264,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "static int write_frame(k_wire_prefix *prefix, k_pattern *pattern, k_value *value) {",
     "  size_t length = 0;",
     "  unsigned char *payload = k_encode_wire_as_with_prefix(prefix, pattern, value, &length);",
+    "  if (payload == NULL) {",
+    "    payload = k_encode_wire(value, &length);",
+    "  }",
     "  if (payload == NULL || length > UINT32_MAX) {",
     "    free(payload);",
     "    return 0;",
@@ -292,7 +296,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_wire_input_free(input);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    return 5;",
     "  }",
@@ -350,7 +354,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_value *in_val = k_decode_wire_value_with_prefix(payload, length, &input_prefix, &compiled_input_pattern, rt);",
     "    if (in_val == 0) {",
     "      k_wire_input envelope = k_decode_wire_envelope(payload, length, rt);",
-    "      if (envelope.value != 0 && envelope.pattern != 0 && k_pattern_equal(envelope.pattern, &compiled_input_pattern)) {",
+    "      if (envelope.value != 0 && envelope.pattern != 0 && k_pattern_compatible(envelope.pattern, &compiled_input_pattern)) {",
     "        in_val = envelope.value;",
     "      } else {",
     "        k_wire_input_free(envelope);",
@@ -376,6 +380,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    }",
     "    size_t out_len = 0;",
     "    unsigned char *out_payload = k_encode_wire_as_with_prefix(&output_prefix, &compiled_output_pattern, result.value, &out_len);",
+    "    if (out_payload == NULL) {",
+    "      out_payload = k_encode_wire(result.value, &out_len);",
+    "    }",
     "    if (tracing) t4 = monotonic_ns();",
     "    int ok = 0;",
     "    uint64_t write_start = t4;",
@@ -437,7 +444,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_rt_free(input_rt);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    k_rt_free(run_rt);",
     "    k_rt_free(input_rt);",
@@ -478,7 +485,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_rt_free(rt);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    k_wire_prefix_free(output_prefix);",
     "    k_rt_free(rt);",
@@ -495,6 +502,9 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "  }",
     "  size_t output_length = 0;",
     "  unsigned char *output_payload = k_encode_wire_as_with_prefix(&output_prefix, &compiled_output_pattern, result.value, &output_length);",
+    "  if (output_payload == NULL) {",
+    "    output_payload = k_encode_wire(result.value, &output_length);",
+    "  }",
     "  if (tracing) t3 = monotonic_ns();",
     "  int ok = output_payload != NULL && fwrite(output_payload, 1, output_length, stdout) == output_length && fflush(stdout) == 0;",
     "  if (tracing) {",
@@ -540,12 +550,25 @@ export function compileLLVMToExecutable(llvm, outputPath, { driver = stdioDriver
   }
 }
 
-export function compileObjectToExecutable(object, outputPath, { relation = object.main, inputPattern = null, runtimeMode = "fast", clangOpt = "-O3" } = {}) {
-  const { inputPattern: compiledInputPattern, outputPattern, llvm } = compileObjectToLLVM(object, {
-    relation,
-    inputPattern: inputPattern || inputPatternForObjectRelation(object, relation),
-    runtimeMode
-  });
+export function compileObjectToExecutable(
+  object,
+  outputPath,
+  {
+    relation = object.main,
+    inputPattern = null,
+    runtimeMode = "fast",
+    clangOpt = "-O3",
+    usePKIR = false
+  } = {}
+) {
+  const { inputPattern: compiledInputPattern, outputPattern, llvm } =
+    compileObjectToLLVM(object, {
+      relation,
+      inputPattern:
+        inputPattern || inputPatternForObjectRelation(object, relation),
+      runtimeMode,
+      usePKIR
+    });
   compileLLVMToExecutable(llvm, outputPath, {
     driver: stdioDriverSource({
       inputPattern: compiledInputPattern,
@@ -559,7 +582,8 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
   entry = null,
   inputPattern = null,
   runtimeMode = "fast",
-  clangOpt = "-O3"
+  clangOpt = "-O3",
+  usePKIR = false
 } = {}) {
   let kvm = kvmInput;
   if (kvm?.format === "k-vm") {
@@ -578,7 +602,8 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
     relation: entryFunc,
     inputPattern: compiledInputPattern,
     outputPattern,
-    runtimeMode
+    runtimeMode,
+    usePKIR
   });
   compileLLVMToExecutable(llvm, outputPath, {
     driver: stdioDriverSource({
@@ -589,10 +614,102 @@ export function compileKVMToExecutable(kvmInput, outputPath, {
   });
 }
 
-export function compileObjectAndRun(object, { relation = object.main, input, expected = null, inputPattern = null }) {
+export function compilePKIRToExecutable(
+  pkirInput,
+  outputPath,
+  {
+    entry = null,
+    inputPattern = null,
+    runtimeMode = "fast",
+    clangOpt = "-O3"
+  } = {}
+) {
+  let kvmProgram;
+  let entryFunc;
+  if (
+    (pkirInput.format === "pk-ir" || pkirInput.format === "k-pkir") &&
+    pkirInput.functions
+  ) {
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+    entryFunc =
+      entry ||
+      pkirInput.entry ||
+      Object.keys(kvmProgram)[0] ||
+      "__main__";
+  } else if (pkirInput.instructions) {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entryFunc = pkirInput.name || entry || "__main__";
+    kvmProgram = { [entryFunc]: kvm };
+    const scan = (insts) => {
+      for (const inst of insts || []) {
+        if (inst.op === "call" && inst.func && !kvmProgram[inst.func]) {
+          kvmProgram[inst.func] = kvm;
+        }
+        if (inst.branches) {
+          for (const b of inst.branches) scan(b.body);
+        }
+      }
+    };
+    scan(kvm.body);
+  } else if (pkirInput.functions) {
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+    entryFunc =
+      entry ||
+      pkirInput.entry ||
+      Object.keys(kvmProgram)[0] ||
+      "__main__";
+  } else {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entryFunc = pkirInput.name || entry || "__main__";
+    kvmProgram = { [entryFunc]: kvm };
+  }
+  return compileKVMToExecutable(
+    {
+      format: "k-vm",
+      layer: "KVM",
+      entry: entryFunc,
+      functions: kvmProgram
+    },
+    outputPath,
+    {
+      entry: entryFunc,
+      inputPattern,
+      runtimeMode,
+      clangOpt,
+      usePKIR: true
+    }
+  );
+}
+
+export function compileObjectAndRun(
+  object,
+  {
+    relation = object.main,
+    input,
+    expected = null,
+    inputPattern = null,
+    usePKIR = false
+  }
+) {
   const { llvm } = compileObjectToLLVM(object, {
     relation,
-    inputPattern: inputPattern || inputPatternForObjectValue(object, input, relation)
+    inputPattern:
+      inputPattern || inputPatternForObjectValue(object, input, relation),
+    usePKIR
   });
   return compileAndRunLLVM(llvm, { input, expected });
 }
+
+export function compilePKIRAndRun(
+  pkirInput,
+  { input, expected = null, options = {} } = {}
+) {
+  const llvm = compileLLVMArtifactFromPKIR(pkirInput, options);
+  return compileAndRunLLVM(llvm, { input, expected });
+}

package/backends/llvm/src/kvm2llvm.mjs

@@ -35,15 +35,17 @@ function alignArenaSize(size) {
 }
 
 function cStringBytes(text) {
-  return [...Buffer.from(text, "utf8"), 0]
-    .map((byte) => {
-      if (byte === 10) return "\\0A";
-      if (byte === 34) return "\\22";
-      if (byte === 92) return "\\5C";
-      if (byte >= 32 && byte <= 126) return String.fromCharCode(byte);
-      return `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
-    })
-    .join("");
+  const buf = Buffer.from(text, "utf8");
+  let out = "";
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i];
+    if (byte === 10) out += "\\0A";
+    else if (byte === 34) out += "\\22";
+    else if (byte === 92) out += "\\5C";
+    else if (byte >= 32 && byte <= 126) out += String.fromCharCode(byte);
+    else out += `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
+  }
+  return out + "\\00";
 }
 
 export function runtimeDeclarations() {
@@ -449,12 +451,15 @@ function hasSelfTailCall(insts, funcName, isTail = true) {
   return false;
 }
 
-function getFieldEdgeIndex(inst, regPatterns, kvmFunc) {
+function getFieldEdgeIndex(inst, regPatterns, kvmFunc, ctx = {}) {
   const srcReg = cleanReg(inst.src);
   const srcPattern = regPatterns.get(srcReg) || (srcReg === "in" ? kvmFunc.inputPattern : null);
   if (Array.isArray(srcPattern) && srcPattern.length > 0) {
     const root = srcPattern[0];
-    if ((root[0] === "open-product" || root[0] === "closed-product") && Array.isArray(root[1])) {
+    const allowed = ctx.usePKIR
+      ? root[0] === "closed-product"
+      : (root[0] === "open-product" || root[0] === "closed-product");
+    if (allowed && Array.isArray(root[1])) {
       const idx = root[1].findIndex(([l]) => l === inst.label);
       if (idx >= 0) return idx;
     }
@@ -512,6 +517,7 @@ export function compileKVMModuleToLLVM(entryName, kvmProgram, options = {}) {
     labels,
     functionNames,
     runtimeMode,
+    usePKIR: Boolean(options.usePKIR),
     armIndex: 0,
     unionExprIndex: 0,
     syntheticFunctions: [],
@@ -551,8 +557,7 @@ export function compileKVMModuleToLLVM(entryName, kvmProgram, options = {}) {
   const payload = JSON.stringify({
     format: ARTIFACT_FORMAT,
     version: ARTIFACT_VERSION,
-    relation,
-    kvm: kvmProgram
+    relation
   });
   const payloadBytes = Buffer.byteLength(payload, "utf8") + 1;
   const symbol = llvmIdentifier(options.symbol || relation);
@@ -583,6 +588,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
     labels: moduleCtx.labels,
     functionNames: moduleCtx.functionNames,
     runtimeMode: moduleCtx.runtimeMode,
+    usePKIR: moduleCtx.usePKIR,
     allocas: [],
     lines: [],
     currentBlock: "entry",
@@ -674,7 +680,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
         case "project_field": {
           const input = getReg(inst.src);
           nullCheck(ctx, input, failTarget);
-          const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc);
+          const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc, ctx);
           const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
@@ -815,11 +821,32 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           storeI64At(ctx, product, K_VALUE_PRODUCT_CAPACITY_OFFSET, N);
           storePtrAt(ctx, product, K_VALUE_PRODUCT_FIELDS_OFFSET, fields);
 
-          const sortedFields = [...fieldValues].sort((a, b) => {
-            if (a.label < b.label) return -1;
-            if (a.label > b.label) return 1;
-            return 0;
-          });
+          let sortedFields;
+          if (Array.isArray(inst.pattern) && inst.pattern.length > 0) {
+            const root = inst.pattern[0];
+            if (
+              (root[0] === "open-product" ||
+                root[0] === "closed-product") &&
+              Array.isArray(root[1])
+            ) {
+              const order = new Map(root[1].map(([l], i) => [l, i]));
+              sortedFields = [...fieldValues].sort((a, b) => {
+                const aI = order.has(a.label)
+                  ? order.get(a.label)
+                  : 999999;
+                const bI = order.has(b.label)
+                  ? order.get(b.label)
+                  : 999999;
+                if (aI !== bI) return aI - bI;
+                return a.label.localeCompare(b.label);
+              });
+            }
+          }
+          if (!sortedFields) {
+            sortedFields = [...fieldValues].sort((a, b) =>
+              a.label.localeCompare(b.label)
+            );
+          }
 
           for (let sIdx = 0; sIdx < N; sIdx++) {
             const { label: fLabel, val: fVal } = sortedFields[sIdx];
@@ -838,12 +865,12 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const uInput = getReg(inst.src);
 
           if (!isTopLevel) {
-            // Nested union: synthesize a helper function @k_union_expr_${index}
+            // Nested union: synthesize helper @k_union_expr_${index}
             const exprIndex = moduleCtx.unionExprIndex++;
             const exprName = `@k_union_expr_${exprIndex}`;
             const exprFunc = {
               name: `union_expr_${exprIndex}`,
-              inputPattern: kvmFunc.inputPattern,
+              inputPattern: regPatterns.get(cleanReg(inst.src)) || null,
               outputPattern: kvmFunc.outputPattern,
               body: [
                 { op: "id", dest: "%v0", src: "%in" },
@@ -863,7 +890,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
             break;
           }
 
-          // Top-level union: synthesize arm functions @k_union_arm_${index}
+          // Top-level union: synthesize arms @k_union_arm_${index}
           const mark = lowerRtMark(ctx);
           const unionDone = ctx.blockName("union_done");
           const N = inst.branches.length;
@@ -877,7 +904,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
 
             const armFunc = {
               name: `union_arm_${armIndex}`,
-              inputPattern: kvmFunc.inputPattern,
+              inputPattern: regPatterns.get(cleanReg(inst.src)) || null,
               outputPattern: kvmFunc.outputPattern,
               body: branch.body
             };

package/backends/llvm/src/llvm.mjs

@@ -7,7 +7,11 @@ import {
   objectToKVMArtifact,
   specializeKVM,
   lowerKIRToKVM,
-  objectToKIRP
+  objectToKIRP,
+  compileRelationToPKIR,
+  lowerPKIRToKVM,
+  exportPatternGraph,
+  patternToPropertyList
 } from "@fraczak/k/backend-api.mjs";
 import { compileKVMModuleToLLVM } from "./kvm2llvm.mjs";
 
@@ -45,15 +49,17 @@ function alignArenaSize(size) {
 }
 
 function cStringBytes(text) {
-  return [...Buffer.from(text, "utf8"), 0]
-    .map((byte) => {
-      if (byte === 10) return "\\0A";
-      if (byte === 34) return "\\22";
-      if (byte === 92) return "\\5C";
-      if (byte >= 32 && byte <= 126) return String.fromCharCode(byte);
-      return `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
-    })
-    .join("");
+  const buf = Buffer.from(text, "utf8");
+  let out = "";
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i];
+    if (byte === 10) out += "\\0A";
+    else if (byte === 34) out += "\\22";
+    else if (byte === 92) out += "\\5C";
+    else if (byte >= 32 && byte <= 126) out += String.fromCharCode(byte);
+    else out += `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
+  }
+  return out + "\\00";
 }
 
 function readPattern(inputPattern) {
@@ -921,7 +927,8 @@ function emitFunctionBody(symbol, body, ctx, linkage = "", options = {}) {
   }
   const value = lowerExpr(ctx, body, input, { tail: options.tail !== false });
   if (value === false) {
-    // The expression emitted complete control flow, including all returns.
+    // The expression emitted complete control flow, including all
+    // returns.
   } else if (value == null) {
     unsupported(ctx);
   } else {
@@ -986,8 +993,7 @@ export function emitLLVMModule(input, options = {}) {
   const payload = JSON.stringify({
     format: ARTIFACT_FORMAT,
     version: ARTIFACT_VERSION,
-    relation,
-    kir
+    relation
   });
   const payloadBytes = Buffer.byteLength(payload, "utf8") + 1;
   const symbol = llvmIdentifier(options.symbol || relation);
@@ -1009,25 +1015,74 @@ export function emitLLVMModule(input, options = {}) {
 }
 
 export function compileObjectToLLVM(object, options = {}) {
-  const inputPattern = options.inputPattern ? readPattern(options.inputPattern) : null;
+  const inputPattern = options.inputPattern
+    ? readPattern(options.inputPattern)
+    : null;
   const relation = options.relation || object.main;
   let targetObject = object;
   let entryInputPattern = inputPattern;
   let outputPattern = null;
 
-  if (inputPattern) {
-    const retyped = retypeObjectRelationForBackend(object, relation, inputPattern, {
-      source: options.source || "<k-llvm>"
-    });
+  if (options.usePKIR) {
+    const rel = object.rels?.[relation] ||
+      (object.relAlias?.[relation] &&
+       object.rels?.[object.relAlias[relation]]) ||
+      object.rels?.[object.main];
+    if (rel?.typePatternGraph) {
+      const graph = rel.typePatternGraph;
+      if (!entryInputPattern &&
+          rel.def?.patterns?.[0] !== undefined) {
+        const inId = graph.find(rel.def.patterns[0]);
+        entryInputPattern =
+          patternToPropertyList(exportPatternGraph(graph, inId));
+      }
+      if (rel.def?.patterns?.[1] !== undefined) {
+        const outId = graph.find(rel.def.patterns[1]);
+        outputPattern =
+          patternToPropertyList(exportPatternGraph(graph, outId));
+      }
+    }
+  } else if (inputPattern) {
+    const retyped = retypeObjectRelationForBackend(
+      object, relation, inputPattern, {
+        source: options.source || "<k-llvm>"
+      }
+    );
     targetObject = retyped.retypedObject;
     entryInputPattern = retyped.inputPattern;
     outputPattern = retyped.outputPattern;
   }
 
-  const retypedKir = objectToKIRP(targetObject);
-  const functions = lowerKIRToKVM(retypedKir);
+  let functions;
+  let retypedKir = null;
   const entry = relation || targetObject.main || "__main__";
 
+  if (options.usePKIR) {
+    functions = {};
+    for (const [name, relDef] of Object.entries(targetObject.rels || {})) {
+      const pkir = compileRelationToPKIR(relDef, name);
+      functions[name] = lowerPKIRToKVM(pkir);
+    }
+    for (const [alias, target] of Object.entries(targetObject.relAlias || {})) {
+      if (functions[target] && !functions[alias]) {
+        functions[alias] = functions[target];
+      }
+      const stripped = target.startsWith("@") ? target.slice(1) : target;
+      if (functions[stripped] && !functions[alias]) {
+        functions[alias] = functions[stripped];
+      }
+      if (functions[alias] && !functions[target]) {
+        functions[target] = functions[alias];
+      }
+    }
+    if (relation && !functions[relation] && functions[targetObject.main]) {
+      functions[relation] = functions[targetObject.main];
+    }
+  } else {
+    retypedKir = objectToKIRP(targetObject);
+    functions = lowerKIRToKVM(retypedKir);
+  }
+
   const specializedKvm = {
     format: "k-vm",
     version: 1,
@@ -1064,6 +1119,63 @@ export function compileLLVMArtifactFromKVM(kvmInput, options = {}) {
   return compileKVMModuleToLLVM(entry, functions, options);
 }
 
+export function compileLLVMArtifactFromPKIR(pkirInput, options = {}) {
+  let kvmProgram;
+  let entry;
+  if (
+    (pkirInput.format === "pk-ir" || pkirInput.format === "k-pkir") &&
+    pkirInput.functions
+  ) {
+    entry =
+      pkirInput.entry ||
+      options.entry ||
+      Object.keys(pkirInput.functions)[0] ||
+      "__main__";
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+  } else if (pkirInput.instructions) {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entry = pkirInput.name || options.entry || "__main__";
+    kvmProgram = { [entry]: kvm };
+    const scan = (insts) => {
+      for (const inst of insts || []) {
+        if (inst.op === "call" && inst.func && !kvmProgram[inst.func]) {
+          kvmProgram[inst.func] = kvm;
+        }
+        if (inst.branches) {
+          for (const b of inst.branches) scan(b.body);
+        }
+      }
+    };
+    scan(kvm.body);
+  } else if (pkirInput.functions) {
+    entry =
+      pkirInput.entry ||
+      options.entry ||
+      Object.keys(pkirInput.functions)[0] ||
+      "__main__";
+    kvmProgram = {};
+    for (const [name, f] of Object.entries(pkirInput.functions)) {
+      kvmProgram[name] = lowerPKIRToKVM(f);
+    }
+  } else {
+    const kvm = lowerPKIRToKVM(pkirInput);
+    entry = pkirInput.name || options.entry || "__main__";
+    kvmProgram = { [entry]: kvm };
+  }
+  return compileLLVMArtifactFromKVM(
+    {
+      format: "k-vm",
+      layer: "KVM",
+      entry,
+      functions: kvmProgram
+    },
+    options
+  );
+}
+
 export function compileLLVMArtifactFromObject(object, options = {}) {
   return compileObjectToLLVM(object, options);
 }
@@ -1079,6 +1191,7 @@ export default {
   compileBufferToLLVM,
   compileObjectToLLVM,
   compileLLVMArtifactFromKVM,
+  compileLLVMArtifactFromPKIR,
   compileLLVMArtifactFromObject,
   emitLLVMModule,
   llvmIdentifier

package/backends/llvm/tests/integration.sh

@@ -72,19 +72,19 @@ node ./bin/k-llvm-compile.mjs --help | grep -q 'Compile a k .ko/.klib object'
 
 node ./bin/k-llvm-build.mjs --help | grep -q 'binary k pattern+value envelope'
 
-node ./bin/k-llvm-jit.mjs --help | grep -q 'stdin binary envelope'
+node ./bin/k-llvm.mjs --help | grep -q 'binary pattern+value wire stream'
 
-node ./bin/k-llvm-run.mjs --help | grep -q 'Compile and execute a k .ko/.klib object'
+node ./tests/k-llvm-run.mjs --help | grep -q 'Compile and execute a k .ko/.klib object'
 
 node ../../objects/compile.mjs '.x' "$TMP_DIR/run.ko"
 printf '{"x":"left","y":"right"}' > "$TMP_DIR/run-input.kv"
 printf '"left"' > "$TMP_DIR/run-expected.kv"
-node ./bin/k-llvm-run.mjs --expect "$TMP_DIR/run-expected.kv" "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx 'OK'
-node ./bin/k-llvm-run.mjs "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx '"left"'
+node ./tests/k-llvm-run.mjs --expect "$TMP_DIR/run-expected.kv" "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx 'OK'
+node ./tests/k-llvm-run.mjs "$TMP_DIR/run.ko" "$TMP_DIR/run-input.kv" | grep -qx '"left"'
 
 node ../../objects/compile.mjs '{ .x fieldA, .y fieldB }' "$TMP_DIR/run-product.ko"
 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"}'
+node ./tests/k-llvm-run.mjs "$TMP_DIR/run-product.ko" "$TMP_DIR/run-product-input.kv" | grep -qx '{"fieldA":"left","fieldB":"right"}'
 
 node ./bin/k-llvm-build.mjs '?{<{}=X0 left, ...> x, <X0 right, ...> y} .x' -o "$TMP_DIR/run-exe"
 printf '{"x":"left","y":"right"}' \
@@ -130,31 +130,31 @@ printf '987654321' \
 
 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" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/run.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"left"'
 
 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));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | 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",[]]]'
 
 node ../../objects/compile.mjs '/"ह" |"😀"' "$TMP_DIR/unicode-variant.ko"
 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 = [[\"closed-union\", [[\"ह\", 1]]], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant('ह', Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/unicode-variant.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/unicode-variant.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"😀"'
 
 node ../../objects/compile.mjs '/"a\u0000b" |"nul-ok"' "$TMP_DIR/nul-variant.ko"
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const tag = 'a\u0000b'; const pattern = [[\"closed-union\", [[tag, 1]]], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant(tag, Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/nul-variant.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/nul-variant.ko" \
   | node ../../codecs/k-print.mjs \
   | grep -qx '"nul-ok"'
 
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const pattern = [[\"closed-product\", labels.map((label) => [label, 1])], [\"closed-product\", []]]; const value = Value.product(Object.fromEntries(labels.map((label) => [label, Value.product({})])), pattern); stdout.write(encodeToWire(value, pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | node --input-type=module -e "import assert from 'node:assert/strict'; import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; for await (const chunk of stdin) chunks.push(chunk); const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const { pattern } = decodeWire(Buffer.concat(chunks)); assert.equal(pattern[0][0], 'closed-product'); assert.deepEqual(new Set(pattern[0][1].map(([label]) => label)), new Set(labels));"
 
 node --input-type=module -e "import { stdout } from 'node:process'; import { encodeToWire } from '../../codecs/runtime/prefix-codec.mjs'; import { Value } from '../../Value.mjs'; const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const pattern = [[\"open-union\", labels.map((label) => [label, 1])], [\"closed-product\", []]]; stdout.write(encodeToWire(Value.variant('a\u0000b', Value.product({}), pattern), pattern));" \
-  | node ./bin/k-llvm-jit.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
+  | node ./bin/k-llvm.mjs --cache-dir "$TMP_DIR/jit-cache" "$TMP_DIR/id.ko" \
   | node --input-type=module -e "import assert from 'node:assert/strict'; import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; for await (const chunk of stdin) chunks.push(chunk); const labels = ['a', 'é', 'ह', '\uE000', '😀', '𠀀', 'a\u0000b']; const { pattern, value } = decodeWire(Buffer.concat(chunks)); assert.equal(pattern[0][0], 'open-union'); assert.deepEqual(new Set(pattern[0][1].map(([label]) => label)), new Set(labels)); assert.equal(value.tag, 'a\u0000b');"