@scriptc/compiler 0.4.7 → 0.4.8

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { setShapeOverlayMemoDir, shapeOverlayEnabled } from "./frontend/shape-inference/index.js";
 import { jsInferenceEnabled } from "./frontend/js-inference.js";
-import { createNodeFrontendServices, nodeFrontendServices } from "./frontend/services-node.js";
+import { beginCompileServices, compileFrontendServices, createNodeFrontendServices, endCompileServices, nodeFrontendServices, } from "./frontend/services-node.js";
 import { runTypePatchCommand, } from "./frontend/type-patches/command.js";
 import { optimizationField } from "./backend/optimization.js";
 import { targetCpuField, targetCpuTargetRefusal } from "./backend/target-cpu.js";
@@ -57,7 +57,7 @@ import { loadLibraryProfile } from "./library/library-profile.js";
 import { clearFenceEvalCaches, decorateLibraryRefusals } from "./library/fence-eval.js";
 import { canonicalModuleGraph, clearSidecarCaches, compilerReleaseVersion, libraryIdentityHashes, updateSidecarIdentity, } from "./library/sidecar.js";
 import {} from "./ir/ir.js";
-import { moduleRuntimeFeatures } from "./ir/runtime-features.js";
+import { jsObjectModelFact, moduleRuntimeFeatures } from "./ir/runtime-features.js";
 import { serializeModuleParts } from "./ir/serialize.js";
 import { readTextParts, writeTextParts } from "./text-parts.js";
 import { validateModule } from "./ir/validate.js";
@@ -71,6 +71,7 @@ import { loadFfiProfile } from "./ffi/ffi-manifest.js";
 import { executableLinkFeatures } from "./backend/executable-features.js";
 import { youngNurseryRequested } from "./backend/young-nursery.js";
 import { heapCensusRequested } from "./backend/llvm/heap-census.js";
+import { debugJsIcWays } from "./backend/llvm/js-ic.js";
 import { representationReportPath } from "./backend/llvm/repr-report.js";
 import { FrontendInputTracker, trackedReadFile, } from "./frontend/input-tracker.js";
 import { libraryFrontendImplementationFingerprint, publishEarlyLibraryCache, readEarlyLibraryCache, readSemanticLibraryCache, } from "./library/library-cache.js";
