@scriptc/compiler 0.0.9 → 0.0.10

package/dist/backend/emission/emit-exprs.js

@@ -489,6 +489,28 @@ export function emitExpr(E, e) {
                     E.currentFrame().push({ name, type: e.type });
                 return { name, type: e.type };
             }
+            if (e.left.type.kind === "dyn") {
+                // `a ?? b` on a checked-dynamic left: the runtime kind decides
+                // (UNDEF/NULL take the default; a wrapped island value asks the
+                // engine); the right runs lazily in its branch (already dyn).
+                const l = E.emitExpr(e.left);
+                E.moveTemp(l);
+                const name = `sc_t${E.tempCounter++}`;
+                E.line(`${cDecl(e.type, name)};`);
+                E.line(`if (scr_dyn_is_nullish(${l.name})) {`);
+                E.indent++;
+                E.releaseValue(l.name, e.left.type);
+                E.emitBranchInto(name, e.right);
+                E.indent--;
+                E.line(`} else {`);
+                E.indent++;
+                E.line(`${name} = ${l.name};`);
+                E.indent--;
+                E.line(`}`);
+                if (isRefCounted(e.type))
+                    E.currentFrame().push({ name, type: e.type });
+                return { name, type: e.type };
+            }
             if (e.left.type.kind !== "union")
                 throw new Error("emitter bug: nullish left is not a union");
             const def = E.unionsById.get(e.left.type.unionId);
@@ -1589,6 +1611,13 @@ export function emitExpr(E, e) {
             }
             return E.newTemp(e.type, `${E.toDynHelper(v.type)}(${v.name})`);
         }
