@scriptc/compiler 0.0.35 → 0.1.1

package/dist/backend/{cc-cache.test.js → native-toolchain.test.js}

@@ -5,7 +5,7 @@ import { chmod, cp, mkdir, mkdtemp, readdir, readFile, rm, stat, symlink, utimes
 import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import { afterAll, afterEach, expect, test as vitestTest } from "vitest";
-import { cacheTargetIdentity, ccVersionOnce, compileC, compileLibArchive, executableNativeEnvironmentFingerprint, implicitDependencyProbeIncludes, parseLinkTraceFiles, resolveBuildCacheRoot, runtimeFingerprint, runtimeSrcDir, stageRuntimeObjects, supportedNativeCacheWarmProfiles, toolchainEnvironmentCachePolicy, toolchainEnvironmentFingerprint, vendorCacheBuildIdentity, vendorCacheTargetFlavor, warmNativeCaches, } from "./cc.js";
+import { cacheTargetIdentity, ccVersion, compileC, compileLibArchive, executableSectionEliminationFlags, executableNativeEnvironmentFingerprint, implicitDependencyProbeIncludes, parseLinkTraceFiles, resolveBuildCacheRoot, runtimeFingerprint, runtimeSrcDir, stageRuntimeObjects, supportedNativeCacheWarmProfiles, toolchainEnvironmentCachePolicy, toolchainEnvironmentFingerprint, vendorCacheBuildIdentity, vendorCacheTargetFlavor, warmNativeCaches, } from "./native-toolchain.js";
 import { splitLlvmProgram } from "./llvm/split.js";
 const scratch = [];
 const TEST_CACHE_IDENTITY = "cc-cache-tests-v1";
@@ -96,6 +96,21 @@ test("the production cache root follows overrides, platform defaults, and the ha
     expect(resolveBuildCacheRoot({}, "darwin", "/Users/tester")).toBe("/Users/tester/Library/Caches/scriptc/build");
     expect(resolveBuildCacheRoot({ LOCALAPPDATA: "/Users/tester/AppData/Local" }, "win32", "/Users/tester")).toBe("/Users/tester/AppData/Local/scriptc/cache/build");
 });