@@ -142,7 +143,16 @@ export function sourceTargetPlatform(env = process.env) {
     return configuredTargetPlatform(env);
 }
 export function analyze(entryPath, opts = {}) {
-    return analyzeWithFrontend(entryPath, opts, buildTargetPlatform(), nodeFrontend);
+    // One scope for the whole analysis: its island reload and retry lowerings
+    // load the program again, and they reuse the checker that answered the
+    // first load instead of starting a cold one.
+    const services = beginCompileServices();
+    try {
+        return analyzeWithFrontend(entryPath, opts, buildTargetPlatform(), nodeFrontend);
+    }
+    finally {
+        endCompileServices(services);
+    }
 }
 /** analyze() behind the coverage verdict cache (the CLI's `scriptc
  * coverage`): an unchanged program, or one whose TypeScript edits only
@@ -172,8 +182,12 @@ export async function analyzeCached(entryPath, opts = {}) {
 setIslandResolver((fromFile, spec) => createRequire(fromFile).resolve(spec));
 const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options) => {
     // One syntax parser for every load of this compile, and program hosts
-    // that serve several loads (FrontendServices.reuseProgramHosts).
-    const services = createNodeFrontendServices();
+    // that serve several loads (FrontendServices.reuseProgramHosts). Inside a
+    // compile scope (beginCompileServices) the later frontends — the island
+    // reload and each retry round's loads — share the hosts this one leaves
+    // idle instead of starting a cold checker each.
+    const shared = compileFrontendServices();
+    const services = shared ?? createNodeFrontendServices();
     try {
         services.reuseProgramHosts(programHostLoads());
         const frontend = runFrontend(entry, (path, loadOptions) => loadProgramWithServices(path, services, loadOptions), npmStatic, externalTypes, libraryNpmStatic, options);
@@ -184,13 +198,16 @@ const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options
                     frontend.dispose();
                 }
                 finally {
-                    services.close();
+                    // A shared scope closes its services when the compile ends.
+                    if (shared === null)
+                        services.close();
                 }
             },
         };
     }
     catch (error) {
-        services.close();
+        if (shared === null)
+            services.close();
         throw error;
     }
 };
@@ -267,6 +284,11 @@ function performanceWarnings(sink) {
 function profileMatchField(object) {
     return object?.profileMatch === undefined ? {} : { profileMatch: object.profileMatch };
 }
+/** The partitions a divided module's executable was linked from, for its
+ * executable cache entry (executable/executable-cache.ts). */
+function partitionsField(object) {
+    return object?.partitions === undefined ? {} : { partitions: object.partitions };
+}
 function withCompileWarnings(result, sink) {
     if (!result.ok)
         return result;
@@ -299,11 +321,15 @@ function assertCompileResultCompatibility(result) {
 }
 void assertCompileResultCompatibility;
 function executableNativeFeatures(mod, backend, optimization, largePages) {
-    return {
+    const features = {
         backend,
         ...optimizationField(optimization),
         ...executableLinkFeatures(mod, largePages),
     };
+    // The executable cache record spells every boolean key (BOOLEAN_NATIVE_KEYS
+    // in executable-cache.ts), and mutableBuffers is optional in the link
+    // features so that a program without the fact keeps its link identity.
+    return { ...features, mutableBuffers: features.mutableBuffers === true };
 }
 /** Install the run-time data files of the selected runtime pack beside an
  * executable this build linked while features.intl is true (ICU's
@@ -412,12 +438,14 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         regex: features.regex,
         copying: features.copying,
         textDecoderLegacy: features.textDecoderLegacy,
+        bigintBytes: features.bigintBytes,
         fileHandle: features.fileHandle,
         fetch: features.fetch,
         ...(features.eventTarget ? { eventTarget: true } : {}),
         ...(features.wasm ? { wasm: true } : {}),
         ...(features.warningReplace ? { warningReplace: true } : {}),
-        ...(features.recordViewPartial ? { recordViewPartial: true } : {}),
+        ...(jsObjectModelFact(features) ? { jsObjectModel: true } : {}),
+        ...(features.mutableBuffers === true ? { mutableBuffers: true } : {}),
         ...(features.stdioExtended ? { stdioExtended: true } : {}),
         ...(features.fsFlags ? { fsFlags: true } : {}),
         ...(features.strdecDyn ? { strdecDyn: true } : {}),
@@ -428,8 +456,10 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         ...(features.moduleNamespace ? { moduleNamespace: true } : {}),
         ...(features.moduleNamespaceDyn ? { moduleNamespaceDyn: true } : {}),
         ...(features.primitiveWrapper ? { primitiveWrapper: true } : {}),
+        ...(features.iteratorProto ? { iteratorProto: true } : {}),
         zlib: features.zlib,
         ...(features.brotli ? { brotli: true } : {}),
+        ...(features.zstd ? { zstd: true } : {}),
         ...(features.intl ? { intl: true } : {}),
         ...(icuPack === null ? {} : { icuPack }),
         assert: features.assert,
@@ -438,12 +468,16 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         dc: features.dc,
         dynAsync: features.dynAsync,
         ...(features.dynTier ? { dynTier: true } : {}),
+        ...(features.promiseGeneric ? { promiseGeneric: true } : {}),
         ...(features.streamDyn ? { streamDyn: true } : {}),
         ...(features.handleProps ? { handleProps: true } : {}),
         ...(features.childLifecycle ? { childLifecycle: true } : {}),
+        ...(features.childOptionExt ? { childOptionExt: true } : {}),
         ...(features.declAdopt ? { declAdopt: true } : {}),
         ...(features.typeOrigins ? { typeOrigins: true } : {}),
         ...(features.dynForAwait ? { dynForAwait: true } : {}),
+        ...(features.dynIntegrityQueries ? { dynIntegrityQueries: true } : {}),
+        ...(features.genBind ? { genBind: true } : {}),
         ...(features.eventsOnceSignal ? { eventsOnceSignal: true } : {}),
         ...(features.mime ? { mime: true } : {}),
         ...(features.largePages ? { largePages: true } : {}),
@@ -453,6 +487,7 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.builtinValues ? { builtinValues: true } : {}),
         ...(features.stdlibPrototypeValue ? { stdlibPrototypeValue: true } : {}),
+        ...(features.hostAbsentGlobals ? { hostAbsentGlobals: true } : {}),
         ...(features.arrayLikeDispatch ? { arrayLikeDispatch: true } : {}),
         ...(features.builtinPrototypeValue ? { builtinPrototypeValue: true } : {}),
         ...(features.computedRequire ? { computedRequire: true } : {}),
@@ -477,7 +512,6 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         textCodecDyn: features.textCodecDyn,
         watch: features.watch,
         watchFile: features.watchFile,
-        fsBufferBrand: features.fsBufferBrand,
         foreignFfi: features.foreignFfi,
         ...(features.workers ? { workers: true } : {}),
         ...(features.youngNursery ? { youngNursery: true } : {}),
@@ -527,9 +561,13 @@ async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
             partitions,
             ...(profile === undefined ? {} : { profile }),
         });
+        // A divided module's count depends on the host's thread count, which chose
+        // it, so the executable cache entry records the count a later build
+        // compares again (executable/executable-cache.ts).
         return {
             linkPath,
             partitionPaths: artifact.outputPaths.slice(1),
+            ...(single ? {} : { partitions }),
             artifactPath,
             dependencies: artifact.dependencies,
             ...(artifact.profileMatch === undefined ? {} : { profileMatch: artifact.profileMatch }),
@@ -643,7 +681,20 @@ async function nodeUnitStore(entryPath, opts, ffi, buildPlatform) {
  * typed IR can be reclaimed before the native optimizer needs its heap. */
 async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timing, warningSink) {
     const outputKind = opts.outputKind ?? "exe";
-    const prepared = prepareExecutableModule(entryPath, opts, ffi, buildPlatform, nodeFrontend, timing, new Map(), true, await nodeUnitStore(entryPath, opts, ffi, buildPlatform));
+    // The frontend loads of one build — the island decision's reload and every
+    // retry round's load — share one services scope, so each load after the
+    // first rebinds the checker the previous one leaves idle instead of
+    // starting a cold one. The scope ends with the last load: LLVM emission and
+    // native code generation run after it, and no idle checker process holds
+    // its heap through them.
+    const services = beginCompileServices();
+    let prepared;
+    try {
+        prepared = prepareExecutableModule(entryPath, opts, ffi, buildPlatform, nodeFrontend, timing, new Map(), true, await nodeUnitStore(entryPath, opts, ffi, buildPlatform));
+    }
+    finally {
+        endCompileServices(services);
+    }
     if (!prepared.ok)
         return prepared;
     const { mod, sourceTexts } = prepared;
@@ -1365,6 +1416,8 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
     let earlyCacheOptions = null;
     if (outputKind === "exe") {
         const helperObjectRoute = opts.nativeProgramObject === true || usesPrecompiledRuntimePack(opts, "llvm");
+        // An attribution build emits different code, so it is its own cache entry.
+        const jsIcWays = debugJsIcWays();
         const routeOptions = {
             entryPath,
             outDir: opts.outDir,
@@ -1398,6 +1451,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             ...(jsInferenceEnabled() && process.env["SCRIPTC_SHAPE_OVERLAY"] !== "0"
                 ? { jsInference: true }
                 : {}),
+            ...(jsIcWays === null ? {} : { jsIcWays }),
             ffiProfile: opts.ffiProfilePath === undefined || ffiProfileBytes === null
                 ? null
                 : { path: opts.ffiProfilePath, bytes: ffiProfileBytes },
@@ -1543,6 +1597,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                         nativeDependencies: dependencies,
                         frontend: earlyHit.frontend,
                         ...profileMatchField(nativeProgramObject),
+                        ...partitionsField(nativeProgramObject),
                     });
                 }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, hitSources.llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
             if (nativeProgramObject !== null && opts.nativeProgramObject === true) {
@@ -1557,11 +1612,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     sourceTexts: new Map(),
                 };
             }