+        case "dynFromJsval": {
+            // Island value → DOM: the by-reference wrap (scr_dyn_from_jsval
+            // retains the cell in; engine scalars normalize to native DOM
+            // kinds at wrap time). Operand borrowed, result +1, never throws.
+            const v = E.emitExpr(e.value);
+            return E.newTemp(e.type, `scr_dyn_from_jsval(${v.name})`);
+        }
         case "dynCall": {
             // Calling a dyn value: args are already dyn (the lowering boxed or
             // converted them); everything is BORROWED by scr_dyn_call — the
@@ -1867,6 +1896,9 @@ export function emitExpr(E, e) {
         case "dynHasKey": {
             // `"k" in pkg`: a kind-guarded presence answer, computed against
             // the literal key at compile time — no allocation, borrowed box.
+            // An ISLAND-held receiver fences loudly (Node asks the real
+            // engine object — `false` would be a silent wrong answer), so
+            // the temp rides the fallible path.
             const d = E.emitExpr(e.value);
             const keyBytes = Buffer.from(e.key, "utf8");
             const keyLit = cStringLiteral(keyBytes);
@@ -1876,8 +1908,8 @@ export function emitExpr(E, e) {
                 : /^(0|[1-9][0-9]*)$/.test(e.key) && Number(e.key) <= Number.MAX_SAFE_INTEGER
                     ? `${d.name}->v.arr.len > ${e.key}`
                     : "false";
-            const test = `(${d.name}->kind == SCR_DYN_OBJ ? (${objTest}) : ${d.name}->kind == SCR_DYN_ARR ? (${arrTest}) : false)`;
-            return E.newTemp(e.type, e.negated ? `!${test}` : test);
+            const test = `(${d.name}->kind == SCR_DYN_OBJ ? (${objTest}) : ${d.name}->kind == SCR_DYN_ARR ? (${arrTest}) : scr_dyn_isl_fence(${d.name}, "'in'"))`;
+            return E.fallibleTemp(e.type, e.negated ? `!${test}` : test);
         }
         case "dynScalarEq": {
             // dyn vs scalar strict equality: kind test + payload compare.
@@ -1899,26 +1931,40 @@ export function emitExpr(E, e) {
         }
         case "dynTest": {
             // A pure kind compare on the DOM node — borrowed; only the truthy
-            // form also reads a scalar payload.
+            // form also reads a scalar payload. ISLAND-held nodes (the jsval
+            // kind — engine objects/arrays/functions only, scalars normalize
+            // at wrap time) route the tests that depend on the engine's
+            // answer through the scr_dyn_isl_* helpers (false on every other
+            // kind, so the calls stay unconditional); narrowing never changes
+            // representation (SEMANTICS.md).
             const d = E.emitExpr(e.value);
             const test = e.test === "nullish"
                 ? `(${d.name}->kind == SCR_DYN_UNDEF || ${d.name}->kind == SCR_DYN_NULL)`
                 : e.test === "object"
                     ? // `typeof v === "object"`: objects, arrays, bytes, native
-                        // handles, promises, AND null.
-                        `(${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE || ${d.name}->kind == SCR_DYN_NULL)`
+                        // handles, promises, AND null — engine-held objects by the
+                        // engine's own typeof.
+                        `(${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE || ${d.name}->kind == SCR_DYN_NULL || scr_dyn_isl_typeof_is(${d.name}, "object"))`
                     : e.test === "truthy"
                         ? // ToBoolean over the DOM: bool by value; number falsy for
                             // 0, -0 (== 0 in C), and NaN (self-inequality); string
                             // falsy when empty; obj/arr/bytes/func/handle always true;
-                            // the remaining kinds (undefined, null) always false.
-                            `(${d.name}->kind == SCR_DYN_BOOL ? ${d.name}->v.b : ${d.name}->kind == SCR_DYN_NUM ? (${d.name}->v.num == ${d.name}->v.num && ${d.name}->v.num != 0) : ${d.name}->kind == SCR_DYN_STR ? ${d.name}->v.str->len != 0 : (${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_FUNC || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE))`
+                            // JSVAL through the runtime's routed arm (the bigint 0n
+                            // edge); the remaining kinds (undefined, null) always false.
+                            `(${d.name}->kind == SCR_DYN_BOOL ? ${d.name}->v.b : ${d.name}->kind == SCR_DYN_NUM ? (${d.name}->v.num == ${d.name}->v.num && ${d.name}->v.num != 0) : ${d.name}->kind == SCR_DYN_STR ? ${d.name}->v.str->len != 0 : ${d.name}->kind == SCR_DYN_JSVAL ? scr_dyn_truthy(${d.name}) : (${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_FUNC || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE))`
                         : e.test === "error"
                             ? // `u instanceof Error`: the DOM's error encoding — an
                                 // object carrying the reserved "%error" marker key
-                                // (built by caughtToDyn for Error payloads).
-                                `(${d.name}->kind == SCR_DYN_OBJ && scr_dyn_obj_get(${d.name}, "%error", 6) != NULL)`
-                            : `${d.name}->kind == ${{ string: "SCR_DYN_STR", number: "SCR_DYN_NUM", boolean: "SCR_DYN_BOOL", undefined: "SCR_DYN_UNDEF", null: "SCR_DYN_NULL", bytes: "SCR_DYN_BYTES", array: "SCR_DYN_ARR", function: "SCR_DYN_FUNC" }[e.test]}`;
+                                // (built by caughtToDyn for Error payloads) — or a real
+                                // engine Error held by reference.
+                                `((${d.name}->kind == SCR_DYN_OBJ && scr_dyn_obj_get(${d.name}, "%error", 6) != NULL) || scr_dyn_isl_is_error(${d.name}))`
+                            : e.test === "array"
+                                ? // Array.isArray: the DOM's array kind, or the engine's
+                                    // own answer for an engine-held value.
+                                    `(${d.name}->kind == SCR_DYN_ARR || scr_dyn_isl_is_array(${d.name}))`
+                                : e.test === "function"
+                                    ? `(${d.name}->kind == SCR_DYN_FUNC || scr_dyn_isl_typeof_is(${d.name}, "function"))`
+                                    : `${d.name}->kind == ${{ string: "SCR_DYN_STR", number: "SCR_DYN_NUM", boolean: "SCR_DYN_BOOL", undefined: "SCR_DYN_UNDEF", null: "SCR_DYN_NULL", bytes: "SCR_DYN_BYTES" }[e.test]}`;
             return E.newTemp(e.type, e.negated ? `!(${test})` : test);
         }
         case "unionEq": {
@@ -2188,13 +2234,20 @@ export function emitExpr(E, e) {
                     // member retains the value in); throws Node's TypeErrors on
                     // non-object receivers (may-throw seed set).
                     return finish(`scr_dyn_key_set(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "dyn.iterPack":
+                    // Destructuring pack over a dyn source: both borrowed, fresh
+                    // array +1; throws V8's destructuring TypeError on
+                    // non-iterable DOM kinds (may-throw seed set).
+                    return finish(`scr_dyn_iter_pack(${arg(0)}, ${arg(1)})`);
                 case "dyn.typeof":
                     // Bare typeof on a dyn value: the DOM kind's JS answer (+1).
                     return finish(`scr_dyn_typeof(${arg(0)})`);
                 case "dyn.toString":
                     // Receiver-kind-dispatched toString (+1); throws Node's
-                    // TypeError on undefined/null (may-throw seed set).
-                    return finish(`scr_dyn_to_string(${arg(0)}, ${arg(1)})`);
+                    // TypeError on undefined/null and the "is not a function"
+                    // TypeError on null-prototype dictionaries (may-throw seed
+                    // set) — args[2] carries the call's source spelling.
+                    return finish(`scr_dyn_to_string_method(${arg(0)}, ${arg(1)}, ${arg(2)})`);
                 case "fs.readFileSync":
                     // args[1] is the (always-"utf8") encoding: evaluated for
                     // JS-exact side-effect order, ignored by the runtime.
@@ -3041,6 +3094,15 @@ export function emitExpr(E, e) {
                 case "net.connect":
                     E.usesTimers = true; // a connecting/open socket holds the loop open
                     return finish(`scr_net_connect(${arg(0)}, ${arg(1)}, NULL)`);
+                case "net.connectAttempt":
+                    // The validated autoSelectFamilyAttemptTimeout form: Node's
+                    // range ladder runs first, the dial follows.
+                    E.usesTimers = true;
+                    return finish(`scr_net_connect_attempt(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "net.connectOptsChk":
+                    // The runtime option-bag ladder (always throws — a validation
+                    // error or the trailing fence; the error.nodeThrow dummy).
+                    return finish(`(scr_net_connect_opts_chk(${arg(0)}, ${arg(1)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "net.connectCb": {
                     E.usesTimers = true;
                     const cb = args[2];
@@ -3143,6 +3205,9 @@ export function emitExpr(E, e) {
                 case "dgram.sendBytes":
                     E.usesTimers = true;
                     return finish(`scr_dgram_send_bytes(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+                case "dgram.sendChk":
+                    E.usesTimers = true; // a validated send implicit-binds
+                    return finish(`scr_dgram_send_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)})`);
                 case "dgram.address": {
                     // The AddressInfo record, built here from runtime parts (the
                     // frontend pinned the {address, family, port} shape). The
@@ -3850,6 +3915,13 @@ export function emitExpr(E, e) {
                     // SNI answer serves; bad material is the construction-time
                     // print-and-die trap, like createServer's.
                     return finish(`scr_tls_create_secure_context((const char *)${arg(0)}->data, ${arg(0)}->len, (const char *)${arg(1)}->data, ${arg(1)}->len)`);
+                case "tls.createSecureContextDyn":
+                    // The runtime option-bag form: Node's typed validations, then
+                    // the pem walk (throws catchably on both ladders).
+                    return finish(`scr_tls_create_secure_context_dyn(${arg(0)})`);
+                case "tls.caCertsChk":
+                    // Always throws (validation error or the trailing fence).
+                    return finish(`(scr_tls_ca_certs_chk(${arg(0)}, ${arg(1)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "http.serverOnRequest": {
                     const cbT = e.args[1].type;
                     if (cbT.kind !== "func")
@@ -4278,10 +4350,41 @@ export function emitExpr(E, e) {
                     return finish(`scr_buffer_new_string_fail(${arg(0)})`);
                 case "fs.toUnixTimestamp":
                     return finish(`scr_fs_to_unix_timestamp(${arg(0)})`);
+                // The fs argument-validation ladders: the always-throw Chk
+                // forms (validation error or the trailing fence) take the
+                // error.nodeThrow dummy pattern; mkdtempSyncChk and the lchmod
+                // pair answer real results on a validated pass.
+                case "fs.existsChk":
+                    E.usesTimers = true; // the scheduled answer holds the loop open
+                    return finish(`scr_fs_exists_async(${arg(0)}, ${arg(1)})`);
+                case "fs.mkdtempChk":
+                    return finish(`(scr_fs_mkdtemp_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.mkdtempSyncChk":
+                    return finish(`scr_fs_mkdtemp_sync_chk(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "fs.readFileChk":
+                    return finish(`(scr_fs_read_file_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.opendirChk":
+                    return finish(`(scr_fs_opendir_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.watchFileChk":
+                    return finish(`(scr_fs_watch_file_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.lchmodChk":
+                    return finish(`(scr_fs_lchmod_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.lchmodSyncChk":
+                    return finish(`scr_fs_lchmod_sync_chk(${arg(0)}, ${arg(1)})`);
+                case "fsp.lchmodChk":
+                    return finish(`scr_fsp_lchmod_chk(${arg(0)}, ${arg(1)})`);
+                case "fs.readChk":
+                    return finish(`(scr_fs_read_chk(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "fs.streamOptsChk":
+                    return finish(`(scr_fs_stream_opts_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "error.argTypeThrow":
                     // Always throws with the runtime-rendered Received tail (the
                     // error.nodeThrow dummy pattern). Borrows all three.
                     return finish(`(scr_throw_arg_type(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
+                case "error.propTypeThrow":
+                    // The property flavor ("The \"options.x\" property must be
+                    // ...") — same always-throw dummy pattern.
+                    return finish(`(scr_throw_prop_type(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 // The fs Buffer forms (scr_bytes_io.c): the sync pair throws
                 // like the utf8 forms (may-throw seed set); the promise form
                 // rejects instead.
@@ -4706,6 +4809,27 @@ export function emitExpr(E, e) {
                     // Object.assign over DOM values: own members copy, the target
                     // returns (+1); non-object receivers throw like Node.
                     return finish(`scr_dyn_assign(${arg(0)}, ${arg(1)})`);
+                case "dyn.packPush":
+                    // Variadic Object.assign's source pack: a plain source
+                    // retains in (both args borrowed). Never throws.
+                    return finish(`scr_dyn_pack_push(${arg(0)}, ${arg(1)})`);
+                case "dyn.packPushSpread":
+                    // A spread source flattens through the spread-call walk —
+                    // V8's exact TypeError texts (may-throw seed set); the string
+                    // spells the spread expression for the nullish form.
+                    return finish(`scr_dyn_pack_push_spread(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "dyn.packPushSpreadIter":
+                    // The non-last/multi-spread positions: V8's iterator-protocol
+                    // failure texts describe the value (may-throw seed set).
+                    return finish(`scr_dyn_pack_push_spread_iter(${arg(0)}, ${arg(1)})`);
+                case "dyn.assignAll":
+                    // The flattened pack copies onto the target left to right;
+                    // the target returns (+1). Nullish targets throw like Node.
+                    return finish(`scr_dyn_assign_all(${arg(0)}, ${arg(1)})`);
+                case "dyn.objCreateNullProto":
+                    // Object.create(null): the fresh null-prototype dictionary
+                    // (+1). Never throws.
+                    return finish(`scr_dyn_new_obj_null_proto()`);
                 case "dyn.hasOwn":
                     // Object.hasOwn over a DOM receiver (throws on nullish, like
                     // Node's ToObject).