@scriptc/compiler 0.4.6 → 0.4.7

package/dist/index.js

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { setShapeOverlayMemoDir, shapeOverlayEnabled } from "./frontend/shape-inference/index.js";
-import { nodeFrontendServices } from "./frontend/services-node.js";
+import { jsInferenceEnabled } from "./frontend/js-inference.js";
+import { createNodeFrontendServices, 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";
@@ -14,6 +15,7 @@ import { checkerCacheIdentity } from "./frontend/ts7/checker-backend.js";
 import { setLibDiagnosticsStore } from "./frontend/ts7/lib-diagnostics.js";
 import { analyzeWithVerdictCache, fileVerdictStore } from "./coverage/verdict-cache.js";
 import { coverageCompilerIdentity } from "./coverage/verdict-startup.js";
+import { directoryUnitStore, unitReuseEnabled, } from "./frontend/lowering/unit-reuse.js";
 import { commentOnlyReplay } from "./coverage/verdict-semantic.js";
 import { llvmRefusalDiag, targetRefusalDiag } from "./backend/target-diagnostics.js";
 import { compilePackedLibrary } from "./backend/library-pack.js";
@@ -41,10 +43,10 @@ import { privateSiblingPath } from "./backend/build-cache.js";
 import { nativeCodegenTarget, nativeCodegenTargetRefusal, staticLinkRefusal, } from "./backend/targets.js";
 import { windowsSubsystemLinkerArgs } from "./backend/targets.js";
 import { createNativeLinkInfo } from "./backend/native-link-info.js";
-import { RuntimePackError } from "./backend/runtime-pack.js";
+import { RuntimePackError, loadRuntimePack, } from "./backend/runtime-pack.js";
 import { createNativeLinkPlan } from "./backend/link-plan.js";
 import { nativeProfileKey, nativeProfileLayout, nativeProfileRefusal, profileBlocksPath, profileHasContextCounts, recordProfileBlocksPath, } from "./backend/native-profile.js";
-import { executableLinkerEnvironmentFingerprint, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
+import { executableLinkerEnvironmentFingerprint, installRuntimeDataFiles, linkNativeExecutable, platformLinkerSupportsPersistentCache, resolvePlatformLinker, } from "./backend/linker.js";
 import { splitLlvmLibraryProgram, splitLlvmProgram, splitLlvmProgramFile, } from "./backend/llvm/split.js";
 import { emitLibraryIdentityLines, replaceLibraryIdentity, stripLibraryIdentity, } from "./backend/library-identity-markers.js";
 import { ffiNativeBuildDiag, iceDiag, nativeCodegenDiag, nodeIslandNodeDiag, nodeIslandModuleDiag, isTypePatchCode, } from "./diagnostics/diagnostic.js";
@@ -60,7 +62,8 @@ import { serializeModuleParts } from "./ir/serialize.js";
 import { readTextParts, writeTextParts } from "./text-parts.js";
 import { validateModule } from "./ir/validate.js";
 import { compilerOwnedFileRoots } from "./frontend/dts-paths.js";
-import { loadProgram } from "./frontend/program-node.js";
+import { loadProgramWithServices } from "./frontend/program-node.js";
+import { programHostLoads } from "./frontend/services.js";
 import { runFrontend } from "./frontend/pipeline.js";
 import { provenanceSources, setProvenanceSources, } from "./frontend/provenance-registry.js";
 import { clearResolveCaches } from "./frontend/resolve.js";
@@ -167,7 +170,30 @@ export async function analyzeCached(entryPath, opts = {}) {
 // Island code resolves through Node (node-islands/resolve.ts; the
 // self-hosted compiler builds no islands).
 setIslandResolver((fromFile, spec) => createRequire(fromFile).resolve(spec));
-const nodeFrontend = (entry, npmStatic, externalTypes, libraryNpmStatic, options) => runFrontend(entry, loadProgram, npmStatic, externalTypes, libraryNpmStatic, options);
+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();
+    try {
+        services.reuseProgramHosts(programHostLoads());
+        const frontend = runFrontend(entry, (path, loadOptions) => loadProgramWithServices(path, services, loadOptions), npmStatic, externalTypes, libraryNpmStatic, options);
+        return {
+            ...frontend,
+            dispose: () => {
+                try {
+                    frontend.dispose();
+                }
+                finally {
+                    services.close();
+                }
+            },
+        };
+    }
+    catch (error) {
+        services.close();
+        throw error;
+    }
+};
 /** The checker's part of the executable cache key (`checkerCacheIdentity`), as the CLI's startup route computes it. */
 function checkerField() {
     const checker = checkerCacheIdentity();
@@ -222,6 +248,12 @@ function cachedWarningSources(warnings) {
     }
     return texts;
 }
+/** The Node islands a build ran, stored with its cache entry so a cache hit
+ * reports them again (a runner reads them to tell an island pass from a
+ * native one). */
+function islandFields(sink) {
+    return sink?.islands === undefined ? {} : { islands: sink.islands };
+}
 /** The build's performance warnings (SC61xx), stored with its cache entry
  * so a cache hit repeats them. */
 function performanceWarnings(sink) {
@@ -236,9 +268,17 @@ function profileMatchField(object) {
     return object?.profileMatch === undefined ? {} : { profileMatch: object.profileMatch };
 }
 function withCompileWarnings(result, sink) {
-    if (!result.ok || sink.warnings.length === 0)
+    if (!result.ok)
         return result;
-    return { ...result, warnings: sink.warnings, sourceTexts: sink.sourceTexts ?? new Map() };
+    const islands = sink.islands === undefined ? {} : { islands: sink.islands };
+    if (sink.warnings.length === 0)
+        return { ...result, ...islands };
+    return {
+        ...result,
+        warnings: sink.warnings,
+        sourceTexts: sink.sourceTexts ?? new Map(),
+        ...islands,
+    };
 }
 /** Build-time API compatibility fence: a caller's existing CompileOptions
  * variable must retain the executable result aliases without narrowing. */
@@ -265,6 +305,48 @@ function executableNativeFeatures(mod, backend, optimization, largePages) {
         ...executableLinkFeatures(mod, largePages),
     };
 }
+/** Install the run-time data files of the selected runtime pack beside an
+ * executable this build linked while features.intl is true (ICU's
+ * icudt78l.dat). Every path that produces an Intl executable calls it: the
+ * pack link path installs them from its own selection (linker.ts), and the
+ * C-source path — sanitized builds, and links that do not start from a
+ * program object — compiles the runtime itself and would otherwise leave a
+ * binary whose Intl forms throw at run time for want of data. */
+async function installRuntimeDataBesideExecutable(features, outPath) {
+    const pack = await intlRuntimePack(features);
+    if (pack !== null)
+        await installRuntimeDataFiles(pack, outPath);
+}
+/** The host target's runtime pack selection for an Intl program, or null
+ * when the program does not use Intl or the build has no host target. */
+async function intlRuntimePack(features) {
+    if (features.intl !== true)
+        return null;
+    const target = nativeCodegenTarget();
+    if (target === null)
+        return null;
+    return loadRuntimePack({
+        target,
+        features,
+        optimization: features.optimization ?? "release",
+    });
+}
+/** The pack's ICU archive and the include root of the ICU headers it ships
+ * (`<root>/unicode/*.h`), both verified by loadRuntimePack, for the
+ * C-source path to link and compile scr_intl.c against. Null when the pack
+ * lists no headers: that path then builds ICU from its fetched release. */
+function runtimePackIcuInputs(pack) {
+    if (pack === null)
+        return null;
+    const header = pack.selectedHeaderArtifacts[0];
+    const index = pack.selectedArchiveArtifacts.findIndex((artifact) => "id" in artifact && artifact.id === "icu");
+    if (header === undefined || index < 0)
+        return null;
+    return {
+        archive: pack.archives[index],
+        include: join(pack.root, dirname(dirname(header.path))),
+    };
+}
 async function compileExecutableNative(features, llvmPath, outPath, sanitize, ffi, windowsSubsystem, strip, staticLink = false, programSplit = null, programObjectDependencies = [], onArtifactReady, programPartitions = [], profileGenerate = false, 
 /** The kept LLVM text's shared name, when `llvmPath` is the build's private copy of it
  * (BuildSources): the spelling clang sees and native cache keys name. */
@@ -309,6 +391,8 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         throw new InternalCompilerError("program objects must link against a precompiled runtime pack");
     if (staticLink)
         throw new InternalCompilerError("--static executables link against a precompiled runtime pack");
+    const intlPack = await intlRuntimePack(features);
+    const icuPack = runtimePackIcuInputs(intlPack);
     await compileExternalC({
         ...(llvmVisiblePath === undefined || llvmVisiblePath === llvmPath
             ? { cPath: llvmPath }
@@ -333,12 +417,21 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         ...(features.eventTarget ? { eventTarget: true } : {}),
         ...(features.wasm ? { wasm: true } : {}),
         ...(features.warningReplace ? { warningReplace: true } : {}),
+        ...(features.recordViewPartial ? { recordViewPartial: true } : {}),
         ...(features.stdioExtended ? { stdioExtended: true } : {}),
+        ...(features.fsFlags ? { fsFlags: true } : {}),
+        ...(features.strdecDyn ? { strdecDyn: true } : {}),
+        ...(features.processExtras ? { processExtras: true } : {}),
+        ...(features.streamWriteErrors ? { streamWriteErrors: true } : {}),
+        ...(features.stdioWriteSlot ? { stdioWriteSlot: true } : {}),
         ...(features.nodeIsland ? { nodeIsland: true } : {}),
         ...(features.moduleNamespace ? { moduleNamespace: true } : {}),
         ...(features.moduleNamespaceDyn ? { moduleNamespaceDyn: true } : {}),
+        ...(features.primitiveWrapper ? { primitiveWrapper: true } : {}),
         zlib: features.zlib,
         ...(features.brotli ? { brotli: true } : {}),
+        ...(features.intl ? { intl: true } : {}),
+        ...(icuPack === null ? {} : { icuPack }),
         assert: features.assert,
         inspect: features.inspect,
         dynInvoke: features.dynInvoke,
@@ -359,6 +452,9 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         ...(features.utilTiming ? { utilTiming: true } : {}),
         ...(features.dynBuffer ? { dynBuffer: true } : {}),
         ...(features.builtinValues ? { builtinValues: true } : {}),
+        ...(features.stdlibPrototypeValue ? { stdlibPrototypeValue: true } : {}),
+        ...(features.arrayLikeDispatch ? { arrayLikeDispatch: true } : {}),
+        ...(features.builtinPrototypeValue ? { builtinPrototypeValue: true } : {}),
         ...(features.computedRequire ? { computedRequire: true } : {}),
         events: features.events,
         emitter: features.emitter,
@@ -380,6 +476,8 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
         dgramDyn: features.dgramDyn,
         textCodecDyn: features.textCodecDyn,
         watch: features.watch,
+        watchFile: features.watchFile,
+        fsBufferBrand: features.fsBufferBrand,
         foreignFfi: features.foreignFfi,
         ...(features.workers ? { workers: true } : {}),
         ...(features.youngNursery ? { youngNursery: true } : {}),
@@ -403,6 +501,8 @@ llvmVisiblePath, profileLayout = false, hugeText = true) {
                 frameworks: ffi.frameworks,
             }),
     });
+    if (intlPack !== null)
+        await installRuntimeDataFiles(intlPack, outPath);
 }
 async function emitNativeProgramObject(entryPath, opts, llvm, profile) {
     const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
@@ -513,11 +613,37 @@ function usesPrecompiledRuntimePack(opts, backend) {
 function runtimePackDiagnostic(error, entryPath) {
     return nativeCodegenDiag(error.code === "unsupported" ? "SC3002" : "SC3003", error.message, entryPath, error.hint);
 }
+/** The unit store of a Node-hosted build (unit-reuse.ts), keyed by the
+ * compiler, the entry, the options that reach lowering and the target
+ * platform. */
+async function nodeUnitStore(entryPath, opts, ffi, buildPlatform) {
+    if (!unitReuseEnabled() || provenanceSources() !== null)
+        return null;
+    const root = await prepareBuildCacheRoot(buildCacheRoot());
+    if (root === null)
+        return null;
+    const directory = join(root, "units-v1");
+    const implementation = await coverageCompilerIdentity(directory);
+    if (implementation === null)
+        return null;
+    const { outPath: _outPath, outDir: _outDir, ...lowering } = opts;
+    const key = createHash("sha256")
+        .update(JSON.stringify({
+        schema: 1,
+        entry: resolve(entryPath),
+        options: lowering,
+        ffi,
+        platform: buildPlatform,
+        compiler: implementation.digest,
+    }))
+        .digest("hex");
+    return directoryUnitStore(directory, key);
+}
 /** Finish frontend work in a separate scope so the AST, checker caches and
  * 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);
+    const prepared = prepareExecutableModule(entryPath, opts, ffi, buildPlatform, nodeFrontend, timing, new Map(), true, await nodeUnitStore(entryPath, opts, ffi, buildPlatform));
     if (!prepared.ok)
         return prepared;
     const { mod, sourceTexts } = prepared;
@@ -571,6 +697,8 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         warningSink.warnings = prepared.warnings;
         warningSink.sourceTexts = sourceTexts;
     }
+    if (warningSink !== undefined && prepared.islands !== undefined)
+        warningSink.islands = prepared.islands;
     const stem = basename(entryPath).replace(/\.(ts|mts|cts|js|mjs|cjs)$/, "");
     const defaultSourcePaths = {
         ir: join(opts.outDir, `${stem}.ir.json`),
@@ -719,6 +847,7 @@ async function prepareExecutableInput(entryPath, opts, ffi, buildPlatform, timin
         nativeFeatures,
         programSplit,
         sourceTexts,
+        ...(prepared.islands === undefined ? {} : { islands: prepared.islands }),
     };
 }
 /** Moves a build's private copies to the shared names, or drops them when that fails. */
@@ -887,6 +1016,8 @@ async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, f
         warningSink.warnings = result.warnings;
         warningSink.sourceTexts = sourceTexts;
     }
+    if (warningSink !== undefined && result.kind === "prepared" && result.islands !== undefined)
+        warningSink.islands = result.islands;
     if (result.kind === "diagnostics")
         return { ok: false, diagnostics: result.diagnostics, sourceTexts };
     return {
@@ -898,6 +1029,7 @@ async function prepareExecutableInputInChild(frontendProcess, entryPath, opts, f
         nativeFeatures: result.nativeFeatures,
         programSplit: null,
         sourceTexts,
+        ...(result.islands === undefined ? {} : { islands: result.islands }),
     };
 }
 /**
@@ -961,6 +1093,7 @@ export async function runFrontendProcess(requestPath, resultPath) {
                 nativeFeatures: prepared.nativeFeatures,
                 sourceTexts: [...prepared.sourceTexts],
                 warnings: warnings.warnings,
+                ...(prepared.islands === undefined ? {} : { islands: prepared.islands }),
                 frontend,
             };
         }
@@ -1262,6 +1395,9 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             ...(heapCensusRequested() ? { heapCensus: true } : {}),
             npmStatic: opts.npmStatic ?? null,
             ...(shapeOverlayEnabled() ? { shapeOverlay: true } : {}),
+            ...(jsInferenceEnabled() && process.env["SCRIPTC_SHAPE_OVERLAY"] !== "0"
+                ? { jsInference: true }
+                : {}),
             ffiProfile: opts.ffiProfilePath === undefined || ffiProfileBytes === null
                 ? null
                 : { path: opts.ffiProfilePath, bytes: ffiProfileBytes },
@@ -1321,12 +1457,18 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
             warningSink.warnings = earlyHit.performance;
             warningSink.sourceTexts = cachedWarningSources(earlyHit.performance);
         }
+        if (warningSink !== undefined && earlyHit.islands !== undefined)
+            warningSink.islands = earlyHit.islands;
         const executableCacheOptions = earlyCacheOptions;
         // Route/proof metadata is independently evictable. A full-compiler
         // fallback that still finds the validated payload repairs that lightweight
         // index so the next identical CLI invocation can avoid this module graph.
         await publishEarlyExecutableRoute(cacheRoot, executableCacheOptions).catch(() => undefined);
         if (earlyHit.executableRestored) {
+            // The executable came back from the cache without a link, so the data
+            // files its Intl program loads at RUN time (ICU's icudt78l.dat) are not
+            // beside it yet; a cache hit that links gets them from the linker.
+            await installRuntimeDataBesideExecutable(earlyHit.native, opts.outPath);
             await pruneBuildCache(cacheRoot);
             timing("complete");
             return {
@@ -1520,6 +1662,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                     frontend: frontendInputs.snapshot(),
                     ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                     ...performanceWarnings(warningSink),
+                    ...islandFields(warningSink),
                     ...profileMatchField(nativeProgramObject),
                 });
                 publishedExecutable = true;
@@ -1536,6 +1679,7 @@ async function compileTracked(entryPath, opts, frontendInputs, warningSink, fron
                 frontend: frontendInputs.snapshot(),
                 ...(irSourcePath === undefined ? {} : { irPath: irSourcePath }),
                 ...performanceWarnings(warningSink),
+                ...islandFields(warningSink),
                 ...profileMatchField(nativeProgramObject),
             }).catch(() => undefined);
         }