@scriptc/compiler 0.0.17 → 0.0.18

package/dist/backend/llvm/emitter.js

@@ -564,7 +564,7 @@ const LIB_FN_SYMS = {
     "dc.chanRunStores": "scr_dc_chan_run_stores",
     // process warning/rejection events (scr_lib.c / scr_async_dyn.c):
     // dyn listeners are borrowed (the runtime retains its copy);
-    // onUnhandledRejection marks the loop live (the loop-end report
+    // onUnhandledRejection marks the loop live (the checkpoint report
     // dispatches the listeners).
     "process.onWarning": "scr_process_on_warning",
     "process.offWarning": "scr_process_off_warning",
@@ -649,12 +649,12 @@ const USES_TIMERS_LIB_FNS = new Set([
     "fs.existsChk",
     "http.createServer", "http.createServerEmpty",
     "http.request", "http.requestCb", "http.requestUrl", "http.requestUrlCb",
-    "https.requestUrl", "https.requestUrlCb",
+    "https.request", "https.requestCb", "https.requestUrl", "https.requestUrlCb",
     "http.requestConn", "http.requestConnCb",
     "http.agentNew", "http.requestAgent", "http.requestAgentCb",
     // The dyn-async slice (emit-exprs.ts's markings): fiber parks, the
     // microtask/immediate mints, the tracing-promise reaction fiber, and
-    // the loop-end unhandled-rejection report.
+    // the checkpoint unhandled-rejection report.
     "async.hop", "async.awaitDyn",
     "dc.tcTracePromise",
     "process.onUnhandledRejection", "process.onRejectionHandled",
@@ -1068,6 +1068,7 @@ class LlEmitter {
             ];
         };
         const globalReleases = globalReleaseLines("g");
+        const asyncEntry = this.fnByName.get(this.mod.entry)?.async === true;
         const entryMayThrow = this.mayThrow.has(this.mod.entry);
         // The event loop runs when timers appeared OR any async/generator
         // function exists (the C main's hasAsync || hasGenerators ||
@@ -1077,17 +1078,26 @@ class LlEmitter {
         // async loop-exhaustion story.
         const runsLoop = this.usesTimers ||
             this.mod.functions.some((f) => f.async === true || f.generator !== undefined);
-        const uncaughtReleases = entryMayThrow ? globalReleaseLines("gu") : [];
+        const uncaughtReleases = entryMayThrow && !asyncEntry ? globalReleaseLines("gu") : [];
         const loopReleasesU = runsLoop ? globalReleaseLines("gl") : [];
         const loopReleasesR = runsLoop ? globalReleaseLines("gr") : [];
+        const topRejectReleases = asyncEntry ? globalReleaseLines("gt") : [];
+        const topPendingReleases = asyncEntry ? globalReleaseLines("gp") : [];
+        const loopReportedReleases = runsLoop ? globalReleaseLines("gq") : [];
         // main's epilogues read the flag / the loop entry points — declared
         // HERE, before the extern block flushes (a pending check usually
         // declared the flag already; the Set dedupes).
         if (entryMayThrow || runsLoop)
             this.declare(`declare zeroext i1 @scr_exc_pending()`);
         if (runsLoop) {
-            this.declare(`declare void @scr_loop_run()`);
+            this.declare(`declare zeroext i1 @scr_loop_run(ptr)`);
             this.declare(`declare zeroext i1 @scr_report_unhandled_rejections()`);
+            this.declare(`declare void @scr_discard_unhandled_rejections()`);
+        }
+        if (asyncEntry) {
+            this.declare(`declare i32 @scr_promise_finish_top_level(ptr)`);
+            this.declare(`declare void @scr_promise_rethrow_top_level(ptr)`);
+            this.declare(`declare void @scr_promise_release(ptr)`);
         }
         // LIBRARY mode: the runtime entry points the generated library
         // symbols delegate to — declared before the extern block flushes.
@@ -1288,9 +1298,11 @@ class LlEmitter {
         ...(usesEvents ? [`  call void @scr_events_install()`] : []), 
         // fs.watch programs fill the loop's watch hooks the same way —
         // scr_watch.c links only when this line is emitted.
-        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, `  call void @${mangleFunction(this.mod.entry)}()`, 
+        ...(usesFsWatch ? [`  call void @scr_watch_install()`] : []), ...(usesFetch ? [`  call void @scr_fetch_install()`] : []), ...(usesNet ? [`  call void @scr_net_install()`, `  call void @scr_net_dyn_install()`] : []), ...(usesHttp ? [`  call void @scr_http_dyn_install()`] : []), ...(usesStream ? [`  call void @scr_stream_install()`] : []), `  call void @scr_lib_init(i32 %argc, ptr %argv)`, ...(asyncEntry
+            ? [`  %top = call ptr @${mangleAsyncSpawn(this.mod.entry)}()`]
+            : [`  call void @${mangleFunction(this.mod.entry)}()`]), 
         // Uncaught exception from top-level code: Node exits 1.
-        ...(entryMayThrow
+        ...(entryMayThrow && !asyncEntry
             ? [
                 `  %exc = call zeroext i1 @scr_exc_pending()`,
                 `  br i1 %exc, label %uncaught, label %ok`,
@@ -1307,15 +1319,44 @@ class LlEmitter {
         // both exit 1, like Node — the C main's loop block exactly.
         ...(runsLoop
             ? [
-                `  call void @scr_loop_run()`,
+                `  %loop_rejection = call zeroext i1 @scr_loop_run(ptr ${asyncEntry ? "%top" : "null"})`,
                 `  %lexc = call zeroext i1 @scr_exc_pending()`,
                 `  br i1 %lexc, label %luncaught, label %lok`,
                 `luncaught:`,
                 `  call void @scr_exc_print_uncaught()`,
+                ...(asyncEntry ? [`  call void @scr_promise_release(ptr %top)`] : []),
                 ...exitListenerLines("xl"),
                 ...loopReleasesU,
                 `  ret i32 1`,
                 `lok:`,
+                `  br i1 %loop_rejection, label %lreported, label %lclean`,
+                `lreported:`,
+                `  call void @scr_discard_unhandled_rejections()`,
+                ...(asyncEntry ? [`  call void @scr_promise_release(ptr %top)`] : []),
+                ...exitListenerLines("xq"),
+                ...loopReportedReleases,
+                `  ret i32 1`,
+                `lclean:`,
+                ...(asyncEntry
+                    ? [
+                        `  %tla_status = call i32 @scr_promise_finish_top_level(ptr %top)`,
+                        `  %tla_rejected = icmp eq i32 %tla_status, 1`,
+                        `  br i1 %tla_rejected, label %tla_fail, label %tla_not_rejected`,
+                        `tla_fail:`,
+                        // The loop already delivered every earlier-checkpoint
+                        // rejection. Drop same-checkpoint competitors before
+                        // surfacing the fatal module verdict.
+                        `  call void @scr_discard_unhandled_rejections()`,
+                        `  call void @scr_promise_rethrow_top_level(ptr %top)`,
+                        `  call void @scr_promise_release(ptr %top)`,
+                        `  call void @scr_exc_print_uncaught()`,
+                        ...exitListenerLines("xt"),
+                        ...topRejectReleases,
+                        `  ret i32 1`,
+                        `tla_not_rejected:`,
+                        `  call void @scr_promise_release(ptr %top)`,
+                    ]
+                    : []),
                 `  %rej = call zeroext i1 @scr_report_unhandled_rejections()`,
                 `  br i1 %rej, label %lrej, label %lrok`,
                 `lrej:`,
@@ -1323,6 +1364,17 @@ class LlEmitter {
                 ...loopReleasesR,
                 `  ret i32 1`,
                 `lrok:`,
+                ...(asyncEntry
+                    ? [
+                        `  %tla_pending = icmp eq i32 %tla_status, 13`,
+                        `  br i1 %tla_pending, label %tla_stuck, label %tla_ok`,
+                        `tla_stuck:`,
+                        ...exitListenerLines("xp"),
+                        ...topPendingReleases,
+                        `  ret i32 13`,
+                        `tla_ok:`,
+                    ]
+                    : []),
             ]
             : []), ...exitListenerLines("xn"), ...globalReleases, `  ret i32 0`, `}`, ``, 
         // sanitize_address is inert under the plain pipeline; the sanitized
@@ -1645,9 +1697,29 @@ class LlEmitter {
             out.push(...tr);
             // Spawn wrapper: pack the args (+1 moves in), spawn the fiber.
             const params = fieldTys.map((ty, i) => `${ty} %a${i}`);
+            const cache = fn.asyncCacheGlobal !== undefined ? mangleGlobal(fn.asyncCacheGlobal) : null;
+            const cycleCache = fn.asyncCycleCacheGlobal !== undefined ? mangleGlobal(fn.asyncCycleCacheGlobal) : null;
+            if (cache !== null || cycleCache !== null) {
+                this.declare(`declare ptr @scr_promise_retain_v(ptr)`);
+                this.declare(`declare void @scr_promise_release(ptr)`);
+            }
+            if (cache !== null) {
+                this.declare(`declare void @scr_promise_mark_handled(ptr)`);
+            }
             const sp = [
                 `define internal ptr @${mangleAsyncSpawn(fn.name)}(${params.join(", ")}) ${FN_ATTRS} { ; spawn ${fn.name}`,
                 `entry:`,
+                ...(cache !== null
+                    ? [
+                        `  %cached = load ptr, ptr @${cache}`,
+                        `  %cache_hit = icmp ne ptr %cached, null`,
+                        `  br i1 %cache_hit, label %cached_return, label %cache_miss`,
+                        `cached_return:`,
+                        `  %cached_owned = call ptr @scr_promise_retain_v(ptr %cached)`,
+                        `  ret ptr %cached_owned`,
+                        `cache_miss:`,
+                    ]
+                    : []),
                 `  %ap = call ptr @malloc(i64 ${sizeOf})`,
                 `  %isnull = icmp eq ptr %ap, null`,
                 `  br i1 %isnull, label %oom, label %ok`,
@@ -1666,7 +1738,36 @@ class LlEmitter {
                 const src = lifted && i === 0 ? "%env" : `%a${i}`;
                 sp.push(`  %sp${i} = getelementptr inbounds %${pack}, ptr %ap, i64 0, i32 ${i}`, `  store ${ty} ${src}, ptr %sp${i}`);
             });
-            sp.push(`  %p = call ptr @scr_async_spawn(ptr @${mangleTrampoline(fn.name)}, ptr %ap)`, `  ret ptr %p`, `}`, ``);
+            sp.push(`  %p = call ptr @scr_async_spawn(ptr @${mangleTrampoline(fn.name)}, ptr %ap)`, ...(cache !== null
+                ? [
+                    // The module loader owns this evaluation promise
+                    // immediately. A later sibling can throw before the
+                    // aggregate dependency wait is built, but this rejection
+                    // must never become an unrelated unhandled rejection.
+                    `  call void @scr_promise_mark_handled(ptr %p)`,
+                ]
+                : []), ...(cache !== null
+                ? [
+                    `  %cache_owned = call ptr @scr_promise_retain_v(ptr %p)`,
+                    // The eager spawn may have re-entered this guarded module
+                    // through an admitted async cycle and installed a temporary
+                    // cache entry. Drop that owned slot before replacing it
+                    // with the outer evaluation promise.
+                    `  %replaced_cache = load ptr, ptr @${cache}`,
+                    `  call void @scr_promise_release(ptr %replaced_cache)`,
+                    `  store ptr %cache_owned, ptr @${cache}`,
+                ]
+                : []), ...(cycleCache !== null
+                ? [
+                    // Eager recursive spawns publish from the inside out. The
+                    // runtime-requested outermost member writes last and is the
+                    // SCC's actual evaluation root.
+                    `  %cycle_cache_owned = call ptr @scr_promise_retain_v(ptr %p)`,
+                    `  %replaced_cycle_cache = load ptr, ptr @${cycleCache}`,
+                    `  call void @scr_promise_release(ptr %replaced_cycle_cache)`,
+                    `  store ptr %cycle_cache_owned, ptr @${cycleCache}`,
+                ]
+                : []), `  ret ptr %p`, `}`, ``);
             out.push(...sp);
         }
         out.push(...this.emitGenScaffolding());
@@ -3651,11 +3752,12 @@ class LlEmitter {
             case "strCmp": {
                 const l = this.emitExpr(e.left);
                 const r = this.emitExpr(e.right);
-                this.declare(`declare i32 @scr_str_cmp(ptr, ptr)`);
+                const fn = e.utf16 === true ? "scr_str_cmp_u16" : "scr_str_cmp";
+                this.declare(`declare i32 @${fn}(ptr, ptr)`);
                 const c = B.tmp();
                 const t = B.tmp();
                 const pred = { "<": "slt", "<=": "sle", ">": "sgt", ">=": "sge" }[e.op];
-                B.line(`${c} = call i32 @scr_str_cmp(ptr ${l.name}, ptr ${r.name})`);
+                B.line(`${c} = call i32 @${fn}(ptr ${l.name}, ptr ${r.name})`);
                 B.line(`${t} = icmp ${pred} i32 ${c}, 0`);
                 return { name: t, type: e.type };
             }
@@ -5533,6 +5635,15 @@ class LlEmitter {
             case "libCall":
                 return this.emitLibCall(e);
             case "intrinsic": {
+                if (e.name === "module.await") {
+                    // Internal ESM dependency wait: pending promises park the module
+                    // fiber, while settled ones continue synchronously.
+                    const p = this.emitExpr(e.args[0]);
+                    this.declare(`declare void @scr_module_await(ptr)`);
+                    B.line(`call void @scr_module_await(ptr ${p.name})`);
+                    this.emitPendingCheck();
+                    return { name: "", type: e.type };
+                }
                 if (e.name === "promise.all") {
                     // The runtime countdown combinator (emit-exprs.ts): a pre-sized
                     // values array filled per INPUT index as entries fulfill, plus
@@ -8052,6 +8163,33 @@ class LlEmitter {
                 B.line(`${t} = call ptr @scr_arr_slice(ptr ${r.name}, double ${start}, double ${end})`);
                 return this.own({ name: t, type: e.type });
             }
+            case "toReversed": {
+                this.declare(`declare ptr @scr_arr_to_reversed(ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_arr_to_reversed(ptr ${r.name})`);
+                return this.own({ name: t, type: e.type });
+            }
+            case "toSpliced": {
+                const start = this.emitExpr(e.args[0]);
+                const count = this.emitExpr(e.args[1]);
+                const items = this.emitExpr(e.args[2]);
+                this.declare(`declare ptr @scr_arr_to_spliced(ptr, double, double, ptr)`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_arr_to_spliced(ptr ${r.name}, double ${start.name}, ` +
+                    `double ${count.name}, ptr ${items.name})`);
+                return this.own({ name: t, type: e.type });
+            }
+            case "with": {
+                const index = this.emitExpr(e.args[0]);
+                const value = this.emitExpr(e.args[1]);
+                this.declare(`declare ptr @scr_arr_with_${acc}(ptr, double, ${accArg})`);
+                const t = B.tmp();
+                B.line(`${t} = call ptr @scr_arr_with_${acc}(ptr ${r.name}, double ${index.name}, ` +
+                    `${accTy} ${value.name})`);
+                const out = this.own({ name: t, type: e.type });
+                this.emitPendingCheck();
+                return out;
+            }
             case "splice": {
                 // The removal splice: removed elements come back as a fresh +1
                 // array, ownership MOVED out of the receiver. An omitted count
@@ -8495,6 +8633,14 @@ class LlEmitter {
                 // A +1 VIEW aliasing the receiver's storage (subarray / Buffer's
                 // slice); same index defaults as slice.
                 return call("scr_bytes_subarray", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0]?.name ?? f64Lit(0)}, double ${args[1]?.name ?? F64_INF}`, true, false);
+            case "toReversed":
+                return call("scr_bytes_to_reversed", "ptr (ptr)", `ptr ${r.name}`, true, false);
+            case "with":
+                return call("scr_bytes_with", "ptr (ptr, double, double)", `ptr ${r.name}, double ${args[0].name}, double ${args[1].name}`, true, true);
+            case "join":
+                return call("scr_bytes_join", "ptr (ptr, ptr)", `ptr ${r.name}, ptr ${args[0].name}`, true, false);
+            case "toArray":
+                return call("scr_bytes_to_arr", "ptr (ptr)", `ptr ${r.name}`, true, false);
             case "setFrom":
                 // dst.set(src, offset?) — void; throws Node's RangeError on
                 // overflow.
@@ -10736,14 +10882,17 @@ class LlEmitter {
         }
         if (e.fn === "http.request" || e.fn === "http.requestCb" || e.fn === "http.requestUrl" || e.fn === "http.requestUrlCb" ||
             e.fn === "http.requestAgent" || e.fn === "http.requestAgentCb" ||
+            e.fn === "https.request" || e.fn === "https.requestCb" ||
             e.fn === "https.requestUrl" || e.fn === "https.requestUrlCb") {
             // The https URL row is the http one with the TLS entry point — same
-            // three arguments, same response-callback adapter. (The https
-            // OPTIONS forms are a separate, wider row and are not here yet.)
+            // three arguments, same response-callback adapter. The https options
+            // row is wider: rejectUnauthorized stays an i1, while its ScrStr or
+            // ScrBytes CA value expands to the runtime's raw pointer + length.
             const isTls = e.fn.startsWith("https.");
-            const isUrl = isTls || e.fn.startsWith("http.requestUrl");
+            const isUrl = e.fn.includes("requestUrl");
+            const isTlsOptions = isTls && !isUrl;
             const isAgent = e.fn.startsWith("http.requestAgent");
-            const cbIdx = isUrl ? 3 : isAgent ? 8 : 7;
+            const cbIdx = isUrl ? 3 : isTlsOptions ? 9 : isAgent ? 8 : 7;
             const hasCb = e.fn.endsWith("Cb");
             const args = e.args.map((a) => this.emitExpr(a));
             let cb = "null";
@@ -10759,13 +10908,42 @@ class LlEmitter {
                 adapter = `@${sym}`;
             }
             const head = args.slice(0, cbIdx);
-            const decls = head.map((a) => (this.llType(a.type) === "i1" ? "i1 zeroext" : this.llType(a.type)));
-            const entry = isTls ? "scr_https_request_url"
-                : isUrl ? "scr_http_request_url"
-                    : isAgent ? "scr_http_request_agent" : "scr_http_request";
-            this.declare(`declare ptr @${entry}(${[...decls, "ptr", "ptr"].join(", ")})`);
+            const entry = isTlsOptions ? "scr_https_request"
+                : isTls ? "scr_https_request_url"
+                    : isUrl ? "scr_http_request_url"
+                        : isAgent ? "scr_http_request_agent" : "scr_http_request";
+            let callArgs = head.map((a) => `${this.llType(a.type)} ${a.name}`);
+            if (isTlsOptions) {
+                const ca = args[8];
+                const caLenPtr = B.tmp();
+                const caLen = B.tmp();
+                let caData;
+                if (ca.type.kind === "string") {
+                    caData = B.tmp();
+                    B.line(`${caLenPtr} = getelementptr inbounds %ScrStr, ptr ${ca.name}, i64 0, i32 1`);
+                    B.line(`${caLen} = load i64, ptr ${caLenPtr}`);
+                    B.line(`${caData} = getelementptr inbounds i8, ptr ${ca.name}, i64 24`);
+                }
+                else if (ca.type.kind === "bytes" && ca.type.elem === "u8") {
+                    const caDataPtr = B.tmp();
+                    caData = B.tmp();
+                    B.line(`${caLenPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 8`);
+                    B.line(`${caLen} = load i64, ptr ${caLenPtr}`);
+                    B.line(`${caDataPtr} = getelementptr inbounds i8, ptr ${ca.name}, i64 24`);
+                    B.line(`${caData} = load ptr, ptr ${caDataPtr}`);
+                }
+                else {
+                    throw new Error(`llvm emitter bug: ${e.fn} CA is not a string or Buffer`);
+                }
+                callArgs = [...callArgs.slice(0, 8), `ptr ${caData}`, `i64 ${caLen}`];
+                this.declare(`declare ptr @scr_https_request(ptr, double, ptr, ptr, double, ptr, i1 zeroext, i1 zeroext, ptr, i64, ptr, ptr)`);
+            }
+            else {
+                const decls = head.map((a) => (this.llType(a.type) === "i1" ? "i1 zeroext" : this.llType(a.type)));
+                this.declare(`declare ptr @${entry}(${[...decls, "ptr", "ptr"].join(", ")})`);
+            }
             const t = B.tmp();
-            B.line(`${t} = call ptr @${entry}(${[...head.map((a) => `${this.llType(a.type)} ${a.name}`), `ptr ${cb}`, `ptr ${adapter}`].join(", ")})`);
+            B.line(`${t} = call ptr @${entry}(${[...callArgs, `ptr ${cb}`, `ptr ${adapter}`].join(", ")})`);
             const out = this.own({ name: t, type: e.type });
             if (MAY_THROW_LIB_FNS.has(e.fn))
                 this.emitPendingCheck();