@scriptc/compiler 0.2.2 → 0.2.3

package/dist/backend/llvm/dyn.js

@@ -60,7 +60,7 @@ export class LlDyn {
     }
     /** Branch to a variant only after its literal discriminator and complete
      * structure match. Use the same path for predicates and builders. */
-    unionArmMatch(B, def, tag, yes, no) {
+    unionArmMatch(B, def, tag, yes, no, preserveRefs = false) {
         const guard = def.discriminant?.cases.find((candidate) => candidate.tag === tag);
         if (guard && def.discriminant) {
             const structure = B.newLabel("du.shape");
@@ -81,7 +81,7 @@ export class LlDyn {
             B.startBlock(structure);
         }
         const matches = B.tmp();
-        B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag])}(ptr %d)`);
+        B.line(`${matches} = call zeroext i1 @${this.dynMatchHelper(def.arms[tag], preserveRefs)}(ptr %d)`);
         B.condBr(matches, yes, no);
     }
     get S() { return this.host.sizeType; }
@@ -93,7 +93,7 @@ export class LlDyn {
     }
     /** The value LLVM type of a dynCheck result / toDyn operand for `t`. */
     valTy(t) {
-        return t.kind === "f64" || t.kind === "date" ? "double" : t.kind === "bool" ? "i1" : "ptr";
+        return t.kind === "f64" || t.kind === "date" || t.kind === "procStream" ? "double" : t.kind === "bool" ? "i1" : "ptr";
     }
     collectionDynOps(t) {
         const key = typeKey(t);
@@ -342,13 +342,14 @@ export class LlDyn {
         return matched;
     }
     /** `sc_dm_<n>(ptr d) -> i1` — does this dyn fit T? Never throws. */
-    dynMatchHelper(t) {
+    dynMatchHelper(t, preserveRefs = false) {
         const key = typeKey(t);
-        const existing = this.dynMatchers.get(key);
+        const matcherKey = preserveRefs ? `identity:${key}` : key;
+        const existing = this.dynMatchers.get(matcherKey);
         if (existing)
             return existing;
         const name = `sc_dm_${this.dynMatchers.size}`;
-        this.dynMatchers.set(key, name);
+        this.dynMatchers.set(matcherKey, name);
         const B = new BlockBuilder();
         if (isRefCounted(t) && t.kind !== "dyn") {
             const matched = this.typedRefMatches(B, t);
@@ -369,12 +370,17 @@ export class LlDyn {
             const lPlain = B.newLabel("dm.tr.plain");
             B.condBr(capsule, lCapsule, lPlain);
             B.startBlock(lCapsule);
-            const materialized = B.tmp();
-            const matched = B.tmp();
-            B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
-            B.line(`${matched} = call zeroext i1 @${name}(ptr ${materialized})`);
-            B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
-            B.terminate(`ret i1 ${matched}`);
+            if (preserveRefs) {
+                B.terminate(`ret i1 false`);
+            }
+            else {
+                const materialized = B.tmp();
+                const matched = B.tmp();
+                B.line(`${materialized} = call ptr @scr_dyn_typed_ref_materialize(ptr %d)`);
+                B.line(`${matched} = call zeroext i1 @${name}(ptr ${materialized})`);
+                B.line(`call void @scr_dyn_release_v(ptr ${materialized})`);
+                B.terminate(`ret i1 ${matched}`);
+            }
             B.startBlock(lPlain);
         }
         const kindIs = (k) => {
@@ -422,6 +428,13 @@ export class LlDyn {
             case "promise":
                 kindIs(DYN_KIND.PROMISE);
                 break;
+            case "procStream": {
+                this.host.declare(`declare zeroext i1 @scr_dyn_process_stdio_is(ptr)`);
+                const matched = B.tmp();
+                B.line(`${matched} = call zeroext i1 @scr_dyn_process_stdio_is(ptr %d)`);
+                B.terminate(`ret i1 ${matched}`);
+                break;
+            }
             case "symbol":
                 kindIs(DYN_KIND.SYMBOL);
                 break;
@@ -516,7 +529,7 @@ export class LlDyn {
                     for (const [i, f] of byIndex.entries()) {
                         const e = this.itemAt(B, items, `${i}`);
                         const m = B.tmp();
-                        B.line(`${m} = call zeroext i1 @${this.dynMatchHelper(f.type)}(ptr ${e})`);
+                        B.line(`${m} = call zeroext i1 @${this.dynMatchHelper(f.type, preserveRefs)}(ptr ${e})`);
                         const ln = B.newLabel("dm.i");
                         B.condBr(m, ln, fail);
                         B.startBlock(ln);
@@ -547,7 +560,7 @@ export class LlDyn {
                     this.host.declare(`declare void @scr_dyn_release(ptr)`);
                     this.pendingBail(B, "dm.read", () => B.line(`call void @scr_dyn_release(ptr ${m})`), "i1 false");
                     const ok = B.tmp();
-                    B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(f.type)}(ptr ${m})`);
+                    B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(f.type, preserveRefs)}(ptr ${m})`);
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     B.condBr(ok, lNext, fail);
                     B.startBlock(lNext);
@@ -583,7 +596,7 @@ export class LlDyn {
                             B.startBlock(lNo);
                         }
                         const ok = B.tmp();
-                        B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(shape.indexValue)}(ptr ${ent.value})`);
+                        B.line(`${ok} = call zeroext i1 @${this.dynMatchHelper(shape.indexValue, preserveRefs)}(ptr ${ent.value})`);
                         const lOk = B.newLabel("dm.vo");
                         B.condBr(ok, lOk, fail);
                         B.startBlock(lOk);