-            if (ffi !== null && err instanceof CcCompileError) {
+            if (err instanceof CcCompileError) {
                 return {
                     ok: false,
                     diagnostics: [
-                        ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath),
+                        ffi !== null
+                            ? ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath)
+                            : nativeCodegenDiag("SC3004", err.message, entryPath),
                     ],
                     sourceTexts: new Map(),
                 };
@@ -1664,6 +1721,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     ...performanceWarnings(warningSink),
                     ...islandFields(warningSink),
                     ...profileMatchField(nativeProgramObject),
+                    ...partitionsField(nativeProgramObject),
                 });
                 publishedExecutable = true;
             }, nativeProgramObject?.partitionPaths, profile?.generate !== undefined, llvmPath, nativeProfileLayout(profile), opts.hugeText !== false);
@@ -1681,6 +1739,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 ...performanceWarnings(warningSink),
                 ...islandFields(warningSink),
                 ...profileMatchField(nativeProgramObject),
+                ...partitionsField(nativeProgramObject),
             }).catch(() => undefined);
         }
     }
@@ -1688,11 +1747,13 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
         if (err instanceof RuntimePackError) {
             return { ok: false, diagnostics: [runtimePackDiagnostic(err, entryPath)], sourceTexts };
         }
-        if (ffi !== null && err instanceof CcCompileError) {
+        if (err instanceof CcCompileError) {
             return {
                 ok: false,
                 diagnostics: [
-                    ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath),
+                    ffi !== null
+                        ? ffiNativeBuildDiag(ffiNativeBuildDetail(err), opts.ffiProfilePath ?? entryPath)
+                        : nativeCodegenDiag("SC3004", err.message, entryPath),
                 ],
                 sourceTexts,
             };
@@ -1754,9 +1815,11 @@ function libraryNativeFeatures(mod, backend) {
         x509: features.x509,
         copying: features.copying,
         textDecoderLegacy: features.legacyTextDecoder,
+        bigintBytes: features.bigintBytes,
         dynInvoke: features.dynInvoke,
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.dynTier ? { dynTier: true } : {}),
+        mutableBuffers: features.mutableBuffers,
         ...(mod.lib?.identity !== undefined ? { buildId: mod.lib.identity.buildId } : {}),
     };
 }
@@ -1830,9 +1893,11 @@ async function compileLibraryNative(profile, llvmPath, archivePath, sanitize, fe
         x509: features.x509,
         copying: features.copying,
         textDecoderLegacy: features.textDecoderLegacy,
+        bigintBytes: features.bigintBytes,
         dynInvoke: features.dynInvoke,
         ...(features.dynBuffer === true ? { dynBuffer: true } : {}),
         ...(features.dynTier === true ? { dynTier: true } : {}),
+        ...(features.mutableBuffers === true ? { mutableBuffers: true } : {}),
     };
     if (packTarget !== null)
         await compilePackedLibrary(archiveOptions, packTarget);