+test("executable section elimination flags are target-aware and never enter library recipes", () => {
+    expect(executableSectionEliminationFlags("darwin")).toEqual({
+        compile: [],
+        link: ["-Wl,-dead_strip"],
+    });
+    expect(executableSectionEliminationFlags("linux")).toEqual({
+        compile: ["-ffunction-sections", "-fdata-sections"],
+        link: ["-Wl,--gc-sections"],
+    });
+    expect(executableSectionEliminationFlags("win32")).toEqual({
+        compile: ["-ffunction-sections", "-fdata-sections"],
+        link: ["-Wl,--gc-sections"],
+    });
+    expect(executableSectionEliminationFlags("wasi")).toEqual({ compile: [], link: [] });
+});
 test.skipIf(process.platform === "win32")("the early executable identity follows a compiler selected behind a stable driver", async () => {
     const dir = await mkdtemp(join(tmpdir(), "scriptc-effective-compiler-"));
     scratch.push(dir);
@@ -134,6 +149,95 @@ test("native cache identities separate host architectures while cross targets re
     expect(vendorCacheTargetFlavor({ target: null }, "darwin", "x64")).toBe("native-darwin-x64");
     expect(vendorCacheTargetFlavor({ target: "x86_64-linux-gnu.2.36" }, "darwin", "arm64")).toBe("x86_64-linux-gnu.2.36");
 });
+test.skipIf(process.platform === "win32" || zigExecutable === undefined ||
+    clangExecutable === undefined || arExecutable === undefined)("targetless Zig vendor caches are separate from host-clang and reusable", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-zig-vendor-cache-"));
+    scratch.push(dir);
+    const cacheRoot = join(dir, "cache");
+    const vendorRoot = join(dir, "vendor-cache");
+    const cPath = join(dir, "program.c");
+    const oldCacheDir = process.env["SCRIPTC_CACHE_DIR"];
+    const oldNoCache = process.env["SCRIPTC_NO_CACHE"];
+    const oldVendorCacheDir = process.env["SCRIPTC_TEST_VENDOR_CACHE_DIR"];
+    const oldCc = process.env["SCRIPTC_CC"];
+    const oldTarget = process.env["SCRIPTC_TARGET"];
+    try {
+        await writeFile(cPath, "int main(void) { return 0; }\n");
+        process.env["SCRIPTC_CACHE_DIR"] = cacheRoot;
+        process.env["SCRIPTC_TEST_VENDOR_CACHE_DIR"] = vendorRoot;
+        delete process.env["SCRIPTC_NO_CACHE"];
+        delete process.env["SCRIPTC_TARGET"];
+        process.env["SCRIPTC_CC"] = "clang";
+        await compileC({
+            cPath,
+            outPath: join(dir, "host"),
+            cacheIdentity: TEST_CACHE_IDENTITY,
+            dynamic: true,
+            net: true,
+            http: true,
+            tls: true,
+            zlib: true,
+            // Keep the complete executable tier out of this test: the second Zig
+            // invocation must walk the vendor cache and prove its artifacts are
+            // reusable independently of the output path.
+            systemLibraries: ["m"],
+        });
+        const hostEngine = (await readdir(vendorRoot)).find((name) => /^3c8f3d689539-plain-/.test(name));
+        const hostTls = (await readdir(vendorRoot)).find((name) => name.startsWith("mbedtls-"));
+        expect(hostEngine).toBeDefined();
+        expect(hostTls).toBeDefined();
+        process.env["SCRIPTC_CC"] = "zigcc";
+        const zigOptions = {
+            cPath,
+            cacheIdentity: TEST_CACHE_IDENTITY,
+            dynamic: true,
+            net: true,
+            http: true,
+            tls: true,
+            zlib: true,
+            systemLibraries: ["m"],
+        };
+        await compileC({ ...zigOptions, outPath: join(dir, "zig-first") });
+        let vendorEntries = await readdir(vendorRoot);
+        expect(vendorEntries.filter((name) => /^3c8f3d689539-plain-/.test(name))).toHaveLength(2);
+        expect(vendorEntries.filter((name) => name.startsWith("mbedtls-")).length).toBe(2);
+        // Host clang uses system zlib, so only the Zig build materializes a zlib
+        // object family in the shared vendor root.
+        expect(vendorEntries.filter((name) => name.startsWith("zlib-")).length).toBe(1);
+        // Invalidate the host archive. A targetless Zig rebuild must continue to
+        // use the separately keyed Zig archive instead of repairing or consuming
+        // the host-clang entry.
+        await writeFile(join(vendorRoot, hostEngine, "libqjs.a"), "host archive intentionally invalid\n");
+        await writeFile(join(vendorRoot, hostTls, "libmbedtls.a"), "host archive intentionally invalid\n");
+        await compileC({ ...zigOptions, outPath: join(dir, "zig-second") });
+        vendorEntries = await readdir(vendorRoot);
+        expect(vendorEntries.filter((name) => /^3c8f3d689539-plain-/.test(name))).toHaveLength(2);
+        expect(await readFile(join(vendorRoot, hostEngine, "libqjs.a"), "utf8")).toBe("host archive intentionally invalid\n");
+        expect(await readFile(join(vendorRoot, hostTls, "libmbedtls.a"), "utf8")).toBe("host archive intentionally invalid\n");
+    }
+    finally {
+        if (oldCacheDir === undefined)
+            delete process.env["SCRIPTC_CACHE_DIR"];
+        else
+            process.env["SCRIPTC_CACHE_DIR"] = oldCacheDir;
+        if (oldNoCache === undefined)
+            delete process.env["SCRIPTC_NO_CACHE"];
+        else
+            process.env["SCRIPTC_NO_CACHE"] = oldNoCache;
+        if (oldVendorCacheDir === undefined)
+            delete process.env["SCRIPTC_TEST_VENDOR_CACHE_DIR"];
+        else
+            process.env["SCRIPTC_TEST_VENDOR_CACHE_DIR"] = oldVendorCacheDir;
+        if (oldCc === undefined)
+            delete process.env["SCRIPTC_CC"];
+        else
+            process.env["SCRIPTC_CC"] = oldCc;
+        if (oldTarget === undefined)
+            delete process.env["SCRIPTC_TARGET"];
+        else
+            process.env["SCRIPTC_TARGET"] = oldTarget;
+    }
+}, 600_000);
 test("Zig COFF dry-run parsing retains every linker input on its single command line", async () => {
     const dir = await mkdtemp(join(tmpdir(), "scriptc-link-trace-"));
     scratch.push(dir);
@@ -218,7 +322,7 @@ printf 'fake zig cc version probe\n'
         // Zig 0.16 creates cwd/a.o for `zig cc --version`. Model that side
         // effect directly so this regression does not depend on Zig being
         // installed in every generic test shard.
-        await ccVersionOnce([fakeCompiler, "cc"], `version-probe-${dir}`);
+        await ccVersion([fakeCompiler, "cc"], `version-probe-${dir}`);
         expect(await readdir(probeTmp)).toEqual([]);
     }
     finally {
@@ -349,6 +453,69 @@ test("implicit dependency seeds include separately compiled vendor system header
     // to the native object/cache identity.
     expect(includes).toContain("<stdatomic.h>");
 });
+test.skipIf(process.platform === "win32" || clangExecutable === undefined || arExecutable === undefined ||
+    ldExecutable === undefined)("public native builds re-probe ccache availability after PATH changes", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-ccache-reset-"));
+    scratch.push(dir);
+    const binDir = join(dir, "bin");
+    const cacheRoot = join(dir, "cache");
+    const cPath = join(dir, "program.c");
+    const ccacheLog = join(dir, "ccache.log");
+    const oldCacheDir = process.env["SCRIPTC_CACHE_DIR"];
+    const oldNoCache = process.env["SCRIPTC_NO_CACHE"];
+    const oldPath = process.env["PATH"];
+    const oldCcacheLog = process.env["SCRIPTC_TEST_CCACHE_LOG"];
+    try {
+        await Promise.all([mkdir(binDir), mkdir(cacheRoot, { mode: 0o700 })]);
+        await Promise.all([
+            symlink(clangExecutable, join(binDir, "clang")),
+            symlink(arExecutable, join(binDir, "ar")),
+            symlink(ldExecutable, join(binDir, "ld")),
+            writeFile(cPath, "int main(void) { return 0; }\n"),
+        ]);
+        process.env["SCRIPTC_CACHE_DIR"] = cacheRoot;
+        process.env["PATH"] = binDir;
+        delete process.env["SCRIPTC_NO_CACHE"];
+        await compileC({
+            cPath,
+            outPath: join(dir, "first"),
+            cacheIdentity: TEST_CACHE_IDENTITY,
+            regex: true,
+        });
+        await writeFile(join(binDir, "ccache"), `#!/bin/sh
+if [ "$1" = "--version" ]; then exit 0; fi
+printf '%s\n' "$*" >> "$SCRIPTC_TEST_CCACHE_LOG"
+exec "$@"
+`);
+        await chmod(join(binDir, "ccache"), 0o755);
+        process.env["SCRIPTC_TEST_CCACHE_LOG"] = ccacheLog;
+        await compileC({
+            cPath,
+            outPath: join(dir, "second"),
+            cacheIdentity: TEST_CACHE_IDENTITY,
+            dynamic: true,
+        });
+        expect((await readFile(ccacheLog, "utf8")).trim()).not.toBe("");
+    }
+    finally {
+        if (oldCacheDir === undefined)
+            delete process.env["SCRIPTC_CACHE_DIR"];
+        else
+            process.env["SCRIPTC_CACHE_DIR"] = oldCacheDir;
+        if (oldNoCache === undefined)
+            delete process.env["SCRIPTC_NO_CACHE"];
+        else
+            process.env["SCRIPTC_NO_CACHE"] = oldNoCache;
+        if (oldPath === undefined)
+            delete process.env["PATH"];
+        else
+            process.env["PATH"] = oldPath;
+        if (oldCcacheLog === undefined)
+            delete process.env["SCRIPTC_TEST_CCACHE_LOG"];
+        else
+            process.env["SCRIPTC_TEST_CCACHE_LOG"] = oldCcacheLog;
+    }
+});
 test.skipIf(process.platform === "win32")("opaque compiler wrappers bypass persistent caches", async () => {
     const dir = await mkdtemp(join(tmpdir(), "scriptc-cache-compiler-wrapper-"));
     scratch.push(dir);
@@ -2560,7 +2727,11 @@ done
 exec "$SCRIPTC_TEST_REAL_CLANG" "$@"
 `);
         await chmod(wrapper, 0o755);
-        await writeFile(cPath, "int main(void) { return 0; }\n");
+        // Keep the injected datum reachable. With executable section GC an
+        // unreferenced test-only global is rightly removed before the binary
+        // assertion below can observe it.
+        await writeFile(cPath, "extern int scriptc_runtime_race_marker(void);\n" +
+            "int main(void) { return scriptc_runtime_race_marker(); }\n");
         process.env["SCRIPTC_CACHE_DIR"] = cacheRoot;
         process.env["SCRIPTC_TEST_RUNTIME_SRC_DIR"] = fakeRuntime;
         process.env["SCRIPTC_TEST_REAL_CLANG"] = realClang;
@@ -2585,7 +2756,11 @@ exec "$SCRIPTC_TEST_REAL_CLANG" "$@"
                 throw new Error("timed out waiting for runtime compile");
             await new Promise((resolveWait) => setTimeout(resolveWait, 10));
         }
-        await writeFile(raceSource, `${originalRuntimeSource}\nconst char scriptc_runtime_race_marker[] = "${marker}";\n`);
+        await writeFile(raceSource, `${originalRuntimeSource}\n` +
+            `volatile const char scriptc_runtime_race_marker_data[] = "${marker}";\n` +
+            "int scriptc_runtime_race_marker(void) {\n" +
+            "  return scriptc_runtime_race_marker_data[0] == '\\0';\n" +
+            "}\n");
         await writeFile(release, "go");
         await firstBuild;
         expect((await readFile(firstOut)).includes(Buffer.from(marker))).toBe(true);
@@ -2814,6 +2989,39 @@ test("frontend-generated same-output builds no-op only while output and dependen
         process.umask(oldUmask);
     }
 });
+test("pre-section-GC output-local stamps cannot restore an old executable", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "scriptc-section-gc-local-stamp-"));
+    scratch.push(dir);
+    const cacheRoot = join(dir, "cache");
+    const cPath = join(dir, "program.c");
+    const outPath = join(dir, "program");
+    const oldCacheDir = process.env["SCRIPTC_CACHE_DIR"];
+    const oldNoCache = process.env["SCRIPTC_NO_CACHE"];
+    try {
+        process.env["SCRIPTC_CACHE_DIR"] = cacheRoot;
+        delete process.env["SCRIPTC_NO_CACHE"];
+        await writeFile(cPath, "int main(void) { return 0; }\n");
+        await compileC({ cPath, outPath, cacheIdentity: "scriptc-generated-v1" });
+        const stampPath = join(cacheRoot, "local", createHash("sha256").update(outPath).digest("hex"));
+        const current = JSON.parse(await readFile(stampPath, "utf8"));
+        const legacy = { ...current, key: "old-non-gc-output", version: 1 };
+        await writeFile(stampPath, `${JSON.stringify(legacy)}\n`);
+        const pinnedTime = new Date("2001-01-01T00:00:00.000Z");
+        await utimes(outPath, pinnedTime, pinnedTime);
+        await compileC({ cPath, outPath, cacheIdentity: "scriptc-generated-v1" });
+        expect((await stat(outPath)).mtimeMs).toBeGreaterThan(pinnedTime.getTime());
+    }
+    finally {
+        if (oldCacheDir === undefined)
+            delete process.env["SCRIPTC_CACHE_DIR"];
+        else
+            process.env["SCRIPTC_CACHE_DIR"] = oldCacheDir;
+        if (oldNoCache === undefined)
+            delete process.env["SCRIPTC_NO_CACHE"];
+        else
+            process.env["SCRIPTC_NO_CACHE"] = oldNoCache;
+    }
+});
 test("artifact-ready callbacks expose native dependencies on builds and validated hits", async () => {
     const dir = await mkdtemp(join(tmpdir(), "scriptc-artifact-ready-"));
     scratch.push(dir);
@@ -2930,7 +3138,7 @@ test("fresh processes preserve output-local dependency coverage after source edi
     delete childEnv["SCRIPTC_NO_CACHE"];
     delete childEnv["SCRIPTC_TEST_STABLE_TOOLCHAIN"];
     delete childEnv["SCRIPTC_TEST_TRUST_COMPILER_WRAPPER"];
-    await writeFile(helperPath, `import { compileC } from ${JSON.stringify(new URL("./cc.ts", import.meta.url).href)};\n` +
+    await writeFile(helperPath, `import { compileC } from ${JSON.stringify(new URL("./native-toolchain.ts", import.meta.url).href)};\n` +
         `await compileC({ cPath: process.argv[2], outPath: process.argv[3], cacheIdentity: "scriptc-generated-v1" });\n`);
     const compileInFreshProcess = () => {
         execFileSync(process.execPath, ["--import", "tsx", helperPath, cPath, outPath], {
@@ -3805,7 +4013,11 @@ test.skipIf(process.platform === "win32" || clangExecutable === undefined || arE
         const probeSource = join(dir, "probe.c");
         const probe = join(dir, "probe");
         await writeFile(probeSource, "long long public_value(void);\nint main(void) { return public_value() != 7; }\n");
-        execFileSync(clangExecutable, [probeSource, outPath, "-lm", "-o", probe]);
+        // The failed linker belongs only to the shard-merge probe. Link the
+        // resulting archive with the real host tools to verify its fallback.
+        execFileSync(clangExecutable, [probeSource, outPath, "-lm", "-o", probe], {
+            env: { ...process.env, PATH: oldPath },
+        });
         expect(execFileSync(probe, { encoding: "utf8" })).toBe("");
         // The canonical retry is valid for this invocation, but must not occupy a
         // key describing merged shard bytes. A repaired merge tool retries the
@@ -3895,4 +4107,4 @@ test.skipIf(process.platform === "win32" || zigExecutable === undefined)("cross-
             process.env["SCRIPTC_TARGET"] = oldTarget;
     }
 });
-//# sourceMappingURL=cc-cache.test.js.map
+//# sourceMappingURL=native-toolchain.test.js.map