@@ -595,7 +608,7 @@ export class LlDyn {
                 break;
             }
             case "array": {
-                const m = this.dynMatchHelper(t.elem);
+                const m = this.dynMatchHelper(t.elem, preserveRefs);
                 const fail = B.newLabel("dm.f");
                 const kd = this.kindOf(B, "%d");
                 const isArr = B.tmp();
@@ -635,7 +648,7 @@ export class LlDyn {
                 const yes = B.newLabel("dm.y");
                 for (let tag = 0; tag < def.arms.length; tag++) {
                     const ln = B.newLabel("dm.n");
-                    this.unionArmMatch(B, def, tag, yes, ln);
+                    this.unionArmMatch(B, def, tag, yes, ln, preserveRefs);
                     B.startBlock(ln);
                 }
                 B.terminate(`ret i1 false`);
@@ -673,13 +686,14 @@ export class LlDyn {
     /** `sc_dc_<n>(ptr d, ptr path) -> T` — validate the checked-dynamic tree against T and
      * BUILD the typed value (+1), or throw the catchable path-annotated
      * TypeError and return a dummy with the pending flag set. */
-    dynCheckHelper(t) {
+    dynCheckHelper(t, preserveRefs = false) {
         const key = typeKey(t);
-        const existing = this.dynBuilders.get(key);
+        const builderKey = preserveRefs ? `identity:${key}` : key;
+        const existing = this.dynBuilders.get(builderKey);
         if (existing)
             return existing;
         const name = `sc_dc_${this.dynBuilders.size}`;
-        this.dynBuilders.set(key, name);
+        this.dynBuilders.set(builderKey, name);
         const host = this.host;
         const retTy = this.valTy(t);
         const dummy = retTy === "double" ? `double ${f64Lit(0)}` : retTy === "i1" ? "i1 false" : "ptr null";
@@ -716,7 +730,19 @@ export class LlDyn {
             B.line(`${ref} = call ptr @scr_dyn_typed_ref_unbox(ptr %d)`);
             B.terminate(`ret ptr ${ref}`);
             B.startBlock(lNext);
-            if (t.kind !== "union") {
+            if (t.kind !== "union" && preserveRefs) {
+                const kind = this.kindOf(B, "%d");
+                const capsule = B.tmp();
+                B.line(`${capsule} = icmp eq i32 ${kind}, ${DYN_KIND.TYPED_REF}`);
+                const reject = B.newLabel("dc.identity.reject");
+                const plain = B.newLabel("dc.identity.plain");
+                B.condBr(capsule, reject, plain);
+                B.startBlock(reject);
+                B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
+                B.terminate(`ret ${dummy}`);
+                B.startBlock(plain);
+            }
+            else if (t.kind !== "union") {
                 host.declare(`declare ptr @scr_dyn_typed_ref_materialize(ptr)`);
                 host.declare(`declare ptr @scr_dyn_typed_ref_cached_cast(ptr, ptr, ${host.sizeType})`);
                 host.declare(`declare void @scr_dyn_typed_ref_cache_cast(ptr, ptr, ${host.sizeType}, ptr, ptr, ptr, i1)`);
@@ -926,6 +952,13 @@ export class LlDyn {
                 B.terminate(`ret ptr ${retained}`);
                 break;
             }
+            case "procStream": {
+                host.declare(`declare double @scr_dyn_process_stdio_fd(ptr, ptr)`);
+                const r = B.tmp();
+                B.line(`${r} = call double @scr_dyn_process_stdio_fd(ptr %d, ptr %path)`);
+                B.terminate(`ret double ${r}`);
+                break;
+            }
             case "bytes": {
                 host.declare(`declare zeroext i1 @scr_dyn_bytes_is(ptr, i32)`);
                 const matched = B.tmp();
@@ -1072,7 +1105,7 @@ export class LlDyn {
                         setPath(null, `${i}`);
                         const e = this.itemAt(B, items, `${i}`);
                         const v = B.tmp();
-                        B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type)}(ptr ${e}, ptr ${pathSlot})`);
+                        B.line(`${v} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${e}, ptr ${pathSlot})`);
                         storeInto(f.name, f.type, v);
                         this.pendingBail(B, "dct", releaseR, "ptr null");
                     });
@@ -1115,7 +1148,7 @@ export class LlDyn {
                     this.pendingBail(B, "dcr.read", () => { B.line(`call void @scr_dyn_release(ptr ${m})`); releaseR(); }, "ptr null");
                     setPath(f.name, "0");
                     const value = B.tmp();
-                    B.line(`${value} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type)}(ptr ${m}, ptr ${pathSlot})`);
+                    B.line(`${value} = call ${this.valTy(f.type)} @${this.dynCheckHelper(f.type, preserveRefs)}(ptr ${m}, ptr ${pathSlot})`);
                     B.line(`call void @scr_dyn_release(ptr ${m})`);
                     storeInto(f.name, f.type, value);
                     this.pendingBail(B, "dcr", releaseR, "ptr null");
@@ -1163,7 +1196,7 @@ export class LlDyn {
                         else {
                             setPathKeyPtr(ent.key);
                             ev = B.tmp();
-                            B.line(`${ev} = call ${this.valTy(iv)} @${this.dynCheckHelper(iv)}(ptr ${ent.value}, ptr ${pathSlot})`);
+                            B.line(`${ev} = call ${this.valTy(iv)} @${this.dynCheckHelper(iv, preserveRefs)}(ptr ${ent.value}, ptr ${pathSlot})`);
                             this.pendingBail(B, "dcv", releaseR, "ptr null");
                         }
                         const ek = B.tmp();
@@ -1188,7 +1221,7 @@ export class LlDyn {
             }
             case "array": {
                 const elem = t.elem;
-                const c = this.dynCheckHelper(elem);
+                const c = this.dynCheckHelper(elem, preserveRefs);
                 requireKind(DYN_KIND.ARR, "dca");
                 const n = this.lenOf(B, "%d");
                 const a = B.tmp();
@@ -1249,18 +1282,18 @@ export class LlDyn {
                 def.arms.forEach((arm, i) => {
                     const lHit = B.newLabel("dcu.h");
                     const lNext = B.newLabel("dcu.n");
-                    this.unionArmMatch(B, def, i, lHit, lNext);
+                    this.unionArmMatch(B, def, i, lHit, lNext, preserveRefs);
                     B.startBlock(lHit);
                     if (arm.kind === "undefinedT" || arm.kind === "nullT") {
                         // A matched unit arm builds nothing: THE interned immortal
                         // instance (rc == SIZE_MAX — no retain owed).
                         B.terminate(`ret ptr ${host.unitInstanceRef(t.unionId, i)}`);
                     }
-                    else if (arm.kind === "f64") {
+                    else if (arm.kind === "f64" || arm.kind === "procStream") {
                         host.declare(`declare ptr @scr_union_new_f64(i32, double)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call double @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call double @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_f64(i32 ${i}, double ${x})`);
                         B.terminate(`ret ptr ${u}`);
                     }
@@ -1268,7 +1301,7 @@ export class LlDyn {
                         host.declare(`declare ptr @scr_union_new_bool(i32, i1 zeroext)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call zeroext i1 @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call zeroext i1 @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_bool(i32 ${i}, i1 ${x})`);
                         B.terminate(`ret ptr ${u}`);
                     }
@@ -1277,12 +1310,17 @@ export class LlDyn {
                         host.declare(`declare ptr @scr_union_new_ref(i32, ptr, ptr, ptr, ptr)`);
                         const x = B.tmp();
                         const u = B.tmp();
-                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm)}(ptr %d, ptr %path)`);
+                        B.line(`${x} = call ptr @${this.dynCheckHelper(arm, preserveRefs)}(ptr %d, ptr %path)`);
                         B.line(`${u} = call ptr @scr_union_new_ref(i32 ${i}, ptr ${x}, ptr ${rc.retain}, ptr ${rc.release}, ptr ${traceArg(host, arm)})`);
                         B.terminate(`ret ptr ${u}`);
                     }
                     B.startBlock(lNext);
                 });
+                if (preserveRefs) {
+                    B.line(`call void @scr_dyn_check_fail(ptr %path, ptr ${host.cstr("reference with its original layout")}, ptr %d)`);
+                    B.terminate(`ret ptr null`);
+                    break;
+                }
                 // Preserve an exact typed-ref arm above. If no producer tag matched,
                 // retry the union against the ordinary copy-based structural
                 // snapshot (the compiler's width-coercion stance, rather than a
@@ -1516,6 +1554,13 @@ export class LlDyn {
                 B.terminate(`ret ptr ${r}`);
                 break;
             }
+            case "procStream": {
+                host.declare(`declare ptr @scr_process_stdio(double)`);
+                const r = B.tmp();
+                B.line(`${r} = call ptr @scr_process_stdio(double %v)`);
+                B.terminate(`ret ptr ${r}`);
+                break;
+            }
             case "string": {
                 host.declare(`declare ptr @scr_dyn_new_str(ptr)`);
                 const r = B.tmp();
@@ -1834,13 +1879,12 @@ export class LlDyn {
                         B.line(`${r} = call ptr @scr_dyn_new_null()`);
                         B.terminate(`ret ptr ${r}`);
                     }
-                    else if (arm.kind === "f64") {
+                    else if (arm.kind === "f64" || arm.kind === "procStream") {
                         host.declare(`declare double @scr_union_get_f64(ptr)`);
-                        host.declare(`declare ptr @scr_dyn_new_num(double)`);
                         const x = B.tmp();
                         const r = B.tmp();
                         B.line(`${x} = call double @scr_union_get_f64(ptr %v)`);
-                        B.line(`${r} = call ptr @scr_dyn_new_num(double ${x})`);
+                        B.line(`${r} = call ptr @${this.toDynHelper(arm)}(double ${x})`);
                         B.terminate(`ret ptr ${r}`);
                     }
                     else if (arm.kind === "bool") {
@@ -1957,13 +2001,13 @@ export class LlDyn {
                 fulfill(dv);
                 break;
             }
+            case "procStream":
             case "f64": {
                 host.declare(`declare double @scr_promise_payload_f64(ptr)`);
-                host.declare(`declare ptr @scr_dyn_new_num(double)`);
                 const x = B.tmp();
                 const dv = B.tmp();
                 B.line(`${x} = call double @scr_promise_payload_f64(ptr %src)`);
-                B.line(`${dv} = call ptr @scr_dyn_new_num(double ${x})`);
+                B.line(`${dv} = call ptr @${this.toDynHelper(inner)}(double ${x})`);
                 fulfill(dv);
                 break;
             }