wehub-resource-sync
e7738de6d2
CI / Deep Native Runtime Cases (1/6) (push) Has been skipped
CI / Native Preflight (push) Failing after 1s
CI / Native Runtime Cases (1/2) (push) Failing after 0s
CI / Native Runtime Cases (2/2) (push) Failing after 1s
CI / Native Metadata Reports (push) Failing after 0s
CI / Native Direct Backend Artifacts (push) Failing after 0s
CI / Native Sanitizer Smoke (push) Failing after 1s
CI / Command Contract Snapshots (push) Failing after 1s
CI / Deep Conformance Suite (push) Has been skipped
CI / Graph Build Perf (push) Failing after 1s
CI / Deep Native Preflight (push) Has been skipped
CI / Deep Native Runtime Cases (2/6) (push) Has been skipped
CI / Deep Native Runtime Cases (3/6) (push) Has been skipped
CI / Conformance Suite (push) Failing after 1s
CI / Workspace Checks (push) Failing after 0s
CI / Deep Native Runtime Cases (5/6) (push) Has been skipped
CI / Deep Native Runtime Cases (6/6) (push) Has been skipped
CI / Deep Native Runtime Cases (4/6) (push) Has been skipped
CI / Deep Graph Build Perf (push) Has been skipped
8691 lines
554 KiB
TypeScript
Executable File
8691 lines
554 KiB
TypeScript
Executable File
#!/usr/bin/env -S node --experimental-strip-types --disable-warning=ExperimentalWarning
|
|
import { execFileSync, spawnSync } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
import { chmodSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join, resolve } from "node:path";
|
|
import { createAggregateAssert, finishAggregateAssert } from "./aggregate-assert.mjs";
|
|
|
|
const assert = createAggregateAssert();
|
|
|
|
if (process.env.ZERO_NATIVE_TEST_SANDBOX !== "1" && process.env.ZERO_NATIVE_TEST_ALLOW_LOCAL !== "1") {
|
|
console.error("command contract snapshots emit native test artifacts; run `pnpm run command-contracts` for Vercel Sandbox execution or set ZERO_NATIVE_TEST_ALLOW_LOCAL=1 to opt into local artifacts.");
|
|
process.exit(1);
|
|
}
|
|
|
|
const outDir = ".zero/command-contracts";
|
|
const execMaxBuffer = 64 * 1024 * 1024;
|
|
const zeroBin = process.env.ZERO_BIN || (existsSync(".zero/bin/zero") ? resolve(".zero/bin/zero") : resolve("bin/zero"));
|
|
mkdirSync(outDir, { recursive: true });
|
|
|
|
function graphSidecarPath(sourcePath: string) {
|
|
return `${sourcePath.slice(0, -2)}.graph`;
|
|
}
|
|
|
|
function zero(args, options: { allowFailure?: boolean; env?: Record<string, string> } = {}) {
|
|
try {
|
|
const stdout = execFileSync(zeroBin, args, { encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"], env: options.env ? { ...process.env, ...options.env } : process.env });
|
|
return { code: 0, stdout };
|
|
} catch (error) {
|
|
if (!options.allowFailure) throw error;
|
|
return {
|
|
code: error.status ?? 1,
|
|
stdout: error.stdout?.toString() ?? "",
|
|
stderr: error.stderr?.toString() ?? "",
|
|
};
|
|
}
|
|
}
|
|
|
|
function zeroWithStderr(args, options: { cwd?: string } = {}) {
|
|
const result = spawnSync(zeroBin, args, { encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"], cwd: options.cwd });
|
|
if (result.error) throw result.error;
|
|
return { code: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
|
|
}
|
|
|
|
function zeroWithInput(args, input: string, options: { allowFailure?: boolean } = {}) {
|
|
const result = spawnSync(zeroBin, args, { encoding: "utf8", maxBuffer: execMaxBuffer, input, stdio: ["pipe", "pipe", "pipe"] });
|
|
if (result.error) throw result.error;
|
|
const code = result.status ?? 1;
|
|
if (code !== 0 && !options.allowFailure) {
|
|
throw new Error(`zero ${args.join(" ")} exited ${code}: ${result.stderr ?? ""}`);
|
|
}
|
|
return { code, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
|
|
}
|
|
|
|
function zeroRaw(args, options: { allowFailure?: boolean; env?: Record<string, string> } = {}) {
|
|
try {
|
|
const stdout = execFileSync(zeroBin, args, { encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"], env: options.env ? { ...process.env, ...options.env } : process.env });
|
|
return { code: 0, stdout };
|
|
} catch (error) {
|
|
if (!options.allowFailure) throw error;
|
|
return {
|
|
code: error.status ?? 1,
|
|
stdout: error.stdout?.toString() ?? "",
|
|
stderr: error.stderr?.toString() ?? "",
|
|
};
|
|
}
|
|
}
|
|
|
|
function assertPatchOkOutput(stdout: string, expectedSaved?: string) {
|
|
assert.match(stdout, /^program graph patch ok\n/);
|
|
if (expectedSaved) {
|
|
assert.match(stdout, new RegExp(`saved: ${expectedSaved.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\n`));
|
|
}
|
|
assert.match(stdout, /graphHash: graph:[0-9a-f]{16}\n/);
|
|
assert.match(stdout, /applied: \d+ ops?, \d+ nodes? touched\n/);
|
|
}
|
|
|
|
function json(args, options = {}) {
|
|
const result = zero(args, options);
|
|
return { ...result, body: JSON.parse(result.stdout) };
|
|
}
|
|
|
|
function jsonRaw(args, options = {}) {
|
|
const result = zeroRaw(args, options);
|
|
return { ...result, body: JSON.parse(result.stdout) };
|
|
}
|
|
|
|
function projectionSidecarGraphPath(sourcePath: string) {
|
|
assert(sourcePath.endsWith(".0"), `projection path must end in .0: ${sourcePath}`);
|
|
return graphSidecarPath(sourcePath);
|
|
}
|
|
|
|
function importProjectionSidecar(sourcePath: string) {
|
|
const graphPath = projectionSidecarGraphPath(sourcePath);
|
|
assert.equal(zero(["import", "--format", "binary", "--out", graphPath, sourcePath]).stdout, "");
|
|
return graphPath;
|
|
}
|
|
|
|
function assertProjectionCheckOk(sourcePath: string) {
|
|
const graphPath = importProjectionSidecar(sourcePath);
|
|
assert.equal(zero(["check", graphPath]).stdout, "ok\n");
|
|
}
|
|
|
|
function writeProjectionFile(sourcePath: string, contents: string) {
|
|
rmSync(projectionSidecarGraphPath(sourcePath), { force: true });
|
|
writeFileSync(sourcePath, contents);
|
|
}
|
|
|
|
function repositoryGraphVerifyScript(root, options: { allowFailure?: boolean; target?: string } = {}) {
|
|
const args = [
|
|
"--experimental-strip-types",
|
|
"--disable-warning=ExperimentalWarning",
|
|
"scripts/repository-graph-verify-projection.mts",
|
|
"--root",
|
|
root,
|
|
];
|
|
if (options.target) args.push("--target", options.target);
|
|
try {
|
|
const stdout = execFileSync(
|
|
process.execPath,
|
|
args,
|
|
{ encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] },
|
|
);
|
|
return { code: 0, stdout, stderr: "" };
|
|
} catch (error) {
|
|
if (!options.allowFailure) throw error;
|
|
return {
|
|
code: error.status ?? 1,
|
|
stdout: error.stdout?.toString() ?? "",
|
|
stderr: error.stderr?.toString() ?? "",
|
|
};
|
|
}
|
|
}
|
|
|
|
function sha256File(path) {
|
|
return createHash("sha256").update(readFileSync(path)).digest("hex");
|
|
}
|
|
|
|
function assertSourceGraph(body, artifact, moduleIdentity, lowering = "typed-program-graph-mir", canonicalSource = true, sourceProjectionState = undefined) {
|
|
assert.equal(body.graph.artifact, artifact);
|
|
assert.equal(body.graph.canonicalSource, canonicalSource);
|
|
assert.equal(body.graph.moduleIdentity, moduleIdentity);
|
|
assert.match(body.graph.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
assert.equal(body.graph.lowering, lowering);
|
|
if (sourceProjectionState !== undefined) assert.equal(body.graph.sourceProjectionState, sourceProjectionState);
|
|
}
|
|
|
|
const programGraphParseTreeKeys = new Map();
|
|
|
|
function assertProgramGraphCompilerInput(body, artifact) {
|
|
assert(body.compilerCaches.every((cache) => cache.sourceKind === "program-graph" && cache.graphHash === body.graph.graphHash));
|
|
assert(body.compilerCaches.every((cache) => cache.parserArtifactsInKey === false));
|
|
const caches = new Map<string, any>();
|
|
for (const cache of body.compilerCaches) caches.set(cache.name, cache);
|
|
const assertCacheInputs = (name, includes, excludes = []) => {
|
|
const cache = caches.get(name);
|
|
assert(cache, `missing compiler cache ${name}`);
|
|
for (const key of includes) assert(cache.graphKeyInputs.includes(key), `${name} cache key inputs should include ${key}`);
|
|
for (const key of excludes) assert(!cache.graphKeyInputs.includes(key), `${name} cache key inputs should not include ${key}`);
|
|
};
|
|
assertCacheInputs("parseTree", ["graphHash", "stdlibGraph", "nodeHashes", "importPaths", "compilerVersion", "packageDependencies"], ["sourceFiles", "targetFacts", "profile"]);
|
|
assertCacheInputs("interface", ["graphHash", "modulePaths", "symbolFacts", "importGraph"], ["targetFacts", "profile", "compilerVersion", "packageDependencies"]);
|
|
assertCacheInputs("checkedBody", ["graphHash", "stdlibGraph", "importPaths", "targetFacts", "compilerVersion", "packageDependencies"], ["sourceFiles", "profile"]);
|
|
assertCacheInputs("specialization", ["graphHash", "stdlibGraph", "importPaths", "targetFacts", "profile", "compilerVersion", "packageDependencies"], ["sourceFiles"]);
|
|
if (body.graph.lowering === "mapped-final-mir") {
|
|
assertCacheInputs("mappedFinalMir", ["graphHash", "stdlibGraph", "importPaths", "targetFacts", "compilerVersion", "packageDependencies", "emitKind", "backend"], ["sourceFiles", "profile"]);
|
|
const mappedMirCache = caches.get("mappedFinalMir");
|
|
assert.match(mappedMirCache.path, /\.zero\/cache\/native\/mir-[0-9a-f]+\.zmir$/);
|
|
assert.equal(mappedMirCache.memoryMapped, true);
|
|
assert.equal(mappedMirCache.borrowedStorage, true);
|
|
assert.equal(mappedMirCache.byteLength > 0, true);
|
|
assert.equal(typeof mappedMirCache.codegenImmediate, "boolean");
|
|
assert.equal(typeof mappedMirCache.programReconstructed, "boolean");
|
|
assert.equal(body.incrementalInvalidation.graphInput.mappedFinalMir.path, mappedMirCache.path);
|
|
assert.equal(body.incrementalInvalidation.graphInput.mappedFinalMir.memoryMapped, true);
|
|
assert.equal(body.incrementalInvalidation.graphInput.mappedFinalMir.borrowedStorage, true);
|
|
assert.equal(body.incrementalInvalidation.graphInput.mappedFinalMir.codegenImmediate, mappedMirCache.codegenImmediate);
|
|
assert.equal(body.incrementalInvalidation.graphInput.mappedFinalMir.programReconstructed, mappedMirCache.programReconstructed);
|
|
}
|
|
assertCacheInputs("emittedObject", ["graphHash", "stdlibGraph", "importPaths", "targetFacts", "profile", "compilerVersion", "packageDependencies"], ["sourceFiles"]);
|
|
const parseTreeCache = caches.get("parseTree");
|
|
assert.equal(parseTreeCache.invalidatesOn, "ProgramGraph input");
|
|
if (programGraphParseTreeKeys.has(artifact)) assert.equal(parseTreeCache.key, programGraphParseTreeKeys.get(artifact));
|
|
else programGraphParseTreeKeys.set(artifact, parseTreeCache.key);
|
|
assert.equal(body.incrementalInvalidation.sourceKind, "program-graph");
|
|
assert.equal(body.incrementalInvalidation.graphInput.artifact, artifact);
|
|
assert.equal(body.incrementalInvalidation.graphInput.graphHash, body.graph.graphHash);
|
|
assert.equal(body.incrementalInvalidation.graphInput.parserArtifactsInKey, false);
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("graphHash"));
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("nodeHashes"));
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("typeFacts"));
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("symbolFacts"));
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("modulePaths"));
|
|
assert(body.incrementalInvalidation.graphInput.keyedBy.includes("importPaths"));
|
|
assert.equal(body.incrementalInvalidation.changedInputs.graphArtifact, artifact);
|
|
assert.equal(body.incrementalInvalidation.interfaceFingerprints.sourceKind, "program-graph");
|
|
assert.equal(body.incrementalInvalidation.interfaceFingerprints.graphHash, body.graph.graphHash);
|
|
}
|
|
|
|
function assertRepositoryGraphNativeCheck(body, sourceProjectionState = "clean", options: { graphHirToMirUsed?: boolean } = {}) {
|
|
const graphHirToMirUsed = options.graphHirToMirUsed === false ? false : true;
|
|
assert.equal(body.graphCompiler.input, "repository-graph-store");
|
|
assert.equal(body.graphCompiler.graphStoreLoaded, true);
|
|
assert.equal(body.graphCompiler.sourceProjectionRequiredForCompilerInput, false);
|
|
assert.equal(body.graphCompiler.sourceProjectionState, sourceProjectionState);
|
|
assert.equal(body.graphCompiler.graphNativeCheckerUsed, true);
|
|
assert.equal(body.graphCompiler.graphHirToMirUsed, graphHirToMirUsed);
|
|
assert.equal(body.graphCompiler.unsupportedGraphFacts.count, 0);
|
|
assert.equal(body.graphCompiler.resolution.ok, true);
|
|
assert.equal(body.graphCompiler.resolution.state, "resolved-graph-facts");
|
|
assert.equal(body.graphCompiler.checking.ok, true);
|
|
assert.equal(body.graphCompiler.checking.state, "checked-graph-readiness-facts");
|
|
assert.equal(body.graphCompiler.checking.scope, "resolution-package-target-and-graph-mir-readiness");
|
|
assert.equal(body.graphCompiler.checking.semanticDiagnosticsEnforced, false);
|
|
assert.equal(body.graphCompiler.checking.authority, "ProgramGraphStore");
|
|
assert.equal(body.graphCompiler.checking.sourceTextAuthority, false);
|
|
assert.equal(body.graphCompiler.semanticFacts.state, "typed-facts");
|
|
assert.equal(body.graphCompiler.semanticFacts.ok, true);
|
|
const targetReady = body.targetReadiness?.ok === true;
|
|
const compilerInputReady = targetReady && graphHirToMirUsed;
|
|
assert.equal(body.graphCompiler.defaultReadiness.compilerInputReady, compilerInputReady);
|
|
assert.equal(body.graphCompiler.defaultReadiness.claim, compilerInputReady ? "ready-for-repository-graph-input" : "blocked");
|
|
assert.equal(body.graphCompiler.defaultReadiness.sourceFreeCompile, compilerInputReady);
|
|
assert.equal(body.graphCompiler.defaultReadiness.sourceProjectionRequired, false);
|
|
assert.equal(body.graphCompiler.defaultReadiness.sourceProjectionState, sourceProjectionState);
|
|
assert.equal(body.graphCompiler.defaultReadiness.graphMir.used, graphHirToMirUsed);
|
|
assert.equal(Object.hasOwn(body.graphCompiler.defaultReadiness, "fallback"), false);
|
|
assert.equal(body.graphCompiler.defaultReadiness.performance.validationInLoad, true);
|
|
assert.equal(body.graphCompiler.defaultReadiness.cacheInvalidation.parserArtifactsInKey, false);
|
|
assert(body.graphCompiler.defaultReadiness.cacheInvalidation.keyedBy.includes("nodeHashes"));
|
|
assert(body.graphCompiler.defaultReadiness.cacheInvalidation.keyedBy.includes("symbolFacts"));
|
|
assert(body.graphCompiler.defaultReadiness.cacheInvalidation.keyedBy.includes("modulePaths"));
|
|
assert(body.graphCompiler.defaultReadiness.cacheInvalidation.keyedBy.includes("importPaths"));
|
|
assert.equal(body.graphCompiler.defaultReadiness.targetReadinessOk, targetReady);
|
|
assert.equal(body.compileTime.deterministic, true);
|
|
assert.equal(body.targetReadiness.languageOk, true);
|
|
assert.equal(body.safetyFacts.schemaVersion, 1);
|
|
}
|
|
|
|
const graphHashPrime = 1099511628211n;
|
|
const graphHashMask = (1n << 64n) - 1n;
|
|
|
|
function graphHashText(hash, text) {
|
|
for (const byte of Buffer.from(text ?? "")) {
|
|
hash ^= BigInt(byte);
|
|
hash = (hash * graphHashPrime) & graphHashMask;
|
|
}
|
|
hash ^= 0xffn;
|
|
return (hash * graphHashPrime) & graphHashMask;
|
|
}
|
|
|
|
function graphHashU64(hash, value) {
|
|
let item = BigInt(value);
|
|
for (let i = 0n; i < 8n; i++) {
|
|
hash ^= (item >> (i * 8n)) & 0xffn;
|
|
hash = (hash * graphHashPrime) & graphHashMask;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
function graphQuotedField(line, field) {
|
|
const match = line.match(new RegExp(`(?:^| )${field}:"((?:\\\\.|[^"])*)"`));
|
|
return match ? JSON.parse(`"${match[1]}"`) : "";
|
|
}
|
|
|
|
function graphBareField(line, field, fallback = "") {
|
|
const match = line.match(new RegExp(`(?:^| )${field}:([^ ]+)`));
|
|
return match ? match[1] : fallback;
|
|
}
|
|
|
|
function graphTopLevelQuoted(line, field) {
|
|
const match = line.match(new RegExp(`^${field} "([^"]*)"$`));
|
|
return match ? match[1] : "";
|
|
}
|
|
|
|
function graphNodeHandle(line) {
|
|
const match = line.match(/^node (#[A-Za-z0-9_.-]+)/);
|
|
return match ? match[1] : "";
|
|
}
|
|
|
|
function graphNodeKind(line) {
|
|
const match = line.match(/^node #[A-Za-z0-9_.-]+ ([A-Za-z_][A-Za-z0-9_-]*)/);
|
|
return match ? match[1] : "";
|
|
}
|
|
|
|
function graphStoredModuleIdentity(text) {
|
|
if (!text) return "module:main";
|
|
if (text.startsWith("module:") || text.startsWith("package:")) return text;
|
|
return `module:${text}`;
|
|
}
|
|
|
|
function graphEdgeRecord(line) {
|
|
const match = line.match(/^edge (#[A-Za-z0-9_.-]+) ([A-Za-z_][A-Za-z0-9_-]*) ([^ ]+)/);
|
|
return {
|
|
line,
|
|
from: match?.[1] ?? "",
|
|
kind: match?.[2] ?? "",
|
|
to: match?.[3] ?? "",
|
|
target: graphBareField(line, "target", "node"),
|
|
order: graphBareField(line, "order", "0"),
|
|
};
|
|
}
|
|
|
|
function graphDomainId(domain, hash) {
|
|
return `${domain}:${hash.toString(16).padStart(16, "0")}`;
|
|
}
|
|
|
|
function graphNodeDeclaresSymbol(node) {
|
|
if (!node?.name) return false;
|
|
return [
|
|
"Module",
|
|
"Const",
|
|
"CImport",
|
|
"TypeAlias",
|
|
"Shape",
|
|
"Interface",
|
|
"Enum",
|
|
"Choice",
|
|
"Function",
|
|
"Param",
|
|
"Field",
|
|
"EnumCase",
|
|
"ChoiceCase",
|
|
"Let",
|
|
"ErrorVariant",
|
|
].includes(node.kind);
|
|
}
|
|
|
|
function graphNodeHash(line) {
|
|
let hash = 1469598103934665603n;
|
|
hash = graphHashText(hash, graphNodeKind(line));
|
|
hash = graphHashText(hash, graphQuotedField(line, "name"));
|
|
hash = graphHashText(hash, graphQuotedField(line, "type"));
|
|
hash = graphHashText(hash, graphQuotedField(line, "value"));
|
|
hash = graphHashU64(hash, graphBareField(line, "public", "false") === "true" ? 1n : 0n);
|
|
hash = graphHashU64(hash, graphBareField(line, "mutable", "false") === "true" ? 1n : 0n);
|
|
hash = graphHashU64(hash, graphBareField(line, "static", "false") === "true" ? 1n : 0n);
|
|
hash = graphHashU64(hash, graphBareField(line, "fallible", "false") === "true" ? 1n : 0n);
|
|
hash = graphHashU64(hash, graphBareField(line, "exportC", "false") === "true" ? 1n : 0n);
|
|
return graphDomainId("nodehash", hash);
|
|
}
|
|
|
|
function graphSymbolComponent(text) {
|
|
let out = "";
|
|
for (const ch of text ?? "") out += /^[A-Za-z0-9._@/-]$/.test(ch) ? ch : "_";
|
|
return out || "main";
|
|
}
|
|
|
|
function graphIdentityName(identity) {
|
|
if (identity?.startsWith("module:")) return identity.slice("module:".length);
|
|
if (identity?.startsWith("package:")) return identity.slice("package:".length);
|
|
return identity || "main";
|
|
}
|
|
|
|
function graphModuleScopeName(moduleIdentity, moduleNode) {
|
|
const moduleName = moduleNode?.name || graphIdentityName(moduleIdentity);
|
|
if (moduleIdentity?.startsWith("package:")) return `${graphSymbolComponent(graphIdentityName(moduleIdentity))}/${graphSymbolComponent(moduleName)}`;
|
|
return graphSymbolComponent(moduleName);
|
|
}
|
|
|
|
function graphImportBindingName(node) {
|
|
if (node.value) return node.value;
|
|
const parts = (node.name ?? "").split(".");
|
|
return parts.at(-1) || node.name || "";
|
|
}
|
|
|
|
function graphSymbolName(node) {
|
|
return node.kind === "Import" ? graphImportBindingName(node) : (node.name ?? "");
|
|
}
|
|
|
|
const graphOwnerKinds = new Set([
|
|
"alias",
|
|
"arg",
|
|
"arm",
|
|
"body",
|
|
"cImport",
|
|
"case",
|
|
"choice",
|
|
"const",
|
|
"constraint",
|
|
"declaredType",
|
|
"default",
|
|
"effect",
|
|
"else",
|
|
"enum",
|
|
"error",
|
|
"expr",
|
|
"field",
|
|
"function",
|
|
"guard",
|
|
"import",
|
|
"interface",
|
|
"left",
|
|
"method",
|
|
"param",
|
|
"rangeEnd",
|
|
"returnType",
|
|
"right",
|
|
"shape",
|
|
"statement",
|
|
"target",
|
|
"then",
|
|
"type",
|
|
"typeArg",
|
|
"typeParam",
|
|
"value",
|
|
"variant",
|
|
]);
|
|
|
|
function graphOwnerEdgeForNode(edges, nodeId) {
|
|
return edges.find((edge) => edge.target === "node" && edge.to === nodeId && graphOwnerKinds.has(edge.kind)) ?? null;
|
|
}
|
|
|
|
function graphSymbolOwner(nodesById, edges, node) {
|
|
let current = node?.id ?? "";
|
|
for (let depth = 0; current && depth < nodesById.size; depth++) {
|
|
const ownerEdge = graphOwnerEdgeForNode(edges, current);
|
|
if (!ownerEdge) return null;
|
|
const owner = nodesById.get(ownerEdge.from);
|
|
if (!owner) return null;
|
|
if (owner.kind === "Module" || graphNodeDeclaresSymbol(owner)) return owner;
|
|
current = owner.id;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function graphNodeSymbolNamespace(node, ownerEdge) {
|
|
switch (node.kind) {
|
|
case "Module": return "module";
|
|
case "Import": return "import";
|
|
case "CImport": return "c-import";
|
|
case "Const": return "value";
|
|
case "Function": return ownerEdge?.kind === "method" ? "method" : "value";
|
|
case "TypeAlias":
|
|
case "Shape":
|
|
case "Interface":
|
|
case "Enum":
|
|
case "Choice":
|
|
return "type";
|
|
case "Param": return "param";
|
|
case "Field": return "field";
|
|
case "EnumCase":
|
|
case "ChoiceCase":
|
|
case "ErrorVariant":
|
|
return "variant";
|
|
case "Let": return "local";
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
function graphLocalSymbolSuffix(node) {
|
|
if (node.kind !== "Let") return "";
|
|
const suffix = node.id.split(".").at(-1) || node.id;
|
|
return suffix ? `@${graphSymbolComponent(suffix)}` : "";
|
|
}
|
|
|
|
function graphNodeSymbolIdFromGraph(moduleIdentity, nodesById, edges, node, depth = 0) {
|
|
if (!graphNodeDeclaresSymbol(node) || depth > nodesById.size) return "";
|
|
const name = graphSymbolName(node);
|
|
if (!name) return "";
|
|
if (node.kind === "Module") return `symbol:${graphModuleScopeName(moduleIdentity, node)}::module`;
|
|
const ownerEdge = graphOwnerEdgeForNode(edges, node.id);
|
|
const owner = graphSymbolOwner(nodesById, edges, node);
|
|
const namespace = graphNodeSymbolNamespace(node, ownerEdge);
|
|
if (!namespace) return "";
|
|
if (owner?.kind === "Module") {
|
|
return `symbol:${graphModuleScopeName(moduleIdentity, owner)}::${graphSymbolComponent(namespace)}.${graphSymbolComponent(name)}${graphLocalSymbolSuffix(node)}`;
|
|
}
|
|
if (owner) {
|
|
const ownerSymbol = graphNodeSymbolIdFromGraph(moduleIdentity, nodesById, edges, owner, depth + 1);
|
|
if (ownerSymbol) return `${ownerSymbol}/${graphSymbolComponent(namespace)}.${graphSymbolComponent(name)}${graphLocalSymbolSuffix(node)}`;
|
|
}
|
|
return `symbol:${graphSymbolComponent(graphIdentityName(moduleIdentity))}::${graphSymbolComponent(namespace)}.${graphSymbolComponent(name)}${graphLocalSymbolSuffix(node)}`;
|
|
}
|
|
|
|
function graphNodeTypeId(line) {
|
|
const type = graphQuotedField(line, "type");
|
|
return type ? graphDomainId("type", graphHashText(1469598103934665603n, type)) : "";
|
|
}
|
|
|
|
function graphNodeEffectId(line) {
|
|
const kind = graphNodeKind(line);
|
|
const name = graphQuotedField(line, "name");
|
|
return kind === "EffectRef" && name ? graphDomainId("effect", graphHashText(1469598103934665603n, name)) : "";
|
|
}
|
|
|
|
function recomputeGraphHash(text) {
|
|
const lines = text.trimEnd().split("\n");
|
|
const moduleIdentity = graphStoredModuleIdentity(graphTopLevelQuoted(lines.find((line) => line.startsWith("module ")) ?? "", "module"));
|
|
const nodeRecords = lines.filter((item) => item.startsWith("node ")).map((line) => ({
|
|
line,
|
|
id: graphNodeHandle(line),
|
|
kind: graphNodeKind(line),
|
|
name: graphQuotedField(line, "name"),
|
|
type: graphQuotedField(line, "type"),
|
|
value: graphQuotedField(line, "value"),
|
|
}));
|
|
const edgeRecords = lines.filter((item) => item.startsWith("edge ")).map(graphEdgeRecord);
|
|
const nodesById = new Map(nodeRecords.map((node) => [node.id, node]));
|
|
let hash = 1469598103934665603n;
|
|
hash = graphHashU64(hash, 1n);
|
|
hash = graphHashText(hash, moduleIdentity);
|
|
for (const node of nodeRecords) {
|
|
const line = node.line;
|
|
hash = graphHashText(hash, node.id);
|
|
hash = graphHashText(hash, graphQuotedField(line, "nodeHash") || graphNodeHash(line));
|
|
hash = graphHashText(hash, graphQuotedField(line, "symbolId") || graphNodeSymbolIdFromGraph(moduleIdentity, nodesById, edgeRecords, node));
|
|
hash = graphHashText(hash, graphQuotedField(line, "typeId") || graphNodeTypeId(line));
|
|
hash = graphHashText(hash, graphQuotedField(line, "effectId") || graphNodeEffectId(line));
|
|
}
|
|
for (const edge of edgeRecords) {
|
|
hash = graphHashText(hash, edge.from);
|
|
hash = graphHashText(hash, edge.to);
|
|
hash = graphHashText(hash, edge.kind);
|
|
hash = graphHashText(hash, edge.target);
|
|
hash = graphHashU64(hash, edge.order);
|
|
}
|
|
return `graph:${hash.toString(16).padStart(16, "0")}`;
|
|
}
|
|
|
|
function repositoryGraphPayload(storeText) {
|
|
const marker = "\ngraph\n";
|
|
const start = storeText.indexOf(marker);
|
|
assert.notEqual(start, -1);
|
|
return storeText.slice(start + marker.length);
|
|
}
|
|
|
|
function repositoryGraphModuleIdentity(storeText, graphText) {
|
|
const stored = storeText.match(/^moduleIdentity "([^"]+)"$/m)?.[1];
|
|
if (stored) return stored;
|
|
const moduleLine = graphText.split("\n").find((line) => line.startsWith("module ")) ?? "";
|
|
return graphStoredModuleIdentity(graphTopLevelQuoted(moduleLine, "module"));
|
|
}
|
|
|
|
function graphNodeHasSourceMap(line) {
|
|
return graphQuotedField(line, "path") !== "" ||
|
|
Number.parseInt(graphBareField(line, "line", "0"), 10) > 0 ||
|
|
Number.parseInt(graphBareField(line, "column", "0"), 10) > 0;
|
|
}
|
|
|
|
function graphNodeIsDeclaration(kind) {
|
|
return [
|
|
"Import",
|
|
"CImport",
|
|
"Const",
|
|
"TypeAlias",
|
|
"Shape",
|
|
"Interface",
|
|
"Enum",
|
|
"Choice",
|
|
"Function",
|
|
"Param",
|
|
"Field",
|
|
"EnumCase",
|
|
"ChoiceCase",
|
|
"Let",
|
|
"ErrorVariant",
|
|
].includes(kind);
|
|
}
|
|
|
|
function graphNodeIsScope(kind) {
|
|
return [
|
|
"Module",
|
|
"Function",
|
|
"Block",
|
|
"Shape",
|
|
"Interface",
|
|
"Enum",
|
|
"Choice",
|
|
].includes(kind);
|
|
}
|
|
|
|
function graphTypeIsCapability(type) {
|
|
return ["World", "Fs", "File", "Net", "HttpClient"].includes(type);
|
|
}
|
|
|
|
function graphTypeIsOwnership(type) {
|
|
return type.includes("owned<") || type.includes("MutSpan<") || type.includes("mutref<");
|
|
}
|
|
|
|
function graphTypeIsResource(type) {
|
|
return ["World", "Fs", "File"].includes(type) || type.includes("owned<File>");
|
|
}
|
|
|
|
function repositoryGraphCompilerTableCounts(storeText) {
|
|
const graphText = repositoryGraphPayload(storeText);
|
|
const moduleIdentity = repositoryGraphModuleIdentity(storeText, graphText);
|
|
const nodeLines = graphText.split("\n").filter((line) => line.startsWith("node "));
|
|
const edgeLines = graphText.split("\n").filter((line) => line.startsWith("edge "));
|
|
const projection = storeText.match(/^projection path:/gm)?.length ?? 0;
|
|
const counts = {
|
|
schema: 1,
|
|
package: moduleIdentity.startsWith("package:") ? 1 : 0,
|
|
module: 0,
|
|
declaration: 0,
|
|
scope: 0,
|
|
import: 0,
|
|
symbol: 0,
|
|
type: 0,
|
|
effect: 0,
|
|
capability: 0,
|
|
ownership: 0,
|
|
resource: 0,
|
|
node: nodeLines.length,
|
|
edge: edgeLines.length,
|
|
projection,
|
|
sourceMap: 0,
|
|
};
|
|
for (const line of nodeLines) {
|
|
const kind = graphNodeKind(line);
|
|
const type = graphQuotedField(line, "type");
|
|
const fallible = graphBareField(line, "fallible", "false") === "true";
|
|
const mutable = graphBareField(line, "mutable", "false") === "true";
|
|
const node = {
|
|
id: graphNodeHandle(line),
|
|
kind,
|
|
name: graphQuotedField(line, "name"),
|
|
type,
|
|
value: graphQuotedField(line, "value"),
|
|
};
|
|
if (kind === "Module") counts.module++;
|
|
if (graphNodeIsDeclaration(kind)) counts.declaration++;
|
|
if (graphNodeIsScope(kind)) counts.scope++;
|
|
if (kind === "Import" || kind === "CImport") counts.import++;
|
|
if (graphQuotedField(line, "symbolId") || graphNodeDeclaresSymbol(node)) counts.symbol++;
|
|
if (graphQuotedField(line, "typeId") || type) counts.type++;
|
|
if (graphQuotedField(line, "effectId") || kind === "EffectRef" || fallible) counts.effect++;
|
|
if (fallible || graphTypeIsCapability(type)) counts.capability++;
|
|
if (mutable || graphTypeIsOwnership(type)) counts.ownership++;
|
|
if (graphTypeIsResource(type)) counts.resource++;
|
|
if (graphNodeHasSourceMap(line)) counts.sourceMap++;
|
|
}
|
|
return counts;
|
|
}
|
|
|
|
function repositoryGraphCompilerTablesLine(storeText) {
|
|
const counts = repositoryGraphCompilerTableCounts(storeText);
|
|
return `compilerTables schema:${counts.schema} package:${counts.package} module:${counts.module} declaration:${counts.declaration} scope:${counts.scope} import:${counts.import} symbol:${counts.symbol} type:${counts.type} effect:${counts.effect} capability:${counts.capability} ownership:${counts.ownership} resource:${counts.resource} node:${counts.node} edge:${counts.edge} projection:${counts.projection} sourceMap:${counts.sourceMap}`;
|
|
}
|
|
|
|
function refreshRepositoryGraphCompilerMetadata(storeText) {
|
|
const compilerStoreLine = 'compilerStore schemaVersion:1 shape:"compiler-oriented-tables" semanticOk:true semanticValidity:"shape-valid" sourceProjectionRequired:false sourceMapRequired:false storageInterface:"ProgramGraphStore"';
|
|
const compilerHashInputsLine = 'compilerHashInputs graphHashExcludes:"source-path,line,column,projection-text" nodeHashExcludes:"source-path,line,column,projection-text" idCollisionFallbackMayUse:"source-path,line,column"';
|
|
return storeText
|
|
.replace(/^compilerStore .*$/m, compilerStoreLine)
|
|
.replace(/^compilerTables .*$/m, repositoryGraphCompilerTablesLine(storeText))
|
|
.replace(/^compilerHashInputs .*$/m, compilerHashInputsLine);
|
|
}
|
|
|
|
function repeatBuildHash(args, firstPath, repeatOut, repeatPath = repeatOut) {
|
|
const repeatArgs = [...args];
|
|
const outIndex = repeatArgs.indexOf("--out");
|
|
assert(outIndex >= 0, "repeat build args should include --out");
|
|
repeatArgs[outIndex + 1] = repeatOut;
|
|
rmSync(repeatPath, { force: true, recursive: true });
|
|
rmSync(`${repeatOut}.exe`, { force: true });
|
|
const repeatReport = json(repeatArgs).body;
|
|
assert.equal(repeatReport.generatedCBytes, 0);
|
|
assert.equal(repeatReport.cBridgeFallback ?? false, false);
|
|
assert.equal(sha256File(repeatPath), sha256File(firstPath));
|
|
return repeatReport;
|
|
}
|
|
|
|
function hasAarch64Instruction(bytes, expected) {
|
|
for (let offset = 0; offset + 4 <= bytes.length; offset++) {
|
|
if (bytes.readUInt32LE(offset) === expected) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function hasAarch64CondBranch(bytes, cond) {
|
|
for (let offset = 0; offset + 4 <= bytes.length; offset++) {
|
|
const instruction = bytes.readUInt32LE(offset);
|
|
if ((instruction & 0xff000010) === 0x54000000 && (instruction & 0xf) === cond) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function hasAarch64VoidReturnEpilogue(bytes) {
|
|
for (let offset = 0; offset + 12 <= bytes.length; offset++) {
|
|
if (bytes.readUInt32LE(offset) !== 0x52800000) continue;
|
|
let cursor = offset + 4;
|
|
const maybeAddSp = bytes.readUInt32LE(cursor);
|
|
if (((maybeAddSp & 0xffc003ff) >>> 0) === 0x910003ff) cursor += 4;
|
|
if (cursor + 8 <= bytes.length &&
|
|
bytes.readUInt32LE(cursor) === 0xa8c17bfd &&
|
|
bytes.readUInt32LE(cursor + 4) === 0xd65f03c0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function assertMachOLoadCommand(bytes, expectedCommand, expectedSize) {
|
|
const ncmds = bytes.readUInt32LE(16);
|
|
for (let offset = 32, i = 0; i < ncmds; i++) {
|
|
const cmd = bytes.readUInt32LE(offset);
|
|
const cmdsize = bytes.readUInt32LE(offset + 4);
|
|
assert(cmdsize >= 8);
|
|
assert(offset + cmdsize <= bytes.length);
|
|
if (cmd === expectedCommand) {
|
|
if (expectedSize !== undefined) assert.equal(cmdsize, expectedSize);
|
|
return bytes.subarray(offset, offset + cmdsize);
|
|
}
|
|
offset += cmdsize;
|
|
}
|
|
assert.fail(`missing Mach-O load command 0x${expectedCommand.toString(16)}`);
|
|
}
|
|
|
|
function elfPackedErrorBytes(code, flagged = false) {
|
|
// Raises functions pack (code << 32); world-main envelopes fold the error
|
|
// flag into the same movabs as (code << 32) | 1, since a separate 32-bit
|
|
// flag mov would zero-extend over the code.
|
|
const bytes = Buffer.alloc(10);
|
|
bytes[0] = 0x48;
|
|
bytes[1] = 0xb8;
|
|
bytes.writeBigUInt64LE((BigInt(code) << 32n) | (flagged ? 1n : 0n), 2);
|
|
return bytes;
|
|
}
|
|
|
|
function hasAnsiControlBytes(text) {
|
|
return /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07]*(?:\x07|\x1b\\)/.test(text);
|
|
}
|
|
|
|
function removeInlineTests(path) {
|
|
if (!existsSync(path)) return;
|
|
const source = readFileSync(path, "utf8");
|
|
const testStart = source.indexOf("\n\ntest ");
|
|
if (testStart >= 0) writeFileSync(path, `${source.slice(0, testStart)}\n`);
|
|
}
|
|
|
|
function tomlQuote(value: unknown) {
|
|
return JSON.stringify(String(value));
|
|
}
|
|
|
|
function tomlArray(values: unknown[]) {
|
|
return `[${values.map(tomlQuote).join(", ")}]`;
|
|
}
|
|
|
|
function appendManifestFields(lines: string[], object: Record<string, unknown>, order: string[]) {
|
|
for (const key of order) {
|
|
if (!(key in object)) continue;
|
|
const value = object[key];
|
|
if (Array.isArray(value)) lines.push(`${key} = ${tomlArray(value)}`);
|
|
else if (typeof value === "boolean") lines.push(`${key} = ${value ? "true" : "false"}`);
|
|
else lines.push(`${key} = ${tomlQuote(value)}`);
|
|
}
|
|
}
|
|
|
|
function manifestToml(manifest: Record<string, any>) {
|
|
const lines = ["[package]"];
|
|
appendManifestFields(lines, manifest.package ?? {}, ["name", "version", "license"]);
|
|
for (const [targetName, target] of Object.entries(manifest.targets ?? {})) {
|
|
lines.push("", `[targets.${targetName}]`);
|
|
appendManifestFields(lines, target as Record<string, unknown>, ["kind", "main", "graph", "defaultTarget", "devTarget", "releaseProfile"]);
|
|
}
|
|
if (manifest.repositoryGraph) {
|
|
lines.push("", "[repositoryGraph]");
|
|
appendManifestFields(lines, manifest.repositoryGraph, ["compilerInput"]);
|
|
}
|
|
for (const sectionName of ["deps", "dependencies"]) {
|
|
if (!manifest[sectionName]) continue;
|
|
lines.push("", `[${sectionName}]`);
|
|
for (const [name, value] of Object.entries(manifest[sectionName])) {
|
|
if (typeof value === "string") lines.push(`${name} = ${tomlQuote(value)}`);
|
|
}
|
|
for (const [name, value] of Object.entries(manifest[sectionName])) {
|
|
if (typeof value === "string") continue;
|
|
lines.push("", `[${sectionName}.${name}]`);
|
|
appendManifestFields(lines, value as Record<string, unknown>, ["path", "version", "targets", "target"]);
|
|
}
|
|
}
|
|
for (const [name, lib] of Object.entries(manifest.c?.libs ?? {})) {
|
|
lines.push("", `[c.libs.${name}]`);
|
|
appendManifestFields(lines, lib as Record<string, unknown>, ["headers", "include", "lib", "link", "mode", "pkg_config", "pkgConfig"]);
|
|
}
|
|
return `${lines.join("\n").replace(/\n{3,}/g, "\n\n")}\n`;
|
|
}
|
|
|
|
function writeZeroTomlSync(root: string, manifest: Record<string, any>) {
|
|
writeFileSync(join(root, "zero.toml"), manifestToml(manifest));
|
|
}
|
|
|
|
function parseSimpleTomlManifest(text: string) {
|
|
const manifest: Record<string, any> = {};
|
|
let section: string[] = [];
|
|
for (const rawLine of text.split(/\r?\n/)) {
|
|
const line = rawLine.trim();
|
|
if (!line || line.startsWith("#")) continue;
|
|
const sectionMatch = line.match(/^\[([A-Za-z0-9_.-]+)\]$/);
|
|
if (sectionMatch) {
|
|
section = sectionMatch[1].split(".");
|
|
let cursor = manifest;
|
|
for (const part of section) cursor = cursor[part] ??= {};
|
|
continue;
|
|
}
|
|
const valueMatch = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*"([^"]*)"$/);
|
|
if (!valueMatch) continue;
|
|
let cursor = manifest;
|
|
for (const part of section) cursor = cursor[part] ??= {};
|
|
cursor[valueMatch[1]] = valueMatch[2];
|
|
}
|
|
return manifest;
|
|
}
|
|
|
|
function readGeneratedManifest(root: string) {
|
|
const tomlPath = join(root, "zero.toml");
|
|
if (existsSync(tomlPath)) return parseSimpleTomlManifest(readFileSync(tomlPath, "utf8"));
|
|
return JSON.parse(readFileSync(join(root, "zero.json"), "utf8"));
|
|
}
|
|
|
|
function assertTemplateManifest(kind, manifest, readme) {
|
|
assert.equal(manifest.package.version, "0.1.0");
|
|
assert.equal(manifest.targets.cli.defaultTarget, "linux-musl-x64");
|
|
assert.equal(manifest.targets.cli.devTarget, "host");
|
|
assert.equal(manifest.targets.cli.releaseProfile, "release-small");
|
|
if (manifest.docs) {
|
|
assert.equal(manifest.docs.readme, "README.md");
|
|
assert.deepEqual(manifest.docs.examples, [manifest.targets.cli.main]);
|
|
}
|
|
assert.match(readme, /zero check/);
|
|
assert.match(readme, /zero test/);
|
|
assert.match(readme, /zero dev --json/);
|
|
if (kind === "lib") {
|
|
assert.equal(manifest.targets.cli.main, "src/lib.0");
|
|
assert.match(readme, /zero doc --json/);
|
|
} else {
|
|
assert.equal(manifest.targets.cli.main, "src/main.0");
|
|
assert.match(readme, /zero run/);
|
|
assert.match(readme, /zero build --target linux-musl-x64/);
|
|
}
|
|
}
|
|
|
|
function assertDevReport(report, kind) {
|
|
assert.equal(report.schemaVersion, 1);
|
|
assert.equal(report.ok, true);
|
|
assert.equal(report.mode, "watch-plan");
|
|
assert.equal(report.generatedCBytes, 0);
|
|
assert.equal(report.cBridgeFallback, false);
|
|
assert.equal(report.watch.planOnly, true);
|
|
assert.equal(report.watch.manifest, "zero.toml");
|
|
assert.deepEqual(report.watch.rerun, ["check", "test", "examples"]);
|
|
assert(Array.isArray(report.watch.packageLocks));
|
|
assert(Array.isArray(report.watch.generatedBindingInputs));
|
|
assert.equal(report.watch.restartOnSuccess, kind !== "lib");
|
|
assert.equal(report.restart.runnableCli, kind !== "lib");
|
|
assert.equal(report.trace.enabled, true);
|
|
assert.equal(report.trace.requested, false);
|
|
assert.equal(report.trace.phaseTiming, true);
|
|
assert.equal(report.trace.cacheFacts, true);
|
|
assert.equal(report.trace.diagnosticsPassthrough, true);
|
|
assert.equal(report.partialDiagnostics.stable, true);
|
|
assert.equal(report.partialDiagnostics.whileCodegenPending, true);
|
|
assert.equal(report.interfaceFingerprints.algorithm, "fnv1a64-zero-interface-v1");
|
|
assert.match(report.interfaceFingerprints.targetFactsHash, /^[0-9a-f]{16}$/);
|
|
assert(report.interfaceFingerprints.modules.length >= 1);
|
|
assert.equal(report.incrementalInvalidation.partialDiagnosticsStable, true);
|
|
assert.match(String(report.incrementalInvalidation.cacheHits), /^\d+$/);
|
|
assert.match(String(report.incrementalInvalidation.cacheMisses), /^\d+$/);
|
|
assert(report.actions.some((action) => action.kind === "check"));
|
|
assert(report.actions.some((action) => action.kind === "test"));
|
|
assert(report.actions.some((action) => action.kind === "examples"));
|
|
assert(report.actions.some((action) => action.kind === "restart" && action.enabled === (kind !== "lib")));
|
|
}
|
|
|
|
function assertReleaseTargetContract(report, expected) {
|
|
const contract = report.releaseTargetContract;
|
|
assert(contract, "release target contract should be present");
|
|
assert.equal(contract.schemaVersion, 1);
|
|
assert.equal(contract.target, expected.target);
|
|
assert.equal(contract.emit, expected.emit);
|
|
assert.equal(contract.artifactKind, expected.artifactKind);
|
|
assert.equal(contract.objectFormat, expected.objectFormat);
|
|
assert.equal(contract.linkerFlavor, expected.linkerFlavor);
|
|
assert.equal(contract.libc.targetMode, expected.targetLibcMode);
|
|
assert.equal(contract.libc.artifactMode, "none");
|
|
assert.equal(contract.generatedCBytes, 0);
|
|
assert.equal(contract.cBridgeFallback, false);
|
|
assert.equal(contract.fallbackPolicy, "explicit-direct-never-c-bridge");
|
|
assert.equal(contract.readiness.status, "supported");
|
|
assert.equal(contract.readiness.directArtifact, true);
|
|
assert.equal(contract.sysroot.requiredByArtifact, false);
|
|
assert.equal(contract.determinism.repeatBuildHash, "checked-by-command-contracts");
|
|
assert(contract.capabilityFacts.some((capability) => capability.name === "memory" && capability.available === true));
|
|
}
|
|
|
|
function directExeEmitterForTarget(target: string) {
|
|
if (target.startsWith("linux") && target.includes("arm64")) return "zero-elf-aarch64-exe";
|
|
if (target.startsWith("linux")) return "zero-elf64-exe";
|
|
if (target === "darwin-x64") return "zero-macho-x64-exe";
|
|
if (target.startsWith("darwin")) return "zero-macho64-exe";
|
|
if (target === "win32-arm64.exe") return "zero-coff-aarch64-exe";
|
|
if (target.startsWith("win32")) return "zero-coff-x64-exe";
|
|
return "direct";
|
|
}
|
|
|
|
const generatedCBytesBeforeReadOnlyCommands = json(["size", "--json", "examples/memory-package"]).body.generatedCBytes;
|
|
|
|
assert.match(zero(["--version"]).stdout, /^zero 0\.3\.4 \(build (?:[0-9a-f]{7,40}|unknown)\)\n$/);
|
|
|
|
const version = json(["--version", "--json"]).body;
|
|
assert.equal(version.schemaVersion, 1);
|
|
assert.equal(version.version, "0.3.4");
|
|
assert.match(version.commit, /^(?:[0-9a-f]{7,40}|unknown)$/);
|
|
assert.equal(version.backend, "zero-c");
|
|
assert.equal(typeof version.host, "string");
|
|
assert(version.targets.includes("darwin-arm64"));
|
|
assert(version.targets.includes("linux-musl-x64"));
|
|
assert(version.targets.includes("win32-x64.exe"));
|
|
assert.equal(typeof version.targetCompiler.available, "boolean");
|
|
|
|
const doctor = json(["doctor", "--json"]).body;
|
|
assert.equal(doctor.schemaVersion, 1);
|
|
assert(["ok", "warning", "error"].includes(doctor.status));
|
|
assert(doctor.checks.some((check) => check.name === "native-c-compiler"));
|
|
assert(doctor.checks.some((check) => check.name === "target-c-compiler"));
|
|
assert(doctor.checks.some((check) => check.name === "llvm-toolchain"));
|
|
assert(["ready", "tool-missing", "unsupported-target"].includes(doctor.llvmToolchain.status));
|
|
assert.equal(typeof doctor.llvmToolchain.compiler, "string");
|
|
assert.equal(doctor.llvmToolchain.backendLifecycle.stability, "experimental");
|
|
assert.equal(doctor.llvmToolchain.backendLifecycle.defaultEligible, false);
|
|
assert.equal(doctor.llvmToolchain.backendLifecycle.releaseEligible, false);
|
|
assert(doctor.checks.some((check) => check.name === "cross-executable-builds" && /non-host executable builds|target-capable C compiler available/.test(check.message)));
|
|
assert(doctor.checks.some((check) => check.name === "path" && /PATH/.test(check.message)));
|
|
assert(doctor.checks.some((check) => check.name === "host-target" && /host target/.test(check.message)));
|
|
assert(doctor.checks.some((check) => check.name === "target-sdk-sysroot" && /sysroot|target-capable C compiler/.test(check.message)));
|
|
assert(doctor.checks.some((check) => check.name === "docs-examples"));
|
|
|
|
for (const [command, expected] of [
|
|
[["--help"], /zero init --template cli hello/],
|
|
[["check", "--help"], /Usage: zero check/],
|
|
[["build", "--help"], /Usage: zero build/],
|
|
[["run", "--help"], /Usage: zero run/],
|
|
[["test", "--help"], /Usage: zero test/],
|
|
[["fmt", "--help"], /Usage: zero fmt/],
|
|
[["init", "--help"], /--template cli\|lib\|package/],
|
|
[["skills", "--help"], /Usage: zero skills/],
|
|
[["targets", "--help"], /Usage: zero targets/],
|
|
[["tokens", "--help"], /Usage: zero tokens/],
|
|
[["parse", "--help"], /Usage: zero parse/],
|
|
[["query", "--help"], /Usage: zero query \[--json\] \[--fn <name>\] \[--find <text>\] \[--refs <name>\] \[--calls <name>\] \[--node <id>\] \[--depth <n>\] \[--full\] \[--handles\] \[--no-help\] \[graph-input\|name\]/],
|
|
[["inspect", "--help"], /Usage: zero init \[--template cli\|lib\|package\] \[project-path\]; zero query\|view\|diff\|dump\|inspect\|validate\|source-map\|roundtrip \[--json\] \[graph-input\]/],
|
|
[["diff", "--help"], /Usage: zero diff \[--fn <name>\] \[graph-input\]/],
|
|
[["size", "--help"], /Usage: zero size/],
|
|
[["explain", "--help"], /Usage: zero explain/],
|
|
[["fix", "--help"], /Usage: zero fix/],
|
|
] as Array<[string[], RegExp]>) {
|
|
assert.match(zero(command).stdout, expected);
|
|
}
|
|
const removedNewCommand = zero(["new", "--help"], { allowFailure: true });
|
|
assert.notEqual(removedNewCommand.code, 0);
|
|
assert.match(removedNewCommand.stdout, /zero init --template cli hello/);
|
|
|
|
const tomlInitRoot = join(outDir, "init-toml-manifest");
|
|
rmSync(tomlInitRoot, { recursive: true, force: true });
|
|
const tomlInit = json(["init", "--json", "--manifest", "toml", tomlInitRoot]).body;
|
|
assert.equal(tomlInit.ok, true);
|
|
assert(tomlInit.writes.includes(join(tomlInitRoot, "zero.toml")));
|
|
assert(tomlInit.writes.includes(join(tomlInitRoot, "zero.graph")));
|
|
assert(existsSync(join(tomlInitRoot, "zero.toml")));
|
|
assert(!existsSync(join(tomlInitRoot, "zero.json")));
|
|
assert.match(readFileSync(join(tomlInitRoot, "zero.toml"), "utf8"), /\[package\]/);
|
|
const defaultInitRoot = join(outDir, "init-default-manifest");
|
|
rmSync(defaultInitRoot, { recursive: true, force: true });
|
|
const defaultInit = json(["init", "--json", defaultInitRoot]).body;
|
|
assert.equal(defaultInit.ok, true);
|
|
assert(defaultInit.writes.includes(join(defaultInitRoot, "zero.toml")));
|
|
assert(!existsSync(join(defaultInitRoot, "zero.json")));
|
|
|
|
for (const [code, goodExample, stalePattern] of [
|
|
["STD003", "var bytes: [4]u8 = [0, 0, 0, 0]", /\bmut bytes\b|std\.mem\.fill bytes/],
|
|
["TYP026", "alias Bytes = Span<u8>", /\btype [A-Z][A-Za-z0-9_]* =/],
|
|
["PUB001", "pub const answer: i32 = 42", /pub const answer (42|i32 42)/],
|
|
["IFC002", "fn describe(self: ref<Self>) -> String", /type Person\n|fn describe (String|i32)|ret self/],
|
|
["IFC003", "fn describe(self: ref<Self>) -> String", /fn describe (String|i32)|ret self/],
|
|
["IFC004", "fn describe(self: ref<Self>) -> String", /fn describe (String|i32)|ret self/],
|
|
["IFC005", "fn describe(self: ref<Self>) -> String", /fn describe (String|i32)|ret self/],
|
|
["STC001", "type Buf<static N: usize> {", /type Buf<static N: usize>\n|len usize/],
|
|
["RCV002", "var vec: FixedVec<u8, 4>", /\bmut vec\b|vec\.push 1|use `mut`/],
|
|
] as Array<[string, string, RegExp]>) {
|
|
const explanation = json(["explain", "--json", code]).body;
|
|
assert.equal(explanation.code, code);
|
|
assert(explanation.examples.good.includes(goodExample), `${code} explain good example should use canonical source`);
|
|
assert.doesNotMatch(
|
|
`${explanation.repair.summary}\n${explanation.examples.bad}\n${explanation.examples.good}`,
|
|
stalePattern,
|
|
`${code} explain examples should use canonical source syntax`,
|
|
);
|
|
}
|
|
|
|
// Every diagnostic code the compiler can emit must resolve in `zero explain`.
|
|
const compilerSourceDir = "native/zero-c/src";
|
|
const emittableDiagnosticCodes = new Set<string>();
|
|
for (const entry of readdirSync(compilerSourceDir)) {
|
|
if (!entry.endsWith(".c")) continue;
|
|
const source = readFileSync(join(compilerSourceDir, entry), "utf8");
|
|
for (const match of source.matchAll(/"([A-Z]{3,4}[0-9]{3})"/g)) emittableDiagnosticCodes.add(match[1]);
|
|
}
|
|
assert(emittableDiagnosticCodes.size > 100, "expected to discover the compiler diagnostic code catalog");
|
|
for (const code of [...emittableDiagnosticCodes].sort()) {
|
|
const explained = json(["explain", "--json", code], { allowFailure: true });
|
|
assert.equal(explained.code, 0, `zero explain ${code} must have an explain entry`);
|
|
assert.equal(explained.body.code, code, `zero explain ${code} must explain the requested code`);
|
|
}
|
|
|
|
const graphHelp = zero(["inspect", "--help"]).stdout;
|
|
assert.match(graphHelp, /zero dump\|validate\|roundtrip \[--json\] \[--format text\|binary\] --out <program-graph-artifact> \[graph-input\]; zero import \[--json\] \[--format text\|binary\] --out <program-graph-artifact> \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(graphHelp, /zero view \[--json\] \[--fn <name> \[--around <text>\|--handles\]\] \[--outline <module-or-file>\] \[--out <file\.0>\] \[graph-input\]/);
|
|
assert.match(graphHelp, /zero diff \[--fn <name>\] \[graph-input\]/);
|
|
assert.match(graphHelp, /zero source-map \[--json\] \[graph-input\]/);
|
|
assert.match(graphHelp, /zero query \[--json\] \[--fn <name>\] \[--find <text>\] \[--refs <name>\] \[--calls <name>\] \[--node <id>\] \[--depth <n>\] \[--full\] \[--handles\] \[--no-help\] \[graph-input\|name\]/);
|
|
assert.match(graphHelp, /zero reconcile \[--json\] <base-graph-input> --source <edited-file\.0\|project\|zero\.toml\|zero\.json>/);
|
|
assert.match(graphHelp, /zero status\|verify-projection \[--json\] \[project\|zero\.toml\|zero\.json\|file\.0\|zero\.graph\]/);
|
|
assert.match(graphHelp, /zero import \[--json\] \[--format text\|binary\] \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(graphHelp, /zero export \[--json\] \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(graphHelp, /zero merge --base <base-zero\.graph> --left <left-zero\.graph> --right <right-zero\.graph> \[--json\] \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(graphHelp, /zero size \[--json\] \[--target <target>\] \[--out <artifact>\] \[graph-input\]/);
|
|
assert.match(graphHelp, /Patch usage: zero patch \[--json\] \[--check-only\|--dry-run\] \[--format text\|binary\] \[--out <program-graph-artifact>\] \[graph-input\] \(<patch-file>\|--op <operation>\|--replace-fn <name> --body-file <file\|->\|--replace-in-fn <name> --old <text> --new <text>\|--rewrite <pattern> --to <template> \[--fn <name>\] \[--apply\]\)/);
|
|
assert.match(graphHelp, /Patch operation help: zero patch --op help/);
|
|
assert.match(graphHelp, /binary is the default zero\.graph encoding/);
|
|
assert.match(graphHelp, /--format text writes readable repository stores when explicitly requested/);
|
|
assert.match(graphHelp, /--format binary opts explicit graph artifact outputs into binary storage/);
|
|
assert.doesNotMatch(graphHelp, /setMain[A-Za-z]+Cli/);
|
|
assert.match(graphHelp, /replaceFunctionBody main \.\.\. end/);
|
|
assert.match(graphHelp, /replaceBlockBody #block_id \.\.\. end/);
|
|
assert.match(graphHelp, /addLetBinary fn="add" name="sum" type="i32" operator="\+"/);
|
|
assert.match(graphHelp, /addReturnExpr fn="maybe" expr="null"/);
|
|
assert.match(graphHelp, /appendStmt fn="main" stmt="check std\.http\.listen\(world, 3000_u16\)"/);
|
|
assert.match(graphHelp, /addTestBody name="api add"/);
|
|
assert.match(graphHelp, /renameTest name="api add" value="api add route"/);
|
|
assert.match(graphHelp, /deleteTest name="api add"/);
|
|
assert.match(graphHelp, /upsertFunction handle/);
|
|
assert.match(graphHelp, /zero build \[--json\] \[--emit exe\|obj\|llvm-ir\].*\[graph-input\]/);
|
|
assert.match(graphHelp, /zero run \[--target <host-target>\].*\[graph-input\] \[-- args\.\.\.\]/);
|
|
assert.match(graphHelp, /zero test \[--json\] \[--filter <name>\] \[--target <target>\] \[graph-input\]/);
|
|
assert.doesNotMatch(graphHelp, /zero graph (check|patch|size|build|run|test)/);
|
|
assert.doesNotMatch(graphHelp, /zero sync/);
|
|
const runHelp = zero(["run", "--help"]).stdout;
|
|
assert.match(runHelp, /Usage: zero run \[--backend direct\|llvm\|<direct-emitter>\]/);
|
|
assert.match(runHelp, /LLVM is explicit and requires clang/);
|
|
const rootHelp = zero(["--help"]).stdout;
|
|
assert.match(rootHelp, /zero run \[--backend direct\|llvm\|<direct-emitter>\].*\[graph-input\] \[-- args\.\.\.\]/);
|
|
assert.match(rootHelp, /zero build \[--json\] \[--emit exe\|obj\|llvm-ir\].*\[graph-input\]/);
|
|
assert.match(rootHelp, /zero test \[graph-input\]/);
|
|
assert.match(rootHelp, /zero check \[--json\] \[--target <target>\] \[--emit exe\|obj\|llvm-ir\] \[graph-input\]/);
|
|
assert.match(rootHelp, /zero fix --plan --json \[graph-input\]/);
|
|
assert.match(rootHelp, /zero patch \[--json\] \[--check-only\|--dry-run\] \[--format text\|binary\] \[--out <program-graph-artifact>\] \[graph-input\] \(<patch-file>\|--op <operation>\|--replace-fn <name> --body-file <file\|->\|--replace-in-fn <name> --old <text> --new <text>\|--rewrite <pattern> --to <template> \[--fn <name>\] \[--apply\]\)/);
|
|
assert.match(rootHelp, /zero dump\|validate\|roundtrip \[--json\] \[--format text\|binary\] \[--out <program-graph-artifact>\] \[graph-input\]/);
|
|
assert.match(rootHelp, /zero view \[--json\] \[--fn <name> \[--around <text>\|--handles\]\] \[--outline <module-or-file>\] \[--out <file\.0>\] \[graph-input\]/);
|
|
assert.match(rootHelp, /zero diff \[--fn <name>\] \[graph-input\]/);
|
|
assert.match(rootHelp, /zero source-map \[--json\] \[graph-input\]/);
|
|
assert.match(rootHelp, /zero query \[--json\] \[--fn <name>\] \[--find <text>\] \[--refs <name>\] \[--calls <name>\] \[--node <id>\] \[--depth <n>\] \[--full\] \[--handles\] \[--no-help\] \[graph-input\|name\]/);
|
|
assert.match(rootHelp, /zero reconcile \[--json\] <base-graph-input> --source <edited-file\.0\|project\|zero\.toml\|zero\.json>/);
|
|
assert.match(rootHelp, /zero status\|verify-projection \[--json\] \[project\|zero\.toml\|zero\.json\|file\.0\|zero\.graph\]/);
|
|
assert.match(rootHelp, /zero import \[--json\] \[--format text\|binary\] \[--out <program-graph-artifact>\] \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(rootHelp, /zero export \[--json\] \[project\|zero\.toml\|zero\.json\|file\.0\]/);
|
|
assert.match(rootHelp, /zero merge --base <base-zero\.graph> --left <left-zero\.graph> --right <right-zero\.graph> \[--json\] \[--format text\|binary\] <project\|zero\.toml\|zero\.json\|file\.0>/);
|
|
assert.doesNotMatch(rootHelp, /zero graph (check|patch|size|build|run|test)/);
|
|
assert.doesNotMatch(rootHelp, /zero sync/);
|
|
const graphPatchHelp = zero(["patch", "--op", "help"]).stdout;
|
|
assert.match(graphPatchHelp, /program graph patch operations/);
|
|
assert.match(graphPatchHelp, /accepted by zero patch --op, --patch-text, and zero-program-graph-patch v1 files/);
|
|
assert.match(graphPatchHelp, /insert node="#id" kind="Literal"/);
|
|
assert.match(graphPatchHelp, /insertEdge from="#from" to="#to"/);
|
|
assert.match(graphPatchHelp, /replace node="#id" expect="nodehash:abc123"/);
|
|
assert.doesNotMatch(graphPatchHelp, /setMain[A-Za-z]+Cli/);
|
|
assert.match(graphPatchHelp, /replaceFunctionBody main/);
|
|
assert.match(graphPatchHelp, /replaceBlockBody #block_id/);
|
|
assert.match(graphPatchHelp, /use --replace-fn with --body-file/);
|
|
assert.match(graphPatchHelp, /--body-file - reads the body rows from stdin, so a heredoc does the whole edit in one call/);
|
|
assert.match(graphPatchHelp, /zero patch \. --replace-fn greet --body-file - <<'EOF'/);
|
|
assert.match(graphPatchHelp, /Alternative: write the rows to a file and pass its path/);
|
|
assert.match(graphPatchHelp, /zero patch \. --replace-fn greet --body-file \/tmp\/greet\.body/);
|
|
assert(graphPatchHelp.indexOf("--body-file - <<'EOF'") < graphPatchHelp.indexOf("/tmp/greet.body"), "patch help should show the stdin heredoc form before the temp-file form");
|
|
assert.match(graphPatchHelp, /--replace-in-fn/);
|
|
assert.match(graphPatchHelp, /zero patch \. --replace-in-fn greet --old 'return 1' --new 'return 2'/);
|
|
assert.match(graphPatchHelp, /--old must match the body text zero view --fn <name> prints exactly once/);
|
|
assert.match(graphPatchHelp, /advanced: node-level ops \(see zero view --fn <name> --handles\)/);
|
|
assert.match(graphPatchHelp, /replaceExpr node="#id" with="left \+ 1"/);
|
|
assert.match(graphPatchHelp, /--patch-text - reads a complete patch from stdin/);
|
|
const patchHelpInFnIdx = graphPatchHelp.indexOf("--replace-in-fn greet");
|
|
const patchHelpReplaceFnIdx = graphPatchHelp.indexOf("--replace-fn greet --body-file - <<'EOF'");
|
|
const patchHelpGrammarIdx = graphPatchHelp.indexOf("zero-program-graph-patch v1 files");
|
|
const patchHelpAdvancedIdx = graphPatchHelp.indexOf("advanced: node-level ops");
|
|
assert(patchHelpInFnIdx >= 0 && patchHelpInFnIdx < patchHelpReplaceFnIdx, "patch help leads with --replace-in-fn");
|
|
assert(patchHelpReplaceFnIdx < patchHelpGrammarIdx, "the --replace-fn heredoc precedes the op grammar reference");
|
|
assert(patchHelpGrammarIdx < patchHelpAdvancedIdx, "the op grammar precedes the advanced node-level section");
|
|
assert(graphPatchHelp.indexOf('set node="#id"') > patchHelpAdvancedIdx, "node-handle ops sit under the advanced header");
|
|
assert(graphPatchHelp.indexOf("addMain") < patchHelpAdvancedIdx, "authoring ops print before node-level ops");
|
|
assert.match(graphPatchHelp, /addLetLiteral fn="main" name="count" type="u32" value="0"/);
|
|
assert.match(graphPatchHelp, /addReturnValue fn="identity" value="input" type="i32"/);
|
|
assert.match(graphPatchHelp, /addReturnExpr fn="maybe" expr="null"/);
|
|
assert.match(graphPatchHelp, /appendStmt fn="main" stmt="check std\.http\.listen\(world, 3000_u16\)"/);
|
|
assert.match(graphPatchHelp, /addTestBody name="api add"/);
|
|
assert.match(graphPatchHelp, /renameTest name="api add" value="api add route"/);
|
|
assert.match(graphPatchHelp, /deleteTest name="api add"/);
|
|
assert.match(graphPatchHelp, /upsertFunction handle/);
|
|
const graphPatchHelpJson = json(["patch", "--op", "help", "--json"]).body;
|
|
assert.equal(graphPatchHelpJson.ok, true);
|
|
assert.equal(graphPatchHelpJson.command, "zero patch");
|
|
assert.equal(graphPatchHelpJson.operations.includes("insert node=\"#id\" kind=\"Literal\" parent=\"#parent\" edge=\"arg\" order=\"0\" type=\"String\" value=\"text\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("insertEdge from=\"#from\" to=\"#to\" edge=\"arg\" target=\"node\" order=\"0\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("replace node=\"#id\" expect=\"nodehash:abc123\" kind=\"Literal\" type=\"String\" value=\"text\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.some((op) => op.includes("setMain")), false);
|
|
assert.equal(graphPatchHelpJson.operations.some((op) => op.startsWith("replaceFunctionBody main\n")), true);
|
|
assert.equal(graphPatchHelpJson.operations.some((op) => op.startsWith("replaceBlockBody #block_id\n")), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("addLetBinary fn=\"add\" name=\"sum\" type=\"i32\" operator=\"+\" left=\"left\" right=\"right\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("addCheckWriteValue fn=\"main\" value=\"message\" type=\"String\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("addReturnExpr fn=\"maybe\" expr=\"null\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("appendStmt fn=\"main\" stmt=\"check std.http.listen(world, 3000_u16)\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.some((op) => op.startsWith("addTestBody name=\"api add\"\n")), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("renameTest name=\"api add\" value=\"api add route\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.includes("deleteTest name=\"api add\""), true);
|
|
assert.equal(graphPatchHelpJson.operations.some((op) => op.startsWith("upsertFunction handle\n")), true);
|
|
const retiredGraphCheckJson = json(["graph", "check", "--json", "examples/hello.0"], { allowFailure: true });
|
|
assert.equal(retiredGraphCheckJson.code, 1);
|
|
assert.equal(retiredGraphCheckJson.body.diagnostics[0].message, "zero graph check is not supported");
|
|
assert.equal(retiredGraphCheckJson.body.diagnostics[0].expected, "zero check [graph-input]");
|
|
const retiredGraphPatchJson = json(["graph", "patch", "--json", "--op", "help"], { allowFailure: true });
|
|
assert.equal(retiredGraphPatchJson.code, 1);
|
|
assert.equal(retiredGraphPatchJson.body.diagnostics[0].message, "zero graph patch is not supported");
|
|
assert.match(retiredGraphPatchJson.body.diagnostics[0].expected, /zero patch/);
|
|
const retiredGraphDumpJson = json(["graph", "dump", "--json", "examples/hello.0"], { allowFailure: true });
|
|
assert.equal(retiredGraphDumpJson.code, 1);
|
|
assert.equal(retiredGraphDumpJson.body.diagnostics[0].message, "zero graph dump is not supported");
|
|
assert.equal(retiredGraphDumpJson.body.diagnostics[0].expected, "zero dump [graph-input]");
|
|
const retiredGraphDefaultJson = json(["graph", "--json", "examples/hello.0"], { allowFailure: true });
|
|
assert.equal(retiredGraphDefaultJson.code, 1);
|
|
assert.equal(retiredGraphDefaultJson.body.diagnostics[0].message, "zero graph is not supported");
|
|
assert.equal(retiredGraphDefaultJson.body.diagnostics[0].expected, "zero inspect [graph-input]");
|
|
const retiredGraphHelpJson = json(["graph", "--help", "--json"], { allowFailure: true });
|
|
assert.equal(retiredGraphHelpJson.code, 1);
|
|
assert.equal(retiredGraphHelpJson.body.diagnostics[0].message, "zero graph is not supported");
|
|
assert.equal(retiredGraphHelpJson.body.diagnostics[0].expected, "zero inspect [graph-input]");
|
|
|
|
const graphDump = zero(["dump", "examples/hello.0"]).stdout;
|
|
const graphDumpAgain = zero(["dump", "examples/hello.0"]).stdout;
|
|
assert.equal(graphDumpAgain, graphDump);
|
|
assert.equal(zero(["dump", "examples/hello.0"]).stdout, graphDump);
|
|
assert.match(graphDump, /^zero-graph v1\n/);
|
|
assert.match(graphDump, /origin source-text/);
|
|
assert.match(graphDump, /module "hello"/);
|
|
assert.match(graphDump, /hash "graph:[0-9a-f]{16}"/);
|
|
assert.doesNotMatch(graphDump, /idStrategy/);
|
|
assert.doesNotMatch(graphDump, /canonicalSource/);
|
|
assert.doesNotMatch(graphDump, /moduleIdentity/);
|
|
assert.doesNotMatch(graphDump, /graphHash/);
|
|
assert.doesNotMatch(graphDump, /counts nodes=/);
|
|
assert.doesNotMatch(graphDump, /validation "shape-valid" ok/);
|
|
assert.doesNotMatch(graphDump, / nodeHash:/);
|
|
assert.match(graphDump, / path:"hello\.0"/);
|
|
assert.match(graphDump, / line:1 column:1/);
|
|
assert.match(graphDump, / line:2 column:27/);
|
|
assert.doesNotMatch(graphDump, / public:false/);
|
|
assert.doesNotMatch(graphDump, / target:node order:0/);
|
|
|
|
const rootQueryHello = json(["query", "--json", "--fn", "main", "examples/hello.0"]).body;
|
|
assert.equal(rootQueryHello.ok, true);
|
|
assert.equal(rootQueryHello.query.function, "main");
|
|
assert.equal(rootQueryHello.functions.some((fun: any) => fun.name === "main"), true);
|
|
assert.equal(zero(["view", "examples/hello.0"]).stdout, readFileSync("examples/hello.0", "utf8"));
|
|
|
|
const queryScopeRoot = join("/tmp", `zero-query-scope-${process.pid}`);
|
|
rmSync(queryScopeRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", queryScopeRoot]).body.ok, true);
|
|
mkdirSync(join(queryScopeRoot, "src"), { recursive: true });
|
|
writeFileSync(
|
|
join(queryScopeRoot, "src", "main.0"),
|
|
'fn dealsTotal(amount: usize) -> usize {\n return amount + 1\n}\n\npub fn main(world: World) -> Void raises {\n let total: usize = dealsTotal(41)\n if total == 42 {\n check world.out.write("query scope\\n")\n }\n}\n',
|
|
);
|
|
assert.equal(json(["import", "--json", join(queryScopeRoot, "src", "main.0")]).body.ok, true);
|
|
const queryScopeFind = json(["query", "--json", "--find", "dealsTotal", queryScopeRoot]).body;
|
|
assert.equal(queryScopeFind.ok, true);
|
|
const queryScopeFunctionId = queryScopeFind.matches.find((match: any) => match.kind === "Function")?.id;
|
|
assert(queryScopeFunctionId);
|
|
const queryScopeWholeModule = zero(["query", "--json", queryScopeRoot]);
|
|
const queryScopeNode = json(["query", "--json", "--node", queryScopeFunctionId, queryScopeRoot]);
|
|
assert.equal(queryScopeNode.body.ok, true);
|
|
assert.equal(queryScopeNode.body.query.scope, "node");
|
|
assert.equal(queryScopeNode.body.query.depth, 1);
|
|
assert.equal(queryScopeNode.body.node.selected.id, queryScopeFunctionId);
|
|
assert.equal(queryScopeNode.body.node.span.path, "src/main.0");
|
|
assert(queryScopeNode.body.node.parents.length >= 1);
|
|
assert(queryScopeNode.body.node.children.length >= 1);
|
|
assert.equal(queryScopeNode.body.node.children.every((edge: any) => edge.children === undefined), true);
|
|
assert.match(queryScopeNode.body.hint, /--depth <n>.*--full.*zero view --fn <name>/);
|
|
assert(queryScopeNode.stdout.length < 4096, `node-scoped query output should stay within a few KB, got ${queryScopeNode.stdout.length}`);
|
|
assert(queryScopeNode.stdout.length < queryScopeWholeModule.stdout.length, "node-scoped query output should be smaller than the whole-module report");
|
|
const queryScopeDepthTwo = json(["query", "--json", "--node", queryScopeFunctionId, "--depth", "2", queryScopeRoot]).body;
|
|
assert.equal(queryScopeDepthTwo.query.depth, 2);
|
|
assert.equal(queryScopeDepthTwo.node.children.some((edge: any) => Array.isArray(edge.children)), true);
|
|
const queryScopeFullModule = json(["query", "--json", "--node", queryScopeFunctionId, "--full", queryScopeRoot]).body;
|
|
assert.equal(queryScopeFullModule.ok, true);
|
|
assert(queryScopeFullModule.counts.nodes > 0);
|
|
assert.equal(queryScopeFullModule.node.selected.id, queryScopeFunctionId);
|
|
assert(Array.isArray(queryScopeFullModule.functions));
|
|
const queryScopeBadDepth = json(["query", "--json", "--node", queryScopeFunctionId, "--depth", "0", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(queryScopeBadDepth.code, 0);
|
|
assert.match(queryScopeBadDepth.body.diagnostics[0].message, /invalid query depth '0'/);
|
|
const queryBareName = JSON.parse(execFileSync(zeroBin, ["query", "--json", "dealsTotal"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer }));
|
|
assert.equal(queryBareName.ok, true);
|
|
assert.equal(queryBareName.query.find, "dealsTotal");
|
|
assert.equal(queryBareName.argument.value, "dealsTotal");
|
|
assert.equal(queryBareName.argument.resolvedAs, "find");
|
|
assert.match(queryBareName.argument.hint, /zero view --fn <name>/);
|
|
assert.equal(queryBareName.matches.some((match: any) => match.kind === "Function" && match.name === "dealsTotal"), true);
|
|
const queryBareNameText = execFileSync(zeroBin, ["query", "dealsTotal"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(queryBareNameText, /argument: dealsTotal is not an existing path; treated as --find dealsTotal/);
|
|
assert.match(queryBareNameText, /zero view --fn <name> prints one function's source/);
|
|
assert.doesNotMatch(queryBareNameText, /modules:/, "scoped query text output must not repeat the module list");
|
|
assert.doesNotMatch(queryBareNameText, /patch help:/, "scoped query text output must not repeat the patch footer");
|
|
const queryOverviewText = execFileSync(zeroBin, ["query"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(queryOverviewText, /modules:/);
|
|
assert.match(queryOverviewText, /main path:src\/main\.0 functions:2 \(entry\)/);
|
|
assert.match(queryOverviewText, /functions \(module main\):/);
|
|
assert.match(queryOverviewText, /dealsTotal\(amount: usize\) -> usize #decl_/);
|
|
assert.doesNotMatch(queryOverviewText, /stmt\[0\]/, "overview hides stmt handle inventories unless --handles is set");
|
|
assert.doesNotMatch(queryOverviewText, /resolution:/, "overview omits resolution facts");
|
|
assert.match(queryOverviewText, /tips: zero query --fn <name> \| --find <text> \| --calls <name> \| --refs <name>/);
|
|
assert.match(queryOverviewText, /zero view --fn <name>.*zero view --outline/);
|
|
assert(queryOverviewText.length < 3072, `bare query overview should stay compact, got ${queryOverviewText.length}`);
|
|
const queryFnText = execFileSync(zeroBin, ["query", "--fn", "dealsTotal"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(queryFnText, /query: fn:dealsTotal/);
|
|
assert.match(queryFnText, /dealsTotal\(amount: usize\) -> usize #decl_/);
|
|
assert.doesNotMatch(queryFnText, /stmt\[0\]/);
|
|
assert.match(queryFnText, /add --handles/);
|
|
const queryFnHandlesText = execFileSync(zeroBin, ["query", "--fn", "dealsTotal", "--handles"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(queryFnHandlesText, /param\[0\] amount: usize #param_/);
|
|
assert.match(queryFnHandlesText, /stmt\[0\] Return #stmt_/);
|
|
assert.match(queryFnHandlesText, /patch help:/);
|
|
const queryFnHandlesNoHelpText = execFileSync(zeroBin, ["query", "--fn", "dealsTotal", "--handles", "--no-help"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(queryFnHandlesNoHelpText, /param\[0\] amount: usize #param_/);
|
|
assert.match(queryFnHandlesNoHelpText, /stmt\[0\] Return #stmt_/);
|
|
assert.doesNotMatch(queryFnHandlesNoHelpText, /patch help:/, "--handles --no-help keeps handles without the operation footer");
|
|
assert(queryFnText.length < queryFnHandlesText.length, "default --fn output must be smaller than the --handles report");
|
|
const queryMissingPathInput = zero(["query", "no-such-dir/no-such-input"], { allowFailure: true });
|
|
assert.notEqual(queryMissingPathInput.code, 0, "path-shaped query arguments must keep file input semantics");
|
|
const viewFunction = zero(["view", "--fn", "dealsTotal", queryScopeRoot]).stdout;
|
|
assert.match(viewFunction, /^fn dealsTotal\(amount: usize\) -> usize \{\n/);
|
|
assert.match(viewFunction, /return amount \+ 1/);
|
|
assert.doesNotMatch(viewFunction, /fn main/);
|
|
const viewFunctionMiss = zero(["view", "--fn", "dealsTotle", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(viewFunctionMiss.code, 0);
|
|
const viewFunctionMissOutput = `${viewFunctionMiss.stdout}${viewFunctionMiss.stderr}`;
|
|
assert.match(viewFunctionMissOutput, /function 'dealsTotle' not found in graph view/);
|
|
assert.match(viewFunctionMissOutput, /close matches: dealsTotal/);
|
|
assert.match(viewFunctionMissOutput, /zero query --find dealsTotle/);
|
|
const viewOutline = zero(["view", "--outline", "main", queryScopeRoot]).stdout;
|
|
assert.match(viewOutline, /module main path:src\/main\.0/);
|
|
assert.match(viewOutline, /fn dealsTotal\(amount: usize\) -> usize/);
|
|
assert.match(viewOutline, /pub fn main\(world: World\) -> Void raises/);
|
|
assert.doesNotMatch(viewOutline, /return amount/, "outline must not print function bodies");
|
|
assert.equal(zero(["view", "--outline", ".", queryScopeRoot]).stdout, viewOutline);
|
|
const viewOutlineMiss = zero(["view", "--outline", "nosuch", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(viewOutlineMiss.code, 0);
|
|
assert.match(`${viewOutlineMiss.stdout}${viewOutlineMiss.stderr}`, /no module matches --outline nosuch/);
|
|
assert.match(`${viewOutlineMiss.stdout}${viewOutlineMiss.stderr}`, /modules in this graph: main/);
|
|
const viewAround = zero(["view", "--fn", "main", "--around", "total == 42", queryScopeRoot]).stdout;
|
|
assert.match(viewAround, /pub fn main\(world: World\) -> Void raises \{/);
|
|
assert.match(viewAround, /if total == 42 \{/);
|
|
assert.match(viewAround, /query scope/);
|
|
assert.match(viewAround, /\n \.\.\.\n/, "around output elides lines outside the enclosing block");
|
|
assert.doesNotMatch(viewAround, /let total/, "around output keeps only the enclosing block");
|
|
const viewAroundNoFn = zero(["view", "--around", "total", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(viewAroundNoFn.code, 0);
|
|
assert.match(`${viewAroundNoFn.stdout}${viewAroundNoFn.stderr}`, /--around requires --fn <name>/);
|
|
const viewAroundMiss = zero(["view", "--fn", "main", "--around", "zzz-not-here", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(viewAroundMiss.code, 0);
|
|
assert.match(`${viewAroundMiss.stdout}${viewAroundMiss.stderr}`, /text 'zzz-not-here' not found in function 'main'/);
|
|
const diffFunction = zero(["diff", "--fn", "dealsTotal", queryScopeRoot]).stdout;
|
|
assert.equal(diffFunction, viewFunction);
|
|
const diffFunctionMiss = zero(["diff", "--fn", "dealsTotle", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(diffFunctionMiss.code, 0);
|
|
assert.match(`${diffFunctionMiss.stdout}${diffFunctionMiss.stderr}`, /close matches: dealsTotal/);
|
|
const diffHelp = zero(["diff", "--help"]).stdout;
|
|
assert.match(diffHelp, /Usage: zero diff \[--fn <name>\] \[graph-input\]/);
|
|
assert.match(diffHelp, /zero diff --fn handleLine \./);
|
|
assert.doesNotMatch(diffHelp, /Patch usage:/);
|
|
const queryHelp = zero(["query", "--help"]).stdout;
|
|
assert.match(queryHelp, /Usage: zero query .*\[--node <id>\] \[--depth <n>\] \[--full\] \[--handles\] \[--no-help\] \[graph-input\|name\]/);
|
|
assert.match(queryHelp, /--handles adds stmt and param patch handles/);
|
|
assert.match(queryHelp, /--no-help suppresses the long patch-operation footer/);
|
|
assert.match(queryHelp, /zero query userTotals/);
|
|
assert.match(queryHelp, /zero query --json --node '#decl_12ab34cd' --depth 2/);
|
|
assert.match(queryHelp, /zero view --fn <name>/);
|
|
const reconcileHelp = zero(["reconcile", "--help"]).stdout;
|
|
assert.match(reconcileHelp, /Usage: zero reconcile \[--json\] <base-graph-input> --source/);
|
|
assert.match(reconcileHelp, /zero reconcile zero\.graph --source src\/main\.0/);
|
|
assert.match(reconcileHelp, /zero reconcile --json \. --source src\/main\.0/);
|
|
assert.match(reconcileHelp, /zero reconcile --json baseline\.graph --source \./);
|
|
const viewHelp = zero(["view", "--help"]).stdout;
|
|
assert.match(viewHelp, /Usage: zero view \[--json\] \[--fn <name> \[--around <text>\|--handles\]\] \[--outline <module-or-file>\] \[--out <file\.0>\] \[graph-input\]/);
|
|
assert.match(viewHelp, /zero view --fn handleLine \./);
|
|
assert.match(viewHelp, /--outline <module-or-file> prints function signatures/);
|
|
assert.match(viewHelp, /--around <text> prints only the enclosing block/);
|
|
assert.match(viewHelp, /close matches/);
|
|
// --- think-in-graph addressing: zero view --fn <name> --handles ---
|
|
const viewPlainMain = zero(["view", "--fn", "main", queryScopeRoot]).stdout;
|
|
const viewHandlesMain = zero(["view", "--fn", "main", "--handles", queryScopeRoot]).stdout;
|
|
assert.equal(viewHandlesMain.replace(/ \/\/ [^\n]*$/gm, ""), viewPlainMain, "--handles must only add margin comments");
|
|
assert.match(viewHandlesMain, /let total: usize = dealsTotal\(41\) \/\/ #\S+\n/, "every statement line gains a trailing handle comment");
|
|
assert.match(viewHandlesMain, /if total == 42 \{ \/\/ #\S+ #\S+\n/, "compound headers show the stmt handle and the clause block handle");
|
|
assert(viewHandlesMain.length <= viewPlainMain.length * 1.3, `--handles annotation overhead must stay under 30%, got ${Math.round((viewHandlesMain.length / viewPlainMain.length - 1) * 1000) / 10}%`);
|
|
const viewHandlesNoFn = zero(["view", "--handles", queryScopeRoot], { allowFailure: true });
|
|
assert.notEqual(viewHandlesNoFn.code, 0);
|
|
assert.match(`${viewHandlesNoFn.stdout}${viewHandlesNoFn.stderr}`, /--handles requires --fn <name>/);
|
|
|
|
// refs and find rows gain the enclosing statement handle with --handles
|
|
const refsHandlesText = execFileSync(zeroBin, ["query", "--refs", "dealsTotal", "--handles"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(refsHandlesText, /call #expr_\S+ fn:main stmt:#stmt_\S+/, "--refs --handles rows show the enclosing statement handle");
|
|
const refsPlainText = execFileSync(zeroBin, ["query", "--refs", "dealsTotal"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.doesNotMatch(refsPlainText, / stmt:#/, "--refs without --handles stays unchanged");
|
|
const refsHandlesJson = json(["query", "--json", "--refs", "dealsTotal", queryScopeRoot]).body;
|
|
assert(refsHandlesJson.references.some((ref: any) => typeof ref.stmt === "string" && ref.stmt.startsWith("#stmt_")), "refs JSON rows carry the enclosing statement handle");
|
|
const findHandlesText = execFileSync(zeroBin, ["query", "--find", "dealsTotal", "--handles"], { cwd: queryScopeRoot, encoding: "utf8", maxBuffer: execMaxBuffer });
|
|
assert.match(findHandlesText, /Identifier #expr_\S+ name:dealsTotal stmt:#stmt_\S+/, "--find --handles match rows show the enclosing statement handle");
|
|
|
|
// the printed handles are the identifiers zero patch accepts: set-by-handle round trip
|
|
const letHandle = viewHandlesMain.match(/let total[^\n]* \/\/ (#\S+)$/m)?.[1];
|
|
assert(letHandle, "let statement line carries a handle");
|
|
const letNode = json(["query", "--json", "--node", letHandle, "--depth", "2", queryScopeRoot]).body;
|
|
assert.equal(letNode.node.selected.kind, "Let", "short handles resolve in zero query --node");
|
|
const letCall = letNode.node.children.find((edge: any) => edge.kind === "expr");
|
|
const letLiteralId = letCall?.children?.find((edge: any) => edge.kind === "arg")?.node?.id;
|
|
assert(letLiteralId, "literal argument node is reachable from the statement handle");
|
|
const setByHandle = zero(["patch", queryScopeRoot, "--op", `set node="${letLiteralId}" field="value" expect="41" value="43"`]);
|
|
assert.equal(setByHandle.code, 0);
|
|
const viewAfterSet = zero(["view", "--fn", "main", "--handles", queryScopeRoot]).stdout;
|
|
assert.match(viewAfterSet, /let total: usize = dealsTotal\(43\) \/\/ #\S+\n/, "set-by-handle edit shows up in the handles view");
|
|
|
|
// clause block handles drive replaceBlockBody directly from the view output
|
|
const ifClause = viewAfterSet.match(/if total == 42 \{ \/\/ (#\S+) (#\S+)$/m);
|
|
assert(ifClause, "if header carries stmt and clause block handles");
|
|
const clausePatch = zero(["patch", queryScopeRoot, "--patch-text", `zero-program-graph-patch v1\nreplaceBlockBody ${ifClause[2]}\n check world.out.write "clause by handle\\n"\nend\n`]);
|
|
assert.equal(clausePatch.code, 0);
|
|
assert.match(zero(["view", "--fn", "main", queryScopeRoot]).stdout, /clause by handle/, "replaceBlockBody accepts the clause handle printed by --handles");
|
|
|
|
// replaceExpr: one-line micro edits by handle (value, condition, subexpression)
|
|
const viewDealsHandles = zero(["view", "--fn", "dealsTotal", "--handles", queryScopeRoot]).stdout;
|
|
const returnHandle = viewDealsHandles.match(/return amount \+ 1 \/\/ (#\S+)$/m)?.[1];
|
|
assert(returnHandle, "return statement carries a handle");
|
|
const exprBadText = zero(["patch", queryScopeRoot, "--op", `replaceExpr node="${returnHandle}" with="amount ) 2"`], { allowFailure: true });
|
|
assert.notEqual(exprBadText.code, 0);
|
|
assert.match(exprBadText.stderr, /replaceExpr text did not parse as a Zero expression/);
|
|
const exprEdit = zero(["patch", queryScopeRoot, "--op", `replaceExpr node="${returnHandle}" with="amount * 2 + 1"`]);
|
|
assert.equal(exprEdit.code, 0);
|
|
assert.match(zero(["view", "--fn", "dealsTotal", queryScopeRoot]).stdout, /return amount \* 2 \+ 1/, "replaceExpr on a statement handle replaces its expression");
|
|
|
|
// micro-op batch: three --op edits, one patch, one revalidation pass
|
|
const viewMainBatch = zero(["view", "--fn", "main", "--handles", queryScopeRoot]).stdout;
|
|
const batchLetHandle = viewMainBatch.match(/let total[^\n]* \/\/ (#\S+)$/m)?.[1];
|
|
const batchIfHandle = viewMainBatch.match(/if total == 42 \{ \/\/ (#\S+) #\S+$/m)?.[1];
|
|
assert(batchLetHandle && batchIfHandle, "main handles for batch edit");
|
|
const batchPatch = zero(["patch", queryScopeRoot,
|
|
"--op", `replaceExpr node="${batchLetHandle}" with="dealsTotal(20) + 1"`,
|
|
"--op", `replaceExpr node="${batchIfHandle}" with="total != 0"`,
|
|
"--op", `set node="${batchLetHandle}" field="mutable" value="true"`,
|
|
]);
|
|
assert.equal(batchPatch.code, 0);
|
|
assert.match(batchPatch.stdout, /applied: 3 ops/, "batched --op edits apply as one patch");
|
|
const viewMainAfterBatch = zero(["view", "--fn", "main", queryScopeRoot]).stdout;
|
|
assert.match(viewMainAfterBatch, /var total: usize = dealsTotal\(20\) \+ 1/);
|
|
assert.match(viewMainAfterBatch, /if total != 0 \{/);
|
|
|
|
// structural rewrite by example: zero patch --rewrite '<pattern>' --to '<template>'
|
|
const rewriteRoot = join("/tmp", `zero-rewrite-scope-${process.pid}`);
|
|
rmSync(rewriteRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", rewriteRoot]).body.ok, true);
|
|
mkdirSync(join(rewriteRoot, "src"), { recursive: true });
|
|
writeFileSync(
|
|
join(rewriteRoot, "src", "main.0"),
|
|
'fn calc(a: usize) -> usize {\n let x: usize = a + 1\n let y: usize = a + 1\n return x + y\n}\n\nfn calc2(b: usize) -> usize {\n return b + 1\n}\n\npub fn main(world: World) -> Void raises {\n let t: usize = calc(1) + calc2(2)\n if t == t {\n check world.out.write("rewrite scope\\n")\n }\n}\n',
|
|
);
|
|
assert.equal(json(["import", "--json", join(rewriteRoot, "src", "main.0")]).body.ok, true);
|
|
|
|
// dry run is the default: each site lists file, fn, handle, and rendered before/after
|
|
const rewriteDry = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A + 2"]);
|
|
assert.equal(rewriteDry.code, 0);
|
|
assert.match(rewriteDry.stdout, /rewrite: \$A \+ 1 -> \$A \+ 2/);
|
|
assert.match(rewriteDry.stdout, /matches: 3/, "package-wide rewrite matches all three sites");
|
|
assert.match(rewriteDry.stdout, /src\/main\.0 fn:calc #\S+/);
|
|
assert.match(rewriteDry.stdout, /- a \+ 1/);
|
|
assert.match(rewriteDry.stdout, /\+ a \+ 2/);
|
|
assert.match(rewriteDry.stdout, /- b \+ 1/);
|
|
assert.match(rewriteDry.stdout, /dry run: pass --apply/);
|
|
assert.equal(zero(["view", "--fn", "calc", rewriteRoot]).stdout.includes("a + 2"), false, "dry run leaves the store untouched");
|
|
|
|
// --fn scopes matching to one function
|
|
const rewriteScoped = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A + 2", "--fn", "calc"]);
|
|
assert.match(rewriteScoped.stdout, /matches: 2/, "--fn calc scopes the rewrite to two sites");
|
|
assert.doesNotMatch(rewriteScoped.stdout, /fn:calc2/);
|
|
|
|
// the same metavariable twice must match equal subtrees
|
|
const rewriteEquality = zero(["patch", rewriteRoot, "--rewrite", "$A == $A", "--to", "true"]);
|
|
assert.match(rewriteEquality.stdout, /matches: 1/, "$A == $A matches t == t and nothing else");
|
|
assert.match(rewriteEquality.stdout, /- t == t/);
|
|
|
|
// JSON dry run carries the match list
|
|
const rewriteJson = json(["patch", "--json", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A + 2"]).body;
|
|
assert.equal(rewriteJson.ok, true);
|
|
assert.equal(rewriteJson.matchCount, 3);
|
|
assert.equal(rewriteJson.matches.length, 3);
|
|
assert.equal(rewriteJson.matches[0].before, "a + 1");
|
|
assert.equal(rewriteJson.matches[0].after, "a + 2");
|
|
assert.equal(rewriteJson.rewrite.apply, false);
|
|
|
|
// revalidation failure rolls the whole batch back
|
|
const rewriteRollback = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A + nosuchconst", "--apply"], { allowFailure: true });
|
|
assert.notEqual(rewriteRollback.code, 0);
|
|
assert.match(`${rewriteRollback.stdout}${rewriteRollback.stderr}`, /revalidation/);
|
|
assert.equal(zero(["view", "--fn", "calc", rewriteRoot]).stdout.includes("nosuchconst"), false, "failed rewrite leaves the store untouched");
|
|
|
|
// metavar capture reuse on both sides, applied in one batch
|
|
const rewriteApply = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A + 1 + ($A - $A)", "--apply"]);
|
|
assert.equal(rewriteApply.code, 0);
|
|
assert.match(rewriteApply.stdout, /matches: 3/);
|
|
assert.match(rewriteApply.stdout, /applied: 3 ops/, "apply rewrites every site in one batch with one revalidation");
|
|
const rewriteCalcView = zero(["view", "--fn", "calc", rewriteRoot]).stdout;
|
|
assert.match(rewriteCalcView, /let x: usize = a \+ 1 \+ \(a - a\)/, "applied rewrite matches the dry-run rendering");
|
|
assert.match(rewriteCalcView, /let y: usize = a \+ 1 \+ \(a - a\)/);
|
|
assert.match(zero(["view", "--fn", "calc2", rewriteRoot]).stdout, /return b \+ 1 \+ \(b - b\)/);
|
|
|
|
// rewrite needs both halves and a real function for --fn
|
|
const rewriteMissingTo = zero(["patch", rewriteRoot, "--rewrite", "$A + 1"], { allowFailure: true });
|
|
assert.notEqual(rewriteMissingTo.code, 0);
|
|
assert.match(rewriteMissingTo.stderr, /graph rewrite needs both --rewrite and --to/);
|
|
const rewriteBadFn = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$A", "--fn", "nosuchfn"], { allowFailure: true });
|
|
assert.notEqual(rewriteBadFn.code, 0);
|
|
assert.match(rewriteBadFn.stderr, /rewrite --fn function 'nosuchfn' was not found/);
|
|
const rewriteUnboundVar = zero(["patch", rewriteRoot, "--rewrite", "$A + 1", "--to", "$B + 1"], { allowFailure: true });
|
|
assert.notEqual(rewriteUnboundVar.code, 0);
|
|
assert.match(rewriteUnboundVar.stderr, /template uses \$B which the pattern does not bind/);
|
|
rmSync(rewriteRoot, { force: true, recursive: true });
|
|
|
|
// GPH004 with a near-miss handle names the nearest existing handle
|
|
const nearMiss = `${letHandle.slice(0, -1)}${letHandle.endsWith("z") ? "y" : "z"}`;
|
|
const nearMissPatch = zero(["patch", queryScopeRoot, "--op", `set node="${nearMiss}" field="value" value="9"`], { allowFailure: true });
|
|
assert.notEqual(nearMissPatch.code, 0);
|
|
assert.match(nearMissPatch.stderr, /patch node was not found; nearest: #/, "GPH004 suggests the nearest handle");
|
|
|
|
rmSync(queryScopeRoot, { force: true, recursive: true });
|
|
const repoGraphStatus = json(["status", "--json", "."]).body;
|
|
assert.equal(repoGraphStatus.ok, true);
|
|
assert.equal(repoGraphStatus.mode, "status");
|
|
assert.equal(repoGraphStatus.writes, false);
|
|
assert.equal(repoGraphStatus.repositoryGraph.storePath, "./zero.graph");
|
|
assert.equal(repoGraphStatus.repositoryGraph.storePresent, false);
|
|
assert.equal(repoGraphStatus.repositoryGraph.storeValid, false);
|
|
assert.equal(repoGraphStatus.repositoryGraph.enabled, true);
|
|
assert.equal(repoGraphStatus.repositoryGraph.projectionState, "store-missing");
|
|
assert.equal(repoGraphStatus.repositoryGraph.semanticValidity, "unavailable");
|
|
assert.equal(repoGraphStatus.repositoryGraph.projectionValidity, "unavailable");
|
|
assert.equal(repoGraphStatus.contract.artifact, "zero.graph");
|
|
assert.equal(repoGraphStatus.contract.compilerInput, "manifest package plus checked-in zero.graph repository store");
|
|
assert.equal(repoGraphStatus.contract.commands.status.writes, false);
|
|
assert.equal(repoGraphStatus.contract.commands.verifyProjection.writes, false);
|
|
assert.equal(repoGraphStatus.contract.commands.verifyProjection.available, false);
|
|
assert.equal(repoGraphStatus.contract.commands.import.writes, true);
|
|
assert.equal(repoGraphStatus.contract.commands.import.available, true);
|
|
assert.equal(repoGraphStatus.contract.commands.export.writes, true);
|
|
assert.equal(repoGraphStatus.contract.commands.export.available, false);
|
|
assert.equal(repoGraphStatus.contract.commands.merge.writes, true);
|
|
assert.equal(repoGraphStatus.contract.commands.merge.available, true);
|
|
assert.deepEqual(repoGraphStatus.contract.commands.merge.requires, ["--base", "--left", "--right"]);
|
|
assert.equal(repoGraphStatus.storage.encoding, "single-file-binary");
|
|
assert.equal(repoGraphStatus.storage.defaultEncoding, "binary");
|
|
assert.equal(repoGraphStatus.storage.interface, "ProgramGraphStore");
|
|
assert.equal(repoGraphStatus.storage.evolvable, true);
|
|
assert.equal(repoGraphStatus.scale.nodes, 0);
|
|
assert.equal(repoGraphStatus.scale.edges, 0);
|
|
assert.deepEqual(repoGraphStatus.repairCommands, []);
|
|
const invalidRepoGraphCompilerInputRoot = join("/tmp", `zero-repo-graph-invalid-compiler-input-${process.pid}`);
|
|
rmSync(invalidRepoGraphCompilerInputRoot, { force: true, recursive: true });
|
|
mkdirSync(invalidRepoGraphCompilerInputRoot, { recursive: true });
|
|
writeFileSync(join(invalidRepoGraphCompilerInputRoot, "zero.toml"), `[package]
|
|
name = "invalid-repo-graph-compiler-input"
|
|
version = "0.1.0"
|
|
|
|
[targets.cli]
|
|
kind = "exe"
|
|
main = "main.0"
|
|
|
|
[repositoryGraph]
|
|
compilerInput = "true"
|
|
`);
|
|
const invalidRepoGraphCompilerInputStatus = json(["status", "--json", invalidRepoGraphCompilerInputRoot], { allowFailure: true });
|
|
assert.notEqual(invalidRepoGraphCompilerInputStatus.code, 0);
|
|
assert.equal(invalidRepoGraphCompilerInputStatus.body.ok, false);
|
|
assert.equal(invalidRepoGraphCompilerInputStatus.body.repositoryGraph.compilerInput, "invalid");
|
|
assert.equal(invalidRepoGraphCompilerInputStatus.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(invalidRepoGraphCompilerInputStatus.body.diagnostics[0].path, join(invalidRepoGraphCompilerInputRoot, "zero.toml"));
|
|
assert.equal(invalidRepoGraphCompilerInputStatus.body.diagnostics[0].message, "repositoryGraph.compilerInput must be a boolean");
|
|
const standaloneRepoGraphRoot = join("/tmp", `zero-repo-graph-contract-${process.pid}`);
|
|
const standaloneRepoGraphSource = join(standaloneRepoGraphRoot, "standalone.0");
|
|
const standaloneRepoGraphStore = join(standaloneRepoGraphRoot, "zero.graph");
|
|
rmSync(standaloneRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(standaloneRepoGraphRoot, { recursive: true });
|
|
const standaloneRepoGraphComment = "// repository graph projection comment\n";
|
|
writeFileSync(standaloneRepoGraphSource, standaloneRepoGraphComment + readFileSync("examples/hello.0", "utf8"));
|
|
const standaloneRepoGraphStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)]).body;
|
|
assert.equal(standaloneRepoGraphStatus.repositoryGraph.root, resolve(standaloneRepoGraphRoot));
|
|
assert.equal(standaloneRepoGraphStatus.repositoryGraph.storePath, standaloneRepoGraphStore);
|
|
const nestedRelativeRepoGraphStatus = JSON.parse(execFileSync(zeroBin, ["status", "--json", "main.0"], { cwd: "examples/systems-package/src", encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] }));
|
|
assert.equal(nestedRelativeRepoGraphStatus.repositoryGraph.root, "..");
|
|
assert.equal(nestedRelativeRepoGraphStatus.repositoryGraph.storePath, "../zero.graph");
|
|
writeFileSync(standaloneRepoGraphStore, "");
|
|
const standaloneRepoGraphInvalidStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(standaloneRepoGraphInvalidStatus.code, 0);
|
|
assert.equal(standaloneRepoGraphInvalidStatus.body.repositoryGraph.storePresent, true);
|
|
assert.equal(standaloneRepoGraphInvalidStatus.body.repositoryGraph.storeValid, false);
|
|
assert.equal(standaloneRepoGraphInvalidStatus.body.repositoryGraph.projectionState, "store-invalid");
|
|
assert.equal(standaloneRepoGraphInvalidStatus.body.diagnostics[0].code, "RGP003");
|
|
rmSync(standaloneRepoGraphStore, { force: true });
|
|
const repoGraphImport = json(["import", "--format", "text", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(repoGraphImport.code, 0);
|
|
assert.equal(repoGraphImport.body.ok, true);
|
|
assert.equal(repoGraphImport.body.mode, "import");
|
|
assert.equal(repoGraphImport.body.writes, true);
|
|
assert.equal(repoGraphImport.body.repositoryGraph.storePresent, true);
|
|
assert.equal(repoGraphImport.body.repositoryGraph.storeValid, true);
|
|
assert.equal(repoGraphImport.body.repositoryGraph.enabled, true);
|
|
assert.equal(repoGraphImport.body.repositoryGraph.projectionState, "clean");
|
|
assert.equal(repoGraphImport.body.repositoryGraph.semanticValidity, "shape-valid");
|
|
assert.equal(repoGraphImport.body.repositoryGraph.projectionValidity, "clean");
|
|
assert.equal(repoGraphImport.body.compilerStore.shape, "compiler-oriented-tables");
|
|
assert.equal(repoGraphImport.body.compilerStore.sourceFreeInspection, true);
|
|
assert.equal(repoGraphImport.body.compilerStore.sourceProjectionRequiredForSemanticFacts, false);
|
|
assert.equal(repoGraphImport.body.compilerStore.semanticValidity.state, "shape-valid");
|
|
assert.equal(repoGraphImport.body.compilerStore.projectionValidity.state, "clean");
|
|
assert.equal(repoGraphImport.body.compilerStore.tables.node, repoGraphImport.body.store.nodes);
|
|
assert.deepEqual(repoGraphImport.body.compilerStore.hashInputs.graphHashExcludes, ["sourcePath", "line", "column", "projectionText"]);
|
|
assert(repoGraphImport.body.repositoryGraph.possibleProjectionStates.includes("source-stale"));
|
|
assert(repoGraphImport.body.repositoryGraph.possibleProjectionStates.includes("conflict"));
|
|
assert.equal(repoGraphImport.body.contract.commands.export.available, true);
|
|
assert.equal(repoGraphImport.body.changedPaths[0], standaloneRepoGraphStore);
|
|
assert(existsSync(standaloneRepoGraphStore));
|
|
const storeText = readFileSync(standaloneRepoGraphStore, "utf8");
|
|
assert.match(storeText, /^zero-repository-graph v1\n/);
|
|
assert.match(storeText, /^sourceProjection "\.0"$/m);
|
|
assert.match(storeText, /^compilerStore schemaVersion:1 shape:"compiler-oriented-tables"/m);
|
|
assert.match(storeText, /^compilerTables schema:1 package:/m);
|
|
assert.match(storeText, /^compilerHashInputs graphHashExcludes:"source-path,line,column,projection-text"/m);
|
|
assert.match(storeText, /^source path:"standalone\.0"$/m);
|
|
assert.match(storeText, /^projection path:"standalone\.0" text:"\/\/ repository graph projection comment\\n/m);
|
|
assert.match(storeText, /^nodeHash node:"#/m);
|
|
assert.match(storeText, /^graph\nzero-graph v1\n/m);
|
|
assert(!storeText.includes(standaloneRepoGraphRoot));
|
|
const firstStoreHash = sha256File(standaloneRepoGraphStore);
|
|
writeFileSync(standaloneRepoGraphStore, storeText.replace('sourceProjection ".0"\n', 'sourceProjection ".0"\n\n'));
|
|
const standaloneRepoGraphNonCanonicalStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(standaloneRepoGraphNonCanonicalStatus.code, 0);
|
|
assert.equal(standaloneRepoGraphNonCanonicalStatus.body.repositoryGraph.storePresent, true);
|
|
assert.equal(standaloneRepoGraphNonCanonicalStatus.body.repositoryGraph.storeValid, false);
|
|
assert.equal(standaloneRepoGraphNonCanonicalStatus.body.diagnostics[0].code, "RGP003");
|
|
assert.match(standaloneRepoGraphNonCanonicalStatus.body.diagnostics[0].actual, /byte-stable/);
|
|
writeFileSync(standaloneRepoGraphStore, storeText);
|
|
const standaloneRepoGraphStatusWithStore = json(["status", "--json", resolve(standaloneRepoGraphSource)]).body;
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.storePresent, true);
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.storeValid, true);
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.enabled, true);
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.projectionState, "clean");
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.semanticValidity, "shape-valid");
|
|
assert.equal(standaloneRepoGraphStatusWithStore.repositoryGraph.projectionValidity, "clean");
|
|
assert.equal(standaloneRepoGraphStatusWithStore.store.format, "zero-repository-graph");
|
|
assert.equal(standaloneRepoGraphStatusWithStore.store.encoding, "text");
|
|
assert.equal(standaloneRepoGraphStatusWithStore.store.graphHash, repoGraphImport.body.store.graphHash);
|
|
assert.equal(standaloneRepoGraphStatusWithStore.compilerStore.tables.sourceMap, standaloneRepoGraphStatusWithStore.store.nodes);
|
|
const binaryRepoGraphRoot = join("/tmp", `zero-repo-graph-binary-contract-${process.pid}`);
|
|
rmSync(binaryRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(binaryRepoGraphRoot, { recursive: true });
|
|
assert.match(zero(["init", binaryRepoGraphRoot]).stdout, /graph project init ok/);
|
|
let binaryRepoGraphStore = readFileSync(join(binaryRepoGraphRoot, "zero.graph"));
|
|
assert.equal(binaryRepoGraphStore.subarray(0, 8).toString("binary"), "ZRGBIN1\0");
|
|
assertPatchOkOutput(zero(["patch", binaryRepoGraphRoot, "--op", "addMain", "--op", 'addCheckWrite fn="main" text="hello binary\\n"']).stdout, join(binaryRepoGraphRoot, "zero.graph"));
|
|
binaryRepoGraphStore = readFileSync(join(binaryRepoGraphRoot, "zero.graph"));
|
|
assert.equal(binaryRepoGraphStore.subarray(0, 8).toString("binary"), "ZRGBIN1\0");
|
|
const binaryRepoGraphStatus = json(["status", "--json", binaryRepoGraphRoot]).body;
|
|
assert.equal(binaryRepoGraphStatus.repositoryGraph.storeValid, true);
|
|
assert.equal(binaryRepoGraphStatus.store.format, "zero-repository-graph");
|
|
assert.equal(binaryRepoGraphStatus.store.encoding, "binary");
|
|
assert.equal(binaryRepoGraphStatus.storage.encoding, "single-file-binary");
|
|
assert.equal(binaryRepoGraphStatus.storage.defaultEncoding, "binary");
|
|
assert.equal(binaryRepoGraphStatus.storage.binaryAvailable, true);
|
|
assert.equal(zero(["check", binaryRepoGraphRoot]).stdout, "ok\n");
|
|
assert.equal(zero(["run", binaryRepoGraphRoot]).stdout, "hello binary\n");
|
|
assert.match(zero(["export", binaryRepoGraphRoot]).stdout, /repository graph export ok/);
|
|
assert.equal(zero(["verify-projection", binaryRepoGraphRoot]).stdout, "repository graph verify-projection ok\n");
|
|
const invalidBinaryFormatSync = zero(["import", "--format", "pickle", binaryRepoGraphRoot], { allowFailure: true });
|
|
assert.notEqual(invalidBinaryFormatSync.code, 0);
|
|
assert.match(invalidBinaryFormatSync.stderr, /repository graph store format is not supported/);
|
|
const standaloneRepoGraphVerifyWithStore = json(["verify-projection", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(standaloneRepoGraphVerifyWithStore.code, 0);
|
|
assert.equal(standaloneRepoGraphVerifyWithStore.body.ok, true);
|
|
assert.equal(standaloneRepoGraphVerifyWithStore.body.writes, false);
|
|
const repositoryGraphVerifyCleanScript = repositoryGraphVerifyScript(standaloneRepoGraphRoot);
|
|
assert.equal(repositoryGraphVerifyCleanScript.code, 0);
|
|
assert.match(repositoryGraphVerifyCleanScript.stdout, /repository graph verify-projection ok \(1 store\)/);
|
|
const repositoryGraphVerifyNoStoresRoot = join("/tmp", `zero-repo-graph-no-stores-${process.pid}`);
|
|
rmSync(repositoryGraphVerifyNoStoresRoot, { force: true, recursive: true });
|
|
mkdirSync(repositoryGraphVerifyNoStoresRoot, { recursive: true });
|
|
const repositoryGraphVerifyNoStoresScript = repositoryGraphVerifyScript(repositoryGraphVerifyNoStoresRoot);
|
|
assert.equal(repositoryGraphVerifyNoStoresScript.code, 0);
|
|
assert.match(repositoryGraphVerifyNoStoresScript.stdout, /repository graph verify-projection ok \(0 stores\)/);
|
|
const repositoryGraphVerifyRedirectRoot = join("/tmp", `zero-repo-graph-redirect-${process.pid}`);
|
|
const repositoryGraphVerifyRedirectGood = join(repositoryGraphVerifyRedirectRoot, "good");
|
|
const repositoryGraphVerifyRedirectBad = join(repositoryGraphVerifyRedirectRoot, "bad");
|
|
rmSync(repositoryGraphVerifyRedirectRoot, { force: true, recursive: true });
|
|
mkdirSync(repositoryGraphVerifyRedirectGood, { recursive: true });
|
|
mkdirSync(repositoryGraphVerifyRedirectBad, { recursive: true });
|
|
writeFileSync(join(repositoryGraphVerifyRedirectGood, "main.0"), readFileSync("examples/hello.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", join(repositoryGraphVerifyRedirectGood, "main.0")]);
|
|
writeFileSync(join(repositoryGraphVerifyRedirectBad, "zero.graph"), 'invalid repository graph store\nprojection path:"../good/main.0" text:""\n');
|
|
const repositoryGraphVerifyRedirectScript = repositoryGraphVerifyScript(repositoryGraphVerifyRedirectRoot, { allowFailure: true });
|
|
assert.notEqual(repositoryGraphVerifyRedirectScript.code, 0);
|
|
assert.match(repositoryGraphVerifyRedirectScript.stderr, /repository graph verify-projection failed/);
|
|
assert.match(repositoryGraphVerifyRedirectScript.stderr, /zero-repo-graph-redirect-[0-9]+\/bad/);
|
|
const standaloneRepoGraphVerifyRelative = JSON.parse(execFileSync(zeroBin, ["verify-projection", "--json", "standalone.0"], { cwd: standaloneRepoGraphRoot, encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] }));
|
|
assert.equal(standaloneRepoGraphVerifyRelative.ok, true);
|
|
const repoGraphImportAgain = json(["import", "--format", "text", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(repoGraphImportAgain.code, 0);
|
|
assert.equal(sha256File(standaloneRepoGraphStore), firstStoreHash);
|
|
writeFileSync(standaloneRepoGraphSource, readFileSync(standaloneRepoGraphSource, "utf8").replace("hello from zero", "hello from graph projection"));
|
|
const standaloneRepoGraphProjectionStale = json(["status", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(standaloneRepoGraphProjectionStale.body.repositoryGraph.projectionState, "source-stale");
|
|
assert.equal(standaloneRepoGraphProjectionStale.body.repositoryGraph.projectionValidity, "stale");
|
|
const standaloneRepoGraphExport = json(["export", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(standaloneRepoGraphExport.code, 0);
|
|
assert.equal(standaloneRepoGraphExport.body.mode, "export");
|
|
assert.equal(standaloneRepoGraphExport.body.writes, true);
|
|
assert.deepEqual(standaloneRepoGraphExport.body.changedPaths, [standaloneRepoGraphSource]);
|
|
const restoredRepoGraphSource = readFileSync(standaloneRepoGraphSource, "utf8");
|
|
assert.match(restoredRepoGraphSource, /hello from zero/);
|
|
assert.equal(restoredRepoGraphSource.startsWith(standaloneRepoGraphComment), true);
|
|
const standaloneRepoGraphExportAgain = json(["export", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(standaloneRepoGraphExportAgain.code, 0);
|
|
assert.deepEqual(standaloneRepoGraphExportAgain.body.changedPaths, []);
|
|
const standaloneRepoGraphVerifyAfterProjection = json(["verify-projection", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(standaloneRepoGraphVerifyAfterProjection.body.ok, true);
|
|
const standaloneRepoGraphSourceMapAfterProjection = json(["source-map", "--json", resolve(standaloneRepoGraphSource)]).body;
|
|
assert.equal(standaloneRepoGraphSourceMapAfterProjection.ok, true);
|
|
assert(standaloneRepoGraphSourceMapAfterProjection.files.some((file: any) => file.path.endsWith("standalone.0") && file.nodeCount > 0));
|
|
assert(standaloneRepoGraphSourceMapAfterProjection.mappings.some((mapping: any) => mapping.sourceAvailable === false && mapping.sourceRange?.path.endsWith("standalone.0")));
|
|
const invalidProjectionText = readFileSync(standaloneRepoGraphSource, "utf8").replace("hello from zero", "projection row changed graph");
|
|
writeFileSync(standaloneRepoGraphStore, storeText.replace(/^projection path:"standalone\.0" text:.*$/m, `projection path:"standalone.0" text:${JSON.stringify(invalidProjectionText)}`));
|
|
const invalidProjectionStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(invalidProjectionStatus.body.repositoryGraph.projectionState, "conflict");
|
|
const invalidProjectionVerify = json(["verify-projection", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(invalidProjectionVerify.code, 0);
|
|
assert.equal(invalidProjectionVerify.body.diagnostics[0].code, "RGP006");
|
|
assert.deepEqual(invalidProjectionVerify.body.repairCommands, [`zero import ${resolve(standaloneRepoGraphSource)}`, `zero export ${resolve(standaloneRepoGraphSource)}`]);
|
|
const invalidProjectionVerifyText = zero(["verify-projection", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(invalidProjectionVerifyText.code, 0);
|
|
assert.match(invalidProjectionVerifyText.stderr, new RegExp(`repair: zero import ${resolve(standaloneRepoGraphSource).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
|
|
assert.match(invalidProjectionVerifyText.stderr, new RegExp(`repair: zero export ${resolve(standaloneRepoGraphSource).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
|
|
const invalidProjectionSync = json(["export", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(invalidProjectionSync.code, 0);
|
|
assert.equal(invalidProjectionSync.body.diagnostics[0].code, "RGP004");
|
|
assert(!readFileSync(standaloneRepoGraphSource, "utf8").includes("projection row changed graph"));
|
|
writeFileSync(standaloneRepoGraphStore, storeText);
|
|
const graphMarker = "\ngraph\n";
|
|
const standaloneRepoGraphGraphStart = storeText.indexOf(graphMarker);
|
|
assert.notEqual(standaloneRepoGraphGraphStart, -1);
|
|
const standaloneRepoGraphBaseArtifact = join(standaloneRepoGraphRoot, "base.program-graph");
|
|
const standaloneRepoGraphPatchedArtifact = join(standaloneRepoGraphRoot, "graph-only-drift.program-graph");
|
|
const standaloneRepoGraphBaseGraphText = storeText.slice(standaloneRepoGraphGraphStart + graphMarker.length);
|
|
writeFileSync(standaloneRepoGraphBaseArtifact, standaloneRepoGraphBaseGraphText);
|
|
const standaloneRepoGraphModule = standaloneRepoGraphBaseGraphText.match(/^node (#[^ ]+) Module /m)?.[1];
|
|
assert(standaloneRepoGraphModule);
|
|
const voidTypeId = graphDomainId("type", graphHashText(1469598103934665603n, "Void"));
|
|
const graphOnlyDriftPatch = `insertEdge from="${standaloneRepoGraphModule}" to="${voidTypeId}" edge="projectionDrift" target="type" order="0"`;
|
|
const graphOnlyDriftPatchResult = json(["patch", "--json", "--out", standaloneRepoGraphPatchedArtifact, standaloneRepoGraphBaseArtifact, "--op", graphOnlyDriftPatch]);
|
|
assert.equal(graphOnlyDriftPatchResult.body.ok, true);
|
|
const standaloneRepoGraphPatchedGraphText = readFileSync(standaloneRepoGraphPatchedArtifact, "utf8");
|
|
const standaloneRepoGraphPatchedHash = standaloneRepoGraphPatchedGraphText.match(/^hash "([^"]+)"$/m)?.[1];
|
|
assert(standaloneRepoGraphPatchedHash);
|
|
const graphOnlyDriftStoreText = refreshRepositoryGraphCompilerMetadata(storeText
|
|
.slice(0, standaloneRepoGraphGraphStart + graphMarker.length)
|
|
.replace(/^graphHash "[^"]+"$/m, `graphHash "${standaloneRepoGraphPatchedHash}"`)
|
|
.replace(/^moduleHash "[^"]+"$/m, `moduleHash "${standaloneRepoGraphPatchedHash}"`) +
|
|
standaloneRepoGraphPatchedGraphText);
|
|
writeFileSync(standaloneRepoGraphStore, graphOnlyDriftStoreText);
|
|
const graphOnlyDriftStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(graphOnlyDriftStatus.body.repositoryGraph.projectionState, "conflict");
|
|
const graphOnlyDriftSync = json(["export", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(graphOnlyDriftSync.code, 0);
|
|
assert.equal(graphOnlyDriftSync.body.diagnostics[0].code, "RGP004");
|
|
writeFileSync(standaloneRepoGraphStore, storeText);
|
|
const typeErasedBaseLiteralLine = standaloneRepoGraphBaseGraphText.match(/^node (#[^ ]+) Literal [^\n]*value:"hello from zero[^\n]*$/m);
|
|
assert(typeErasedBaseLiteralLine);
|
|
assert(typeErasedBaseLiteralLine[0].includes(' type:"String"'));
|
|
const typeErasedLiteralText = typeErasedBaseLiteralLine[0].replace(' type:"String"', "");
|
|
const typeErasedGraphText = standaloneRepoGraphBaseGraphText.replace(typeErasedBaseLiteralLine[0], typeErasedLiteralText);
|
|
assert.notEqual(typeErasedGraphText, standaloneRepoGraphBaseGraphText);
|
|
const typeErasedLiteralLine = typeErasedGraphText.match(/^node (#[^ ]+) Literal [^\n]*value:"hello from zero\\n"[^\n]*$/m);
|
|
assert(typeErasedLiteralLine);
|
|
const typeErasedGraphHash = recomputeGraphHash(typeErasedGraphText);
|
|
const typeErasedStoredGraphText = typeErasedGraphText.replace(/^hash "graph:[0-9a-f]{16}"$/m, `hash "${typeErasedGraphHash}"`);
|
|
const typeErasedStoreText = refreshRepositoryGraphCompilerMetadata(storeText
|
|
.slice(0, standaloneRepoGraphGraphStart + graphMarker.length)
|
|
.replace(/^graphHash "[^"]+"$/m, `graphHash "${typeErasedGraphHash}"`)
|
|
.replace(/^moduleHash "[^"]+"$/m, `moduleHash "${typeErasedGraphHash}"`)
|
|
.replace(
|
|
new RegExp(`^nodeHash node:${JSON.stringify(typeErasedLiteralLine[1])} hash:"[^"]+"$`, "m"),
|
|
`nodeHash node:${JSON.stringify(typeErasedLiteralLine[1])} hash:${JSON.stringify(graphNodeHash(typeErasedLiteralLine[0]))}`,
|
|
) +
|
|
typeErasedStoredGraphText);
|
|
writeFileSync(standaloneRepoGraphStore, typeErasedStoreText);
|
|
const typeErasedProjectionStatus = json(["status", "--json", resolve(standaloneRepoGraphSource)]);
|
|
assert.equal(typeErasedProjectionStatus.body.repositoryGraph.projectionState, "conflict");
|
|
const typeErasedProjectionSync = json(["export", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(typeErasedProjectionSync.code, 0);
|
|
assert.equal(typeErasedProjectionSync.body.diagnostics[0].code, "RGP004");
|
|
writeFileSync(standaloneRepoGraphStore, storeText);
|
|
const relativePackageRoot = join("/tmp", `zero-repo-graph-relative-package-${process.pid}`);
|
|
const relativePackageSource = join(relativePackageRoot, "src", "main.0");
|
|
const relativePackageStore = join(relativePackageRoot, "zero.graph");
|
|
rmSync(relativePackageRoot, { force: true, recursive: true });
|
|
mkdirSync(join(relativePackageRoot, "src"), { recursive: true });
|
|
writeFileSync(join(relativePackageRoot, "zero.toml"), readFileSync("examples/systems-package/zero.toml", "utf8"));
|
|
writeFileSync(relativePackageSource, readFileSync("examples/hello.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", relativePackageRoot]);
|
|
const relativePackageStoreText = readFileSync(relativePackageStore, "utf8");
|
|
assert.match(relativePackageStoreText, /^source path:"src\/main\.0"$/m);
|
|
assert(!relativePackageStoreText.includes(relativePackageRoot));
|
|
const relativePackageStoreHash = sha256File(relativePackageStore);
|
|
const relativePackageVerifyDot = JSON.parse(execFileSync(zeroBin, ["verify-projection", "--json", "."], { cwd: relativePackageRoot, encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] }));
|
|
assert.equal(relativePackageVerifyDot.ok, true);
|
|
const relativePackageSyncDot = JSON.parse(execFileSync(zeroBin, ["import", "--format", "text", "--json", "."], { cwd: relativePackageRoot, encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] }));
|
|
assert.equal(relativePackageSyncDot.ok, true);
|
|
assert.equal(sha256File(relativePackageStore), relativePackageStoreHash);
|
|
const relativePackageVerifyAbsolute = json(["verify-projection", "--json", relativePackageRoot]);
|
|
assert.equal(relativePackageVerifyAbsolute.body.ok, true);
|
|
const relativePackageManifest = join(relativePackageRoot, "zero.toml");
|
|
writeFileSync(relativePackageManifest, manifestToml({ package: { name: "systems-package-renamed", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } }));
|
|
const relativePackageManifestStatus = json(["status", "--json", relativePackageRoot]);
|
|
assert.equal(relativePackageManifestStatus.body.repositoryGraph.projectionState, "conflict");
|
|
const relativePackageManifestVerify = json(["verify-projection", "--json", relativePackageRoot], { allowFailure: true });
|
|
assert.notEqual(relativePackageManifestVerify.code, 0);
|
|
assert.equal(relativePackageManifestVerify.body.repositoryGraph.projectionState, "conflict");
|
|
assert.equal(relativePackageManifestVerify.body.diagnostics[0].code, "RGP007");
|
|
const relativePackageManifestExport = json(["export", "--json", relativePackageRoot], { allowFailure: true });
|
|
assert.notEqual(relativePackageManifestExport.code, 0);
|
|
assert.equal(relativePackageManifestExport.body.repositoryGraph.projectionState, "conflict");
|
|
assert.equal(relativePackageManifestExport.body.diagnostics[0].code, "RGP007");
|
|
writeFileSync(relativePackageManifest, manifestToml({ package: { name: "systems-package", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/missing.0" } } }));
|
|
const relativePackageBrokenManifestStatus = json(["status", "--json", relativePackageRoot]);
|
|
assert.equal(relativePackageBrokenManifestStatus.code, 0);
|
|
assert.equal(relativePackageBrokenManifestStatus.body.ok, true);
|
|
assert.equal(relativePackageBrokenManifestStatus.body.mode, "status");
|
|
assert.equal(relativePackageBrokenManifestStatus.body.repositoryGraph.projectionState, "conflict");
|
|
assert.deepEqual(relativePackageBrokenManifestStatus.body.diagnostics, []);
|
|
const relativePackageBrokenManifestVerify = json(["verify-projection", "--json", relativePackageRoot], { allowFailure: true });
|
|
assert.notEqual(relativePackageBrokenManifestVerify.code, 0);
|
|
const packageRefreshRoot = join("/tmp", `zero-repo-graph-package-refresh-${process.pid}`);
|
|
const packageRefreshSource = join(packageRefreshRoot, "src", "main.0");
|
|
const packageRefreshStore = join(packageRefreshRoot, "zero.graph");
|
|
rmSync(packageRefreshRoot, { force: true, recursive: true });
|
|
const packageRefreshInit = json(["init", "--json", packageRefreshRoot]);
|
|
assert.equal(packageRefreshInit.body.ok, true);
|
|
const packageRefreshName = readFileSync(join(packageRefreshRoot, "zero.toml"), "utf8").match(/^name = "([^"]+)"$/m)?.[1];
|
|
assert(packageRefreshName);
|
|
mkdirSync(join(packageRefreshRoot, "src"), { recursive: true });
|
|
writeFileSync(packageRefreshSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("package refresh one\\n")\n}\n');
|
|
const packageRefreshImport = json(["import", "--json", packageRefreshSource]);
|
|
assert.equal(packageRefreshImport.code, 0);
|
|
assert.equal(packageRefreshImport.body.ok, true);
|
|
const packageRefreshQuery = json(["query", "--json", "--fn", "main", packageRefreshRoot]);
|
|
assert.equal(packageRefreshQuery.body.moduleIdentity, `package:${packageRefreshName}@0.1.0`);
|
|
const packageRefreshMainId = packageRefreshQuery.body.functions[0].id;
|
|
assert(packageRefreshMainId);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh one\n");
|
|
writeFileSync(packageRefreshSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("package refresh two\\n")\n}\n');
|
|
const packageRefreshReimport = json(["import", "--json", packageRefreshSource]);
|
|
assert.equal(packageRefreshReimport.body.ok, true);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh two\n");
|
|
assert.equal(json(["query", "--json", "--fn", "main", packageRefreshRoot]).body.functions[0].id, packageRefreshMainId);
|
|
writeFileSync(packageRefreshSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("package refresh three\\n")\n}\n');
|
|
const packageRefreshRootReimport = json(["import", "--json", packageRefreshRoot]);
|
|
assert.equal(packageRefreshRootReimport.body.ok, true);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh three\n");
|
|
const packageRefreshStoreHash = sha256File(packageRefreshStore);
|
|
const packageRefreshOutRejected = json(["import", "--json", "--format", "binary", "--out", packageRefreshStore, packageRefreshSource], { allowFailure: true });
|
|
assert.notEqual(packageRefreshOutRejected.code, 0);
|
|
assert.equal(packageRefreshOutRejected.body.diagnostics[0].code, "RGP002");
|
|
assert.deepEqual(packageRefreshOutRejected.body.repairCommands, [`zero import ${packageRefreshSource}`]);
|
|
assert.equal(sha256File(packageRefreshStore), packageRefreshStoreHash);
|
|
const packageRefreshManifestText = readFileSync(join(packageRefreshRoot, "zero.toml"), "utf8");
|
|
writeFileSync(join(packageRefreshRoot, "zero.toml"), packageRefreshManifestText.replace('version = "0.1.0"', 'version = "0.2.0"'));
|
|
const packageRefreshBumpImport = json(["import", "--json", packageRefreshRoot]);
|
|
assert.equal(packageRefreshBumpImport.body.ok, true);
|
|
assert.equal(json(["query", "--json", packageRefreshRoot]).body.moduleIdentity, `package:${packageRefreshName}@0.2.0`);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh three\n");
|
|
writeFileSync(join(packageRefreshRoot, "zero.toml"), packageRefreshManifestText);
|
|
assert.equal(json(["import", "--json", packageRefreshRoot]).body.ok, true);
|
|
const packageRefreshBareRoot = join("/tmp", `zero-repo-graph-package-refresh-bare-${process.pid}`);
|
|
rmSync(packageRefreshBareRoot, { force: true, recursive: true });
|
|
mkdirSync(packageRefreshBareRoot, { recursive: true });
|
|
writeFileSync(join(packageRefreshBareRoot, "main.0"), readFileSync(packageRefreshSource, "utf8"));
|
|
assert.equal(json(["import", "--json", "--format", "binary", join(packageRefreshBareRoot, "main.0")]).body.ok, true);
|
|
writeFileSync(packageRefreshStore, readFileSync(join(packageRefreshBareRoot, "zero.graph")));
|
|
const packageRefreshPoisonedCheck = json(["check", "--json", packageRefreshRoot], { allowFailure: true });
|
|
assert.notEqual(packageRefreshPoisonedCheck.code, 0);
|
|
assert.equal(packageRefreshPoisonedCheck.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(packageRefreshPoisonedCheck.body.diagnostics[0].actual, "module:main");
|
|
assert.match(packageRefreshPoisonedCheck.body.diagnostics[0].help, /run zero import to refresh zero\.graph/);
|
|
assert.deepEqual(packageRefreshPoisonedCheck.body.repairCommands, [`zero import ${packageRefreshRoot}`]);
|
|
const packageRefreshHealImport = json(["import", "--json", packageRefreshRoot]);
|
|
assert.equal(packageRefreshHealImport.body.ok, true);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh three\n");
|
|
const packageForeignRoot = join("/tmp", `zero-repo-graph-package-foreign-${process.pid}`);
|
|
rmSync(packageForeignRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", packageForeignRoot]).body.ok, true);
|
|
mkdirSync(join(packageForeignRoot, "src"), { recursive: true });
|
|
writeFileSync(join(packageForeignRoot, "src", "main.0"), readFileSync(packageRefreshSource, "utf8"));
|
|
assert.equal(json(["import", "--json", packageForeignRoot]).body.ok, true);
|
|
writeFileSync(packageRefreshStore, readFileSync(join(packageForeignRoot, "zero.graph")));
|
|
const packageForeignStoreHash = sha256File(packageRefreshStore);
|
|
const packageForeignImport = json(["import", "--json", packageRefreshRoot], { allowFailure: true });
|
|
assert.notEqual(packageForeignImport.code, 0);
|
|
assert.equal(packageForeignImport.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(packageForeignImport.body.diagnostics[0].message, "repository graph source identity has a different module identity");
|
|
assert.equal(sha256File(packageRefreshStore), packageForeignStoreHash);
|
|
const packageForeignCheck = json(["check", "--json", packageRefreshRoot], { allowFailure: true });
|
|
assert.notEqual(packageForeignCheck.code, 0);
|
|
assert.equal(packageForeignCheck.body.diagnostics[0].code, "RGP007");
|
|
rmSync(packageRefreshStore, { force: true });
|
|
assert.equal(json(["import", "--json", packageRefreshRoot]).body.ok, true);
|
|
assert.equal(zero(["run", packageRefreshRoot]).stdout, "package refresh three\n");
|
|
const staleRunRoot = join("/tmp", `zero-repo-graph-stale-run-${process.pid}`);
|
|
const staleRunSource = join(staleRunRoot, "src", "main.0");
|
|
const staleRunStore = join(staleRunRoot, "zero.graph");
|
|
rmSync(staleRunRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", staleRunRoot]).body.ok, true);
|
|
mkdirSync(join(staleRunRoot, "src"), { recursive: true });
|
|
writeFileSync(staleRunSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("stale run one\\n")\n}\n');
|
|
assert.equal(json(["import", "--json", staleRunRoot]).body.ok, true);
|
|
assert.equal(zero(["run", staleRunRoot]).stdout, "stale run one\n");
|
|
writeFileSync(staleRunSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("stale run two\\n")\n}\n');
|
|
assert.equal(json(["status", "--json", staleRunRoot]).body.repositoryGraph.projectionState, "source-stale");
|
|
const staleRunStoreHashBefore = sha256File(staleRunStore);
|
|
assert.equal(zero(["run", staleRunRoot]).stdout, "stale run two\n");
|
|
assert.notEqual(sha256File(staleRunStore), staleRunStoreHashBefore);
|
|
assert.equal(json(["status", "--json", staleRunRoot]).body.repositoryGraph.projectionState, "clean");
|
|
writeFileSync(staleRunSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("stale run three\\n")\n}\n');
|
|
assert.equal(zero(["check", staleRunRoot]).stdout, "ok\n");
|
|
assert.equal(json(["status", "--json", staleRunRoot]).body.repositoryGraph.projectionState, "clean");
|
|
assert.equal(zero(["run", staleRunRoot]).stdout, "stale run three\n");
|
|
const staleRunGoodSource = readFileSync(staleRunSource, "utf8");
|
|
writeFileSync(staleRunSource, `${staleRunGoodSource}fn broken( {\n`);
|
|
const staleRunBrokenCheck = zero(["check", staleRunRoot], { allowFailure: true });
|
|
assert.notEqual(staleRunBrokenCheck.code, 0);
|
|
const staleRunBrokenRun = zero(["run", staleRunRoot], { allowFailure: true });
|
|
assert.notEqual(staleRunBrokenRun.code, 0);
|
|
writeFileSync(staleRunSource, staleRunGoodSource);
|
|
assert.equal(zero(["run", staleRunRoot]).stdout, "stale run three\n");
|
|
writeFileSync(staleRunSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("stale run four\\n")\n}\n');
|
|
const staleRunStrictHash = sha256File(staleRunStore);
|
|
const staleRunStrict = json(["build", "--json", staleRunRoot], { allowFailure: true, env: { ZERO_STALE: "fail" } });
|
|
assert.notEqual(staleRunStrict.code, 0);
|
|
assert.equal(staleRunStrict.body.diagnostics[0].code, "RGP008");
|
|
assert.deepEqual(staleRunStrict.body.repairCommands, [`zero import ${staleRunRoot}`]);
|
|
assert.equal(sha256File(staleRunStore), staleRunStrictHash);
|
|
const staleRunStrictRun = zero(["run", staleRunRoot], { allowFailure: true, env: { ZERO_STALE: "fail" } });
|
|
assert.notEqual(staleRunStrictRun.code, 0);
|
|
assert.equal(zero(["run", staleRunRoot]).stdout, "stale run four\n");
|
|
assert.equal(zero(["run", staleRunSource]).stdout, "stale run four\n");
|
|
assert.equal(zero(["check", staleRunSource]).stdout, "ok\n");
|
|
writeFileSync(staleRunSource, 'pub fn main(world: World) -> Void raises {\n check world.out.write("stale run five\\n")\n}\n');
|
|
assert.equal(zero(["run", staleRunSource]).stdout, "stale run five\n");
|
|
assert.equal(json(["status", "--json", staleRunRoot]).body.repositoryGraph.projectionState, "clean");
|
|
|
|
const cachedArgvRoot = join("/tmp", `zero-repo-graph-cached-argv-${process.pid}`);
|
|
const cachedArgvSource = join(cachedArgvRoot, "src", "main.0");
|
|
rmSync(cachedArgvRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", cachedArgvRoot]).body.ok, true);
|
|
mkdirSync(join(cachedArgvRoot, "src"), { recursive: true });
|
|
writeFileSync(cachedArgvSource, 'pub fn main(world: World) -> Void raises {\n let self: Maybe<String> = std.args.get(0)\n if self.has {\n check world.out.write(self.value)\n check world.out.write("\\n")\n }\n}\n');
|
|
assert.equal(json(["import", "--json", cachedArgvRoot]).body.ok, true);
|
|
assert.match(zero(["run", cachedArgvRoot]).stdout, /\.run-/);
|
|
const cachedArgvSecondRun = zero(["run", cachedArgvRoot]).stdout.trim();
|
|
assert.match(cachedArgvSecondRun, /\.run-/);
|
|
assert.doesNotMatch(cachedArgvSecondRun, /linked-exe-/);
|
|
|
|
const procFdRoot = join("/tmp", `zero-proc-child-fd-inherit-${process.pid}`);
|
|
const procFdSource = join(procFdRoot, "src", "main.0");
|
|
rmSync(procFdRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", procFdRoot]).body.ok, true);
|
|
mkdirSync(join(procFdRoot, "src"), { recursive: true });
|
|
writeFileSync(procFdSource, `pub fn main(world: World) -> Void raises {
|
|
let first: ProcChild = std.proc.spawnChild("sh -c 'cat >/dev/null; printf first-done'")
|
|
let second: ProcChild = std.proc.spawnChild("sleep 5")
|
|
let closed: Bool = std.proc.closeStdin(first)
|
|
let status: ProcStatus = std.proc.wait(first)
|
|
var output: [64]u8 = [0_u8; 64]
|
|
let read: Maybe<usize> = std.proc.readStdout(first, output)
|
|
if closed && std.proc.succeeded(status) && read.has {
|
|
let bytes: Span<u8> = std.io.written(output, read.value)
|
|
check world.out.write(bytes)
|
|
check world.out.write("\\n")
|
|
}
|
|
let killed: Bool = std.proc.kill(second)
|
|
let second_status: ProcStatus = std.proc.wait(second)
|
|
let closed_first: Bool = std.proc.close(first)
|
|
let closed_second: Bool = std.proc.close(second)
|
|
}
|
|
`);
|
|
assert.equal(json(["import", "--json", procFdRoot]).body.ok, true);
|
|
const procFdRun = spawnSync(zeroBin, ["run", procFdRoot], { encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"], timeout: 1800 });
|
|
assert.equal(procFdRun.error, undefined);
|
|
assert.equal(procFdRun.status, 0);
|
|
assert.equal(procFdRun.stdout, "first-done\n");
|
|
|
|
const staleMultiRoot = join("/tmp", `zero-repo-graph-stale-multi-${process.pid}`);
|
|
const staleMultiStore = join(staleMultiRoot, "zero.graph");
|
|
const staleMultiHelper = join(staleMultiRoot, "src", "math.0");
|
|
rmSync(staleMultiRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", staleMultiRoot]).body.ok, true);
|
|
mkdirSync(join(staleMultiRoot, "src"), { recursive: true });
|
|
writeFileSync(
|
|
join(staleMultiRoot, "src", "main.0"),
|
|
'use math\n\npub fn main(world: World) -> Void raises {\n if add_one(41) == 42 {\n check world.out.write("stale multi one\\n")\n }\n if add_one(41) == 43 {\n check world.out.write("stale multi two\\n")\n }\n}\n',
|
|
);
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 1\n}\n");
|
|
assert.equal(json(["import", "--json", staleMultiRoot]).body.ok, true);
|
|
assert.equal(zero(["run", staleMultiRoot]).stdout, "stale multi one\n");
|
|
const staleMultiOverview = zero(["query", staleMultiRoot]).stdout;
|
|
assert.match(staleMultiOverview, /math path:src\/math\.0 functions:1\n/);
|
|
assert.match(staleMultiOverview, /main path:src\/main\.0 functions:1 \(entry\)/);
|
|
assert.match(staleMultiOverview, /functions \(module main\):/);
|
|
assert.doesNotMatch(staleMultiOverview, /add_one\(value: i32\)/, "the bare overview lists only entry-module signatures");
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 2\n}\n");
|
|
const staleMultiCheck = zeroWithStderr(["check"], { cwd: staleMultiRoot });
|
|
assert.equal(staleMultiCheck.code, 0);
|
|
assert.equal(staleMultiCheck.stdout, "ok\n");
|
|
assert.match(staleMultiCheck.stderr, /note: zero check refreshed zero\.graph from the edited package source projection; tip: zero patch --replace-fn <fn> --body-file - edits the graph directly and skips this reconcile/);
|
|
assert.equal((staleMultiCheck.stderr.match(/\n/g) ?? []).length, 1, "graph refresh note plus tip should stay on one stderr line");
|
|
assert.equal(json(["status", "--json", staleMultiRoot]).body.repositoryGraph.projectionState, "clean");
|
|
assert.equal(zero(["run", staleMultiRoot]).stdout, "stale multi two\n");
|
|
// Context-aware refresh tips: a signature-changing source edit teaches the
|
|
// declaration-level patch ops at the moment of fallback, a const initializer
|
|
// edit teaches setConst, and the refreshed (clean) state stays quiet.
|
|
const refreshTipRoot = join("/tmp", `zero-repo-graph-refresh-tip-${process.pid}`);
|
|
const refreshTipMain = join(refreshTipRoot, "src", "main.0");
|
|
const refreshTipMath = join(refreshTipRoot, "src", "math.0");
|
|
rmSync(refreshTipRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", refreshTipRoot]).body.ok, true);
|
|
mkdirSync(join(refreshTipRoot, "src"), { recursive: true });
|
|
writeFileSync(refreshTipMain, 'use math\n\nconst limit: i32 = 42\n\npub fn main(world: World) -> Void raises {\n if add_one(41) == limit {\n check world.out.write("tip one\\n")\n }\n}\n');
|
|
writeFileSync(refreshTipMath, "pub fn add_one(value: i32) -> i32 {\n return value + 1\n}\n");
|
|
assert.equal(json(["import", "--json", refreshTipRoot]).body.ok, true);
|
|
writeFileSync(refreshTipMath, "pub fn add_one(value: i32, bias: i32) -> i32 {\n return value + bias\n}\n");
|
|
writeFileSync(refreshTipMain, 'use math\n\nconst limit: i32 = 42\n\npub fn main(world: World) -> Void raises {\n if add_one(41, 1) == limit {\n check world.out.write("tip one\\n")\n }\n}\n');
|
|
const refreshTipSignature = zeroWithStderr(["check", refreshTipRoot]);
|
|
assert.equal(refreshTipSignature.code, 0);
|
|
assert.match(refreshTipSignature.stderr, /note: zero check refreshed zero\.graph from the edited package source projection; tip: zero patch --op 'addParamTo fn=\.\.\. name=\.\.\. type=\.\.\. default=\.\.\.' threads a new parameter through every call site in one step; setReturnType changes return types/);
|
|
assert.equal((refreshTipSignature.stderr.match(/\n/g) ?? []).length, 1, "signature refresh note plus tip should stay on one stderr line");
|
|
const refreshTipQuiet = zeroWithStderr(["check", refreshTipRoot]);
|
|
assert.equal(refreshTipQuiet.code, 0);
|
|
assert.doesNotMatch(refreshTipQuiet.stderr, /refreshed zero\.graph/, "the refresh note prints once per stale state");
|
|
writeFileSync(refreshTipMain, 'use math\n\nconst limit: i32 = 43\n\npub fn main(world: World) -> Void raises {\n if add_one(41, 1) == limit {\n check world.out.write("tip one\\n")\n }\n}\n');
|
|
const refreshTipConst = zeroWithStderr(["check", refreshTipRoot]);
|
|
assert.equal(refreshTipConst.code, 0);
|
|
assert.match(refreshTipConst.stderr, /note: zero check refreshed zero\.graph from the edited package source projection; tip: zero patch --op 'setConst name=\.\.\. value=\.\.\.' replaces a top-level const initializer directly and skips this reconcile/);
|
|
assert.equal(json(["status", "--json", refreshTipRoot]).body.repositoryGraph.projectionState, "clean");
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 1\n}\n");
|
|
const staleMultiStoreCheck = zeroWithStderr(["check", staleMultiStore]);
|
|
assert.equal(staleMultiStoreCheck.code, 0);
|
|
assert.equal(staleMultiStoreCheck.stdout, "ok\n");
|
|
assert.match(staleMultiStoreCheck.stderr, /note: zero check refreshed zero\.graph from the edited package source projection/);
|
|
assert.equal(json(["status", "--json", staleMultiRoot]).body.repositoryGraph.projectionState, "clean");
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 2\n}\n");
|
|
const staleMultiBuild = zeroWithStderr(["build", staleMultiStore]);
|
|
assert.equal(staleMultiBuild.code, 0);
|
|
assert.match(staleMultiBuild.stderr, /note: zero build refreshed zero\.graph from the edited package source projection/);
|
|
assert.equal(zero(["run", staleMultiRoot]).stdout, "stale multi two\n");
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 1\n}\n");
|
|
const staleMultiView = zeroWithStderr(["view", "--fn", "add_one", staleMultiRoot]);
|
|
assert.equal(staleMultiView.code, 0);
|
|
assert.match(staleMultiView.stdout, /return value \+ 1/);
|
|
assert.match(staleMultiView.stderr, /note: zero view refreshed zero\.graph from the edited package source projection/);
|
|
assert.equal(json(["status", "--json", staleMultiRoot]).body.repositoryGraph.projectionState, "clean");
|
|
const staleMultiPatch = json(["patch", "--json", staleMultiRoot, "--op", 'addLetLiteral fn="main" name="patched" type="u32" value="7"']);
|
|
assert.equal(staleMultiPatch.body.ok, true);
|
|
const staleMultiGraphNewerBuild = zeroWithStderr(["build", staleMultiRoot]);
|
|
assert.equal(staleMultiGraphNewerBuild.code, 0);
|
|
assert.match(staleMultiGraphNewerBuild.stderr, /note: zero build is using zero\.graph, which is newer than the \.0 source projection/);
|
|
// the store-newer note is once-per-state: a second command on the same store
|
|
// stays quiet until the store or source state changes
|
|
const staleMultiGraphNewerRepeat = zeroWithStderr(["check", staleMultiRoot]);
|
|
assert.equal(staleMultiGraphNewerRepeat.code, 0);
|
|
assert.doesNotMatch(staleMultiGraphNewerRepeat.stderr, /is using zero\.graph/, "two consecutive commands print the store-newer note once");
|
|
writeFileSync(staleMultiHelper, "pub fn add_one(value: i32) -> i32 {\n return value + 2\n}\n");
|
|
const staleMultiDiverged = json(["check", "--json", staleMultiRoot], { allowFailure: true });
|
|
assert.notEqual(staleMultiDiverged.code, 0);
|
|
assert.equal(staleMultiDiverged.body.diagnostics[0].code, "RGP006");
|
|
assert.match(staleMultiDiverged.body.diagnostics[0].message, /have diverged/);
|
|
assert.match(staleMultiDiverged.body.repairCommands.join("\n"), /zero import/);
|
|
assert.match(staleMultiDiverged.body.repairCommands.join("\n"), /zero export/);
|
|
const staleMultiDivergedBuild = json(["build", "--json", staleMultiRoot], { allowFailure: true });
|
|
assert.notEqual(staleMultiDivergedBuild.code, 0);
|
|
assert.equal(staleMultiDivergedBuild.body.diagnostics[0].code, "RGP006");
|
|
assert.equal(json(["import", "--json", staleMultiRoot]).body.ok, true);
|
|
assert.equal(zero(["run", staleMultiRoot]).stdout, "stale multi two\n");
|
|
assert.equal(json(["status", "--json", staleMultiRoot]).body.repositoryGraph.projectionState, "clean");
|
|
// Content-based store/source sync classification: a freshly staged workspace
|
|
// with an edited source projection classifies source-newer and runs the
|
|
// edited behavior with the store mtime newest, oldest, or tied, because the
|
|
// store records a hash of the source projection at every write and mtimes
|
|
// never decide the state.
|
|
const stagedSyncBase = join("/tmp", `zero-staged-sync-base-${process.pid}`);
|
|
rmSync(stagedSyncBase, { force: true, recursive: true });
|
|
mkdirSync(join(stagedSyncBase, "src"), { recursive: true });
|
|
writeFileSync(join(stagedSyncBase, "zero.toml"), '[package]\nname = "staged-sync"\nversion = "0.1.0"\n\n[targets.cli]\nkind = "exe"\nmain = "src/main.0"\n');
|
|
writeFileSync(join(stagedSyncBase, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("staged one\\n")\n}\n');
|
|
assert.equal(json(["import", "--json", stagedSyncBase]).body.ok, true);
|
|
assert.equal(zero(["run", stagedSyncBase]).stdout, "staged one\n");
|
|
const stagedSyncEpoch = new Date("2026-01-01T00:00:00Z");
|
|
for (const order of ["store-newest", "store-oldest", "tied"]) {
|
|
const stagedRoot = join("/tmp", `zero-staged-sync-${order}-${process.pid}`);
|
|
rmSync(stagedRoot, { force: true, recursive: true });
|
|
cpSync(stagedSyncBase, stagedRoot, { recursive: true });
|
|
writeFileSync(join(stagedRoot, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("staged two\\n")\n}\n');
|
|
const stagedNow = new Date();
|
|
const storeTime = order === "store-newest" ? stagedNow : stagedSyncEpoch;
|
|
const sourceTime = order === "store-oldest" ? stagedNow : stagedSyncEpoch;
|
|
utimesSync(join(stagedRoot, "zero.graph"), storeTime, storeTime);
|
|
utimesSync(join(stagedRoot, "src", "main.0"), sourceTime, sourceTime);
|
|
const stagedRun = zeroWithStderr(["run", stagedRoot]);
|
|
assert.equal(stagedRun.code, 0, `staged ${order} run exits 0`);
|
|
assert.equal(stagedRun.stdout, "staged two\n", `staged ${order} runs the edited behavior`);
|
|
assert.match(stagedRun.stderr, /refreshed zero\.graph from the edited package source projection/, `staged ${order} classifies source-newer`);
|
|
rmSync(stagedRoot, { force: true, recursive: true });
|
|
}
|
|
// A patched store stays authoritative by content even when its mtime is the
|
|
// oldest file in the workspace.
|
|
const stagedPatch = json(["patch", "--json", stagedSyncBase, "--op", 'addCheckWrite fn="main" text="staged patched\\n"']);
|
|
assert.equal(stagedPatch.body.ok, true);
|
|
utimesSync(join(stagedSyncBase, "zero.graph"), stagedSyncEpoch, stagedSyncEpoch);
|
|
const stagedStoreNewer = zeroWithStderr(["run", stagedSyncBase]);
|
|
assert.equal(stagedStoreNewer.code, 0);
|
|
assert.equal(stagedStoreNewer.stdout, "staged one\nstaged patched\n");
|
|
assert.match(stagedStoreNewer.stderr, /is using zero\.graph, which is newer than the \.0 source projection/);
|
|
// zero export refreshes the recorded source projection hash so a source edit
|
|
// after the export classifies source-newer instead of diverged.
|
|
const stagedExport = json(["export", "--json", stagedSyncBase]);
|
|
assert.equal(stagedExport.body.ok, true);
|
|
assert.equal(stagedExport.body.changedPaths.includes(join(stagedSyncBase, "zero.graph")), true);
|
|
writeFileSync(join(stagedSyncBase, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("staged three\\n")\n}\n');
|
|
utimesSync(join(stagedSyncBase, "src", "main.0"), stagedSyncEpoch, stagedSyncEpoch);
|
|
const stagedAfterExport = zeroWithStderr(["run", stagedSyncBase]);
|
|
assert.equal(stagedAfterExport.code, 0);
|
|
assert.equal(stagedAfterExport.stdout, "staged three\n");
|
|
assert.match(stagedAfterExport.stderr, /refreshed zero\.graph from the edited package source projection/);
|
|
// Editing the source while the store holds unexported patches is a genuine
|
|
// divergence regardless of mtimes.
|
|
assert.equal(json(["patch", "--json", stagedSyncBase, "--op", 'addCheckWrite fn="main" text="staged patched again\\n"']).body.ok, true);
|
|
writeFileSync(join(stagedSyncBase, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("staged four\\n")\n}\n');
|
|
const stagedDiverged = json(["check", "--json", stagedSyncBase], { allowFailure: true });
|
|
assert.notEqual(stagedDiverged.code, 0);
|
|
assert.equal(stagedDiverged.body.diagnostics[0].code, "RGP006");
|
|
rmSync(stagedSyncBase, { force: true, recursive: true });
|
|
// Stores written before the recorded source projection hash existed degrade
|
|
// to one reconciling source refresh instead of an error wall, and the
|
|
// refresh records the hash.
|
|
const legacySyncRoot = join("/tmp", `zero-legacy-sync-${process.pid}`);
|
|
rmSync(legacySyncRoot, { force: true, recursive: true });
|
|
mkdirSync(join(legacySyncRoot, "src"), { recursive: true });
|
|
writeFileSync(join(legacySyncRoot, "zero.toml"), '[package]\nname = "legacy-sync"\nversion = "0.1.0"\n\n[targets.cli]\nkind = "exe"\nmain = "src/main.0"\n');
|
|
writeFileSync(join(legacySyncRoot, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("legacy one\\n")\n}\n');
|
|
assert.equal(json(["import", "--json", "--format", "text", legacySyncRoot]).body.ok, true);
|
|
const legacyStorePath = join(legacySyncRoot, "zero.graph");
|
|
const legacyStoreText = readFileSync(legacyStorePath, "utf8");
|
|
assert.match(legacyStoreText, /\nsourceHash "src:[0-9a-f]{16}"\n/);
|
|
writeFileSync(legacyStorePath, legacyStoreText.replace(/\nsourceHash "[^"]*"/, ""));
|
|
writeFileSync(join(legacySyncRoot, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n check world.out.write("legacy two\\n")\n}\n');
|
|
utimesSync(join(legacySyncRoot, "src", "main.0"), stagedSyncEpoch, stagedSyncEpoch);
|
|
const legacyRun = zeroWithStderr(["run", legacySyncRoot]);
|
|
assert.equal(legacyRun.code, 0);
|
|
assert.equal(legacyRun.stdout, "legacy two\n");
|
|
assert.match(legacyRun.stderr, /refreshed zero\.graph from the edited package source projection/);
|
|
assert.match(readFileSync(legacyStorePath, "utf8"), /\nsourceHash "src:[0-9a-f]{16}"\n/);
|
|
rmSync(legacySyncRoot, { force: true, recursive: true });
|
|
// One diagnostic oracle for the sync verbs: zero check, zero import, and
|
|
// zero patch revalidation accept the same code (Span<T> helpers through
|
|
// std.mem.prefix, integer-literal returns in plain helpers, and ref<shape>
|
|
// parameters), revalidation reports every introduced diagnostic in one
|
|
// shot, and pre-existing diagnostics print as notes instead of walls.
|
|
const oracleAlignRoot = join("/tmp", `zero-oracle-align-${process.pid}`);
|
|
rmSync(oracleAlignRoot, { force: true, recursive: true });
|
|
mkdirSync(join(oracleAlignRoot, "src"), { recursive: true });
|
|
writeFileSync(join(oracleAlignRoot, "zero.toml"), '[package]\nname = "oracle-align"\nversion = "0.1.0"\n\n[targets.cli]\nkind = "exe"\nmain = "src/main.0"\n');
|
|
const oracleAlignSource = [
|
|
"pub type Pair {",
|
|
" left: u64,",
|
|
" right: u64,",
|
|
"}",
|
|
"",
|
|
"fn headBytes(bytes: Span<u8>, len: usize) -> Span<u8> {",
|
|
" return std.mem.prefix(bytes, len)",
|
|
"}",
|
|
"",
|
|
"fn limit() -> usize {",
|
|
" return 5",
|
|
"}",
|
|
"",
|
|
"pub fn pairLeft(p: ref<Pair>) -> u64 {",
|
|
" return p.left",
|
|
"}",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
' let text: String = "alignment"',
|
|
" let head: Span<u8> = headBytes(text, limit())",
|
|
" if std.mem.len(head) == 5 {",
|
|
' check world.out.write("aligned\\n")',
|
|
" }",
|
|
"}",
|
|
"",
|
|
].join("\n");
|
|
writeFileSync(join(oracleAlignRoot, "src", "main.0"), oracleAlignSource);
|
|
assert.equal(json(["import", "--json", oracleAlignRoot]).body.ok, true);
|
|
assert.equal(zero(["check", oracleAlignRoot]).stdout, "ok\n");
|
|
assert.equal(zero(["run", oracleAlignRoot]).stdout, "aligned\n");
|
|
const oracleAlignPatch = json(["patch", "--json", oracleAlignRoot, "--op", 'addLetLiteral fn="main" name="probe" type="u32" value="1"']);
|
|
assert.equal(oracleAlignPatch.body.ok, true);
|
|
// a deliberate bad payload still fails with the diagnostic list and leaves
|
|
// the store untouched
|
|
const oracleHashBefore = json(["status", "--json", oracleAlignRoot]).body.store.graphHash;
|
|
const oracleBadPatch = json(["patch", "--json", oracleAlignRoot, "--op", 'addReturnValue fn="limit" value="no_such_binding" type="usize"'], { allowFailure: true });
|
|
assert.notEqual(oracleBadPatch.code, 0);
|
|
assert.equal(oracleBadPatch.body.ok, false);
|
|
assert.equal(oracleBadPatch.body.diagnostics[0].code, "NAM003");
|
|
assert.equal(json(["status", "--json", oracleAlignRoot]).body.store.graphHash, oracleHashBefore);
|
|
// an import that introduces two diagnostics reports both in one shot
|
|
assert.equal(json(["export", "--json", oracleAlignRoot]).body.ok, true);
|
|
writeFileSync(join(oracleAlignRoot, "src", "main.0"), oracleAlignSource.replace(' if std.mem.len(head) == 5 {', " check world.out.write(missing_one)\n check world.out.write(missing_two)\n if std.mem.len(head) == 5 {"));
|
|
const oracleMultiImport = json(["import", "--json", oracleAlignRoot], { allowFailure: true });
|
|
assert.notEqual(oracleMultiImport.code, 0);
|
|
assert.equal(oracleMultiImport.body.diagnostics.length, 2);
|
|
assert.equal(oracleMultiImport.body.diagnostics[0].code, "NAM003");
|
|
assert.equal(oracleMultiImport.body.diagnostics[1].code, "NAM003");
|
|
rmSync(oracleAlignRoot, { force: true, recursive: true });
|
|
// pre-existing diagnostics report as notes, not walls: the TAR002 a
|
|
// capability-less target reports in zero check predates the patch, so a
|
|
// valid op still applies and the note points back at zero check
|
|
const oraclePreRoot = join("/tmp", `zero-oracle-preexisting-${process.pid}`);
|
|
rmSync(oraclePreRoot, { force: true, recursive: true });
|
|
mkdirSync(join(oraclePreRoot, "src"), { recursive: true });
|
|
writeFileSync(join(oraclePreRoot, "zero.toml"), '[package]\nname = "oracle-preexisting"\nversion = "0.1.0"\n\n[targets.cli]\nkind = "exe"\nmain = "src/main.0"\n');
|
|
writeFileSync(join(oraclePreRoot, "src", "main.0"), 'pub fn main(world: World) -> Void raises {\n let a1: Maybe<String> = std.args.get(1)\n if a1.has {\n check world.out.write(a1.value)\n }\n check world.out.write("done\\n")\n}\n');
|
|
assert.equal(json(["import", "--json", oraclePreRoot]).body.ok, true);
|
|
// win32-x64.exe is a direct-backend cross target on every CI host, so the
|
|
// Args-capability gap is host-independent (linux-x64 resolves to the hosted
|
|
// backend on linux runners and reports nothing).
|
|
const oraclePreCheck = json(["check", "--json", "--target", "win32-x64.exe", oraclePreRoot], { allowFailure: true });
|
|
assert.notEqual(oraclePreCheck.code, 0);
|
|
assert.equal(oraclePreCheck.body.diagnostics[0].code, "TAR002");
|
|
const oraclePrePatch = zeroWithStderr(["patch", "--target", "win32-x64.exe", oraclePreRoot, "--op", 'addLetLiteral fn="main" name="probe" type="u32" value="1"']);
|
|
assert.equal(oraclePrePatch.code, 0);
|
|
assert.match(oraclePrePatch.stdout, /program graph patch ok/);
|
|
assert.match(oraclePrePatch.stderr, /pre-existing diagnostic predates this patch and did not block it/);
|
|
assert.match(oraclePrePatch.stderr, /TAR002: target does not provide required Args capability/);
|
|
// the pre-existing note is once-per-state as well: the next patch against the
|
|
// same unchanged diagnostic set stays quiet
|
|
const oraclePrePatchRepeat = zeroWithStderr(["patch", "--target", "win32-x64.exe", oraclePreRoot, "--op", 'addLetLiteral fn="main" name="probe2" type="u32" value="2"']);
|
|
assert.equal(oraclePrePatchRepeat.code, 0);
|
|
assert.match(oraclePrePatchRepeat.stdout, /program graph patch ok/);
|
|
assert.doesNotMatch(oraclePrePatchRepeat.stderr, /pre-existing diagnostic/, "the pre-existing diagnostics note prints once per diagnostic state");
|
|
rmSync(oraclePreRoot, { force: true, recursive: true });
|
|
// a store whose recorded projection already fails the compiler typecheck
|
|
// (checker drift, stores written by older compilers) does not wall the
|
|
// import of unchanged files: the failure prints as a note and the refresh
|
|
// proceeds, so one pre-existing diagnostic never costs a whack-a-mole round
|
|
const oracleDriftRoot = join("/tmp", `zero-oracle-drift-${process.pid}`);
|
|
rmSync(oracleDriftRoot, { force: true, recursive: true });
|
|
mkdirSync(join(oracleDriftRoot, "src"), { recursive: true });
|
|
writeFileSync(join(oracleDriftRoot, "zero.toml"), '[package]\nname = "oracle-drift"\nversion = "0.1.0"\n\n[targets.cli]\nkind = "exe"\nmain = "src/main.0"\n');
|
|
writeFileSync(join(oracleDriftRoot, "src", "main.0"), 'fn want(v: u32) -> u32 {\n return v\n}\n\npub fn main(world: World) -> Void raises {\n let r: u32 = want(1_u32)\n if r == 1 {\n check world.out.write("drift ok\\n")\n }\n}\n');
|
|
assert.equal(json(["import", "--json", "--format", "text", oracleDriftRoot]).body.ok, true);
|
|
const oracleDriftStorePath = join(oracleDriftRoot, "zero.graph");
|
|
writeFileSync(oracleDriftStorePath, readFileSync(oracleDriftStorePath, "utf8").replace("want(1_u32)", 'want(\\"text\\")'));
|
|
writeFileSync(join(oracleDriftRoot, "src", "main.0"), readFileSync(join(oracleDriftRoot, "src", "main.0"), "utf8").replace("want(1_u32)", 'want("text")'));
|
|
const oracleDriftImport = zeroWithStderr(["import", oracleDriftRoot]);
|
|
assert.equal(oracleDriftImport.code, 0);
|
|
assert.match(oracleDriftImport.stdout, /repository graph import ok/);
|
|
assert.match(oracleDriftImport.stderr, /note: a pre-existing diagnostic predates this import and did not block it \(the file is unchanged since the last sync\)/);
|
|
assert.equal(json(["status", "--json", oracleDriftRoot]).body.repositoryGraph.projectionState, "clean");
|
|
assert.equal(zero(["check", oracleDriftRoot]).stdout, "ok\n");
|
|
rmSync(oracleDriftRoot, { force: true, recursive: true });
|
|
const reconcileScaleRoot = join("/tmp", `zero-reconcile-scale-${process.pid}`);
|
|
const reconcileScaleSource = join(reconcileScaleRoot, "src", "main.0");
|
|
rmSync(reconcileScaleRoot, { force: true, recursive: true });
|
|
assert.equal(json(["init", "--json", reconcileScaleRoot]).body.ok, true);
|
|
mkdirSync(join(reconcileScaleRoot, "src"), { recursive: true });
|
|
const reconcileScaleFunctions: string[] = [];
|
|
for (let i = 0; i < 240; i++) {
|
|
reconcileScaleFunctions.push([
|
|
`fn helper${i}(x: usize) -> usize {`,
|
|
" var a: usize = x",
|
|
...Array.from({ length: 8 }, (_, j) => ` a = a + ${i * 8 + j + 1}_usize`),
|
|
" return a",
|
|
"}",
|
|
].join("\n"));
|
|
}
|
|
const reconcileScaleMain = 'pub fn main(world: World) -> Void raises {\n check world.out.write("reconcile scale\\n")\n}';
|
|
writeFileSync(reconcileScaleSource, `${reconcileScaleFunctions.join("\n\n")}\n\n${reconcileScaleMain}\n`);
|
|
assert.equal(json(["import", "--json", reconcileScaleRoot]).body.ok, true);
|
|
const reconcileScaleNeedle = "fn helper120(x: usize) -> usize {\n var a: usize = x";
|
|
const reconcileScaleText = readFileSync(reconcileScaleSource, "utf8");
|
|
assert(reconcileScaleText.includes(reconcileScaleNeedle));
|
|
writeFileSync(reconcileScaleSource, reconcileScaleText.replace(reconcileScaleNeedle, `${reconcileScaleNeedle}\n var inserted: usize = a + 7001_usize\n inserted = inserted + 7003_usize\n a = a + inserted`));
|
|
const reconcileScaleStarted = Date.now();
|
|
let reconcileScaleStdout = "";
|
|
try {
|
|
reconcileScaleStdout = execFileSync(zeroBin, ["reconcile", "--json", reconcileScaleRoot, "--source", reconcileScaleSource], { encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
|
|
} catch (error) {
|
|
assert(false, `zero reconcile on a multi-statement insertion into a large package did not complete: ${error.signal ?? error.status}`);
|
|
}
|
|
const reconcileScaleElapsed = Date.now() - reconcileScaleStarted;
|
|
assert(reconcileScaleElapsed < 60000, `zero reconcile on a large package took ${reconcileScaleElapsed}ms`);
|
|
if (reconcileScaleStdout) {
|
|
const reconcileScale = JSON.parse(reconcileScaleStdout);
|
|
assert.equal(reconcileScale.ok, true);
|
|
assert.equal(reconcileScale.identity.moduleIdentityChanged, false);
|
|
assert.equal(reconcileScale.identity.ambiguous, 0);
|
|
assert(reconcileScale.identity.inserted > 0);
|
|
assert(reconcileScale.identity.unchanged > 0);
|
|
}
|
|
assert.equal(zero(["run", reconcileScaleRoot]).stdout, "reconcile scale\n");
|
|
assert.equal(json(["status", "--json", reconcileScaleRoot]).body.repositoryGraph.projectionState, "clean");
|
|
const postCheckWriteFailureRoot = join("/tmp", `zero-repo-graph-post-check-write-${process.pid}`);
|
|
const postCheckWriteFailureHelper = join(postCheckWriteFailureRoot, "src", "helper.0");
|
|
rmSync(postCheckWriteFailureRoot, { force: true, recursive: true });
|
|
mkdirSync(join(postCheckWriteFailureRoot, "src"), { recursive: true });
|
|
writeFileSync(join(postCheckWriteFailureRoot, "zero.toml"), readFileSync("conformance/packages/test-app/zero.toml", "utf8"));
|
|
writeFileSync(join(postCheckWriteFailureRoot, "src", "main.0"), readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
writeFileSync(postCheckWriteFailureHelper, readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", postCheckWriteFailureRoot]);
|
|
const postCheckWriteFailureOriginalHelper = readFileSync(postCheckWriteFailureHelper, "utf8");
|
|
writeFileSync(postCheckWriteFailureHelper, postCheckWriteFailureOriginalHelper.replace("return value + value", "return value + value + 0"));
|
|
writeZeroTomlSync(postCheckWriteFailureRoot, { package: { name: "test-app", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/missing.0" } } });
|
|
const postCheckWriteFailure = json(["export", "--json", postCheckWriteFailureRoot], { allowFailure: true });
|
|
assert.notEqual(postCheckWriteFailure.code, 0);
|
|
assert.equal(postCheckWriteFailure.body.diagnostics[0].code, "RGP006");
|
|
assert.equal(postCheckWriteFailure.body.writes, true);
|
|
assert.deepEqual(postCheckWriteFailure.body.changedPaths, [postCheckWriteFailureHelper]);
|
|
assert.equal(readFileSync(postCheckWriteFailureHelper, "utf8"), postCheckWriteFailureOriginalHelper);
|
|
const targetProjectionRoot = join("/tmp", `zero-repo-graph-target-projection-${process.pid}`);
|
|
const targetProjectionSource = join(targetProjectionRoot, "main.0");
|
|
rmSync(targetProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(targetProjectionRoot, { recursive: true });
|
|
writeFileSync(targetProjectionSource, readFileSync("conformance/native/pass/meta-typed-target-type.0", "utf8"));
|
|
const targetProjectionSync = json(["import", "--format", "text", "--json", "--target", "linux-musl-x64", targetProjectionSource]);
|
|
assert.equal(targetProjectionSync.code, 0);
|
|
assert.equal(targetProjectionSync.body.repositoryGraph.projectionState, "clean");
|
|
const targetProjectionStatus = json(["status", "--json", "--target", "linux-musl-x64", targetProjectionSource]);
|
|
assert.equal(targetProjectionStatus.code, 0);
|
|
assert.equal(targetProjectionStatus.body.repositoryGraph.projectionState, "clean");
|
|
const targetProjectionVerify = json(["verify-projection", "--json", "--target", "linux-musl-x64", targetProjectionSource]);
|
|
assert.equal(targetProjectionVerify.code, 0);
|
|
assert.equal(targetProjectionVerify.body.ok, true);
|
|
const targetProjectionVerifyScript = repositoryGraphVerifyScript(targetProjectionRoot, { target: "linux-musl-x64" });
|
|
assert.equal(targetProjectionVerifyScript.code, 0);
|
|
assert.match(targetProjectionVerifyScript.stdout, /repository graph verify-projection ok \(1 store\)/);
|
|
const targetProjectionExport = json(["export", "--json", "--target", "linux-musl-x64", targetProjectionSource]);
|
|
assert.equal(targetProjectionExport.code, 0);
|
|
assert.equal(targetProjectionExport.body.repositoryGraph.projectionState, "clean");
|
|
assert.deepEqual(targetProjectionExport.body.changedPaths, []);
|
|
const typeInvalidRepoGraphRoot = join("/tmp", `zero-repo-graph-type-invalid-${process.pid}`);
|
|
const typeInvalidRepoGraphSource = join(typeInvalidRepoGraphRoot, "main.0");
|
|
const typeInvalidRepoGraphStore = join(typeInvalidRepoGraphRoot, "zero.graph");
|
|
rmSync(typeInvalidRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(typeInvalidRepoGraphRoot, { recursive: true });
|
|
writeFileSync(typeInvalidRepoGraphSource, "pub fn main() -> i32 {\n return true\n}\n");
|
|
const typeInvalidRepoGraphSync = json(["import", "--format", "text", "--json", typeInvalidRepoGraphSource], { allowFailure: true });
|
|
assert.notEqual(typeInvalidRepoGraphSync.code, 0);
|
|
assert.equal(typeInvalidRepoGraphSync.body.diagnostics[0].code, "TYP003");
|
|
assert(!existsSync(typeInvalidRepoGraphStore));
|
|
const stdProjectionRoot = join("/tmp", `zero-repo-graph-std-projection-${process.pid}`);
|
|
const stdProjectionSource = join(stdProjectionRoot, "std-path-io.0");
|
|
const stdProjectionStore = join(stdProjectionRoot, "zero.graph");
|
|
rmSync(stdProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(stdProjectionRoot, { recursive: true });
|
|
writeFileSync(stdProjectionSource, readFileSync("examples/std-path-io.0", "utf8"));
|
|
const stdProjectionSync = json(["import", "--format", "text", "--json", stdProjectionSource]);
|
|
assert.equal(stdProjectionSync.code, 0);
|
|
assert.equal(stdProjectionSync.body.repositoryGraph.projectionState, "clean");
|
|
const stdProjectionStoreText = readFileSync(stdProjectionStore, "utf8");
|
|
assert.match(stdProjectionStoreText, /^source path:"std-path-io\.0"$/m);
|
|
assert.doesNotMatch(stdProjectionStoreText, /^source path:"std\//m);
|
|
assert.match(stdProjectionStoreText, /^projection path:"std-path-io\.0" text:/m);
|
|
assert.doesNotMatch(stdProjectionStoreText, /^projection path:"std\//m);
|
|
const stdProjectionVerify = json(["verify-projection", "--json", stdProjectionSource]);
|
|
assert.equal(stdProjectionVerify.body.ok, true);
|
|
const embeddedStdMainRoot = join("/tmp", `zero-repo-graph-embedded-std-main-${process.pid}`);
|
|
const embeddedStdMainStore = join(embeddedStdMainRoot, "zero.graph");
|
|
rmSync(embeddedStdMainRoot, { force: true, recursive: true });
|
|
mkdirSync(join(embeddedStdMainRoot, "std"), { recursive: true });
|
|
writeZeroTomlSync(embeddedStdMainRoot, { package: { name: "embedded-std-main", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "std/path.0" } } });
|
|
writeFileSync(join(embeddedStdMainRoot, "std", "path.0"), readFileSync("std/path.0", "utf8"));
|
|
const embeddedStdMainSync = json(["import", "--format", "text", "--json", embeddedStdMainRoot]);
|
|
assert.equal(embeddedStdMainSync.code, 0);
|
|
assert.equal(embeddedStdMainSync.body.ok, true);
|
|
assert.equal(embeddedStdMainSync.body.repositoryGraph.projectionState, "clean");
|
|
const embeddedStdMainStoreText = readFileSync(embeddedStdMainStore, "utf8");
|
|
assert.match(embeddedStdMainStoreText, /^projection path:"std\/path\.0" text:/m);
|
|
const embeddedStdMainVerify = json(["verify-projection", "--json", embeddedStdMainRoot]);
|
|
assert.equal(embeddedStdMainVerify.body.ok, true);
|
|
const embeddedStdRelativeRoot = join("/tmp", `zero-repo-graph-embedded-std-relative-${process.pid}`);
|
|
const embeddedStdRelativeSource = join(embeddedStdRelativeRoot, "std", "path.0");
|
|
rmSync(embeddedStdRelativeRoot, { force: true, recursive: true });
|
|
mkdirSync(join(embeddedStdRelativeRoot, "std"), { recursive: true });
|
|
writeFileSync(embeddedStdRelativeSource, readFileSync("std/path.0", "utf8"));
|
|
writeFileSync(join(embeddedStdRelativeRoot, "std", "str.0"), readFileSync("std/str.0", "utf8"));
|
|
const embeddedStdRelativeSync = json(["import", "--format", "text", "--json", embeddedStdRelativeSource]);
|
|
assert.equal(embeddedStdRelativeSync.code, 0);
|
|
assert.equal(embeddedStdRelativeSync.body.repositoryGraph.projectionState, "clean");
|
|
const embeddedStdRelativeVerify = json(["verify-projection", "--json", embeddedStdRelativeSource]);
|
|
assert.equal(embeddedStdRelativeVerify.body.ok, true);
|
|
writeFileSync(stdProjectionStore, refreshRepositoryGraphCompilerMetadata(stdProjectionStoreText.replace(/^nodeHash /m, `projection path:"std/path.0" text:${JSON.stringify("// embedded std projection should be rejected\\n")}\nnodeHash `)));
|
|
const embeddedStdProjectionStatus = json(["status", "--json", stdProjectionSource], { allowFailure: true });
|
|
assert.notEqual(embeddedStdProjectionStatus.code, 0);
|
|
assert.equal(embeddedStdProjectionStatus.body.diagnostics[0].code, "RGP003");
|
|
assert.match(embeddedStdProjectionStatus.body.diagnostics[0].actual, /unknown source path/);
|
|
const partialProjectionRoot = join("/tmp", `zero-repo-graph-partial-projection-${process.pid}`);
|
|
const partialProjectionStore = join(partialProjectionRoot, "zero.graph");
|
|
rmSync(partialProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(join(partialProjectionRoot, "src"), { recursive: true });
|
|
writeFileSync(join(partialProjectionRoot, "zero.toml"), readFileSync("conformance/packages/test-app/zero.toml", "utf8"));
|
|
writeFileSync(join(partialProjectionRoot, "src", "main.0"), readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
writeFileSync(join(partialProjectionRoot, "src", "helper.0"), readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", partialProjectionRoot]);
|
|
const partialProjectionStoreText = readFileSync(partialProjectionStore, "utf8");
|
|
assert.match(partialProjectionStoreText, /^source path:"src\/helper\.0"$/m);
|
|
assert.match(partialProjectionStoreText, /^projection path:"src\/helper\.0" text:/m);
|
|
const swappedProjectionStoreText = partialProjectionStoreText.replace(
|
|
/^(projection path:"src\/helper\.0" text:[^\n]*\n)(projection path:"src\/main\.0" text:[^\n]*\n)/m,
|
|
"$2$1",
|
|
);
|
|
writeFileSync(partialProjectionStore, swappedProjectionStoreText);
|
|
const swappedProjectionStatus = json(["status", "--json", partialProjectionRoot], { allowFailure: true });
|
|
assert.notEqual(swappedProjectionStatus.code, 0);
|
|
assert.equal(swappedProjectionStatus.body.diagnostics[0].code, "RGP003");
|
|
assert.match(swappedProjectionStatus.body.diagnostics[0].actual, /byte-stable/);
|
|
writeFileSync(partialProjectionStore, partialProjectionStoreText);
|
|
writeFileSync(partialProjectionStore, refreshRepositoryGraphCompilerMetadata(partialProjectionStoreText.replace(/^projection path:"src\/helper\.0" text:[^\n]*\n/m, "")));
|
|
const partialProjectionStatus = json(["status", "--json", partialProjectionRoot], { allowFailure: true });
|
|
assert.notEqual(partialProjectionStatus.code, 0);
|
|
assert.equal(partialProjectionStatus.body.diagnostics[0].code, "RGP003");
|
|
assert.match(partialProjectionStatus.body.diagnostics[0].actual, /projection table is missing a source path/);
|
|
const partialProjectionWriteRoot = join("/tmp", `zero-repo-graph-partial-write-${process.pid}`);
|
|
const partialProjectionWriteMain = join(partialProjectionWriteRoot, "src", "main.0");
|
|
const partialProjectionWriteHelper = join(partialProjectionWriteRoot, "src", "helper.0");
|
|
rmSync(partialProjectionWriteRoot, { force: true, recursive: true });
|
|
mkdirSync(join(partialProjectionWriteRoot, "src"), { recursive: true });
|
|
writeFileSync(join(partialProjectionWriteRoot, "zero.toml"), readFileSync("conformance/packages/test-app/zero.toml", "utf8"));
|
|
writeFileSync(partialProjectionWriteMain, readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
writeFileSync(partialProjectionWriteHelper, readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", partialProjectionWriteRoot]);
|
|
const partialProjectionOriginalHelper = readFileSync(partialProjectionWriteHelper, "utf8");
|
|
const partialProjectionDriftedHelper = partialProjectionOriginalHelper.replace("return value + value", "return value + value + 0");
|
|
writeFileSync(partialProjectionWriteHelper, partialProjectionDriftedHelper);
|
|
writeFileSync(partialProjectionWriteMain, readFileSync(partialProjectionWriteMain, "utf8").replace("package tests", "package tests drift"));
|
|
rmSync(partialProjectionWriteMain, { force: true });
|
|
mkdirSync(partialProjectionWriteMain);
|
|
const partialProjectionWriteFailure = json(["export", "--json", partialProjectionWriteRoot], { allowFailure: true });
|
|
assert.notEqual(partialProjectionWriteFailure.code, 0);
|
|
assert.equal(partialProjectionWriteFailure.body.diagnostics[0].code, "RGP004");
|
|
assert.equal(partialProjectionWriteFailure.body.writes, false);
|
|
assert.equal(readFileSync(partialProjectionWriteHelper, "utf8"), partialProjectionDriftedHelper);
|
|
const unsafeProjectionRoot = join("/tmp", `zero-repo-graph-unsafe-projection-${process.pid}`);
|
|
const unsafeProjectionSource = join(unsafeProjectionRoot, "outside.0");
|
|
const unsafeProjectionArtifact = join(unsafeProjectionRoot, "outside.program-graph");
|
|
const unsafeProjectionStoreRoot = join(unsafeProjectionRoot, "repo");
|
|
const unsafeProjectionStore = join(unsafeProjectionStoreRoot, "zero.graph");
|
|
const unsafeProjectionText = "// should not be written outside the repository graph root\n";
|
|
rmSync(unsafeProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(unsafeProjectionStoreRoot, { recursive: true });
|
|
writeFileSync(unsafeProjectionSource, readFileSync("examples/hello.0", "utf8"));
|
|
assert.equal(zero(["import", "--out", unsafeProjectionArtifact, unsafeProjectionSource]).stdout, "");
|
|
const unsafeProjectionGraph = zero(["dump", unsafeProjectionArtifact]).stdout;
|
|
const unsafeProjectionGraphJson = json(["dump", "--json", unsafeProjectionArtifact]).body;
|
|
const unsafeProjectionQuote = JSON.stringify;
|
|
const unsafeProjectionStoreLines = [
|
|
"zero-repository-graph v1",
|
|
`sourceProjection ${unsafeProjectionQuote(".0")}`,
|
|
`moduleIdentity ${unsafeProjectionQuote(unsafeProjectionGraphJson.moduleIdentity)}`,
|
|
`graphHash ${unsafeProjectionQuote(unsafeProjectionGraphJson.graphHash)}`,
|
|
`moduleHash ${unsafeProjectionQuote(unsafeProjectionGraphJson.graphHash)}`,
|
|
`source path:${unsafeProjectionQuote(unsafeProjectionSource)}`,
|
|
`projection path:${unsafeProjectionQuote(unsafeProjectionSource)} text:${unsafeProjectionQuote(unsafeProjectionText)}`,
|
|
...unsafeProjectionGraphJson.nodes.map((node) => `nodeHash node:${unsafeProjectionQuote(node.id)} hash:${unsafeProjectionQuote(node.nodeHash)}`),
|
|
];
|
|
writeFileSync(unsafeProjectionStore, `${unsafeProjectionStoreLines.join("\n")}\n\ngraph\n${unsafeProjectionGraph}`);
|
|
const unsafeProjectionStatus = json(["status", "--json", unsafeProjectionStoreRoot], { allowFailure: true });
|
|
assert.notEqual(unsafeProjectionStatus.code, 0);
|
|
assert.equal(unsafeProjectionStatus.body.diagnostics[0].code, "RGP003");
|
|
assert.match(unsafeProjectionStatus.body.diagnostics[0].actual, /invalid repository graph store/);
|
|
const unsafeProjectionSync = json(["export", "--json", unsafeProjectionStoreRoot], { allowFailure: true });
|
|
assert.notEqual(unsafeProjectionSync.code, 0);
|
|
assert.notEqual(readFileSync(unsafeProjectionSource, "utf8"), unsafeProjectionText);
|
|
if (process.platform !== "win32") {
|
|
const symlinkProjectionParent = join("/tmp", `zero-repo-graph-symlink-projection-${process.pid}`);
|
|
const symlinkProjectionRoot = join(symlinkProjectionParent, "repo");
|
|
const symlinkProjectionOutside = join(symlinkProjectionParent, "outside");
|
|
const symlinkProjectionRootSourceDir = join(symlinkProjectionRoot, "src");
|
|
const symlinkProjectionRootSource = join(symlinkProjectionRootSourceDir, "main.0");
|
|
const symlinkProjectionOutsideSource = join(symlinkProjectionOutside, "main.0");
|
|
rmSync(symlinkProjectionParent, { force: true, recursive: true });
|
|
mkdirSync(symlinkProjectionRoot, { recursive: true });
|
|
mkdirSync(symlinkProjectionRootSourceDir, { recursive: true });
|
|
mkdirSync(symlinkProjectionOutside, { recursive: true });
|
|
writeZeroTomlSync(symlinkProjectionRoot, { package: { name: "symlink-projection", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } });
|
|
writeFileSync(symlinkProjectionRootSource, readFileSync("examples/hello.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", symlinkProjectionRoot]);
|
|
rmSync(symlinkProjectionRootSourceDir, { force: true, recursive: true });
|
|
symlinkSync(symlinkProjectionOutside, symlinkProjectionRootSourceDir, "dir");
|
|
writeFileSync(symlinkProjectionOutsideSource, readFileSync("examples/hello.0", "utf8"));
|
|
const symlinkProjectionDriftedSource = readFileSync(symlinkProjectionOutsideSource, "utf8").replace("hello from zero", "changed outside projection root");
|
|
writeFileSync(symlinkProjectionOutsideSource, symlinkProjectionDriftedSource);
|
|
const symlinkProjectionSync = json(["export", "--json", symlinkProjectionRoot], { allowFailure: true });
|
|
assert.notEqual(symlinkProjectionSync.code, 0);
|
|
assert.equal(symlinkProjectionSync.body.diagnostics[0].code, "RGP004");
|
|
assert.equal(symlinkProjectionSync.body.writes, false);
|
|
assert.equal(readFileSync(symlinkProjectionOutsideSource, "utf8"), symlinkProjectionDriftedSource);
|
|
}
|
|
const repoGraphArtifactInputRoot = join("/tmp", `zero-repo-graph-artifact-input-${process.pid}`);
|
|
const repoGraphArtifactInputPath = join(repoGraphArtifactInputRoot, "hello.program-graph");
|
|
rmSync(repoGraphArtifactInputRoot, { force: true, recursive: true });
|
|
mkdirSync(repoGraphArtifactInputRoot, { recursive: true });
|
|
zero(["dump", "--out", repoGraphArtifactInputPath, "examples/hello.0"]);
|
|
const repoGraphStatusArtifactNoStore = json(["status", "--json", repoGraphArtifactInputPath], { allowFailure: true });
|
|
assert.notEqual(repoGraphStatusArtifactNoStore.code, 0);
|
|
assert.equal(repoGraphStatusArtifactNoStore.body.diagnostics[0].message, "expected Zero source file or package");
|
|
const repoGraphVerifyArtifactNoStore = json(["verify-projection", "--json", repoGraphArtifactInputPath], { allowFailure: true });
|
|
assert.notEqual(repoGraphVerifyArtifactNoStore.code, 0);
|
|
assert.equal(repoGraphVerifyArtifactNoStore.body.diagnostics[0].message, "expected Zero source file or package");
|
|
assert(!existsSync(join(repoGraphArtifactInputRoot, "zero.graph")));
|
|
const repoGraphSyncFromArtifact = json(["import", "--format", "text", "--json", repoGraphArtifactInputPath], { allowFailure: true });
|
|
assert.notEqual(repoGraphSyncFromArtifact.code, 0);
|
|
assert.equal(repoGraphSyncFromArtifact.body.diagnostics[0].message, "expected Zero source file or package");
|
|
assert(!existsSync(join(repoGraphArtifactInputRoot, "zero.graph")));
|
|
writeFileSync(join(repoGraphArtifactInputRoot, "zero.graph"), readFileSync(standaloneRepoGraphStore));
|
|
const repoGraphVerifyArtifactWithStore = json(["verify-projection", "--json", repoGraphArtifactInputPath], { allowFailure: true });
|
|
assert.notEqual(repoGraphVerifyArtifactWithStore.code, 0);
|
|
assert.equal(repoGraphVerifyArtifactWithStore.body.diagnostics[0].message, "expected Zero source file or package");
|
|
const copiedRepoGraphRootA = join("/tmp", `zero-repo-graph-copied-a-${process.pid}`);
|
|
const copiedRepoGraphRootB = join("/tmp", `zero-repo-graph-copied-b-${process.pid}`);
|
|
rmSync(copiedRepoGraphRootA, { force: true, recursive: true });
|
|
rmSync(copiedRepoGraphRootB, { force: true, recursive: true });
|
|
mkdirSync(copiedRepoGraphRootA, { recursive: true });
|
|
mkdirSync(copiedRepoGraphRootB, { recursive: true });
|
|
const copiedRepoGraphSourceText = `pub fn main(world: World) -> Void raises {
|
|
let total: i32 = 41 + 1
|
|
if total == 42 {
|
|
check world.out.write("copied graph source ok\\n")
|
|
}
|
|
}
|
|
`;
|
|
writeFileSync(join(copiedRepoGraphRootA, "main.0"), copiedRepoGraphSourceText);
|
|
writeFileSync(join(copiedRepoGraphRootB, "main.0"), copiedRepoGraphSourceText);
|
|
const copiedRepoGraphSourceA = join(copiedRepoGraphRootA, "main.0");
|
|
const copiedRepoGraphSourceB = join(copiedRepoGraphRootB, "main.0");
|
|
json(["import", "--format", "text", "--json", copiedRepoGraphSourceA]);
|
|
writeFileSync(join(copiedRepoGraphRootB, "zero.graph"), readFileSync(join(copiedRepoGraphRootA, "zero.graph")));
|
|
const copiedRepoGraphVerify = json(["verify-projection", "--json", copiedRepoGraphSourceB]);
|
|
assert.equal(copiedRepoGraphVerify.code, 0);
|
|
assert.equal(copiedRepoGraphVerify.body.ok, true);
|
|
writeFileSync(copiedRepoGraphSourceB, readFileSync(copiedRepoGraphSourceB, "utf8").replace("copied graph source ok", "checker copied graph store"));
|
|
const copiedRepoGraphVerifyDrift = json(["verify-projection", "--json", copiedRepoGraphSourceB], { allowFailure: true });
|
|
assert.notEqual(copiedRepoGraphVerifyDrift.code, 0);
|
|
assert.equal(copiedRepoGraphVerifyDrift.body.diagnostics[0].code, "RGP006");
|
|
const identityRepoGraphRoot = join("/tmp", `zero-repo-graph-identity-${process.pid}`);
|
|
const identityRepoGraphSource = join(identityRepoGraphRoot, "main.0");
|
|
const identityRepoGraphStore = join(identityRepoGraphRoot, "zero.graph");
|
|
rmSync(identityRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(identityRepoGraphRoot, { recursive: true });
|
|
writeFileSync(
|
|
identityRepoGraphSource,
|
|
`use std.mem
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
let text: String = "zero"
|
|
if std.mem.len(text) == 4 {
|
|
check world.out.write("identity ok\\n")
|
|
}
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", identityRepoGraphSource]);
|
|
const identityRepoGraphStoreText = readFileSync(identityRepoGraphStore, "utf8");
|
|
const identityRepoGraphMainId = identityRepoGraphStoreText.match(/^node (#[^ ]+) Function name:"main"/m)?.[1];
|
|
const identityRepoGraphMemImportId = identityRepoGraphStoreText.match(/^node (#[^ ]+) Import name:"std\.mem"/m)?.[1];
|
|
const identityRepoGraphLiteralId = identityRepoGraphStoreText.match(/^node (#[^ ]+) Literal [^\n]*value:"identity ok\\n"/m)?.[1];
|
|
assert(identityRepoGraphMainId);
|
|
assert(identityRepoGraphMemImportId);
|
|
assert(identityRepoGraphLiteralId);
|
|
writeFileSync(
|
|
identityRepoGraphSource,
|
|
`// human source edit
|
|
use std.str
|
|
use std.mem
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
let label: String = "zero"
|
|
let count: usize = std.mem.len(label)
|
|
if count == 4 {
|
|
// projection comment
|
|
check world.out.write("identity updated\\n")
|
|
}
|
|
}
|
|
`,
|
|
);
|
|
const identityRepoGraphSyncEdited = json(["import", "--format", "text", "--json", identityRepoGraphSource]);
|
|
assert.equal(identityRepoGraphSyncEdited.code, 0);
|
|
assert.equal(identityRepoGraphSyncEdited.body.repositoryGraph.projectionState, "clean");
|
|
const identityRepoGraphEditedStoreText = readFileSync(identityRepoGraphStore, "utf8");
|
|
assert(identityRepoGraphEditedStoreText.includes(`node ${identityRepoGraphMainId} Function name:"main"`));
|
|
assert(identityRepoGraphEditedStoreText.includes(`node ${identityRepoGraphMemImportId} Import name:"std.mem"`));
|
|
assert(identityRepoGraphEditedStoreText.includes(`node ${identityRepoGraphLiteralId} Literal type:"String" value:"identity updated\\n"`));
|
|
assert.match(identityRepoGraphEditedStoreText, /^node #[^ ]+ Import name:"std\.str"/m);
|
|
assert.match(identityRepoGraphEditedStoreText, /^projection path:"main\.0" text:"\/\/ human source edit\\n/m);
|
|
assert(identityRepoGraphEditedStoreText.includes("// projection comment"));
|
|
const identityRepoGraphSourceAfterSync = readFileSync(identityRepoGraphSource, "utf8");
|
|
const identityRepoGraphSyncProjection = json(["export", "--json", identityRepoGraphSource]);
|
|
assert.equal(identityRepoGraphSyncProjection.code, 0);
|
|
assert.deepEqual(identityRepoGraphSyncProjection.body.changedPaths, []);
|
|
assert.equal(readFileSync(identityRepoGraphSource, "utf8"), identityRepoGraphSourceAfterSync);
|
|
const deleteRepoGraphRoot = join("/tmp", `zero-repo-graph-delete-${process.pid}`);
|
|
const deleteRepoGraphSource = join(deleteRepoGraphRoot, "main.0");
|
|
const deleteRepoGraphStore = join(deleteRepoGraphRoot, "zero.graph");
|
|
rmSync(deleteRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(deleteRepoGraphRoot, { recursive: true });
|
|
const deleteRepoGraphOriginal = `fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
fn beta() -> i32 {
|
|
return 2
|
|
}
|
|
|
|
fn gamma() -> i32 {
|
|
return 3
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("delete ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(deleteRepoGraphSource, deleteRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", deleteRepoGraphSource]);
|
|
const deleteRepoGraphStoreBefore = readFileSync(deleteRepoGraphStore, "utf8");
|
|
const deleteRepoGraphAlphaId = deleteRepoGraphStoreBefore.match(/^node (#[^ ]+) Function name:"alpha"/m)?.[1];
|
|
const deleteRepoGraphBetaId = deleteRepoGraphStoreBefore.match(/^node (#[^ ]+) Function name:"beta"/m)?.[1];
|
|
const deleteRepoGraphGammaId = deleteRepoGraphStoreBefore.match(/^node (#[^ ]+) Function name:"gamma"/m)?.[1];
|
|
assert(deleteRepoGraphAlphaId);
|
|
assert(deleteRepoGraphBetaId);
|
|
assert(deleteRepoGraphGammaId);
|
|
writeFileSync(
|
|
deleteRepoGraphSource,
|
|
deleteRepoGraphOriginal.replace(
|
|
`\nfn beta() -> i32 {
|
|
return 2
|
|
}
|
|
`,
|
|
"",
|
|
),
|
|
);
|
|
const deleteRepoGraphSync = json(["import", "--format", "text", "--json", deleteRepoGraphSource]);
|
|
assert.equal(deleteRepoGraphSync.code, 0);
|
|
assert.equal(deleteRepoGraphSync.body.repositoryGraph.projectionState, "clean");
|
|
const deleteRepoGraphStoreAfter = readFileSync(deleteRepoGraphStore, "utf8");
|
|
assert(deleteRepoGraphStoreAfter.includes(`node ${deleteRepoGraphAlphaId} Function name:"alpha"`));
|
|
assert(deleteRepoGraphStoreAfter.includes(`node ${deleteRepoGraphGammaId} Function name:"gamma"`));
|
|
assert(!deleteRepoGraphStoreAfter.includes(`node ${deleteRepoGraphBetaId} Function name:"beta"`));
|
|
const renameRepoGraphRoot = join("/tmp", `zero-repo-graph-rename-${process.pid}`);
|
|
const renameRepoGraphSource = join(renameRepoGraphRoot, "main.0");
|
|
const renameRepoGraphStore = join(renameRepoGraphRoot, "zero.graph");
|
|
rmSync(renameRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(renameRepoGraphRoot, { recursive: true });
|
|
const renameRepoGraphOriginal = `fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
fn beta() -> i32 {
|
|
return 2
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("rename ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(renameRepoGraphSource, renameRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", renameRepoGraphSource]);
|
|
const renameRepoGraphStoreBefore = readFileSync(renameRepoGraphStore, "utf8");
|
|
const renameRepoGraphBetaId = renameRepoGraphStoreBefore.match(/^node (#[^ ]+) Function name:"beta"/m)?.[1];
|
|
assert(renameRepoGraphBetaId);
|
|
writeFileSync(renameRepoGraphSource, renameRepoGraphOriginal.replace("fn beta()", "fn gamma()"));
|
|
const renameRepoGraphSync = json(["import", "--format", "text", "--json", renameRepoGraphSource]);
|
|
assert.equal(renameRepoGraphSync.code, 0);
|
|
assert.equal(renameRepoGraphSync.body.repositoryGraph.projectionState, "clean");
|
|
assert(readFileSync(renameRepoGraphStore, "utf8").includes(`node ${renameRepoGraphBetaId} Function name:"gamma"`));
|
|
const moduleIdentityRepoGraphRoot = join("/tmp", `zero-repo-graph-module-identity-${process.pid}`);
|
|
const moduleIdentityRepoGraphSourceOne = join(moduleIdentityRepoGraphRoot, "one.0");
|
|
const moduleIdentityRepoGraphSourceTwo = join(moduleIdentityRepoGraphRoot, "two.0");
|
|
const moduleIdentityRepoGraphStore = join(moduleIdentityRepoGraphRoot, "zero.graph");
|
|
rmSync(moduleIdentityRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(moduleIdentityRepoGraphRoot, { recursive: true });
|
|
writeFileSync(
|
|
moduleIdentityRepoGraphSourceOne,
|
|
`pub fn main(world: World) -> Void raises {
|
|
check world.out.write("module one\\n")
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", moduleIdentityRepoGraphSourceOne]);
|
|
const moduleIdentityRepoGraphStoreBefore = readFileSync(moduleIdentityRepoGraphStore, "utf8");
|
|
renameSync(moduleIdentityRepoGraphSourceOne, moduleIdentityRepoGraphSourceTwo);
|
|
const moduleIdentityRepoGraphSync = json(["import", "--format", "text", "--json", moduleIdentityRepoGraphSourceTwo], { allowFailure: true });
|
|
assert.notEqual(moduleIdentityRepoGraphSync.code, 0);
|
|
assert.equal(moduleIdentityRepoGraphSync.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(moduleIdentityRepoGraphSync.body.diagnostics[0].message, "repository graph source identity has a different module identity");
|
|
assert.equal(moduleIdentityRepoGraphSync.body.diagnostics[0].expected, "module:one");
|
|
assert.equal(moduleIdentityRepoGraphSync.body.diagnostics[0].actual, "module:two");
|
|
assert.match(moduleIdentityRepoGraphSync.body.diagnostics[0].help, /module rename/);
|
|
assert.equal(readFileSync(moduleIdentityRepoGraphStore, "utf8"), moduleIdentityRepoGraphStoreBefore);
|
|
const ambiguousRepoGraphRoot = join("/tmp", `zero-repo-graph-ambiguous-${process.pid}`);
|
|
const ambiguousRepoGraphSource = join(ambiguousRepoGraphRoot, "main.0");
|
|
const ambiguousRepoGraphStore = join(ambiguousRepoGraphRoot, "zero.graph");
|
|
rmSync(ambiguousRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(ambiguousRepoGraphRoot, { recursive: true });
|
|
writeFileSync(
|
|
ambiguousRepoGraphSource,
|
|
`fn add(a: i32, b: i32) -> i32 {
|
|
return a + b
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
let total: i32 = add(1, 2)
|
|
if total == 3 {
|
|
check world.out.write("ambiguous ok\\n")
|
|
}
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", ambiguousRepoGraphSource]);
|
|
const ambiguousRepoGraphStoreBefore = readFileSync(ambiguousRepoGraphStore, "utf8");
|
|
writeFileSync(ambiguousRepoGraphSource, readFileSync(ambiguousRepoGraphSource, "utf8").replace("add(1, 2)", "add(2, 1)"));
|
|
// The argument swap ties structurally, but it is a single-file edit whose
|
|
// function set still matches by name and signature, so import accepts the
|
|
// rewrite wholesale with regenerated node identities instead of RGP007.
|
|
const ambiguousRepoGraphSync = zeroWithStderr(["import", "--format", "text", "--json", ambiguousRepoGraphSource]);
|
|
assert.equal(ambiguousRepoGraphSync.code, 0);
|
|
assert.match(ambiguousRepoGraphSync.stderr, /note: file-scope rewrite accepted; node identities regenerated for main\.0/);
|
|
assert.equal(JSON.parse(ambiguousRepoGraphSync.stdout).repositoryGraph.projectionState, "clean");
|
|
assert.notEqual(readFileSync(ambiguousRepoGraphStore, "utf8"), ambiguousRepoGraphStoreBefore);
|
|
const rotatedRepoGraphRoot = join("/tmp", `zero-repo-graph-rotated-${process.pid}`);
|
|
const rotatedRepoGraphSource = join(rotatedRepoGraphRoot, "main.0");
|
|
const rotatedRepoGraphStore = join(rotatedRepoGraphRoot, "zero.graph");
|
|
rmSync(rotatedRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(rotatedRepoGraphRoot, { recursive: true });
|
|
writeFileSync(
|
|
rotatedRepoGraphSource,
|
|
`fn sum3(a: i32, b: i32, c: i32) -> i32 {
|
|
return a + b + c
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
let total: i32 = sum3(1, 2, 3)
|
|
if total == 6 {
|
|
check world.out.write("rotated ok\\n")
|
|
}
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", rotatedRepoGraphSource]);
|
|
const rotatedRepoGraphStoreBefore = readFileSync(rotatedRepoGraphStore, "utf8");
|
|
writeFileSync(rotatedRepoGraphSource, readFileSync(rotatedRepoGraphSource, "utf8").replace("sum3(1, 2, 3)", "sum3(2, 3, 1)"));
|
|
// Rotated identical arguments tie structurally; the single-file rewrite is
|
|
// accepted wholesale with regenerated identities instead of RGP007.
|
|
const rotatedRepoGraphSync = zeroWithStderr(["import", "--format", "text", "--json", rotatedRepoGraphSource]);
|
|
assert.equal(rotatedRepoGraphSync.code, 0);
|
|
assert.match(rotatedRepoGraphSync.stderr, /note: file-scope rewrite accepted; node identities regenerated for main\.0/);
|
|
assert.equal(JSON.parse(rotatedRepoGraphSync.stdout).repositoryGraph.projectionState, "clean");
|
|
assert.notEqual(readFileSync(rotatedRepoGraphStore, "utf8"), rotatedRepoGraphStoreBefore);
|
|
const ambiguousSiblingRepoGraphRoot = join("/tmp", `zero-repo-graph-ambiguous-sibling-${process.pid}`);
|
|
const ambiguousSiblingRepoGraphSource = join(ambiguousSiblingRepoGraphRoot, "main.0");
|
|
const ambiguousSiblingRepoGraphStore = join(ambiguousSiblingRepoGraphRoot, "zero.graph");
|
|
rmSync(ambiguousSiblingRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(ambiguousSiblingRepoGraphRoot, { recursive: true });
|
|
const ambiguousSiblingRepoGraphOriginal = `fn helper() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("sibling ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(ambiguousSiblingRepoGraphSource, ambiguousSiblingRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", ambiguousSiblingRepoGraphSource]);
|
|
const ambiguousSiblingRepoGraphStoreBefore = readFileSync(ambiguousSiblingRepoGraphStore, "utf8");
|
|
const ambiguousSiblingRepoGraphHelperId = ambiguousSiblingRepoGraphStoreBefore.match(/^node (#[^ ]+) Function name:"helper"/m)?.[1];
|
|
assert(ambiguousSiblingRepoGraphHelperId);
|
|
writeFileSync(
|
|
ambiguousSiblingRepoGraphSource,
|
|
ambiguousSiblingRepoGraphOriginal.replace(
|
|
"\npub fn main",
|
|
"\nfn appendedHelper() -> i32 {\n return 2\n}\n\npub fn main",
|
|
),
|
|
);
|
|
const ambiguousSiblingRepoGraphSync = json(["import", "--format", "text", "--json", ambiguousSiblingRepoGraphSource], { allowFailure: true });
|
|
assert.equal(ambiguousSiblingRepoGraphSync.code, 0);
|
|
assert.equal(ambiguousSiblingRepoGraphSync.body.repositoryGraph.projectionState, "clean");
|
|
const ambiguousSiblingRepoGraphStoreAfter = readFileSync(ambiguousSiblingRepoGraphStore, "utf8");
|
|
assert(ambiguousSiblingRepoGraphStoreAfter.includes(`node ${ambiguousSiblingRepoGraphHelperId} Function name:"helper"`));
|
|
const ambiguousSiblingRepoGraphAppendedId = ambiguousSiblingRepoGraphStoreAfter.match(/^node (#[^ ]+) Function name:"appendedHelper"/m)?.[1];
|
|
assert(ambiguousSiblingRepoGraphAppendedId);
|
|
assert.notEqual(ambiguousSiblingRepoGraphAppendedId, ambiguousSiblingRepoGraphHelperId);
|
|
const insertRunRepoGraphRoot = join("/tmp", `zero-repo-graph-insert-run-${process.pid}`);
|
|
const insertRunRepoGraphSource = join(insertRunRepoGraphRoot, "main.0");
|
|
const insertRunRepoGraphStore = join(insertRunRepoGraphRoot, "zero.graph");
|
|
rmSync(insertRunRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(insertRunRepoGraphRoot, { recursive: true });
|
|
const insertRunRepoGraphOriginal = `fn fill(out: MutSpan<u8>, n: usize) -> usize {
|
|
var i: usize = 0
|
|
var p: usize = 0
|
|
while i < n {
|
|
p = p + 1_usize
|
|
i = i + 1_usize
|
|
}
|
|
return p
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("insert run ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(insertRunRepoGraphSource, insertRunRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", insertRunRepoGraphSource]);
|
|
const insertRunRepoGraphStoreBefore = readFileSync(insertRunRepoGraphStore, "utf8");
|
|
const insertRunRepoGraphWhileId = insertRunRepoGraphStoreBefore.match(/^node (#[^ ]+) While/m)?.[1];
|
|
const insertRunRepoGraphReturnId = insertRunRepoGraphStoreBefore.match(/^node (#[^ ]+) Return path:"main\.0" line:8/m)?.[1];
|
|
assert(insertRunRepoGraphWhileId);
|
|
assert(insertRunRepoGraphReturnId);
|
|
assert(!insertRunRepoGraphWhileId.includes("-"));
|
|
writeFileSync(
|
|
insertRunRepoGraphSource,
|
|
insertRunRepoGraphOriginal.replace(
|
|
" while i < n {",
|
|
" var padded: usize = 0\n while padded < n {\n padded = padded + 1_usize\n }\n var spill: usize = padded\n while i < n {",
|
|
),
|
|
);
|
|
const insertRunRepoGraphSync = json(["import", "--format", "text", "--json", insertRunRepoGraphSource]);
|
|
assert.equal(insertRunRepoGraphSync.code, 0);
|
|
assert.equal(insertRunRepoGraphSync.body.repositoryGraph.projectionState, "clean");
|
|
const insertRunRepoGraphStoreAfter = readFileSync(insertRunRepoGraphStore, "utf8");
|
|
assert(insertRunRepoGraphStoreAfter.includes(`node ${insertRunRepoGraphWhileId} While`));
|
|
assert(insertRunRepoGraphStoreAfter.includes(`node ${insertRunRepoGraphReturnId} Return`));
|
|
const insertRunRepoGraphWhileIds = [...insertRunRepoGraphStoreAfter.matchAll(/^node (#[^ ]+) While/gm)].map((m) => m[1]);
|
|
assert.equal(insertRunRepoGraphWhileIds.length, 2);
|
|
assert(insertRunRepoGraphWhileIds.includes(insertRunRepoGraphWhileId));
|
|
const ambiguousRunRepoGraphRoot = join("/tmp", `zero-repo-graph-ambiguous-run-${process.pid}`);
|
|
const ambiguousRunRepoGraphSource = join(ambiguousRunRepoGraphRoot, "main.0");
|
|
const ambiguousRunRepoGraphStore = join(ambiguousRunRepoGraphRoot, "zero.graph");
|
|
rmSync(ambiguousRunRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(ambiguousRunRepoGraphRoot, { recursive: true });
|
|
writeFileSync(ambiguousRunRepoGraphSource, insertRunRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", ambiguousRunRepoGraphSource]);
|
|
const ambiguousRunRepoGraphStoreBefore = readFileSync(ambiguousRunRepoGraphStore, "utf8");
|
|
const ambiguousRunRepoGraphWhileId = ambiguousRunRepoGraphStoreBefore.match(/^node (#[^ ]+) While/m)?.[1];
|
|
assert(ambiguousRunRepoGraphWhileId);
|
|
writeFileSync(
|
|
ambiguousRunRepoGraphSource,
|
|
insertRunRepoGraphOriginal.replace(
|
|
" while i < n {",
|
|
" var padded: usize = 0\n while padded < n {\n padded = padded + 1_usize\n }\n while i <= n {",
|
|
),
|
|
);
|
|
// An inserted sibling plus an edit to the original statement used to fail RGP007;
|
|
// import now disambiguates by structural similarity and keeps the original handle
|
|
// on the statement that shares its body.
|
|
const ambiguousRunRepoGraphSync = zeroWithStderr(["import", "--format", "text", "--json", ambiguousRunRepoGraphSource]);
|
|
assert.equal(ambiguousRunRepoGraphSync.code, 0);
|
|
assert.match(ambiguousRunRepoGraphSync.stderr, /note: import matched 1 edited node to existing graph identities by structure/);
|
|
const ambiguousRunRepoGraphStoreAfter = readFileSync(ambiguousRunRepoGraphStore, "utf8");
|
|
const ambiguousRunRepoGraphResolvedLine = ambiguousRunRepoGraphStoreAfter
|
|
.split("\n")
|
|
.find((line) => line.startsWith(`node ${ambiguousRunRepoGraphWhileId} While`));
|
|
assert(ambiguousRunRepoGraphResolvedLine, "original while handle survives the auto-resolved import");
|
|
assert.match(ambiguousRunRepoGraphResolvedLine, /line:8/, "original while handle follows the statement that kept its body");
|
|
// Identical edited candidates at shifted orders stay genuinely ambiguous; the
|
|
// same edit also widens fill's signature, so the file-scope rewrite escape
|
|
// stays closed (function set changed) and the import keeps RGP007.
|
|
const tieRunRepoGraphRoot = join("/tmp", `zero-repo-graph-tie-run-${process.pid}`);
|
|
const tieRunRepoGraphSource = join(tieRunRepoGraphRoot, "main.0");
|
|
const tieRunRepoGraphStore = join(tieRunRepoGraphRoot, "zero.graph");
|
|
rmSync(tieRunRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(tieRunRepoGraphRoot, { recursive: true });
|
|
writeFileSync(tieRunRepoGraphSource, insertRunRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", tieRunRepoGraphSource]);
|
|
const tieRunRepoGraphStoreBefore = readFileSync(tieRunRepoGraphStore, "utf8");
|
|
writeFileSync(
|
|
tieRunRepoGraphSource,
|
|
insertRunRepoGraphOriginal.replace(
|
|
" while i < n {\n p = p + 1_usize\n i = i + 1_usize\n }\n",
|
|
" var shift: usize = 0\n while i <= n {\n p = p + 2_usize\n i = i + 1_usize\n }\n while i <= n {\n p = p + 2_usize\n i = i + 1_usize\n }\n",
|
|
).replace(
|
|
"fn fill(out: MutSpan<u8>, n: usize) -> usize {",
|
|
"fn fill(out: MutSpan<u8>, n: usize, pad: usize) -> usize {",
|
|
),
|
|
);
|
|
const tieRunRepoGraphSync = json(["import", "--format", "text", "--json", tieRunRepoGraphSource], { allowFailure: true });
|
|
assert.notEqual(tieRunRepoGraphSync.code, 0);
|
|
assert.equal(tieRunRepoGraphSync.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(tieRunRepoGraphSync.body.diagnostics[0].message, "repository graph source identity is ambiguous");
|
|
assert.match(tieRunRepoGraphSync.body.diagnostics[0].actual, /matches 2 edited candidates at main\.0:\d+-\d+/);
|
|
assert.match(tieRunRepoGraphSync.body.diagnostics[0].help, /split the text edit: import the change touching main\.0:\d+-\d+ on its own first/);
|
|
assert.equal(readFileSync(tieRunRepoGraphStore, "utf8"), tieRunRepoGraphStoreBefore);
|
|
rmSync(tieRunRepoGraphRoot, { force: true, recursive: true });
|
|
// Whole-file rewrite escape: a single-file rewrite of a multi-function module
|
|
// whose function set still matches by name and signature imports in one pass;
|
|
// the file's node identities are regenerated and other files keep theirs.
|
|
const fileScopeRoot = join(outDir, "repository-graph-file-scope-rewrite");
|
|
const fileScopeStore = join(fileScopeRoot, "zero.graph");
|
|
rmSync(fileScopeRoot, { recursive: true, force: true });
|
|
mkdirSync(join(fileScopeRoot, "src"), { recursive: true });
|
|
writeZeroTomlSync(fileScopeRoot, { package: { name: "file-scope", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } });
|
|
const fileScopeUtilOriginal = [
|
|
"pub fn fill(n: usize) -> usize {",
|
|
" var i: usize = 0",
|
|
" var p: usize = 0",
|
|
" while i < n {",
|
|
" p = p + 1_usize",
|
|
" i = i + 1_usize",
|
|
" }",
|
|
" return p",
|
|
"}",
|
|
"",
|
|
"pub fn cap(n: usize) -> usize {",
|
|
" return n",
|
|
"}",
|
|
"",
|
|
].join("\n");
|
|
const fileScopeUtilRewrite = [
|
|
"pub fn fill(n: usize) -> usize {",
|
|
" var i: usize = 0",
|
|
" var p: usize = 0",
|
|
" var shift: usize = 0",
|
|
" while i <= n {",
|
|
" p = p + 2_usize",
|
|
" i = i + 1_usize",
|
|
" }",
|
|
" while i <= n {",
|
|
" p = p + 2_usize",
|
|
" i = i + 1_usize",
|
|
" }",
|
|
" return p + shift",
|
|
"}",
|
|
"",
|
|
"pub fn cap(n: usize) -> usize {",
|
|
" return n + 0_usize",
|
|
"}",
|
|
"",
|
|
].join("\n");
|
|
const fileScopeMainOriginal = [
|
|
"use util",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
" if fill(2) >= cap(1) {",
|
|
' check world.out.write("file scope ok\\n")',
|
|
" }",
|
|
"}",
|
|
"",
|
|
].join("\n");
|
|
writeFileSync(join(fileScopeRoot, "src", "util.0"), fileScopeUtilOriginal);
|
|
writeFileSync(join(fileScopeRoot, "src", "main.0"), fileScopeMainOriginal);
|
|
assert.equal(json(["import", "--format", "text", "--json", fileScopeRoot]).code, 0);
|
|
assert.equal(zero(["check", fileScopeRoot]).stdout, "ok\n");
|
|
const fileScopeStoreBefore = readFileSync(fileScopeStore, "utf8");
|
|
const fileScopeMainId = fileScopeStoreBefore.match(/^node (#[^ ]+) Function name:"main"/m)?.[1];
|
|
assert(fileScopeMainId, "expected a main Function node in the file-scope store");
|
|
writeFileSync(join(fileScopeRoot, "src", "util.0"), fileScopeUtilRewrite);
|
|
const fileScopeSync = zeroWithStderr(["import", "--format", "text", "--json", fileScopeRoot]);
|
|
assert.equal(fileScopeSync.code, 0);
|
|
assert.match(fileScopeSync.stderr, /note: file-scope rewrite accepted; node identities regenerated for src\/util\.0/);
|
|
assert.equal(JSON.parse(fileScopeSync.stdout).repositoryGraph.projectionState, "clean");
|
|
const fileScopeStoreAfter = readFileSync(fileScopeStore, "utf8");
|
|
assert(fileScopeStoreAfter.includes(`node ${fileScopeMainId} Function name:"main"`), "untouched files keep their node identities");
|
|
assert.equal(zero(["check", fileScopeRoot]).stdout, "ok\n");
|
|
// Handles and queries resolve against the regenerated identities in one pass.
|
|
const fileScopeHandlesView = zero(["view", "--fn", "fill", "--handles", fileScopeRoot]).stdout;
|
|
const fileScopeReturnLine = fileScopeHandlesView.split("\n").find((line) => line.includes("return p + shift"));
|
|
assert(fileScopeReturnLine, "expected the rewritten return row in the handles view");
|
|
const fileScopeHandle = fileScopeReturnLine.match(/\/\/ (#[0-9a-z_.]+)/)?.[1];
|
|
assert(fileScopeHandle, "expected a patch handle on the rewritten return row");
|
|
const fileScopeQueryHandles = json(["query", "--json", "--fn", "fill", "--handles", fileScopeRoot]).body;
|
|
assert.equal(fileScopeQueryHandles.ok, true);
|
|
const fileScopePatch = json(["patch", "--json", fileScopeRoot, "--op", `replaceExpr node="${fileScopeHandle}" with="p + shift + 0_usize"`]).body;
|
|
assert.equal(fileScopePatch.ok, true);
|
|
assert.match(zero(["view", "--fn", "fill", fileScopeRoot]).stdout, /return p \+ shift \+ 0_usize/);
|
|
// Cross-file ambiguity keeps RGP007: the same tie-producing rewrite plus an
|
|
// edit in a second file is not a file-scope rewrite.
|
|
writeFileSync(join(fileScopeRoot, "src", "util.0"), fileScopeUtilOriginal);
|
|
writeFileSync(join(fileScopeRoot, "src", "main.0"), fileScopeMainOriginal);
|
|
assert.equal(json(["import", "--format", "text", "--json", fileScopeRoot]).code, 0);
|
|
const crossFileStoreBefore = readFileSync(fileScopeStore, "utf8");
|
|
writeFileSync(join(fileScopeRoot, "src", "util.0"), fileScopeUtilRewrite);
|
|
writeFileSync(join(fileScopeRoot, "src", "main.0"), fileScopeMainOriginal.replace("file scope ok", "cross file ok"));
|
|
const crossFileSync = json(["import", "--format", "text", "--json", fileScopeRoot], { allowFailure: true });
|
|
assert.notEqual(crossFileSync.code, 0);
|
|
assert.equal(crossFileSync.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(crossFileSync.body.diagnostics[0].message, "repository graph source identity is ambiguous");
|
|
assert.equal(readFileSync(fileScopeStore, "utf8"), crossFileStoreBefore);
|
|
const mergeRepoGraphRoot = join("/tmp", `zero-repo-graph-merge-${process.pid}`);
|
|
const mergeRepoGraphSource = join(mergeRepoGraphRoot, "main.0");
|
|
const mergeRepoGraphStore = join(mergeRepoGraphRoot, "zero.graph");
|
|
rmSync(mergeRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeRepoGraphRoot, { recursive: true });
|
|
const mergeRepoGraphOriginal = `fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
fn beta() -> i32 {
|
|
return 2
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(mergeRepoGraphSource, mergeRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", mergeRepoGraphSource]);
|
|
writeFileSync(join(mergeRepoGraphRoot, "base.graph"), readFileSync(mergeRepoGraphStore, "utf8"));
|
|
writeFileSync(mergeRepoGraphSource, mergeRepoGraphOriginal.replace("return 1", "return 10"));
|
|
json(["import", "--format", "text", "--json", mergeRepoGraphSource]);
|
|
writeFileSync(join(mergeRepoGraphRoot, "left.graph"), readFileSync(mergeRepoGraphStore, "utf8"));
|
|
writeFileSync(mergeRepoGraphStore, readFileSync(join(mergeRepoGraphRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeRepoGraphSource, mergeRepoGraphOriginal.replace("return 2", "return 20"));
|
|
json(["import", "--format", "text", "--json", mergeRepoGraphSource]);
|
|
writeFileSync(join(mergeRepoGraphRoot, "right.graph"), readFileSync(mergeRepoGraphStore, "utf8"));
|
|
const mergeRepoGraphResult = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeRepoGraphRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeRepoGraphRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeRepoGraphRoot, "right.graph"),
|
|
mergeRepoGraphRoot,
|
|
]);
|
|
assert.equal(mergeRepoGraphResult.code, 0);
|
|
assert.equal(mergeRepoGraphResult.body.mode, "merge");
|
|
assert.equal(mergeRepoGraphResult.body.writes, true);
|
|
assert.equal(mergeRepoGraphResult.body.repositoryGraph.projectionState, "source-stale");
|
|
assert.equal(mergeRepoGraphResult.body.merge.conflicts, 0);
|
|
assert.equal(mergeRepoGraphResult.body.merge.leftChanges, 1);
|
|
assert.equal(mergeRepoGraphResult.body.merge.rightChanges, 1);
|
|
assert.equal(mergeRepoGraphResult.body.merge.target, mergeRepoGraphStore);
|
|
assert.deepEqual(mergeRepoGraphResult.body.changedPaths, [mergeRepoGraphStore]);
|
|
const mergeRepoGraphText = readFileSync(mergeRepoGraphStore, "utf8");
|
|
assert(mergeRepoGraphText.includes('value:"10"'));
|
|
assert(mergeRepoGraphText.includes('value:"20"'));
|
|
const mergeRepoGraphSyncProjection = json(["export", "--json", mergeRepoGraphSource]);
|
|
assert.equal(mergeRepoGraphSyncProjection.body.repositoryGraph.projectionState, "clean");
|
|
assert(readFileSync(mergeRepoGraphSource, "utf8").includes("return 10"));
|
|
assert(readFileSync(mergeRepoGraphSource, "utf8").includes("return 20"));
|
|
const mergeStaleProjectionRoot = join("/tmp", `zero-repo-graph-merge-stale-projection-${process.pid}`);
|
|
const mergeStaleProjectionSource = join(mergeStaleProjectionRoot, "main.0");
|
|
const mergeStaleProjectionStore = join(mergeStaleProjectionRoot, "zero.graph");
|
|
rmSync(mergeStaleProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeStaleProjectionRoot, { recursive: true });
|
|
writeFileSync(mergeStaleProjectionSource, mergeRepoGraphOriginal);
|
|
json(["import", "--format", "text", "--json", mergeStaleProjectionSource]);
|
|
writeFileSync(join(mergeStaleProjectionRoot, "base.graph"), readFileSync(mergeStaleProjectionStore, "utf8"));
|
|
writeFileSync(join(mergeStaleProjectionRoot, "right.graph"), readFileSync(mergeStaleProjectionStore, "utf8"));
|
|
writeFileSync(mergeStaleProjectionSource, mergeRepoGraphOriginal.replace("return 1", "return 10"));
|
|
json(["import", "--format", "text", "--json", mergeStaleProjectionSource]);
|
|
writeFileSync(
|
|
join(mergeStaleProjectionRoot, "left.graph"),
|
|
readFileSync(mergeStaleProjectionStore, "utf8").replace("return 10", "return 999"),
|
|
);
|
|
writeFileSync(mergeStaleProjectionStore, readFileSync(join(mergeStaleProjectionRoot, "base.graph"), "utf8"));
|
|
const mergeStaleProjection = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeStaleProjectionRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeStaleProjectionRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeStaleProjectionRoot, "right.graph"),
|
|
mergeStaleProjectionRoot,
|
|
]);
|
|
assert.equal(mergeStaleProjection.code, 0);
|
|
assert.equal(mergeStaleProjection.body.merge.conflicts, 0);
|
|
const mergeStaleProjectionText = readFileSync(mergeStaleProjectionStore, "utf8");
|
|
assert(mergeStaleProjectionText.includes('value:"10"'));
|
|
assert(!mergeStaleProjectionText.includes('value:"999"'));
|
|
const mergeProjectionOnlyConflictRoot = join("/tmp", `zero-repo-graph-merge-projection-only-conflict-${process.pid}`);
|
|
const mergeProjectionOnlyConflictSource = join(mergeProjectionOnlyConflictRoot, "main.0");
|
|
const mergeProjectionOnlyConflictStore = join(mergeProjectionOnlyConflictRoot, "zero.graph");
|
|
rmSync(mergeProjectionOnlyConflictRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeProjectionOnlyConflictRoot, { recursive: true });
|
|
const mergeProjectionOnlyConflictOriginal = `// base comment
|
|
fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge projection-only conflict ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(mergeProjectionOnlyConflictSource, mergeProjectionOnlyConflictOriginal);
|
|
json(["import", "--format", "text", "--json", mergeProjectionOnlyConflictSource]);
|
|
writeFileSync(join(mergeProjectionOnlyConflictRoot, "base.graph"), readFileSync(mergeProjectionOnlyConflictStore, "utf8"));
|
|
writeFileSync(mergeProjectionOnlyConflictSource, mergeProjectionOnlyConflictOriginal.replace("return 1", "return 10"));
|
|
json(["import", "--format", "text", "--json", mergeProjectionOnlyConflictSource]);
|
|
writeFileSync(join(mergeProjectionOnlyConflictRoot, "left.graph"), readFileSync(mergeProjectionOnlyConflictStore, "utf8"));
|
|
writeFileSync(mergeProjectionOnlyConflictStore, readFileSync(join(mergeProjectionOnlyConflictRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeProjectionOnlyConflictSource, mergeProjectionOnlyConflictOriginal.replace("base comment", "right comment"));
|
|
json(["import", "--format", "text", "--json", mergeProjectionOnlyConflictSource]);
|
|
writeFileSync(join(mergeProjectionOnlyConflictRoot, "right.graph"), readFileSync(mergeProjectionOnlyConflictStore, "utf8"));
|
|
writeFileSync(mergeProjectionOnlyConflictStore, readFileSync(join(mergeProjectionOnlyConflictRoot, "base.graph"), "utf8"));
|
|
const mergeProjectionOnlyConflict = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeProjectionOnlyConflictRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeProjectionOnlyConflictRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeProjectionOnlyConflictRoot, "right.graph"),
|
|
mergeProjectionOnlyConflictRoot,
|
|
], { allowFailure: true });
|
|
assert.notEqual(mergeProjectionOnlyConflict.code, 0);
|
|
assert.equal(mergeProjectionOnlyConflict.body.writes, false);
|
|
assert.equal(mergeProjectionOnlyConflict.body.diagnostics[0].code, "RGM005");
|
|
assert.equal(mergeProjectionOnlyConflict.body.diagnostics[0].message, "repository graph projection-only edit conflicts with graph changes");
|
|
assert.equal(mergeProjectionOnlyConflict.body.merge.conflicts, 1);
|
|
const mergeProjectionOnlyConflictText = readFileSync(mergeProjectionOnlyConflictStore, "utf8");
|
|
assert(mergeProjectionOnlyConflictText.includes("base comment"));
|
|
assert(!mergeProjectionOnlyConflictText.includes("right comment"));
|
|
assert(!mergeProjectionOnlyConflictText.includes('value:"10"'));
|
|
const mergeDeleteShiftRoot = join("/tmp", `zero-repo-graph-merge-delete-shift-${process.pid}`);
|
|
const mergeDeleteShiftSource = join(mergeDeleteShiftRoot, "main.0");
|
|
const mergeDeleteShiftStore = join(mergeDeleteShiftRoot, "zero.graph");
|
|
rmSync(mergeDeleteShiftRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeDeleteShiftRoot, { recursive: true });
|
|
const mergeDeleteShiftOriginal = `fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
fn beta() -> i32 {
|
|
return 2
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge delete shift ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(mergeDeleteShiftSource, mergeDeleteShiftOriginal);
|
|
json(["import", "--format", "text", "--json", mergeDeleteShiftSource]);
|
|
writeFileSync(join(mergeDeleteShiftRoot, "base.graph"), readFileSync(mergeDeleteShiftStore, "utf8"));
|
|
writeFileSync(mergeDeleteShiftSource, mergeDeleteShiftOriginal.replace(/fn alpha\(\) -> i32 \{\n return 1\n\}\n\n/, ""));
|
|
json(["import", "--format", "text", "--json", mergeDeleteShiftSource]);
|
|
writeFileSync(join(mergeDeleteShiftRoot, "left.graph"), readFileSync(mergeDeleteShiftStore, "utf8"));
|
|
writeFileSync(mergeDeleteShiftStore, readFileSync(join(mergeDeleteShiftRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeDeleteShiftSource, mergeDeleteShiftOriginal.replace("return 2", "return 20"));
|
|
json(["import", "--format", "text", "--json", mergeDeleteShiftSource]);
|
|
writeFileSync(join(mergeDeleteShiftRoot, "right.graph"), readFileSync(mergeDeleteShiftStore, "utf8"));
|
|
writeFileSync(mergeDeleteShiftStore, readFileSync(join(mergeDeleteShiftRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeDeleteShiftSource, mergeDeleteShiftOriginal);
|
|
const mergeDeleteShift = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeDeleteShiftRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeDeleteShiftRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeDeleteShiftRoot, "right.graph"),
|
|
mergeDeleteShiftRoot,
|
|
]);
|
|
assert.equal(mergeDeleteShift.code, 0);
|
|
assert.equal(mergeDeleteShift.body.merge.conflicts, 0);
|
|
const mergeDeleteShiftText = readFileSync(mergeDeleteShiftStore, "utf8");
|
|
assert(!mergeDeleteShiftText.includes('name:"alpha"'));
|
|
assert(mergeDeleteShiftText.includes('name:"beta"'));
|
|
assert(mergeDeleteShiftText.includes('value:"20"'));
|
|
const mergeDeleteShiftSyncProjection = json(["export", "--json", mergeDeleteShiftSource]);
|
|
assert.equal(mergeDeleteShiftSyncProjection.body.repositoryGraph.projectionState, "clean");
|
|
assert(!readFileSync(mergeDeleteShiftSource, "utf8").includes("fn alpha"));
|
|
assert(readFileSync(mergeDeleteShiftSource, "utf8").includes("return 20"));
|
|
const mergeBothDeleteRoot = join("/tmp", `zero-repo-graph-merge-both-delete-${process.pid}`);
|
|
const mergeBothDeleteSource = join(mergeBothDeleteRoot, "main.0");
|
|
const mergeBothDeleteStore = join(mergeBothDeleteRoot, "zero.graph");
|
|
rmSync(mergeBothDeleteRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeBothDeleteRoot, { recursive: true });
|
|
writeFileSync(mergeBothDeleteSource, mergeDeleteShiftOriginal);
|
|
json(["import", "--format", "text", "--json", mergeBothDeleteSource]);
|
|
writeFileSync(join(mergeBothDeleteRoot, "base.graph"), readFileSync(mergeBothDeleteStore, "utf8"));
|
|
const mergeBothDeleteEdited = mergeDeleteShiftOriginal.replace(/fn alpha\(\) -> i32 \{\n return 1\n\}\n\n/, "");
|
|
writeFileSync(mergeBothDeleteSource, mergeBothDeleteEdited);
|
|
json(["import", "--format", "text", "--json", mergeBothDeleteSource]);
|
|
writeFileSync(join(mergeBothDeleteRoot, "left.graph"), readFileSync(mergeBothDeleteStore, "utf8"));
|
|
writeFileSync(mergeBothDeleteStore, readFileSync(join(mergeBothDeleteRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeBothDeleteSource, mergeBothDeleteEdited);
|
|
json(["import", "--format", "text", "--json", mergeBothDeleteSource]);
|
|
writeFileSync(join(mergeBothDeleteRoot, "right.graph"), readFileSync(mergeBothDeleteStore, "utf8"));
|
|
writeFileSync(mergeBothDeleteStore, readFileSync(join(mergeBothDeleteRoot, "base.graph"), "utf8"));
|
|
const mergeBothDelete = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeBothDeleteRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeBothDeleteRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeBothDeleteRoot, "right.graph"),
|
|
mergeBothDeleteRoot,
|
|
]);
|
|
assert.equal(mergeBothDelete.code, 0);
|
|
assert.equal(mergeBothDelete.body.merge.conflicts, 0);
|
|
const mergeBothDeleteText = readFileSync(mergeBothDeleteStore, "utf8");
|
|
assert(!mergeBothDeleteText.includes('name:"alpha"'));
|
|
assert(mergeBothDeleteText.includes('name:"beta"'));
|
|
const mergeBothDeleteSyncProjection = json(["export", "--json", mergeBothDeleteSource]);
|
|
assert.equal(mergeBothDeleteSyncProjection.body.repositoryGraph.projectionState, "clean");
|
|
assert(!readFileSync(mergeBothDeleteSource, "utf8").includes("fn alpha"));
|
|
const mergeNoopProjectionRoot = join("/tmp", `zero-repo-graph-merge-noop-projection-${process.pid}`);
|
|
const mergeNoopProjectionSource = join(mergeNoopProjectionRoot, "main.0");
|
|
const mergeNoopProjectionStore = join(mergeNoopProjectionRoot, "zero.graph");
|
|
rmSync(mergeNoopProjectionRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeNoopProjectionRoot, { recursive: true });
|
|
writeFileSync(
|
|
mergeNoopProjectionSource,
|
|
`// keep projection comment
|
|
fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge no-op projection ok\\n")
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", mergeNoopProjectionSource]);
|
|
writeFileSync(join(mergeNoopProjectionRoot, "base.graph"), readFileSync(mergeNoopProjectionStore, "utf8"));
|
|
writeFileSync(join(mergeNoopProjectionRoot, "left.graph"), readFileSync(mergeNoopProjectionStore, "utf8"));
|
|
writeFileSync(join(mergeNoopProjectionRoot, "right.graph"), readFileSync(mergeNoopProjectionStore, "utf8"));
|
|
const mergeNoopProjection = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeNoopProjectionRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeNoopProjectionRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeNoopProjectionRoot, "right.graph"),
|
|
mergeNoopProjectionRoot,
|
|
]);
|
|
assert.equal(mergeNoopProjection.code, 0);
|
|
assert.equal(mergeNoopProjection.body.repositoryGraph.projectionState, "clean");
|
|
assert(readFileSync(mergeNoopProjectionStore, "utf8").includes("keep projection comment"));
|
|
const mergeNoopProjectionVerify = json(["verify-projection", "--json", mergeNoopProjectionSource]);
|
|
assert.equal(mergeNoopProjectionVerify.body.ok, true);
|
|
const mergeTargetRoot = join("/tmp", `zero-repo-graph-merge-target-${process.pid}`);
|
|
const mergeTargetSource = join(mergeTargetRoot, "main.0");
|
|
const mergeTargetStore = join(mergeTargetRoot, "zero.graph");
|
|
rmSync(mergeTargetRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeTargetRoot, { recursive: true });
|
|
writeFileSync(mergeTargetSource, readFileSync("conformance/native/pass/meta-typed-target-type.0", "utf8"));
|
|
json(["import", "--format", "text", "--json", "--target", "linux-musl-x64", mergeTargetSource]);
|
|
const mergeTargetBefore = readFileSync(mergeTargetStore, "utf8");
|
|
writeFileSync(join(mergeTargetRoot, "base.graph"), mergeTargetBefore);
|
|
writeFileSync(join(mergeTargetRoot, "left.graph"), mergeTargetBefore);
|
|
writeFileSync(join(mergeTargetRoot, "right.graph"), mergeTargetBefore);
|
|
const mergeTarget = json([
|
|
"merge",
|
|
"--json",
|
|
"--target",
|
|
"linux-musl-x64",
|
|
"--base",
|
|
join(mergeTargetRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeTargetRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeTargetRoot, "right.graph"),
|
|
mergeTargetRoot,
|
|
]);
|
|
assert.equal(mergeTarget.code, 0);
|
|
assert.equal(mergeTarget.body.merge.conflicts, 0);
|
|
assert.equal(readFileSync(mergeTargetStore, "utf8"), mergeTargetBefore);
|
|
const mergeTargetVerify = json(["verify-projection", "--json", "--target", "linux-musl-x64", mergeTargetSource]);
|
|
assert.equal(mergeTargetVerify.body.ok, true);
|
|
const mergePathMoveRoot = join("/tmp", `zero-repo-graph-merge-path-move-${process.pid}`);
|
|
const mergePathMoveSource = join(mergePathMoveRoot, "main.0");
|
|
const mergePathMoveRenamedSource = join(mergePathMoveRoot, "renamed.0");
|
|
const mergePathMoveStore = join(mergePathMoveRoot, "zero.graph");
|
|
rmSync(mergePathMoveRoot, { force: true, recursive: true });
|
|
mkdirSync(mergePathMoveRoot, { recursive: true });
|
|
writeZeroTomlSync(mergePathMoveRoot, { package: { name: "merge-path-move", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "main.0" } } });
|
|
writeFileSync(
|
|
mergePathMoveSource,
|
|
`fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge path move ok\\n")
|
|
}
|
|
`,
|
|
);
|
|
json(["import", "--format", "text", "--json", mergePathMoveRoot]);
|
|
writeFileSync(join(mergePathMoveRoot, "base.graph"), readFileSync(mergePathMoveStore, "utf8"));
|
|
writeFileSync(join(mergePathMoveRoot, "right.graph"), readFileSync(mergePathMoveStore, "utf8"));
|
|
renameSync(mergePathMoveSource, mergePathMoveRenamedSource);
|
|
writeZeroTomlSync(mergePathMoveRoot, { package: { name: "merge-path-move", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "renamed.0" } } });
|
|
json(["import", "--format", "text", "--json", mergePathMoveRoot]);
|
|
writeFileSync(join(mergePathMoveRoot, "left.graph"), readFileSync(mergePathMoveStore, "utf8"));
|
|
const mergePathMove = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergePathMoveRoot, "base.graph"),
|
|
"--left",
|
|
join(mergePathMoveRoot, "left.graph"),
|
|
"--right",
|
|
join(mergePathMoveRoot, "right.graph"),
|
|
mergePathMoveRoot,
|
|
]);
|
|
assert.equal(mergePathMove.code, 0);
|
|
const mergePathMoveText = readFileSync(mergePathMoveStore, "utf8");
|
|
assert(mergePathMoveText.includes('source path:"renamed.0"'));
|
|
assert(mergePathMoveText.includes('projection path:"renamed.0"'));
|
|
assert(!mergePathMoveText.includes('source path:"main.0"'));
|
|
assert(!mergePathMoveText.includes('projection path:"main.0"'));
|
|
const mergePathMoveVerify = json(["verify-projection", "--json", mergePathMoveRoot]);
|
|
assert.equal(mergePathMoveVerify.body.ok, true);
|
|
const mergeMissingInput = json(["merge", "--json", "--base", join(mergeRepoGraphRoot, "base.graph"), "--left", join(mergeRepoGraphRoot, "left.graph"), mergeRepoGraphRoot], { allowFailure: true });
|
|
assert.notEqual(mergeMissingInput.code, 0);
|
|
assert.equal(mergeMissingInput.body.diagnostics[0].code, "RGM001");
|
|
assert.equal(mergeMissingInput.body.diagnostics[0].actual, "missing --right");
|
|
const mergeConflictRepoGraphRoot = join("/tmp", `zero-repo-graph-merge-conflict-${process.pid}`);
|
|
const mergeConflictRepoGraphSource = join(mergeConflictRepoGraphRoot, "main.0");
|
|
const mergeConflictRepoGraphStore = join(mergeConflictRepoGraphRoot, "zero.graph");
|
|
rmSync(mergeConflictRepoGraphRoot, { force: true, recursive: true });
|
|
mkdirSync(mergeConflictRepoGraphRoot, { recursive: true });
|
|
const mergeConflictOriginal = `fn alpha() -> i32 {
|
|
return 1
|
|
}
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("merge conflict ok\\n")
|
|
}
|
|
`;
|
|
writeFileSync(mergeConflictRepoGraphSource, mergeConflictOriginal);
|
|
json(["import", "--format", "text", "--json", mergeConflictRepoGraphSource]);
|
|
writeFileSync(join(mergeConflictRepoGraphRoot, "base.graph"), readFileSync(mergeConflictRepoGraphStore, "utf8"));
|
|
writeFileSync(mergeConflictRepoGraphSource, mergeConflictOriginal.replace("return 1", "return 10"));
|
|
json(["import", "--format", "text", "--json", mergeConflictRepoGraphSource]);
|
|
writeFileSync(join(mergeConflictRepoGraphRoot, "left.graph"), readFileSync(mergeConflictRepoGraphStore, "utf8"));
|
|
writeFileSync(mergeConflictRepoGraphStore, readFileSync(join(mergeConflictRepoGraphRoot, "base.graph"), "utf8"));
|
|
writeFileSync(mergeConflictRepoGraphSource, mergeConflictOriginal.replace("return 1", "return 20"));
|
|
json(["import", "--format", "text", "--json", mergeConflictRepoGraphSource]);
|
|
writeFileSync(join(mergeConflictRepoGraphRoot, "right.graph"), readFileSync(mergeConflictRepoGraphStore, "utf8"));
|
|
const mergeConflict = json([
|
|
"merge",
|
|
"--json",
|
|
"--base",
|
|
join(mergeConflictRepoGraphRoot, "base.graph"),
|
|
"--left",
|
|
join(mergeConflictRepoGraphRoot, "left.graph"),
|
|
"--right",
|
|
join(mergeConflictRepoGraphRoot, "right.graph"),
|
|
mergeConflictRepoGraphRoot,
|
|
], { allowFailure: true });
|
|
assert.notEqual(mergeConflict.code, 0);
|
|
assert.equal(mergeConflict.body.mode, "merge");
|
|
assert.equal(mergeConflict.body.writes, false);
|
|
assert.equal(mergeConflict.body.diagnostics[0].code, "RGM002");
|
|
assert.equal(mergeConflict.body.diagnostics[0].message, "repository graph node was changed on both sides");
|
|
assert.equal(mergeConflict.body.diagnostics[0].related[0].kind, "graphNode");
|
|
assert.equal(mergeConflict.body.diagnostics[0].related[1].kind, "semanticObject");
|
|
assert.equal(mergeConflict.body.diagnostics[0].related[2].kind, "field");
|
|
assert.equal(mergeConflict.body.merge.conflicts, 1);
|
|
assert(readFileSync(mergeConflictRepoGraphStore, "utf8").includes('value:"20"'));
|
|
writeFileSync(standaloneRepoGraphSource, readFileSync(standaloneRepoGraphSource, "utf8").replace("hello from zero", "hello from graph store"));
|
|
const standaloneRepoGraphVerifyDrift = json(["verify-projection", "--json", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(standaloneRepoGraphVerifyDrift.code, 0);
|
|
assert.equal(standaloneRepoGraphVerifyDrift.body.diagnostics[0].code, "RGP006");
|
|
assert.deepEqual(standaloneRepoGraphVerifyDrift.body.repairCommands, [`zero import ${resolve(standaloneRepoGraphSource)}`, `zero export ${resolve(standaloneRepoGraphSource)}`]);
|
|
const standaloneRepoGraphVerifyDriftText = zero(["verify-projection", resolve(standaloneRepoGraphSource)], { allowFailure: true });
|
|
assert.notEqual(standaloneRepoGraphVerifyDriftText.code, 0);
|
|
assert.match(standaloneRepoGraphVerifyDriftText.stderr, new RegExp(`repair: zero import ${resolve(standaloneRepoGraphSource).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
|
|
assert.match(standaloneRepoGraphVerifyDriftText.stderr, new RegExp(`repair: zero export ${resolve(standaloneRepoGraphSource).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
|
|
const repositoryGraphVerifyDriftScript = repositoryGraphVerifyScript(standaloneRepoGraphRoot, { allowFailure: true });
|
|
assert.notEqual(repositoryGraphVerifyDriftScript.code, 0);
|
|
assert.match(repositoryGraphVerifyDriftScript.stderr, /repository graph verify-projection failed/);
|
|
assert.match(repositoryGraphVerifyDriftScript.stderr, /repair: zero import/);
|
|
assert.match(repositoryGraphVerifyDriftScript.stderr, /repair: zero export/);
|
|
const repoGraphVerify = json(["verify-projection", "--json", "."], { allowFailure: true });
|
|
assert.notEqual(repoGraphVerify.code, 0);
|
|
assert.equal(repoGraphVerify.body.ok, false);
|
|
assert.equal(repoGraphVerify.body.mode, "verify-projection");
|
|
assert.equal(repoGraphVerify.body.writes, false);
|
|
assert.equal(repoGraphVerify.body.diagnostics[0].code, "RGP001");
|
|
assert.equal(repoGraphVerify.body.diagnostics[0].actual, "missing zero.graph");
|
|
assert(repoGraphVerify.body.repairCommands.includes("zero import ."));
|
|
assert(!repoGraphVerify.body.repairCommands.includes("zero export ."));
|
|
const repoGraphExport = json(["export", "--json", "."], { allowFailure: true });
|
|
assert.notEqual(repoGraphExport.code, 0);
|
|
assert.equal(repoGraphExport.body.mode, "export");
|
|
assert.equal(repoGraphExport.body.writes, false);
|
|
assert.equal(repoGraphExport.body.diagnostics[0].code, "RGP001");
|
|
assert.doesNotMatch(graphDump, /node id=/);
|
|
const graphDumpJson = json(["dump", "--json", "examples/hello.0"]).body;
|
|
assert.equal(graphDumpJson.schemaVersion, 1);
|
|
assert.equal(graphDumpJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphDumpJson.validation.ok, true);
|
|
assert.match(graphDumpJson.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
const graphNodeBy = (predicate) => {
|
|
const node = graphDumpJson.nodes.find(predicate);
|
|
assert(node);
|
|
return node;
|
|
};
|
|
const graphModuleNode = graphNodeBy((node) => node.kind === "Module" && node.name === "hello");
|
|
const graphMainFunctionNode = graphNodeBy((node) => node.kind === "Function" && node.name === "main");
|
|
const graphMainBodyNode = graphNodeBy((node) => node.kind === "Block" && node.name === "body");
|
|
const graphHelloLiteralNode = graphNodeBy((node) => node.kind === "Literal" && node.type === "String" && node.value === "hello from zero\n");
|
|
assert.match(graphModuleNode.id, /^#mod_[0-9a-f]{8}$/);
|
|
assert.equal(graphModuleNode.symbolId, "symbol:hello::module");
|
|
assert.equal(graphMainFunctionNode.symbolId, "symbol:hello::value.main");
|
|
assert.doesNotMatch(graphDump, /node #000001/);
|
|
assert(graphDumpJson.edges.some((edge) => edge.from === graphModuleNode.id && edge.to === graphMainFunctionNode.id && edge.kind === "function" && edge.order === 0));
|
|
const graphDumpPath = join(outDir, "hello.program-graph");
|
|
const graphDumpBinaryPath = join(outDir, "hello.binary.graph");
|
|
const graphDumpJsonPath = join(outDir, "hello.dump-json.program-graph");
|
|
const graphStableSiblingSourcePath = join(outDir, "hello-stable-sibling.0");
|
|
const graphImportPath = join(outDir, "hello.imported.program-graph");
|
|
const graphImportJsonPath = join(outDir, "hello.imported-json.program-graph");
|
|
const graphImportDirectorySourcePath = join(outDir, "hello-source-directory.0");
|
|
const graphImportDirectoryOutPath = join(outDir, "hello-source-directory.program-graph");
|
|
const graphInspectOutPath = join(outDir, "hello.inspect.json");
|
|
const graphSourceMapOutPath = join(outDir, "hello.source-map.json");
|
|
const graphReconcileBasePath = join(outDir, "hello.reconcile-base.program-graph");
|
|
const graphReconcileSourcePath = join(outDir, "hello.0");
|
|
const graphCanonicalPath = join(outDir, "hello.canonical.program-graph");
|
|
const graphSourceTextOutPath = join(outDir, "hello.source-output.0");
|
|
const graphValidateSourceTextOutPath = join(outDir, "hello.validate-source-output.0");
|
|
const checkedInGraphSourcePath = "conformance/program-graph/hello.0";
|
|
const checkedInGraphPackageDir = "conformance/program-graph";
|
|
const checkedInGraphDefaultBuildPath = ".zero/out/hello";
|
|
const checkedInGraphBuildPath = join(outDir, "checked-in-graph-build");
|
|
const checkedInGraphRunPath = join(outDir, "checked-in-graph-run");
|
|
const graphRecordRoot = join(outDir, "repository-graph-record");
|
|
const graphRecordBuildPath = join(outDir, "repository-graph-record-build");
|
|
const graphRecordObjPath = join(outDir, "repository-graph-record.o");
|
|
const graphRecordDirectLlvmIrPath = join(outDir, "repository-graph-record-direct.ll");
|
|
const graphRecordLlvmIrPath = join(outDir, "repository-graph-record.ll");
|
|
const graphViewPath = join(outDir, "hello.graph-view.0");
|
|
const graphViewWrongOutPath = join(outDir, "hello.program-graph.txt");
|
|
const graphViewParentFilePath = join(outDir, "hello.graph-view-parent-file");
|
|
const graphViewParentFileOutPath = join(graphViewParentFilePath, "out.0");
|
|
const graphCheckViewPath = join(outDir, "hello.checked.graph-view.0");
|
|
const graphSizePath = join(outDir, "hello.program-graph.size.json");
|
|
const graphBuildPath = join(outDir, "hello.program-graph-build");
|
|
const graphObjPath = join(outDir, "hello.program-graph.o");
|
|
const graphRunPath = join(outDir, "hello.program-graph-run");
|
|
const graphArgsDumpPath = join(outDir, "std-args.program-graph");
|
|
const graphArgsRunPath = join(outDir, "std-args.program-graph-run");
|
|
const graphTestDumpPath = join(outDir, "test-blocks.program-graph");
|
|
const graphPackageTestDumpPath = join(outDir, "test-app.program-graph");
|
|
const graphManifestPackageDir = join(outDir, "graph-manifest-package");
|
|
const graphManifestSourcePath = join(graphManifestPackageDir, "src", "main.0");
|
|
const graphManifestStorePath = join(graphManifestPackageDir, "zero.graph");
|
|
const graphManifestArtifactPath = join(graphManifestPackageDir, "artifacts", "test-app.program-graph");
|
|
const graphManifestBuildPath = join(outDir, "graph-manifest-package-build");
|
|
const graphManifestRunPath = join(outDir, "graph-manifest-package-run");
|
|
const directGraphManifestBuildPath = join(outDir, "direct-graph-manifest-package-build");
|
|
const directGraphManifestRunPath = join(outDir, "direct-graph-manifest-package-run");
|
|
const directGraphTargetGateRoot = join(outDir, "direct-graph-target-gate");
|
|
const directGraphTargetGatePackageDir = join(directGraphTargetGateRoot, "app");
|
|
const directGraphTargetGateDepDir = join(directGraphTargetGateRoot, "target-webbits");
|
|
const directGraphTargetGateArtifactPath = join(directGraphTargetGatePackageDir, "artifacts", "app.program-graph");
|
|
const directGraphHostLeakPackageDir = join(outDir, "direct-graph-host-leak-package");
|
|
const directGraphHostLeakArtifactPath = join(directGraphHostLeakPackageDir, "artifacts", "app.program-graph");
|
|
const directGraphHostLeakBuildPath = join(outDir, "direct-graph-host-leak-build");
|
|
const graphSizeNoisePatchPath = join(outDir, "hello.program-graph.size-noise.patch");
|
|
const graphSizeNoisePath = join(outDir, "hello.program-graph.size-noise.program-graph");
|
|
const graphSourceRoundtripPath = join(outDir, "hello.source-roundtrip.program-graph");
|
|
const graphSourceRoundtripSourceTextPath = join(outDir, "hello.source-roundtrip.0");
|
|
const graphArtifactRoundtripPath = join(outDir, "hello.roundtrip.program-graph");
|
|
const graphArtifactRoundtripSourceTextPath = join(outDir, "hello.roundtrip.0");
|
|
const graphPatchPath = join(outDir, "hello.program-graph.patch");
|
|
const graphPatchDirectoryPath = join(outDir, "hello.program-graph.patch-directory");
|
|
const graphPatchDirectoryOutPath = join(outDir, "hello.directory-patch.program-graph");
|
|
const graphPatchedPath = join(outDir, "hello.patched.program-graph");
|
|
const graphInlinePatchedPath = join(outDir, "hello.inline-patched.program-graph");
|
|
const graphPatchInsertPath = join(outDir, "hello.insert.program-graph.patch");
|
|
const graphInsertedPath = join(outDir, "hello.insert.program-graph");
|
|
const graphPatchDeletePath = join(outDir, "hello.delete.program-graph.patch");
|
|
const graphDeletedPath = join(outDir, "hello.delete.program-graph");
|
|
const graphPatchDeleteThenInsertPath = join(outDir, "hello.delete-then-insert.program-graph.patch");
|
|
const graphDeleteThenInsertedPath = join(outDir, "hello.delete-then-insert.program-graph");
|
|
const graphPatchDeleteNodeFactPath = join(outDir, "hello.delete-node-fact.program-graph.patch");
|
|
const graphDeletedNodeFactPath = join(outDir, "hello.delete-node-fact.program-graph");
|
|
const graphRepositoryPatchPackageDir = join(outDir, "repository-graph-patch-package");
|
|
const graphRepositoryNewOpsPackageDir = join(outDir, "repository-graph-new-patch-ops");
|
|
const graphRepositoryBodyPatchPath = join(outDir, "repository-graph.replace-body.patch");
|
|
const graphRepositoryNewOpsPatchPath = join(outDir, "repository-graph.new-ops.patch");
|
|
const graphRepositoryBlockPatchPath = join(outDir, "repository-graph.replace-block.patch");
|
|
const graphRepositoryInvalidBlockRowsPatchPath = join(outDir, "repository-graph.invalid-block-rows.patch");
|
|
const graphRepositoryCheckExprPatchPath = join(outDir, "repository-graph.check-expr.patch");
|
|
const graphRepositoryRowErgonomicsPatchPath = join(outDir, "repository-graph.row-ergonomics.patch");
|
|
const graphRepositoryInvalidRowsPatchPath = join(outDir, "repository-graph.invalid-rows.patch");
|
|
const graphRepositoryInvalidBodyPatchPath = join(outDir, "repository-graph.invalid-body.patch");
|
|
const graphPatchDeleteExternalRootRefPath = join(outDir, "hello.delete-external-root-ref.program-graph.patch");
|
|
const graphPatchDeleteExtraOwnerPath = join(outDir, "hello.delete-extra-owner.program-graph.patch");
|
|
const graphPatchReplacePath = join(outDir, "hello.replace.program-graph.patch");
|
|
const graphReplacedPath = join(outDir, "hello.replace.program-graph");
|
|
const graphPatchStaleReplacePath = join(outDir, "hello.stale-replace.program-graph.patch");
|
|
const graphPatchInsertEdgePath = join(outDir, "hello.insert-edge.program-graph.patch");
|
|
const graphInsertedEdgePath = join(outDir, "hello.insert-edge.program-graph");
|
|
const graphPatchEmptyTypeEdgePath = join(outDir, "hello.empty-type-edge.program-graph.patch");
|
|
const graphPatchRenamePath = join(outDir, "hello.rename.program-graph.patch");
|
|
const graphRenamedPath = join(outDir, "hello.rename.program-graph");
|
|
const graphPatchInvalidRenamePath = join(outDir, "hello.invalid-rename.program-graph.patch");
|
|
const graphUncheckedPatchPath = join(outDir, "hello.unchecked.program-graph.patch");
|
|
const graphUncheckedPath = join(outDir, "hello.unchecked.program-graph");
|
|
const graphBorrowDumpPath = join(outDir, "borrow.program-graph");
|
|
const graphBorrowConflictPatchPath = join(outDir, "borrow-conflict.program-graph.patch");
|
|
const graphBorrowConflictPath = join(outDir, "borrow-conflict.program-graph");
|
|
const graphPatchEmptyPath = join(outDir, "hello.empty.program-graph.patch");
|
|
const graphPatchControlPath = join(outDir, "hello.control.program-graph.patch");
|
|
const graphPatchHighBytePath = join(outDir, "hello.high-byte.program-graph.patch");
|
|
const graphPatchBadEscapePath = join(outDir, "hello.bad-escape.program-graph.patch");
|
|
const graphPatchNullEscapePath = join(outDir, "hello.null-escape.program-graph.patch");
|
|
const graphPatchRawNullPath = join(outDir, "hello.raw-null.program-graph.patch");
|
|
const graphPatchInvalidNamePath = join(outDir, "hello.invalid-name.program-graph.patch");
|
|
const graphPatchInvalidTypePath = join(outDir, "hello.invalid-type.program-graph.patch");
|
|
const graphPatchReservedParamPath = join(outDir, "hello.reserved-param.program-graph.patch");
|
|
const graphReservedParamPath = join(outDir, "hello.reserved-param.program-graph");
|
|
const graphPatchInternalFunctionPath = join(outDir, "hello.internal-function.program-graph.patch");
|
|
const graphInternalFunctionPath = join(outDir, "hello.internal-function.program-graph");
|
|
const graphPayloadDumpPath = join(outDir, "payload-match.program-graph");
|
|
const graphPatchInvalidMatchReplacePath = join(outDir, "payload-match.invalid-replace.program-graph.patch");
|
|
const graphPatchInvalidMatchInsertPath = join(outDir, "payload-match.invalid-insert.program-graph.patch");
|
|
const graphPackageDumpPath = join(outDir, "systems-package.program-graph");
|
|
const graphPackageViewPath = join(outDir, "systems-package.graph-view.0");
|
|
const graphPackagePathMismatchPatchPath = join(outDir, "systems-package.path-mismatch.program-graph.patch");
|
|
const graphPackagePathMismatchPath = join(outDir, "systems-package.path-mismatch.program-graph");
|
|
const graphPatchInvalidImportAliasPath = join(outDir, "systems-package.invalid-import-alias.program-graph.patch");
|
|
const graphPatchInvalidImportNamePath = join(outDir, "systems-package.invalid-import-name.program-graph.patch");
|
|
const graphInvalidImportNamePath = join(outDir, "systems-package.invalid-import-name.program-graph");
|
|
const graphPatchMissingImportPath = join(outDir, "systems-package.missing-import.program-graph.patch");
|
|
const graphMissingImportPath = join(outDir, "systems-package.missing-import.program-graph");
|
|
const graphPatchMismatchPath = join(outDir, "hello.mismatch.program-graph.patch");
|
|
const graphPatchBadHashPath = join(outDir, "hello.bad-hash.program-graph.patch");
|
|
const graphSparseOrderPath = join(outDir, "hello.sparse-order.program-graph");
|
|
const graphSparseArgPath = join(outDir, "hello.sparse-arg.program-graph");
|
|
rmSync(graphDumpPath, { force: true });
|
|
rmSync(graphDumpJsonPath, { force: true });
|
|
rmSync(graphStableSiblingSourcePath, { force: true });
|
|
rmSync(graphImportPath, { force: true });
|
|
rmSync(graphImportJsonPath, { force: true });
|
|
rmSync(graphImportDirectorySourcePath, { recursive: true, force: true });
|
|
rmSync(graphImportDirectoryOutPath, { force: true });
|
|
rmSync(graphCanonicalPath, { force: true });
|
|
rmSync(graphSourceTextOutPath, { force: true });
|
|
rmSync(graphValidateSourceTextOutPath, { force: true });
|
|
rmSync(checkedInGraphDefaultBuildPath, { force: true });
|
|
rmSync(checkedInGraphBuildPath, { force: true });
|
|
rmSync(checkedInGraphRunPath, { force: true });
|
|
rmSync(graphRecordRoot, { force: true, recursive: true });
|
|
rmSync(graphRecordBuildPath, { force: true });
|
|
rmSync(graphRecordObjPath, { force: true });
|
|
rmSync(graphRecordDirectLlvmIrPath, { force: true });
|
|
rmSync(graphRecordLlvmIrPath, { force: true });
|
|
rmSync(graphViewPath, { force: true });
|
|
rmSync(graphViewWrongOutPath, { force: true });
|
|
rmSync(graphViewParentFilePath, { force: true, recursive: true });
|
|
rmSync(graphCheckViewPath, { force: true });
|
|
rmSync(graphSizePath, { force: true });
|
|
rmSync(graphBuildPath, { force: true });
|
|
rmSync(graphObjPath, { force: true });
|
|
rmSync(graphRunPath, { force: true });
|
|
rmSync(graphArgsDumpPath, { force: true });
|
|
rmSync(graphArgsRunPath, { force: true });
|
|
rmSync(graphTestDumpPath, { force: true });
|
|
rmSync(graphPackageTestDumpPath, { force: true });
|
|
rmSync(graphManifestPackageDir, { force: true, recursive: true });
|
|
rmSync(graphManifestBuildPath, { force: true });
|
|
rmSync(graphManifestRunPath, { force: true });
|
|
rmSync(directGraphManifestBuildPath, { force: true });
|
|
rmSync(directGraphManifestRunPath, { force: true });
|
|
rmSync(directGraphTargetGateRoot, { force: true, recursive: true });
|
|
rmSync(directGraphHostLeakPackageDir, { force: true, recursive: true });
|
|
rmSync(directGraphHostLeakBuildPath, { force: true });
|
|
rmSync(graphSizeNoisePatchPath, { force: true });
|
|
rmSync(graphSizeNoisePath, { force: true });
|
|
rmSync(graphSourceRoundtripPath, { force: true });
|
|
rmSync(graphSourceRoundtripSourceTextPath, { force: true });
|
|
rmSync(graphArtifactRoundtripPath, { force: true });
|
|
rmSync(graphArtifactRoundtripSourceTextPath, { force: true });
|
|
rmSync(graphPatchPath, { force: true });
|
|
rmSync(graphPatchDirectoryPath, { recursive: true, force: true });
|
|
rmSync(graphPatchDirectoryOutPath, { force: true });
|
|
rmSync(graphPatchedPath, { force: true });
|
|
rmSync(graphInlinePatchedPath, { force: true });
|
|
rmSync(graphPatchInsertPath, { force: true });
|
|
rmSync(graphInsertedPath, { force: true });
|
|
rmSync(graphPatchDeletePath, { force: true });
|
|
rmSync(graphDeletedPath, { force: true });
|
|
rmSync(graphPatchDeleteThenInsertPath, { force: true });
|
|
rmSync(graphDeleteThenInsertedPath, { force: true });
|
|
rmSync(graphPatchDeleteNodeFactPath, { force: true });
|
|
rmSync(graphDeletedNodeFactPath, { force: true });
|
|
rmSync(graphPatchDeleteExternalRootRefPath, { force: true });
|
|
rmSync(graphPatchDeleteExtraOwnerPath, { force: true });
|
|
rmSync(graphPatchReplacePath, { force: true });
|
|
rmSync(graphReplacedPath, { force: true });
|
|
rmSync(graphPatchStaleReplacePath, { force: true });
|
|
rmSync(graphPatchInsertEdgePath, { force: true });
|
|
rmSync(graphInsertedEdgePath, { force: true });
|
|
rmSync(graphPatchEmptyTypeEdgePath, { force: true });
|
|
rmSync(graphPatchRenamePath, { force: true });
|
|
rmSync(graphRenamedPath, { force: true });
|
|
rmSync(graphPatchInvalidRenamePath, { force: true });
|
|
rmSync(graphUncheckedPatchPath, { force: true });
|
|
rmSync(graphUncheckedPath, { force: true });
|
|
rmSync(graphBorrowDumpPath, { force: true });
|
|
rmSync(graphBorrowConflictPatchPath, { force: true });
|
|
rmSync(graphBorrowConflictPath, { force: true });
|
|
rmSync(graphPatchEmptyPath, { force: true });
|
|
rmSync(graphPatchControlPath, { force: true });
|
|
rmSync(graphPatchHighBytePath, { force: true });
|
|
rmSync(graphPatchBadEscapePath, { force: true });
|
|
rmSync(graphPatchNullEscapePath, { force: true });
|
|
rmSync(graphPatchRawNullPath, { force: true });
|
|
rmSync(graphPatchInvalidNamePath, { force: true });
|
|
rmSync(graphPatchInvalidTypePath, { force: true });
|
|
rmSync(graphPatchReservedParamPath, { force: true });
|
|
rmSync(graphReservedParamPath, { force: true });
|
|
rmSync(graphPatchInternalFunctionPath, { force: true });
|
|
rmSync(graphInternalFunctionPath, { force: true });
|
|
rmSync(graphPayloadDumpPath, { force: true });
|
|
rmSync(graphPatchInvalidMatchReplacePath, { force: true });
|
|
rmSync(graphPatchInvalidMatchInsertPath, { force: true });
|
|
rmSync(graphPackageDumpPath, { force: true });
|
|
rmSync(graphPackagePathMismatchPatchPath, { force: true });
|
|
rmSync(graphPackagePathMismatchPath, { force: true });
|
|
rmSync(graphPatchInvalidImportAliasPath, { force: true });
|
|
rmSync(graphPatchInvalidImportNamePath, { force: true });
|
|
rmSync(graphInvalidImportNamePath, { force: true });
|
|
rmSync(graphPatchMissingImportPath, { force: true });
|
|
rmSync(graphMissingImportPath, { force: true });
|
|
rmSync(graphPatchMismatchPath, { force: true });
|
|
rmSync(graphPatchBadHashPath, { force: true });
|
|
rmSync(graphSparseOrderPath, { force: true });
|
|
rmSync(graphSparseArgPath, { force: true });
|
|
writeFileSync(graphStableSiblingSourcePath, readFileSync("examples/hello.0", "utf8"));
|
|
importProjectionSidecar(graphStableSiblingSourcePath);
|
|
const graphStableBaseJson = json(["dump", "--json", graphStableSiblingSourcePath]).body;
|
|
const graphStableBaseMain = graphStableBaseJson.nodes.find((node) => node.kind === "Function" && node.name === "main");
|
|
const graphStableBaseLiteral = graphStableBaseJson.nodes.find((node) => node.kind === "Literal" && node.type === "String" && node.value === "hello from zero\n");
|
|
assert(graphStableBaseMain);
|
|
assert(graphStableBaseLiteral);
|
|
writeFileSync(graphStableSiblingSourcePath, `fn helper() -> u32 {\n return 1\n}\n\n${readFileSync("examples/hello.0", "utf8")}`);
|
|
importProjectionSidecar(graphStableSiblingSourcePath);
|
|
const graphStableSiblingJson = json(["dump", "--json", graphStableSiblingSourcePath]).body;
|
|
assert.equal(graphStableSiblingJson.nodes.find((node) => node.kind === "Function" && node.name === "main")?.id, graphStableBaseMain.id);
|
|
assert.equal(graphStableSiblingJson.nodes.find((node) => node.kind === "Literal" && node.type === "String" && node.value === "hello from zero\n")?.id, graphStableBaseLiteral.id);
|
|
assert.equal(zero(["dump", "--out", graphDumpPath, "examples/hello.0"]).stdout, "");
|
|
assert.equal(readFileSync(graphDumpPath, "utf8"), graphDump);
|
|
assert.equal(zero(["dump", "--format", "binary", "--out", graphDumpBinaryPath, "examples/hello.0"]).stdout, "");
|
|
assert.equal(readFileSync(graphDumpBinaryPath).subarray(0, 8).toString("latin1"), "ZRGBIN1\0");
|
|
assert.equal(zero(["validate", graphDumpBinaryPath]).stdout, "program graph ok\n");
|
|
assert.equal(zero(["view", graphDumpBinaryPath]).stdout, zero(["view", graphDumpPath]).stdout);
|
|
const graphDumpOutJson = json(["dump", "--json", "--out", graphDumpJsonPath, "examples/hello.0"]).body;
|
|
assert.deepEqual(graphDumpOutJson, graphDumpJson);
|
|
assert.equal(readFileSync(graphDumpJsonPath, "utf8"), graphDump);
|
|
assert.equal(zero(["validate", graphDumpJsonPath]).stdout, "program graph ok\n");
|
|
assert.equal(zero(["dump", "--out", graphDumpPath, "examples/hello.0"]).stdout, "");
|
|
assert.equal(readFileSync(graphDumpPath, "utf8"), graphDump);
|
|
const graphImportText = zero(["import", "examples/hello.0"]).stdout;
|
|
assert.match(graphImportText, / path:"examples\/hello\.0"/);
|
|
assert.match(graphImportText, /hash "graph:[0-9a-f]{16}"/);
|
|
assert.equal(zero(["import", "--out", graphImportPath, "examples/hello.0"]).stdout, "");
|
|
assert.equal(readFileSync(graphImportPath, "utf8"), graphImportText);
|
|
const graphImportJson = json(["import", "--json", "examples/hello.0"]).body;
|
|
assert.equal(graphImportJson.moduleIdentity, graphDumpJson.moduleIdentity);
|
|
assert.equal(graphImportJson.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphImportJson.validation.ok, true);
|
|
const graphImportOutJson = json(["import", "--json", "--out", graphImportJsonPath, "examples/hello.0"]).body;
|
|
assert.equal(graphImportOutJson.ok, true);
|
|
assert.equal(graphImportOutJson.moduleIdentity, graphDumpJson.moduleIdentity);
|
|
assert.equal(graphImportOutJson.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphImportOutJson.validation.ok, true);
|
|
assert.equal(graphImportOutJson.saved.path, graphImportJsonPath);
|
|
assert.equal(readFileSync(graphImportJsonPath, "utf8"), graphImportText);
|
|
assert.equal(zero(["validate", graphImportJsonPath]).stdout, "program graph ok\n");
|
|
mkdirSync(graphImportDirectorySourcePath, { recursive: true });
|
|
const graphImportDirectoryJson = json(["import", "--json", "--out", graphImportDirectoryOutPath, graphImportDirectorySourcePath], { allowFailure: true });
|
|
assert.notEqual(graphImportDirectoryJson.code, 0);
|
|
assert.equal(graphImportDirectoryJson.body.diagnostics[0].path, graphImportDirectorySourcePath);
|
|
assert.match(graphImportDirectoryJson.body.diagnostics[0].message, /^failed to read '.+hello-source-directory\.0': /);
|
|
assert.equal(existsSync(graphImportDirectoryOutPath), false);
|
|
const graphInspectJson = json(["inspect", "--json", "examples/hello.0"]).body;
|
|
assert.equal(graphInspectJson.schemaVersion, 1);
|
|
assert.match(graphInspectJson.programGraph.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
assert.equal(graphInspectJson.programGraph.moduleIdentity, graphDumpJson.moduleIdentity);
|
|
assert.equal(graphInspectJson.programGraph.canonicalSource, false);
|
|
assert.equal(graphInspectJson.programGraph.validation.ok, true);
|
|
assert.equal(graphInspectJson.callResolution.schemaVersion, 1);
|
|
const graphStdIoLinesInspectJson = json(["inspect", "--json", "conformance/native/pass/std-io-lines.graph"]).body;
|
|
assert.equal(graphStdIoLinesInspectJson.targetReadiness.ok, true);
|
|
assert.equal(graphStdIoLinesInspectJson.targetReadiness.buildable, true);
|
|
assert.deepEqual(graphStdIoLinesInspectJson.targetReadiness.diagnostics, []);
|
|
const graphInspectText = zero(["inspect", "examples/hello.0"]).stdout;
|
|
assert.match(graphInspectText, /^program graph inspect\n/);
|
|
assert.match(graphInspectText, /graph: module:hello graph:[0-9a-f]{16} \(13 nodes, 12 edges, shape-valid\)/);
|
|
assert.match(graphInspectText, /capabilities: world/);
|
|
assert.match(graphInspectText, /next: use `zero query examples\/hello\.0` for patch-ready node handles/);
|
|
const graphInspectOutJson = json(["inspect", "--json", "--out", graphInspectOutPath, "examples/hello.0"], { allowFailure: true });
|
|
assert.notEqual(graphInspectOutJson.code, 0);
|
|
assert.equal(graphInspectOutJson.body.diagnostics[0].message, "inspect does not support --out");
|
|
assert.equal(graphInspectOutJson.body.diagnostics[0].expected, "zero inspect [--json] [graph-input]");
|
|
assert.equal(zero(["validate", graphDumpPath]).stdout, "program graph ok\n");
|
|
const graphSourceMapJson = json(["source-map", "--json", "examples/hello.0"]).body;
|
|
assert.equal(graphSourceMapJson.ok, true);
|
|
assert.match(graphSourceMapJson.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
const graphMainSourceMapping = graphSourceMapJson.mappings.find((mapping) => mapping.nodeId === graphMainFunctionNode.id);
|
|
assert(graphMainSourceMapping && graphMainSourceMapping.sourceRange.path === "hello.0");
|
|
assert.equal(graphMainSourceMapping.sourceAvailable, false);
|
|
assert.deepEqual(graphMainSourceMapping.sourceRange.start, { line: 1, column: 1 });
|
|
assert.deepEqual(graphMainSourceMapping.sourceRange.end, { line: 1, column: 2 });
|
|
assert.equal(zero(["source-map", "examples/hello.0"]).stdout, `program graph source map ok: ${graphSourceMapJson.counts.mappings} mappings\n`);
|
|
const graphSourceMapOutJson = json(["source-map", "--json", "--out", graphSourceMapOutPath, "examples/hello.0"], { allowFailure: true });
|
|
assert.notEqual(graphSourceMapOutJson.code, 0);
|
|
assert.equal(graphSourceMapOutJson.body.diagnostics[0].message, "source-map does not support --out");
|
|
assert.equal(graphSourceMapOutJson.body.diagnostics[0].expected, "zero source-map [--json] [graph-input]");
|
|
assert.equal(existsSync(graphSourceMapOutPath), false);
|
|
writeFileSync(graphReconcileSourcePath, readFileSync("examples/hello.0", "utf8"));
|
|
const graphReconcileBaseJson = json(["import", "--json", "--out", graphReconcileBasePath, graphReconcileSourcePath]).body;
|
|
assert.equal(graphReconcileBaseJson.saved.path, graphReconcileBasePath);
|
|
writeFileSync(graphReconcileSourcePath, readFileSync(graphReconcileSourcePath, "utf8").replace("hello from zero\\n", "hello from reconcile\\n"));
|
|
const graphReconcileJson = json(["reconcile", "--json", graphReconcileBasePath, "--source", graphReconcileSourcePath]).body;
|
|
assert.equal(graphReconcileJson.ok, true);
|
|
assert.equal(graphReconcileJson.base.graphHash, graphReconcileBaseJson.graphHash);
|
|
assert.equal(graphReconcileJson.identity.ambiguous, 0);
|
|
assert.equal(graphReconcileJson.graphPatch.available, true);
|
|
assert.match(graphReconcileJson.graphPatch.text, /set node="#expr_[^"]+" field="value"/);
|
|
const graphReconcileLiteralDecision = graphReconcileJson.decisions.find((decision) => decision.status === "edited" && decision.kind === "Literal");
|
|
assert.deepEqual(graphReconcileLiteralDecision?.sourceRange.start, { line: 2, column: 27 });
|
|
assert.deepEqual(graphReconcileLiteralDecision?.sourceRange.end, { line: 2, column: 51 });
|
|
assert.equal(zero(["reconcile", graphReconcileBasePath, "--source", graphReconcileSourcePath]).stdout, "program graph reconcile ok\n");
|
|
const graphReconcileMissingSource = json(["reconcile", "--json", graphReconcileBasePath], { allowFailure: true });
|
|
assert.notEqual(graphReconcileMissingSource.code, 0);
|
|
assert.equal(graphReconcileMissingSource.body.diagnostics[0].message, "graph reconcile requires edited source input");
|
|
assert.equal(graphReconcileMissingSource.body.diagnostics[0].actual, "missing --source");
|
|
const graphValidateJson = json(["validate", "--json", "--out", graphCanonicalPath, graphDumpPath]).body;
|
|
assert.equal(graphValidateJson.ok, true);
|
|
assert.equal(graphValidateJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphValidateJson.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphValidateJson.saved.path, graphCanonicalPath);
|
|
assert.equal(readFileSync(graphCanonicalPath, "utf8"), graphDump);
|
|
const graphSourceTextOutJson = json(["dump", "--json", "--out", graphSourceTextOutPath, "examples/hello.0"], { allowFailure: true });
|
|
assert.notEqual(graphSourceTextOutJson.code, 0);
|
|
assert.equal(graphSourceTextOutJson.body.diagnostics[0].message, "program graph output must not use source text extension");
|
|
assert.equal(graphSourceTextOutJson.body.diagnostics[0].expected, "zero dump --out <program-graph-artifact> [graph-input]");
|
|
assert.equal(graphSourceTextOutJson.body.diagnostics[0].help, ".0 files are canonical source text; write derived ProgramGraph artifacts to a non-source path");
|
|
assert.equal(existsSync(graphSourceTextOutPath), false);
|
|
const graphValidateSourceTextOutJson = json(["validate", "--json", "--out", graphValidateSourceTextOutPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphValidateSourceTextOutJson.code, 0);
|
|
assert.equal(graphValidateSourceTextOutJson.body.diagnostics[0].message, "program graph output must not use source text extension");
|
|
assert.equal(graphValidateSourceTextOutJson.body.diagnostics[0].expected, "zero validate --out <program-graph-artifact> [graph-input]");
|
|
assert.equal(existsSync(graphValidateSourceTextOutPath), false);
|
|
const checkedInGraphSource = readFileSync(checkedInGraphSourcePath, "utf8");
|
|
assert.equal(checkedInGraphSource, readFileSync("examples/hello.0", "utf8"));
|
|
const checkedInRepositoryGraphStorePath = join(checkedInGraphPackageDir, "zero.graph");
|
|
const checkedInGraphValidateJson = json(["validate", "--json", checkedInGraphSourcePath]).body;
|
|
assert.equal(checkedInGraphValidateJson.ok, true);
|
|
assert.equal(checkedInGraphValidateJson.artifact, checkedInRepositoryGraphStorePath);
|
|
assert.equal(checkedInGraphValidateJson.moduleIdentity, "package:program-graph-fixture@0.1.0");
|
|
const checkedInGraphViewJson = json(["view", "--json", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphViewJson.ok, true);
|
|
assert.equal(checkedInGraphViewJson.canonicalSource, true);
|
|
assert.match(checkedInGraphViewJson.view, /pub fn main\(world: World\) -> Void raises/);
|
|
const checkedInGraphQueryJson = json(["query", "--json", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphQueryJson.ok, true);
|
|
assert.equal(checkedInGraphQueryJson.inputKind, "repository-graph");
|
|
assert.equal(checkedInGraphQueryJson.functions.some((fun) => fun.name === "main" && fun.public === true), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("insert node=\"#id\" kind=\"Literal\" parent=\"#parent\" edge=\"arg\" order=\"0\" type=\"String\" value=\"text\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("replace node=\"#id\" expect=\"nodehash:abc123\" kind=\"Literal\" type=\"String\" value=\"text\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.some((op) => op.includes("setMain")), false);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.some((op) => op.startsWith("replaceFunctionBody main\n")), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.some((op) => op.startsWith("replaceBlockBody #block_id\n")), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("addLetLiteral fn=\"main\" name=\"count\" type=\"u32\" value=\"0\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("addReturnValue fn=\"identity\" value=\"input\" type=\"i32\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("addReturnExpr fn=\"maybe\" expr=\"null\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("appendStmt fn=\"main\" stmt=\"check std.http.listen(world, 3000_u16)\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.some((op) => op.startsWith("addTestBody name=\"api add\"\n")), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("renameTest name=\"api add\" value=\"api add route\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.includes("deleteTest name=\"api add\""), true);
|
|
assert.equal(checkedInGraphQueryJson.patchOperations.some((op) => op.startsWith("upsertFunction handle\n")), true);
|
|
rmSync(graphRepositoryNewOpsPackageDir, { recursive: true, force: true });
|
|
mkdirSync(graphRepositoryNewOpsPackageDir, { recursive: true });
|
|
writeFileSync(join(graphRepositoryNewOpsPackageDir, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(join(graphRepositoryNewOpsPackageDir, "zero.graph"), readFileSync(checkedInRepositoryGraphStorePath));
|
|
writeFileSync(join(graphRepositoryNewOpsPackageDir, "hello.0"), checkedInGraphSource);
|
|
const repositoryNewOpsHash = json(["query", "--json", graphRepositoryNewOpsPackageDir]).body.graphHash;
|
|
writeFileSync(graphRepositoryNewOpsPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryNewOpsHash}"`,
|
|
"upsertFunction main",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
"}",
|
|
"end",
|
|
'appendStmt fn="main" stmt="check world.out.write(\\"new ops ok\\")"',
|
|
'addFunction name="answer" ret="i32"',
|
|
'addReturnExpr fn="answer" expr="42"',
|
|
'addTestBody name="answer works"',
|
|
" expect (answer() == 42)",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryNewOpsDryRunJson = json(["patch", "--json", "--check-only", graphRepositoryNewOpsPackageDir, graphRepositoryNewOpsPatchPath]).body;
|
|
assert.equal(repositoryNewOpsDryRunJson.ok, true);
|
|
assert.equal(repositoryNewOpsDryRunJson.checkOnly, true);
|
|
assert.equal(repositoryNewOpsDryRunJson.saved, null);
|
|
assert.deepEqual(repositoryNewOpsDryRunJson.operations.map((operation) => operation.op), ["upsertFunction", "appendStmt", "addFunction", "addReturnExpr", "addTestBody"]);
|
|
assert.equal(zero(["view", graphRepositoryNewOpsPackageDir]).stdout, checkedInGraphSource);
|
|
const repositoryNewOpsPatchJson = json(["patch", "--json", graphRepositoryNewOpsPackageDir, graphRepositoryNewOpsPatchPath]).body;
|
|
assert.equal(repositoryNewOpsPatchJson.ok, true);
|
|
assert.deepEqual(repositoryNewOpsPatchJson.operations.map((operation) => operation.op), ["upsertFunction", "appendStmt", "addFunction", "addReturnExpr", "addTestBody"]);
|
|
assert.equal(repositoryNewOpsPatchJson.saved.path, join(graphRepositoryNewOpsPackageDir, "zero.graph"));
|
|
assert.match(zero(["view", "--fn", "main", graphRepositoryNewOpsPackageDir]).stdout, /check world\.out\.write\("new ops ok"\)/);
|
|
assert.match(zero(["view", "--fn", "answer", graphRepositoryNewOpsPackageDir]).stdout, /return 42/);
|
|
assert.equal(zero(["check", graphRepositoryNewOpsPackageDir]).stdout, "ok\n");
|
|
assert.equal(zero(["run", graphRepositoryNewOpsPackageDir]).stdout, "new ops ok");
|
|
assert.equal(zero(["test", graphRepositoryNewOpsPackageDir]).stdout, "1 test(s) ok\n");
|
|
const repositoryRenameTestJson = json(["patch", "--json", graphRepositoryNewOpsPackageDir, "--op", 'renameTest name="answer works" value="answer route works"']).body;
|
|
assert.equal(repositoryRenameTestJson.ok, true);
|
|
assert.equal(repositoryRenameTestJson.operations[0].op, "renameTest");
|
|
assert.equal(repositoryRenameTestJson.operations[0].actual, "answer works");
|
|
assert.equal(zero(["test", graphRepositoryNewOpsPackageDir]).stdout, "1 test(s) ok\n");
|
|
const repositoryUnsupportedTestPatch = zeroWithInput(["patch", graphRepositoryNewOpsPackageDir, "--patch-text", "-"], [
|
|
"zero-program-graph-patch v1",
|
|
'addTestBody name="unsupported buffer test"',
|
|
" var response: [16]u8 = [0_u8; 16]",
|
|
" expect true",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(repositoryUnsupportedTestPatch.stdout, join(graphRepositoryNewOpsPackageDir, "zero.graph"));
|
|
const repositoryUnsupportedTestRun = zero(["test", graphRepositoryNewOpsPackageDir], { allowFailure: true });
|
|
assert.notEqual(repositoryUnsupportedTestRun.code, 0);
|
|
assert.match(repositoryUnsupportedTestRun.stderr, /zero graph test runner does not support .* expression yet/);
|
|
assert.match(repositoryUnsupportedTestRun.stderr, /supported graph tests are pure locals/);
|
|
const repositoryDeleteUnsupportedTestJson = json(["patch", "--json", graphRepositoryNewOpsPackageDir, "--op", 'deleteTest name="unsupported buffer test"']).body;
|
|
assert.equal(repositoryDeleteUnsupportedTestJson.ok, true);
|
|
assert.equal(repositoryDeleteUnsupportedTestJson.operations[0].op, "deleteTest");
|
|
assert.equal(zero(["test", graphRepositoryNewOpsPackageDir]).stdout, "1 test(s) ok\n");
|
|
const repositoryDeleteTestJson = json(["patch", "--json", graphRepositoryNewOpsPackageDir, "--op", 'deleteTest name="answer route works"']).body;
|
|
assert.equal(repositoryDeleteTestJson.ok, true);
|
|
assert.equal(repositoryDeleteTestJson.operations[0].op, "deleteTest");
|
|
const repositoryNoTests = zero(["test", graphRepositoryNewOpsPackageDir]).stdout;
|
|
assert.match(repositoryNoTests, /0 test\(s\) ok/);
|
|
assert.match(repositoryNoTests, /note: no test blocks found/);
|
|
assert.match(zero(["export", graphRepositoryNewOpsPackageDir]).stdout, /repository graph export ok/);
|
|
assert.equal(zero(["verify-projection", graphRepositoryNewOpsPackageDir]).stdout, "repository graph verify-projection ok\n");
|
|
rmSync(graphRepositoryPatchPackageDir, { recursive: true, force: true });
|
|
mkdirSync(graphRepositoryPatchPackageDir, { recursive: true });
|
|
writeFileSync(join(graphRepositoryPatchPackageDir, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(join(graphRepositoryPatchPackageDir, "zero.graph"), readFileSync(checkedInRepositoryGraphStorePath));
|
|
writeFileSync(join(graphRepositoryPatchPackageDir, "hello.0"), checkedInGraphSource);
|
|
const repositoryPatchQueryJson = json(["query", "--json", graphRepositoryPatchPackageDir]).body;
|
|
writeFileSync(graphRepositoryBodyPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryPatchQueryJson.graphHash}"`,
|
|
"replaceFunctionBody main",
|
|
" let name Maybe<String> = std.args.get 1",
|
|
" if name.has",
|
|
" check world.out.write \"hello \"",
|
|
" check world.out.write name.value",
|
|
" check world.out.write \"\\n\"",
|
|
" else",
|
|
" check world.out.write \"hello anonymous\\n\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryPatchDryRunJson = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryBodyPatchPath]).body;
|
|
assert.equal(repositoryPatchDryRunJson.ok, true);
|
|
assert.equal(repositoryPatchDryRunJson.checkOnly, true);
|
|
assert.equal(repositoryPatchDryRunJson.saved, null);
|
|
assert.equal(zero(["view", graphRepositoryPatchPackageDir]).stdout, checkedInGraphSource);
|
|
const repositoryBodyPatchJson = json(["patch", "--json", graphRepositoryPatchPackageDir, graphRepositoryBodyPatchPath]).body;
|
|
assert.equal(repositoryBodyPatchJson.ok, true);
|
|
assert.equal(repositoryBodyPatchJson.checkOnly, false);
|
|
assert.equal(repositoryBodyPatchJson.operations[0].op, "replaceFunctionBody");
|
|
assert.equal(repositoryBodyPatchJson.saved.path, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.match(zero(["view", graphRepositoryPatchPackageDir]).stdout, /let name: Maybe<String> = std\.args\.get\(1\)/);
|
|
assert.equal(zero(["check", graphRepositoryPatchPackageDir]).stdout, "ok\n");
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "hello Ada\n");
|
|
const repositoryBlockQueryJson = json(["query", "--json", "--find", "Block", graphRepositoryPatchPackageDir]).body;
|
|
const repositoryThenBlock = repositoryBlockQueryJson.matches.find((node) => node.kind === "Block" && node.name === "then");
|
|
assert(repositoryThenBlock, "expected replaceFunctionBody patch to expose a then block handle");
|
|
writeFileSync(graphRepositoryInvalidBlockRowsPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryBlockQueryJson.graphHash}"`,
|
|
`replaceBlockBody ${repositoryThenBlock.id}`,
|
|
" check world.out.write \"name: \"",
|
|
" let same Bool = std.mem.eql (std.mem.span name \"Ada\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryInvalidBlockRowsDryRun = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryInvalidBlockRowsPatchPath], { allowFailure: true });
|
|
assert.notEqual(repositoryInvalidBlockRowsDryRun.code, 0);
|
|
assert.equal(repositoryInvalidBlockRowsDryRun.body.diagnostic.code, "GPH001");
|
|
assert.match(repositoryInvalidBlockRowsDryRun.body.diagnostic.actual, /row 2: let same Bool = std\.mem\.eql/);
|
|
writeFileSync(graphRepositoryBlockPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryBlockQueryJson.graphHash}"`,
|
|
`replaceBlockBody ${repositoryThenBlock.id}`,
|
|
" check world.out.write \"name: \"",
|
|
" check world.out.write name.value",
|
|
" check world.out.write \"\\n\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryBlockPatchDryRunJson = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryBlockPatchPath]).body;
|
|
assert.equal(repositoryBlockPatchDryRunJson.ok, true);
|
|
assert.equal(repositoryBlockPatchDryRunJson.checkOnly, true);
|
|
assert.equal(repositoryBlockPatchDryRunJson.saved, null);
|
|
const repositoryBlockPatchJson = json(["patch", "--json", graphRepositoryPatchPackageDir, graphRepositoryBlockPatchPath]).body;
|
|
assert.equal(repositoryBlockPatchJson.ok, true);
|
|
assert.equal(repositoryBlockPatchJson.operations[0].op, "replaceBlockBody");
|
|
assert.equal(repositoryBlockPatchJson.saved.path, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
const repositoryBlockView = zero(["view", graphRepositoryPatchPackageDir]).stdout;
|
|
assert.match(repositoryBlockView, /check world\.out\.write\("name: "\)/);
|
|
assert.match(repositoryBlockView, /check world\.out\.write\("hello anonymous\\n"\)/);
|
|
assert.equal(zero(["check", graphRepositoryPatchPackageDir]).stdout, "ok\n");
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "name: Ada\n");
|
|
assert.match(zero(["status", graphRepositoryPatchPackageDir]).stdout, /source-stale/);
|
|
const statusStorePathStdout = zero(["status", join(graphRepositoryPatchPackageDir, "zero.graph")]).stdout;
|
|
assert.match(statusStorePathStdout, /repository graph status: source-stale/);
|
|
assert.match(statusStorePathStdout, new RegExp(`root: ${graphRepositoryPatchPackageDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\n`));
|
|
assert.match(zero(["export", graphRepositoryPatchPackageDir]).stdout, /repository graph export ok/);
|
|
assert.equal(zero(["verify-projection", graphRepositoryPatchPackageDir]).stdout, "repository graph verify-projection ok\n");
|
|
assert.equal(zero(["verify-projection", join(graphRepositoryPatchPackageDir, "zero.graph")]).stdout, "repository graph verify-projection ok\n");
|
|
const repositoryRowQueryJson = json(["query", "--json", graphRepositoryPatchPackageDir]).body;
|
|
writeFileSync(graphRepositoryCheckExprPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryRowQueryJson.graphHash}"`,
|
|
"replaceFunctionBody main",
|
|
" var path_storage [32]u8 = repeat 0_u8 32",
|
|
" let name String = check std.path.join path_storage \".zero\" \"row-ergonomics\"",
|
|
" if !std.mem.eql name \".zero/row-ergonomics\"",
|
|
" check world.err.write \"wrong name\\n\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryCheckExprDryRunJson = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryCheckExprPatchPath]).body;
|
|
assert.equal(repositoryCheckExprDryRunJson.ok, true);
|
|
assert.equal(repositoryCheckExprDryRunJson.checkOnly, true);
|
|
assert.equal(repositoryCheckExprDryRunJson.saved, null);
|
|
assert.equal(repositoryCheckExprDryRunJson.operations[0].op, "replaceFunctionBody");
|
|
writeFileSync(graphRepositoryRowErgonomicsPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositoryRowQueryJson.graphHash}"`,
|
|
"replaceFunctionBody main",
|
|
" let name String = \".zero/row-ergonomics\"",
|
|
" let same Bool = std.mem.eql (std.mem.span name) \".zero/row-ergonomics\"",
|
|
" let status i32 = 200_u16 as i32",
|
|
" let count i32 = 2",
|
|
" let math Bool = count + 1 > 2",
|
|
" if !same || status != 200",
|
|
" check world.err.write \"wrong name\\n\"",
|
|
" else if math || status == 200",
|
|
" check world.out.write \"row ergonomics ok\\n\"",
|
|
" return",
|
|
" else",
|
|
" return",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryRowErgonomicsDryRunJson = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryRowErgonomicsPatchPath]).body;
|
|
assert.equal(repositoryRowErgonomicsDryRunJson.ok, true);
|
|
assert.equal(repositoryRowErgonomicsDryRunJson.checkOnly, true);
|
|
assert.equal(repositoryRowErgonomicsDryRunJson.saved, null);
|
|
const repositoryRowErgonomicsPatchJson = json(["patch", "--json", graphRepositoryPatchPackageDir, graphRepositoryRowErgonomicsPatchPath]).body;
|
|
assert.equal(repositoryRowErgonomicsPatchJson.ok, true);
|
|
assert.equal(repositoryRowErgonomicsPatchJson.operations[0].op, "replaceFunctionBody");
|
|
const repositoryRowErgonomicsView = zero(["view", graphRepositoryPatchPackageDir]).stdout;
|
|
assert.match(repositoryRowErgonomicsView, /let name: String = "\.zero\/row-ergonomics"/);
|
|
assert.match(repositoryRowErgonomicsView, /let same: Bool = std\.mem\.eql\(std\.mem\.span\(name\), "\.zero\/row-ergonomics"\)/);
|
|
assert.match(repositoryRowErgonomicsView, /let status: i32 = 200_u16 as i32/);
|
|
assert.match(repositoryRowErgonomicsView, /let math: Bool = count \+ 1 > 2/);
|
|
assert.match(repositoryRowErgonomicsView, /if !same \|\| status != 200/);
|
|
assert.match(repositoryRowErgonomicsView, /else if math \|\| status == 200/);
|
|
assert.match(repositoryRowErgonomicsView, /return/);
|
|
assert.equal(zero(["check", graphRepositoryPatchPackageDir]).stdout, "ok\n");
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir]).stdout, "row ergonomics ok\n");
|
|
assert.match(zero(["export", graphRepositoryPatchPackageDir]).stdout, /repository graph export ok/);
|
|
assert.equal(zero(["verify-projection", graphRepositoryPatchPackageDir]).stdout, "repository graph verify-projection ok\n");
|
|
const repositorySyncedQueryJson = json(["query", "--json", graphRepositoryPatchPackageDir]).body;
|
|
writeFileSync(graphRepositoryInvalidRowsPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositorySyncedQueryJson.graphHash}"`,
|
|
"replaceFunctionBody main",
|
|
" let name String = \"Ada\"",
|
|
" let same Bool = std.mem.eql (std.mem.span name \"Ada\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryInvalidRowsDryRun = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryInvalidRowsPatchPath], { allowFailure: true });
|
|
assert.notEqual(repositoryInvalidRowsDryRun.code, 0);
|
|
assert.equal(repositoryInvalidRowsDryRun.body.diagnostic.code, "GPH001");
|
|
assert.match(repositoryInvalidRowsDryRun.body.diagnostic.actual, /row 2: let same Bool = std\.mem\.eql/);
|
|
writeFileSync(graphRepositoryInvalidBodyPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${repositorySyncedQueryJson.graphHash}"`,
|
|
"replaceFunctionBody main",
|
|
" world.out.write \"bad\\n\"",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const repositoryInvalidBodyDryRun = json(["patch", "--json", "--check-only", graphRepositoryPatchPackageDir, graphRepositoryInvalidBodyPatchPath], { allowFailure: true });
|
|
assert.notEqual(repositoryInvalidBodyDryRun.code, 0);
|
|
assert.equal(repositoryInvalidBodyDryRun.body.diagnostics[0].code, "ERR003");
|
|
assert.equal(repositoryInvalidBodyDryRun.body.diagnostics[0].message, "fallible function call must be checked");
|
|
assert.equal(repositoryInvalidBodyDryRun.body.diagnostics[0].path, "hello.0");
|
|
const repositoryInvalidBodyPatch = json(["patch", "--json", graphRepositoryPatchPackageDir, graphRepositoryInvalidBodyPatchPath], { allowFailure: true });
|
|
assert.notEqual(repositoryInvalidBodyPatch.code, 0);
|
|
assert.equal(repositoryInvalidBodyPatch.body.diagnostics[0].code, "ERR003");
|
|
assert.equal(json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash, repositorySyncedQueryJson.graphHash);
|
|
const replaceFnBodyPath = join(outDir, "repository-graph.replace-fn.body");
|
|
writeFileSync(replaceFnBodyPath, [
|
|
" let name: Maybe<String> = std.args.get(1)",
|
|
" if name.has {",
|
|
" check world.out.write(\"hi \")",
|
|
" check world.out.write(name.value)",
|
|
" check world.out.write(\"\\n\")",
|
|
" } else {",
|
|
" check world.out.write(\"hi anonymous\\n\")",
|
|
" }",
|
|
"",
|
|
].join("\n"));
|
|
const replaceFnPatchJson = json(["patch", "--json", graphRepositoryPatchPackageDir, "--expect-graph-hash", repositorySyncedQueryJson.graphHash, "--replace-fn", "main", "--body-file", replaceFnBodyPath]).body;
|
|
assert.equal(replaceFnPatchJson.ok, true);
|
|
assert.equal(replaceFnPatchJson.patch, replaceFnBodyPath);
|
|
assert.equal(replaceFnPatchJson.operationCount, 1);
|
|
assert.equal(replaceFnPatchJson.operations[0].op, "replaceFunctionBody");
|
|
assert.equal(replaceFnPatchJson.saved.path, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.match(zero(["view", "--fn", "main", graphRepositoryPatchPackageDir]).stdout, /check world\.out\.write\("hi "\)/);
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "hi Ada\n");
|
|
const replaceFnStaleHash = json(["patch", "--json", graphRepositoryPatchPackageDir, "--expect-graph-hash", repositorySyncedQueryJson.graphHash, "--replace-fn", "main", "--body-file", replaceFnBodyPath], { allowFailure: true });
|
|
assert.notEqual(replaceFnStaleHash.code, 0);
|
|
assert.equal(replaceFnStaleHash.body.diagnostic.code, "GPH002");
|
|
const replaceFnInvalidBodyPath = join(outDir, "repository-graph.replace-fn.invalid.body");
|
|
writeFileSync(replaceFnInvalidBodyPath, " let same Bool = std.mem.eql (std.mem.span name \"Ada\"\n");
|
|
const replaceFnInvalidText = zero(["patch", graphRepositoryPatchPackageDir, "--replace-fn", "main", "--body-file", replaceFnInvalidBodyPath], { allowFailure: true });
|
|
assert.notEqual(replaceFnInvalidText.code, 0);
|
|
assert.match(replaceFnInvalidText.stderr, /replaceFunctionBody rows did not parse as a Zero function body/);
|
|
assert.match(replaceFnInvalidText.stderr, /row 1: let same Bool = std\.mem\.eql \(std\.mem\.span name "Ada"/);
|
|
const replaceFnInvalidJson = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-fn", "main", "--body-file", replaceFnInvalidBodyPath], { allowFailure: true });
|
|
assert.notEqual(replaceFnInvalidJson.code, 0);
|
|
assert.equal(replaceFnInvalidJson.body.diagnostic.code, "GPH001");
|
|
assert.match(replaceFnInvalidJson.body.diagnostic.actual, /row 1: let same Bool = std\.mem\.eql/);
|
|
const replaceFnEmptyBodyPath = join(outDir, "repository-graph.replace-fn.empty.body");
|
|
writeFileSync(replaceFnEmptyBodyPath, "\n");
|
|
const replaceFnEmptyJson = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-fn", "main", "--body-file", replaceFnEmptyBodyPath], { allowFailure: true });
|
|
assert.notEqual(replaceFnEmptyJson.code, 0);
|
|
assert.equal(replaceFnEmptyJson.body.diagnostic.code, "GPH001");
|
|
assert.equal(replaceFnEmptyJson.body.diagnostic.message, "function body file is empty");
|
|
const replaceFnMissingBodyFlag = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-fn", "main"], { allowFailure: true });
|
|
assert.notEqual(replaceFnMissingBodyFlag.code, 0);
|
|
assert.match(replaceFnMissingBodyFlag.body.diagnostics[0].message, /needs both --replace-fn and --body-file/);
|
|
assert.equal(replaceFnMissingBodyFlag.body.diagnostics[0].actual, "missing --body-file");
|
|
const replaceFnAmbiguousSource = json(["patch", "--json", graphRepositoryPatchPackageDir, graphRepositoryBodyPatchPath, "--replace-fn", "main", "--body-file", replaceFnBodyPath], { allowFailure: true });
|
|
assert.notEqual(replaceFnAmbiguousSource.code, 0);
|
|
assert.match(replaceFnAmbiguousSource.body.diagnostics[0].message, /graph patch source is ambiguous/);
|
|
const replaceFnStdinHash = json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash;
|
|
const replaceFnStdinBody = ' check world.out.write("quoted \\"rows\\" with $HOME and C:\\\\path\\n")\n';
|
|
const replaceFnStdinText = zeroWithInput(["patch", graphRepositoryPatchPackageDir, "--expect-graph-hash", replaceFnStdinHash, "--replace-fn", "main", "--body-file", "-"], replaceFnStdinBody);
|
|
assertPatchOkOutput(replaceFnStdinText.stdout, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.match(zero(["view", "--fn", "main", graphRepositoryPatchPackageDir]).stdout, /quoted \\"rows\\" with \$HOME and C:\\\\path/);
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir]).stdout, 'quoted "rows" with $HOME and C:\\path\n');
|
|
const replaceFnStdinJsonHash = json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash;
|
|
const replaceFnStdinJsonRun = zeroWithInput(["patch", "--json", graphRepositoryPatchPackageDir, "--expect-graph-hash", replaceFnStdinJsonHash, "--replace-fn", "main", "--body-file", "-"], ' check world.out.write("stdin body update\\n")\n');
|
|
const replaceFnStdinJson = JSON.parse(replaceFnStdinJsonRun.stdout);
|
|
assert.equal(replaceFnStdinJson.ok, true);
|
|
assert.equal(replaceFnStdinJson.patch, "<stdin>");
|
|
assert.equal(replaceFnStdinJson.operationCount, 1);
|
|
assert.equal(replaceFnStdinJson.operations[0].op, "replaceFunctionBody");
|
|
assert.equal(replaceFnStdinJson.saved.path, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir]).stdout, "stdin body update\n");
|
|
const replaceFnStdinEmpty = zeroWithInput(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-fn", "main", "--body-file", "-"], "\n", { allowFailure: true });
|
|
assert.notEqual(replaceFnStdinEmpty.code, 0);
|
|
const replaceFnStdinEmptyBody = JSON.parse(replaceFnStdinEmpty.stdout);
|
|
assert.equal(replaceFnStdinEmptyBody.diagnostic.code, "GPH001");
|
|
assert.equal(replaceFnStdinEmptyBody.diagnostic.message, "function body file is empty");
|
|
assert.equal(replaceFnStdinEmptyBody.diagnostic.actual, "<stdin>");
|
|
// Surgical in-function replacement: --replace-in-fn finds --old as a literal
|
|
// substring of the canonical body projection (the text zero view --fn prints),
|
|
// requires it unique within the function, and revalidates exactly like
|
|
// --replace-fn, all in one call.
|
|
const replaceInFnHash = json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash;
|
|
const replaceInFnSingle = zero(["patch", graphRepositoryPatchPackageDir, "--expect-graph-hash", replaceInFnHash, "--replace-in-fn", "main", "--old", "stdin body update\\n", "--new", "surgical update\\n"]);
|
|
assertPatchOkOutput(replaceInFnSingle.stdout, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir]).stdout, "surgical update\n");
|
|
const replaceInFnBodyRows = [
|
|
' let name: Maybe<String> = std.args.get(1)',
|
|
' if name.has {',
|
|
' check world.out.write("hey ")',
|
|
' check world.out.write(name.value)',
|
|
' check world.out.write("\\n")',
|
|
' } else {',
|
|
' check world.out.write("hey anonymous\\n")',
|
|
' }',
|
|
'',
|
|
].join("\n");
|
|
zeroWithInput(["patch", graphRepositoryPatchPackageDir, "--replace-fn", "main", "--body-file", "-"], replaceInFnBodyRows);
|
|
const replaceInFnView = zero(["view", "--fn", "main", graphRepositoryPatchPackageDir]).stdout;
|
|
const replaceInFnViewLines = replaceInFnView.split("\n");
|
|
const replaceInFnHeyIndex = replaceInFnViewLines.findIndex((line) => line.includes('"hey "'));
|
|
assert(replaceInFnHeyIndex > 0, "expected the replaced body in zero view --fn main");
|
|
// multi-line --old/--new through inline \n escapes, exactly as view prints the rows
|
|
const replaceInFnMultiOld = `${replaceInFnViewLines[replaceInFnHeyIndex]}\\n${replaceInFnViewLines[replaceInFnHeyIndex + 1]}`;
|
|
const replaceInFnMultiNew = replaceInFnMultiOld.replace('"hey "', '"hi "');
|
|
const replaceInFnMulti = zero(["patch", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", replaceInFnMultiOld, "--new", replaceInFnMultiNew]);
|
|
assertPatchOkOutput(replaceInFnMulti.stdout, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "hi Ada\n");
|
|
// non-unique --old fails with the occurrence count and a view-oriented hint
|
|
const replaceInFnAmbiguous = zero(["patch", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", "check world.out.write(", "--new", "check world.err.write("], { allowFailure: true });
|
|
assert.notEqual(replaceInFnAmbiguous.code, 0);
|
|
assert.match(replaceInFnAmbiguous.stderr, /replace-in-fn --old text matches 4 places in function 'main'/);
|
|
assert.match(replaceInFnAmbiguous.stderr, /zero view --fn main/);
|
|
// missing --old fails without touching the store
|
|
const replaceInFnMissBefore = json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash;
|
|
const replaceInFnMiss = zero(["patch", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", "zzz-not-here", "--new", "anything"], { allowFailure: true });
|
|
assert.notEqual(replaceInFnMiss.code, 0);
|
|
assert.match(replaceInFnMiss.stderr, /replace-in-fn --old text was not found in function 'main'/);
|
|
assert.match(replaceInFnMiss.stderr, /zero view --fn main/);
|
|
assert.equal(json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash, replaceInFnMissBefore);
|
|
// stdin variants: --old-file - and --new-file - read the text verbatim
|
|
const replaceInFnStdinOld = zeroWithInput(["patch", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old-file", "-", "--new", replaceInFnViewLines[replaceInFnHeyIndex].replace('"hey "', '"hello "')], replaceInFnViewLines[replaceInFnHeyIndex].replace('"hey "', '"hi "'));
|
|
assertPatchOkOutput(replaceInFnStdinOld.stdout, join(graphRepositoryPatchPackageDir, "zero.graph"));
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "hello Ada\n");
|
|
const replaceInFnStdinNew = zeroWithInput(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", '"hello "', "--new-file", "-"], '"howdy "');
|
|
const replaceInFnStdinNewBody = JSON.parse(replaceInFnStdinNew.stdout);
|
|
assert.equal(replaceInFnStdinNewBody.ok, true);
|
|
assert.equal(replaceInFnStdinNewBody.patch, "<replace-in-fn>");
|
|
assert.equal(replaceInFnStdinNewBody.operationCount, 1);
|
|
assert.equal(replaceInFnStdinNewBody.operations[0].op, "replaceFunctionBody");
|
|
assert.equal(zero(["run", graphRepositoryPatchPackageDir, "--", "Ada"]).stdout, "howdy Ada\n");
|
|
// a replacement that introduces a diagnostic fails revalidation with
|
|
// baseline-diff behavior and leaves the store untouched
|
|
const replaceInFnInvalidBefore = json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash;
|
|
const replaceInFnInvalid = zero(["patch", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", 'check world.out.write("howdy ")', "--new", 'world.out.write("howdy ")'], { allowFailure: true });
|
|
assert.notEqual(replaceInFnInvalid.code, 0);
|
|
assert.match(replaceInFnInvalid.stderr, /ERR003: fallible function call must be checked/);
|
|
assert.match(replaceInFnInvalid.stderr, /program graph patch failed revalidation: 1 diagnostic introduced by this patch/);
|
|
assert.equal(json(["query", "--json", graphRepositoryPatchPackageDir]).body.graphHash, replaceInFnInvalidBefore);
|
|
// incomplete or doubled flag sets fail with actionable diagnostics
|
|
const replaceInFnMissingNew = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", "x"], { allowFailure: true });
|
|
assert.notEqual(replaceInFnMissingNew.code, 0);
|
|
assert.match(replaceInFnMissingNew.body.diagnostics[0].message, /needs --replace-in-fn, --old, and --new/);
|
|
assert.equal(replaceInFnMissingNew.body.diagnostics[0].actual, "missing --new");
|
|
const replaceInFnDoubleStdin = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old-file", "-", "--new-file", "-"], { allowFailure: true });
|
|
assert.notEqual(replaceInFnDoubleStdin.code, 0);
|
|
assert.match(replaceInFnDoubleStdin.body.diagnostics[0].message, /cannot read both texts from stdin/);
|
|
const replaceInFnMixedSource = json(["patch", "--json", graphRepositoryPatchPackageDir, "--replace-in-fn", "main", "--old", "x", "--new", "y", "--replace-fn", "main", "--body-file", "-"], { allowFailure: true });
|
|
assert.notEqual(replaceInFnMixedSource.code, 0);
|
|
assert.match(replaceInFnMixedSource.body.diagnostics[0].message, /graph patch source is ambiguous/);
|
|
const genericPatchRoot = join(outDir, "repository-graph-generic-patch");
|
|
rmSync(genericPatchRoot, { recursive: true, force: true });
|
|
mkdirSync(join(genericPatchRoot, "src"), { recursive: true });
|
|
writeZeroTomlSync(genericPatchRoot, { package: { name: "generic-patch", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } });
|
|
writeFileSync(join(genericPatchRoot, "src", "main.0"), [
|
|
"fn tail(data: Span<u8>, offset: usize) -> Span<u8> {",
|
|
" return std.mem.dropPrefix(data, offset)",
|
|
"}",
|
|
"",
|
|
"fn pick(data: Span<u8>, limit: usize) -> usize {",
|
|
" var i: usize = 0",
|
|
" var total: usize = 0",
|
|
" while i < limit {",
|
|
" total = total + std.mem.len(tail(data, i))",
|
|
" i = i + 1_usize",
|
|
" }",
|
|
" return total",
|
|
"}",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
" let bytes: Span<u8> = \"abc\"",
|
|
" if pick(bytes, 2) > 0 {",
|
|
" check world.out.write(\"generic patch ok\\n\")",
|
|
" }",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assert.equal(json(["import", "--format", "text", "--json", genericPatchRoot]).code, 0);
|
|
assert.equal(zero(["check", genericPatchRoot]).stdout, "ok\n");
|
|
const genericPatchDump = zero(["dump", genericPatchRoot]).stdout;
|
|
const genericComparisonNode = genericPatchDump.match(/node (#\S+) Call name:"<"/);
|
|
assert(genericComparisonNode, "expected a comparison Call node in the generic-bearing package dump");
|
|
const genericOperatorFlip = json(["patch", "--json", genericPatchRoot, "--op", `set node="${genericComparisonNode[1]}" field="name" expect="<" value="<="`]).body;
|
|
assert.equal(genericOperatorFlip.ok, true);
|
|
assert.equal(genericOperatorFlip.operations[0].ok, true);
|
|
assert.equal(zero(["check", genericPatchRoot]).stdout, "ok\n");
|
|
assert.match(zero(["view", genericPatchRoot]).stdout, /while i <= limit/);
|
|
assert.equal(zero(["run", genericPatchRoot]).stdout, "generic patch ok\n");
|
|
const genericViewBodyQuery = json(["query", "--json", genericPatchRoot]).body;
|
|
const genericViewSource = zero(["view", genericPatchRoot]).stdout.split("\n");
|
|
const genericPickStart = genericViewSource.findIndex((line) => line.startsWith("fn pick("));
|
|
assert(genericPickStart >= 0, "expected zero view to print fn pick");
|
|
const genericPickBody: string[] = [];
|
|
let genericPickDepth = 0;
|
|
for (const line of genericViewSource.slice(genericPickStart)) {
|
|
genericPickDepth += (line.match(/\{/g) ?? []).length - (line.match(/\}/g) ?? []).length;
|
|
genericPickBody.push(line);
|
|
if (genericPickDepth === 0 && genericPickBody.length > 1) break;
|
|
}
|
|
const genericVerbatimPatchPath = join(outDir, "repository-graph-generic-verbatim.patch");
|
|
writeFileSync(genericVerbatimPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${genericViewBodyQuery.graphHash}"`,
|
|
"replaceFunctionBody pick",
|
|
...genericPickBody.slice(1, -1).map((line) => ` ${line}`),
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const genericVerbatimPatch = json(["patch", "--json", genericPatchRoot, genericVerbatimPatchPath]).body;
|
|
assert.equal(genericVerbatimPatch.ok, true);
|
|
assert.equal(genericVerbatimPatch.operations[0].op, "replaceFunctionBody");
|
|
assert.equal(zero(["check", genericPatchRoot]).stdout, "ok\n");
|
|
assert.equal(zero(["run", genericPatchRoot]).stdout, "generic patch ok\n");
|
|
const genericTypedRowsQuery = json(["query", "--json", genericPatchRoot]).body;
|
|
const genericTypedRowsPatchPath = join(outDir, "repository-graph-generic-typed-rows.patch");
|
|
writeFileSync(genericTypedRowsPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${genericTypedRowsQuery.graphHash}"`,
|
|
"replaceFunctionBody pick",
|
|
" let n: usize = std.mem.len(tail(data, 0))",
|
|
" var total: usize = 0",
|
|
" if n > 0 && limit > 0 {",
|
|
" total = n + limit",
|
|
" } else {",
|
|
" total = limit",
|
|
" }",
|
|
" return total",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const genericTypedRowsPatch = json(["patch", "--json", genericPatchRoot, genericTypedRowsPatchPath]).body;
|
|
assert.equal(genericTypedRowsPatch.ok, true);
|
|
assert.equal(genericTypedRowsPatch.operations[0].op, "replaceFunctionBody");
|
|
const genericTypedRowsView = zero(["view", genericPatchRoot]).stdout;
|
|
assert.match(genericTypedRowsView, /let n: usize = std\.mem\.len\(tail\(data, 0\)\)/);
|
|
assert.match(genericTypedRowsView, /if n > 0 && limit > 0/);
|
|
assert.equal(zero(["check", genericPatchRoot]).stdout, "ok\n");
|
|
const genericUnknownOpPatchPath = join(outDir, "repository-graph-generic-unknown-op.patch");
|
|
writeFileSync(genericUnknownOpPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
'setNodeField node="#missing" value="oops"',
|
|
"",
|
|
].join("\n"));
|
|
const genericUnknownOp = json(["patch", "--json", "--check-only", genericPatchRoot, genericUnknownOpPatchPath], { allowFailure: true });
|
|
assert.notEqual(genericUnknownOp.code, 0);
|
|
assert.equal(genericUnknownOp.body.diagnostic.code, "GPH001");
|
|
assert.match(genericUnknownOp.body.diagnostic.message, /unknown program graph patch operation/);
|
|
assert.match(genericUnknownOp.body.diagnostic.message, /zero patch --op help/);
|
|
assert.match(genericUnknownOp.body.diagnostic.expected, /set, insert, insertEdge, replace, replaceExpr, delete, rename/);
|
|
assert.match(genericUnknownOp.body.diagnostic.expected, /replaceFunctionBody/);
|
|
assert.equal(genericUnknownOp.body.diagnostic.line, 2);
|
|
const genericUnknownOpText = zero(["patch", "--check-only", genericPatchRoot, genericUnknownOpPatchPath], { allowFailure: true });
|
|
assert.notEqual(genericUnknownOpText.code, 0);
|
|
assert.match(genericUnknownOpText.stderr, /unknown program graph patch operation/);
|
|
assert.match(genericUnknownOpText.stderr, new RegExp(`${genericUnknownOpPatchPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:2: setNodeField`));
|
|
assert.match(genericUnknownOpText.stderr, /help: a minimal complete patch file looks exactly like this:\nzero-program-graph-patch v1\nreplaceFunctionBody main\n {2}check world\.out\.write "hello\\n"\nend\n/);
|
|
const genericMissingHeaderPatchPath = join(outDir, "repository-graph-generic-missing-header.patch");
|
|
writeFileSync(genericMissingHeaderPatchPath, [
|
|
"replaceFunctionBody main",
|
|
' check world.out.write("missing header\\n")',
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const genericMissingHeader = zero(["patch", "--check-only", genericPatchRoot, genericMissingHeaderPatchPath], { allowFailure: true });
|
|
assert.notEqual(genericMissingHeader.code, 0);
|
|
assert.match(genericMissingHeader.stderr, /unknown program graph patch schema/);
|
|
assert.match(genericMissingHeader.stderr, new RegExp(`${genericMissingHeaderPatchPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:1: replaceFunctionBody main`));
|
|
assert.match(genericMissingHeader.stderr, /expected: zero-program-graph-patch v1/);
|
|
assert.match(genericMissingHeader.stderr, /help: a minimal complete patch file looks exactly like this:/);
|
|
const genericMissingEndPatchPath = join(outDir, "repository-graph-generic-missing-end.patch");
|
|
writeFileSync(genericMissingEndPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
"replaceFunctionBody main",
|
|
' check world.out.write("missing end\\n")',
|
|
"",
|
|
].join("\n"));
|
|
const genericMissingEnd = zero(["patch", "--check-only", genericPatchRoot, genericMissingEndPatchPath], { allowFailure: true });
|
|
assert.notEqual(genericMissingEnd.code, 0);
|
|
assert.match(genericMissingEnd.stderr, /body patch is missing end marker/);
|
|
assert.match(genericMissingEnd.stderr, new RegExp(`${genericMissingEndPatchPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:2: replaceFunctionBody main`));
|
|
assert.match(genericMissingEnd.stderr, /help: a minimal complete patch file looks exactly like this:/);
|
|
const genericIndentedHeaderPatchPath = join(outDir, "repository-graph-generic-indented-header.patch");
|
|
writeFileSync(genericIndentedHeaderPatchPath, [
|
|
" zero-program-graph-patch v1",
|
|
" replaceFunctionBody main",
|
|
' check world.out.write("indented header ok\\n")',
|
|
" end",
|
|
"",
|
|
].join("\n"));
|
|
const genericIndentedHeaderCheckOnly = zero(["patch", "--check-only", genericPatchRoot, genericIndentedHeaderPatchPath]).stdout;
|
|
assert.match(genericIndentedHeaderCheckOnly, /^program graph patch ok \(check-only\)\n/);
|
|
assert.match(genericIndentedHeaderCheckOnly, /validated: check-equivalent\n$/);
|
|
|
|
const headerlessOpsRoot = join(outDir, "repository-graph-headerless-ops");
|
|
rmSync(headerlessOpsRoot, { recursive: true, force: true });
|
|
mkdirSync(join(headerlessOpsRoot, "src"), { recursive: true });
|
|
writeZeroTomlSync(headerlessOpsRoot, { package: { name: "headerless-ops", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } });
|
|
writeFileSync(join(headerlessOpsRoot, "src", "main.0"), [
|
|
"const LIMIT: usize = 4",
|
|
"",
|
|
"fn bump(value: usize) -> usize {",
|
|
" return value + LIMIT",
|
|
"}",
|
|
"",
|
|
"fn answer() -> usize {",
|
|
" return LIMIT",
|
|
"}",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
" if bump(1) == answer() + 1 {",
|
|
" check world.out.write(\"headerless ops ok\\n\")",
|
|
" }",
|
|
"}",
|
|
"",
|
|
"test \"answer works\" {",
|
|
" expect (answer() == 4)",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assert.equal(json(["import", "--format", "text", "--json", headerlessOpsRoot]).code, 0);
|
|
const headerlessAnswerHandles = zero(["view", "--fn", "answer", "--handles", headerlessOpsRoot]).stdout;
|
|
const headerlessReturnHandle = headerlessAnswerHandles.match(/return LIMIT\s+\/\/ (#\S+)/);
|
|
assert(headerlessReturnHandle, "expected answer return handle for headerless replaceExpr detection");
|
|
function assertHeaderlessPatchFileDetected(name: string, rows: string[]) {
|
|
const patchPath = join(headerlessOpsRoot, `${name}.patch`);
|
|
writeFileSync(patchPath, [...rows, ""].join("\n"));
|
|
const result = zeroWithStderr(["patch", "--check-only", `${name}.patch`], { cwd: headerlessOpsRoot });
|
|
assert.notEqual(result.code, 0);
|
|
assert.match(result.stderr, /unknown program graph patch schema/);
|
|
assert.match(result.stderr, new RegExp(`${name}\\.patch:1: ${rows[0].replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
|
|
assert.match(result.stderr, /expected: zero-program-graph-patch v1/);
|
|
}
|
|
assertHeaderlessPatchFileDetected("set-const", ['setConst name="LIMIT" value="5"']);
|
|
assertHeaderlessPatchFileDetected("set-return-type", [
|
|
'setReturnType fn="answer" type="i64"',
|
|
"replaceFunctionBody answer",
|
|
" return 4 as i64",
|
|
"end",
|
|
]);
|
|
assertHeaderlessPatchFileDetected("replace-expr", [`replaceExpr node="${headerlessReturnHandle[1]}" with="LIMIT + 0"`]);
|
|
assertHeaderlessPatchFileDetected("delete-test", ['deleteTest name="answer works"']);
|
|
assertHeaderlessPatchFileDetected("rename-test", ['renameTest name="answer works" value="answer still works"']);
|
|
assertHeaderlessPatchFileDetected("add-param-to", ['addParamTo fn="bump" name="bias" type="usize" default="0"']);
|
|
|
|
// Declaration-level patch ops: setConst, addParamTo, setReturnType.
|
|
const declOpsRoot = join(outDir, "repository-graph-decl-ops");
|
|
rmSync(declOpsRoot, { recursive: true, force: true });
|
|
mkdirSync(join(declOpsRoot, "src"), { recursive: true });
|
|
writeZeroTomlSync(declOpsRoot, { package: { name: "decl-ops", version: "0.1.0" }, targets: { cli: { kind: "exe", main: "src/main.0" } } });
|
|
writeFileSync(join(declOpsRoot, "src", "main.0"), [
|
|
"const LIMIT: usize = 4",
|
|
"",
|
|
"fn bump(value: usize) -> usize {",
|
|
" return value + LIMIT",
|
|
"}",
|
|
"",
|
|
"fn twice(value: usize) -> usize {",
|
|
" return bump(bump(value))",
|
|
"}",
|
|
"",
|
|
"fn answer() -> usize {",
|
|
" return LIMIT",
|
|
"}",
|
|
"",
|
|
"fn wide(a: Span<u8>, b: Span<u8>, c: Span<u8>, d: usize) -> usize {",
|
|
" return std.mem.len(a) + std.mem.len(b) + std.mem.len(c) + d",
|
|
"}",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
" let start: usize = bump(1)",
|
|
" let total: usize = twice(start)",
|
|
" let padding: usize = wide(\"a\", \"b\", \"c\", 0)",
|
|
" if total + padding > answer() {",
|
|
" check world.out.write(\"decl ops ok\\n\")",
|
|
" }",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assert.equal(json(["import", "--format", "text", "--json", declOpsRoot]).code, 0);
|
|
assert.equal(zero(["check", declOpsRoot]).stdout, "ok\n");
|
|
const declOpsViewBefore = zero(["view", declOpsRoot]).stdout;
|
|
assert.match(declOpsViewBefore, /const LIMIT: usize = 4/);
|
|
// setConst round trip: change the initializer, then restore it.
|
|
const declOpsSetConst = zero(["patch", declOpsRoot, "--op", 'setConst name="LIMIT" value="8"']);
|
|
assertPatchOkOutput(declOpsSetConst.stdout, join(declOpsRoot, "zero.graph"));
|
|
assert.match(declOpsSetConst.stdout, /validated: check-equivalent\n$/);
|
|
assert.match(zero(["view", declOpsRoot]).stdout, /const LIMIT: usize = 8/);
|
|
assert.equal(zero(["check", declOpsRoot]).stdout, "ok\n");
|
|
const declOpsSetConstBack = json(["patch", "--json", declOpsRoot, "--op", 'setConst name="LIMIT" value="4"']).body;
|
|
assert.equal(declOpsSetConstBack.ok, true);
|
|
assert.equal(declOpsSetConstBack.operations[0].op, "setConst");
|
|
assert.equal(zero(["view", declOpsRoot]).stdout, declOpsViewBefore);
|
|
// setConst revalidation failure rolls the store back untouched.
|
|
const declOpsStoreBefore = readFileSync(join(declOpsRoot, "zero.graph"), "utf8");
|
|
const declOpsBadConst = zero(["patch", declOpsRoot, "--op", 'setConst name="LIMIT" value="missingName"'], { allowFailure: true });
|
|
assert.notEqual(declOpsBadConst.code, 0);
|
|
assert.match(declOpsBadConst.stderr, /program graph patch failed revalidation: 1 diagnostic introduced by this patch/);
|
|
assert.equal(readFileSync(join(declOpsRoot, "zero.graph"), "utf8"), declOpsStoreBefore);
|
|
assert.match(zero(["view", declOpsRoot]).stdout, /const LIMIT: usize = 4/);
|
|
// setConst misses fail with the nearest const name.
|
|
const declOpsConstMiss = zero(["patch", declOpsRoot, "--op", 'setConst name="LIMTI" value="8"'], { allowFailure: true });
|
|
assert.notEqual(declOpsConstMiss.code, 0);
|
|
assert.match(declOpsConstMiss.stderr, /setConst const was not found; nearest: LIMIT/);
|
|
// addParamTo without default fails with the call-site count.
|
|
const declOpsNoDefault = zero(["patch", declOpsRoot, "--op", 'addParamTo fn="bump" name="bias" type="usize"'], { allowFailure: true });
|
|
assert.notEqual(declOpsNoDefault.code, 0);
|
|
assert.match(declOpsNoDefault.stderr, /addParamTo needs a default to update existing call sites/);
|
|
assert.match(declOpsNoDefault.stderr, /3 call sites call bump/);
|
|
// addParamTo with default appends the parameter and updates every call site,
|
|
// including the nested bump(bump(value)) calls inside twice.
|
|
const declOpsAddParam = zero(["patch", declOpsRoot, "--op", 'addParamTo fn="bump" name="bias" type="usize" default="0"']);
|
|
assertPatchOkOutput(declOpsAddParam.stdout, join(declOpsRoot, "zero.graph"));
|
|
assert.match(declOpsAddParam.stdout, /updated 3 call sites\n/);
|
|
const declOpsAddParamView = zero(["view", declOpsRoot]).stdout;
|
|
assert.match(declOpsAddParamView, /fn bump\(value: usize, bias: usize\) -> usize/);
|
|
assert.match(declOpsAddParamView, /return bump\(bump\(value, 0\), 0\)/);
|
|
assert.match(declOpsAddParamView, /let start: usize = bump\(1, 0\)/);
|
|
assert.equal(zero(["check", declOpsRoot]).stdout, "ok\n");
|
|
const declOpsAddParamJson = json(["patch", "--json", declOpsRoot, "--op", 'addParamTo fn="answer" name="extra" type="usize" default="1"']).body;
|
|
assert.equal(declOpsAddParamJson.ok, true);
|
|
assert.equal(declOpsAddParamJson.operations[0].op, "addParamTo");
|
|
assert.equal(declOpsAddParamJson.operations[0].callSites, 1);
|
|
// The direct backends cap signatures at 8 ABI argument slots (byte views take
|
|
// 2); addParamTo rejects an over-cap signature at patch time.
|
|
const declOpsAbiCap = zero(["patch", declOpsRoot, "--op", 'addParamTo fn="wide" name="e" type="Span<u8>"'], { allowFailure: true });
|
|
assert.notEqual(declOpsAbiCap.code, 0);
|
|
assert.match(declOpsAbiCap.stderr, /direct backend object buildability has too many ABI argument slots/);
|
|
assert.match(declOpsAbiCap.stderr, /wide would have 9 ABI argument slot\(s\)/);
|
|
// Signature ops compose with other ops in one batched patch.
|
|
const declOpsBatchPath = join(outDir, "repository-graph-decl-ops-batch.patch");
|
|
writeFileSync(declOpsBatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
'setConst name="LIMIT" value="6"',
|
|
'setReturnType fn="answer" type="i64"',
|
|
"replaceFunctionBody answer",
|
|
" return 9 as i64",
|
|
"end",
|
|
"",
|
|
].join("\n"));
|
|
const declOpsBatch = json(["patch", "--json", declOpsRoot, declOpsBatchPath]).body;
|
|
assert.equal(declOpsBatch.ok, true);
|
|
assert.equal(declOpsBatch.operationCount, 3);
|
|
assert.equal(declOpsBatch.operations[0].op, "setConst");
|
|
assert.equal(declOpsBatch.operations[1].op, "setReturnType");
|
|
assert.equal(declOpsBatch.operations[2].op, "replaceFunctionBody");
|
|
const declOpsBatchView = zero(["view", declOpsRoot]).stdout;
|
|
assert.match(declOpsBatchView, /const LIMIT: usize = 6/);
|
|
assert.match(declOpsBatchView, /fn answer\(extra: usize\) -> i64/);
|
|
assert.equal(zero(["check", declOpsRoot]).stdout, "ok\n");
|
|
const checkedInGraphCallsJson = json(["query", "--json", "--fn", "main", "--calls", "write", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphCallsJson.ok, true);
|
|
assert.equal(checkedInGraphCallsJson.query.function, "main");
|
|
assert.equal(checkedInGraphCallsJson.query.calls, "write");
|
|
assert.equal(checkedInGraphCallsJson.references.length, 0);
|
|
assert.equal(checkedInGraphCallsJson.calls.some((call) => call.function === "main" && call.name === "write" && call.resolved === true), true);
|
|
const checkedInGraphPackageCheckJson = json(["check", "--json", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphPackageCheckJson.ok, true);
|
|
assert.equal(checkedInGraphPackageCheckJson.sourceFile, checkedInRepositoryGraphStorePath);
|
|
assert.equal(checkedInGraphPackageCheckJson.package.name, "program-graph-fixture");
|
|
assert.equal(checkedInGraphPackageCheckJson.package.manifestPath, join(checkedInGraphPackageDir, "zero.toml"));
|
|
assertSourceGraph(checkedInGraphPackageCheckJson, checkedInRepositoryGraphStorePath, "package:program-graph-fixture@0.1.0", "graph-native-check", false);
|
|
assertProgramGraphCompilerInput(checkedInGraphPackageCheckJson, checkedInRepositoryGraphStorePath);
|
|
assertRepositoryGraphNativeCheck(checkedInGraphPackageCheckJson);
|
|
const sourceFreeCopiedGraphRoot = join(outDir, "source-free-program-graph");
|
|
const sourceFreeCopiedGraphStorePath = join(sourceFreeCopiedGraphRoot, "zero.graph");
|
|
const sourceFreeCopiedGraphBuildPath = join(outDir, "source-free-program-graph-build");
|
|
const sourceFreeCopiedGraphRunPath = join(outDir, "source-free-program-graph-run");
|
|
const sourceFreeCImportRoot = join(outDir, "source-free-c-import");
|
|
const sourceFreeCImportStorePath = join(sourceFreeCImportRoot, "zero.graph");
|
|
const sourceFreeCImportRunPath = join(outDir, "source-free-c-import-run");
|
|
const sourceFreeCImportCwdRoot = join(outDir, "source-free-c-import-unrelated-cwd");
|
|
const sourceFreeCImportCwdBuildPath = join(outDir, "source-free-c-import-cwd-build");
|
|
const sourceFreeIdentityMismatchRoot = join(outDir, "source-free-identity-mismatch");
|
|
const sourceFreeMissingPackageNameRoot = join(outDir, "source-free-missing-package-name");
|
|
const sourceFreeBadProjectionRoot = join(outDir, "source-free-bad-projection");
|
|
rmSync(sourceFreeCopiedGraphRoot, { recursive: true, force: true });
|
|
rmSync(sourceFreeCImportRoot, { recursive: true, force: true });
|
|
rmSync(sourceFreeCImportRunPath, { recursive: true, force: true });
|
|
rmSync(sourceFreeCImportCwdRoot, { recursive: true, force: true });
|
|
rmSync(sourceFreeCImportCwdBuildPath, { recursive: true, force: true });
|
|
rmSync(sourceFreeIdentityMismatchRoot, { recursive: true, force: true });
|
|
rmSync(sourceFreeMissingPackageNameRoot, { recursive: true, force: true });
|
|
rmSync(sourceFreeBadProjectionRoot, { recursive: true, force: true });
|
|
mkdirSync(sourceFreeCopiedGraphRoot, { recursive: true });
|
|
writeFileSync(join(sourceFreeCopiedGraphRoot, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(sourceFreeCopiedGraphStorePath, readFileSync(checkedInRepositoryGraphStorePath));
|
|
const sourceFreeCopiedGraphCheckJson = json(["check", "--json", sourceFreeCopiedGraphRoot]).body;
|
|
assert.equal(sourceFreeCopiedGraphCheckJson.ok, true);
|
|
assert.equal(sourceFreeCopiedGraphCheckJson.sourceFile, sourceFreeCopiedGraphStorePath);
|
|
assertSourceGraph(sourceFreeCopiedGraphCheckJson, sourceFreeCopiedGraphStorePath, "package:program-graph-fixture@0.1.0", "graph-native-check", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCopiedGraphCheckJson, sourceFreeCopiedGraphStorePath);
|
|
assertRepositoryGraphNativeCheck(sourceFreeCopiedGraphCheckJson, "missing");
|
|
const sourceFreeCopiedGraphSizeJson = json(["size", "--json", "--target", "linux-musl-x64", sourceFreeCopiedGraphRoot]).body;
|
|
assertSourceGraph(sourceFreeCopiedGraphSizeJson, sourceFreeCopiedGraphStorePath, "package:program-graph-fixture@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCopiedGraphSizeJson, sourceFreeCopiedGraphStorePath);
|
|
const sourceFreeCopiedGraphBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", sourceFreeCopiedGraphBuildPath, sourceFreeCopiedGraphRoot]).body;
|
|
assert.equal(sourceFreeCopiedGraphBuildJson.sourceFile, sourceFreeCopiedGraphStorePath);
|
|
assertSourceGraph(sourceFreeCopiedGraphBuildJson, sourceFreeCopiedGraphStorePath, "package:program-graph-fixture@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCopiedGraphBuildJson, sourceFreeCopiedGraphStorePath);
|
|
assert.equal(zero(["run", "--out", sourceFreeCopiedGraphRunPath, sourceFreeCopiedGraphRoot]).stdout, "hello from zero\n");
|
|
const sourceFreeCopiedGraphTestJson = json(["test", "--json", sourceFreeCopiedGraphRoot]).body;
|
|
assert.equal(sourceFreeCopiedGraphTestJson.ok, true);
|
|
assertSourceGraph(sourceFreeCopiedGraphTestJson, sourceFreeCopiedGraphStorePath, "package:program-graph-fixture@0.1.0", "direct-program-graph", false, "missing");
|
|
assert.equal(sourceFreeCopiedGraphTestJson.testBackend, "direct-program-graph");
|
|
assert.equal(sourceFreeCopiedGraphTestJson.testDiscovery.mode, "package-graph");
|
|
const sourceFreeCopiedGraphMemJson = json(["mem", "--json", sourceFreeCopiedGraphRoot]).body;
|
|
assertSourceGraph(sourceFreeCopiedGraphMemJson, sourceFreeCopiedGraphStorePath, "package:program-graph-fixture@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCopiedGraphMemJson, sourceFreeCopiedGraphStorePath);
|
|
const sourceFreeCopiedGraphVerify = json(["verify-projection", "--json", sourceFreeCopiedGraphRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeCopiedGraphVerify.code, 0);
|
|
assert.equal(sourceFreeCopiedGraphVerify.body.diagnostics[0].code, "RGP006");
|
|
assert.equal(sourceFreeCopiedGraphVerify.body.diagnostics[0].actual, "missing source projection file");
|
|
const sourceFreeCopiedGraphExport = json(["export", "--json", sourceFreeCopiedGraphRoot]).body;
|
|
assert.equal(sourceFreeCopiedGraphExport.ok, true);
|
|
assert.deepEqual(sourceFreeCopiedGraphExport.changedPaths, [join(sourceFreeCopiedGraphRoot, "hello.0")]);
|
|
assert.equal(readFileSync(join(sourceFreeCopiedGraphRoot, "hello.0"), "utf8"), readFileSync(checkedInGraphSourcePath, "utf8"));
|
|
const sourceFreeCopiedGraphVerifyAfter = json(["verify-projection", "--json", sourceFreeCopiedGraphRoot]).body;
|
|
assert.equal(sourceFreeCopiedGraphVerifyAfter.ok, true);
|
|
assert.equal(sourceFreeCopiedGraphVerifyAfter.repositoryGraph.projectionValidity, "clean");
|
|
assert.deepEqual(json(["export", "--json", sourceFreeCopiedGraphRoot]).body.changedPaths, []);
|
|
mkdirSync(join(sourceFreeCImportRoot, "src"), { recursive: true });
|
|
mkdirSync(join(sourceFreeCImportRoot, "vendor/include"), { recursive: true });
|
|
writeZeroTomlSync(sourceFreeCImportRoot, {
|
|
package: { name: "source-free-c-import", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
c: {
|
|
libs: {
|
|
ext: { headers: ["vendor/include/zero_ext.h"], include: ["vendor/include"], lib: [], link: [], mode: "static" },
|
|
},
|
|
},
|
|
});
|
|
writeFileSync(join(sourceFreeCImportRoot, "vendor/include/zero_ext.h"), "int zero_ext_add(int a, int b);\n");
|
|
writeFileSync(join(sourceFreeCImportRoot, "src/main.0"), `extern c "vendor/include/zero_ext.h" as c
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
check world.out.write("source-free c import ok\\n")
|
|
}
|
|
`);
|
|
const sourceFreeCImportSync = json(["import", "--format", "text", "--json", sourceFreeCImportRoot]).body;
|
|
assert.equal(sourceFreeCImportSync.ok, true);
|
|
assert.equal(sourceFreeCImportSync.repositoryGraph.projectionValidity, "clean");
|
|
rmSync(join(sourceFreeCImportRoot, "src"), { recursive: true, force: true });
|
|
const sourceFreeCImportCheck = json(["check", "--json", sourceFreeCImportRoot]).body;
|
|
assert.equal(sourceFreeCImportCheck.ok, true);
|
|
assertSourceGraph(sourceFreeCImportCheck, sourceFreeCImportStorePath, "package:source-free-c-import@0.1.0", "graph-native-check", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCImportCheck, sourceFreeCImportStorePath);
|
|
assertRepositoryGraphNativeCheck(sourceFreeCImportCheck, "missing");
|
|
assert.equal(zero(["run", "--out", sourceFreeCImportRunPath, sourceFreeCImportRoot]).stdout, "source-free c import ok\n");
|
|
mkdirSync(sourceFreeCImportCwdRoot, { recursive: true });
|
|
writeZeroTomlSync(sourceFreeCImportCwdRoot, {
|
|
package: { name: "unrelated-cwd-package", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
});
|
|
const sourceFreeCImportCwdBuild = JSON.parse(execFileSync(zeroBin, [
|
|
"build",
|
|
"--json",
|
|
"--out",
|
|
resolve(sourceFreeCImportCwdBuildPath),
|
|
resolve(sourceFreeCImportRoot),
|
|
], { cwd: sourceFreeCImportCwdRoot, encoding: "utf8", maxBuffer: execMaxBuffer, stdio: ["ignore", "pipe", "pipe"] }));
|
|
assertSourceGraph(sourceFreeCImportCwdBuild, resolve(sourceFreeCImportStorePath), "package:source-free-c-import@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeCImportCwdBuild, resolve(sourceFreeCImportStorePath));
|
|
mkdirSync(sourceFreeIdentityMismatchRoot, { recursive: true });
|
|
writeZeroTomlSync(sourceFreeIdentityMismatchRoot, {
|
|
package: { name: "wrong-program-graph-fixture", version: "9.9.9" },
|
|
targets: { cli: { kind: "exe", main: "hello.0" } },
|
|
});
|
|
writeFileSync(join(sourceFreeIdentityMismatchRoot, "zero.graph"), readFileSync(checkedInRepositoryGraphStorePath));
|
|
const sourceFreeIdentityMismatchCheck = json(["check", "--json", sourceFreeIdentityMismatchRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeIdentityMismatchCheck.code, 0);
|
|
assert.equal(sourceFreeIdentityMismatchCheck.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(sourceFreeIdentityMismatchCheck.body.diagnostics[0].expected, "package:wrong-program-graph-fixture@9.9.9");
|
|
assert.equal(sourceFreeIdentityMismatchCheck.body.diagnostics[0].actual, "package:program-graph-fixture@0.1.0");
|
|
const sourceFreeIdentityMismatchSize = json(["size", "--json", sourceFreeIdentityMismatchRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeIdentityMismatchSize.code, 0);
|
|
assert.equal(sourceFreeIdentityMismatchSize.body.diagnostics[0].code, "RGP007");
|
|
mkdirSync(sourceFreeMissingPackageNameRoot, { recursive: true });
|
|
writeZeroTomlSync(sourceFreeMissingPackageNameRoot, {
|
|
targets: { cli: { kind: "exe", main: "hello.0" } },
|
|
});
|
|
writeFileSync(join(sourceFreeMissingPackageNameRoot, "zero.graph"), readFileSync(checkedInRepositoryGraphStorePath));
|
|
const sourceFreeMissingPackageNameCheck = json(["check", "--json", sourceFreeMissingPackageNameRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeMissingPackageNameCheck.code, 0);
|
|
assert.equal(sourceFreeMissingPackageNameCheck.body.diagnostics[0].code, "RGP007");
|
|
assert.equal(sourceFreeMissingPackageNameCheck.body.diagnostics[0].message, "repository graph compiler input requires package.name");
|
|
assert.match(sourceFreeMissingPackageNameCheck.body.diagnostics[0].actual, /package:program-graph-fixture@0\.1\.0/);
|
|
mkdirSync(sourceFreeBadProjectionRoot, { recursive: true });
|
|
writeFileSync(join(sourceFreeBadProjectionRoot, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(join(sourceFreeBadProjectionRoot, "hello.0"), checkedInGraphSource);
|
|
zero(["import", "--format", "text", sourceFreeBadProjectionRoot]);
|
|
const sourceFreeBadProjectionStoreText = readFileSync(join(sourceFreeBadProjectionRoot, "zero.graph"), "utf8");
|
|
writeFileSync(join(sourceFreeBadProjectionRoot, "zero.graph"), sourceFreeBadProjectionStoreText.replace(
|
|
/^projection path:"hello\.0" text:.*$/m,
|
|
`projection path:"hello.0" text:${JSON.stringify("pub fn broken( {\n")}`,
|
|
));
|
|
const sourceFreeBadProjectionStatus = json(["status", "--json", sourceFreeBadProjectionRoot]).body;
|
|
assert.equal(sourceFreeBadProjectionStatus.repositoryGraph.projectionState, "conflict");
|
|
assert.equal(sourceFreeBadProjectionStatus.repositoryGraph.projectionValidity, "conflict");
|
|
const sourceFreeBadProjectionCheck = json(["check", "--json", sourceFreeBadProjectionRoot]).body;
|
|
assert.equal(sourceFreeBadProjectionCheck.ok, true);
|
|
assertSourceGraph(sourceFreeBadProjectionCheck, join(sourceFreeBadProjectionRoot, "zero.graph"), "package:program-graph-fixture@0.1.0", "graph-native-check", false, "conflict");
|
|
assertRepositoryGraphNativeCheck(sourceFreeBadProjectionCheck, "conflict");
|
|
const sourceFreeBadProjectionSync = json(["export", "--json", sourceFreeBadProjectionRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeBadProjectionSync.code, 0);
|
|
assert.equal(sourceFreeBadProjectionSync.body.diagnostics[0].code, "RGP004");
|
|
const missingRepoGraphStoreRoot = join(outDir, "repository-graph-missing-store");
|
|
rmSync(missingRepoGraphStoreRoot, { recursive: true, force: true });
|
|
mkdirSync(missingRepoGraphStoreRoot, { recursive: true });
|
|
writeZeroTomlSync(missingRepoGraphStoreRoot, {
|
|
package: { name: "repository-graph-missing-store", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(missingRepoGraphStoreRoot, "main.0"), "pub fn main() -> i32 { return 0 }\n");
|
|
const missingRepoGraphStoreCheck = json(["check", "--json", missingRepoGraphStoreRoot], { allowFailure: true });
|
|
assert.notEqual(missingRepoGraphStoreCheck.code, 0);
|
|
assert.equal(missingRepoGraphStoreCheck.body.ok, false);
|
|
assert.equal(missingRepoGraphStoreCheck.body.mode, "compiler-input");
|
|
assert.equal(missingRepoGraphStoreCheck.body.repositoryGraph.storePresent, false);
|
|
assert.equal(missingRepoGraphStoreCheck.body.diagnostics[0].code, "RGP001");
|
|
assert.equal(missingRepoGraphStoreCheck.body.diagnostics[0].path, missingRepoGraphStoreRoot);
|
|
assert.match(missingRepoGraphStoreCheck.body.repairCommands.join("\n"), /zero import/);
|
|
const invalidRepoGraphStoreRoot = join(outDir, "repository-graph-invalid-store");
|
|
rmSync(invalidRepoGraphStoreRoot, { recursive: true, force: true });
|
|
mkdirSync(invalidRepoGraphStoreRoot, { recursive: true });
|
|
writeZeroTomlSync(invalidRepoGraphStoreRoot, {
|
|
package: { name: "repository-graph-invalid-store", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(invalidRepoGraphStoreRoot, "main.0"), "pub fn main() -> i32 { return 0 }\n");
|
|
writeFileSync(join(invalidRepoGraphStoreRoot, "zero.graph"), "not a repository graph\n");
|
|
const invalidRepoGraphStoreCheck = json(["check", "--json", invalidRepoGraphStoreRoot], { allowFailure: true });
|
|
assert.notEqual(invalidRepoGraphStoreCheck.code, 0);
|
|
assert.equal(invalidRepoGraphStoreCheck.body.ok, false);
|
|
assert.equal(invalidRepoGraphStoreCheck.body.mode, "compiler-input");
|
|
assert.equal(invalidRepoGraphStoreCheck.body.repositoryGraph.storePresent, true);
|
|
assert.equal(invalidRepoGraphStoreCheck.body.repositoryGraph.storeValid, false);
|
|
assert.equal(invalidRepoGraphStoreCheck.body.diagnostics[0].code, "RGP003");
|
|
assert.equal(invalidRepoGraphStoreCheck.body.diagnostics[0].path, invalidRepoGraphStoreRoot);
|
|
assert.match(invalidRepoGraphStoreCheck.body.repairCommands.join("\n"), /zero import/);
|
|
const directoryRepoGraphStoreRoot = join(outDir, "repository-graph-directory-store");
|
|
rmSync(directoryRepoGraphStoreRoot, { recursive: true, force: true });
|
|
mkdirSync(join(directoryRepoGraphStoreRoot, "zero.graph"), { recursive: true });
|
|
writeZeroTomlSync(directoryRepoGraphStoreRoot, {
|
|
package: { name: "repository-graph-directory-store", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(directoryRepoGraphStoreRoot, "main.0"), "pub fn main() -> i32 { return 0 }\n");
|
|
const directoryRepoGraphStoreCheck = json(["check", "--json", directoryRepoGraphStoreRoot], { allowFailure: true });
|
|
assert.notEqual(directoryRepoGraphStoreCheck.code, 0);
|
|
assert.equal(directoryRepoGraphStoreCheck.body.ok, false);
|
|
assert.equal(directoryRepoGraphStoreCheck.body.repositoryGraph.storePresent, true);
|
|
assert.equal(directoryRepoGraphStoreCheck.body.repositoryGraph.projectionState, "store-invalid");
|
|
assert.equal(directoryRepoGraphStoreCheck.body.diagnostics[0].code, "RGP003");
|
|
assert.equal(directoryRepoGraphStoreCheck.body.diagnostics[0].actual, "failed to read repository graph store");
|
|
const sourceFreeGraphPackageRoot = join(outDir, "source-free-graph-package");
|
|
rmSync(sourceFreeGraphPackageRoot, { recursive: true, force: true });
|
|
mkdirSync(join(sourceFreeGraphPackageRoot, "src"), { recursive: true });
|
|
writeZeroTomlSync(sourceFreeGraphPackageRoot, {
|
|
package: { name: "source-free-graph-package", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
});
|
|
writeFileSync(join(sourceFreeGraphPackageRoot, "src", "main.0"), readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
writeFileSync(join(sourceFreeGraphPackageRoot, "src", "helper.0"), readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
const sourceFreeGraphPackageSync = json(["import", "--format", "text", "--json", sourceFreeGraphPackageRoot]);
|
|
assert.equal(sourceFreeGraphPackageSync.body.ok, true);
|
|
rmSync(join(sourceFreeGraphPackageRoot, "src"), { recursive: true, force: true });
|
|
const sourceFreeGraphPackageStorePath = join(sourceFreeGraphPackageRoot, "zero.graph");
|
|
const sourceFreeGraphPackageCheckJson = json(["check", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageCheckJson.ok, true);
|
|
assertSourceGraph(sourceFreeGraphPackageCheckJson, sourceFreeGraphPackageStorePath, "package:source-free-graph-package@0.1.0", "graph-native-check", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeGraphPackageCheckJson, sourceFreeGraphPackageStorePath);
|
|
assertRepositoryGraphNativeCheck(sourceFreeGraphPackageCheckJson, "missing");
|
|
assert(sourceFreeGraphPackageCheckJson.interfaceFingerprints.modules.some((module) => module.name === "main"));
|
|
assert(sourceFreeGraphPackageCheckJson.interfaceFingerprints.modules.some((module) => module.name === "main" && module.imports.some((entry) => entry.module === "helper")));
|
|
const sourceFreeGraphPackageSizeJson = json(["size", "--json", "--target", "linux-musl-x64", sourceFreeGraphPackageRoot]).body;
|
|
assertSourceGraph(sourceFreeGraphPackageSizeJson, sourceFreeGraphPackageStorePath, "package:source-free-graph-package@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeGraphPackageSizeJson, sourceFreeGraphPackageStorePath);
|
|
const sourceFreeGraphPackageSizeMir = sourceFreeGraphPackageSizeJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(sourceFreeGraphPackageSizeMir.codegenImmediate, sourceFreeGraphPackageSizeMir.hit === true);
|
|
assert.equal(sourceFreeGraphPackageSizeMir.programReconstructed, false);
|
|
const sourceFreeGraphPackageBuildPath = join(outDir, "source-free-graph-package-build");
|
|
const sourceFreeGraphPackageBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", sourceFreeGraphPackageBuildPath, sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageBuildJson.sourceFile, sourceFreeGraphPackageStorePath);
|
|
assertSourceGraph(sourceFreeGraphPackageBuildJson, sourceFreeGraphPackageStorePath, "package:source-free-graph-package@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeGraphPackageBuildJson, sourceFreeGraphPackageStorePath);
|
|
const sourceFreeGraphPackageBuildMir = sourceFreeGraphPackageBuildJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(sourceFreeGraphPackageBuildMir.hit, true);
|
|
assert.equal(sourceFreeGraphPackageBuildMir.codegenImmediate, true);
|
|
assert.equal(sourceFreeGraphPackageBuildMir.programReconstructed, false);
|
|
const sourceFreeGraphPackageRunPath = join(outDir, "source-free-graph-package-run");
|
|
assert.equal(zero(["run", "--out", sourceFreeGraphPackageRunPath, sourceFreeGraphPackageRoot]).stdout, "package tests\n");
|
|
const sourceFreeGraphPackageTestJson = json(["test", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageTestJson.ok, true);
|
|
assertSourceGraph(sourceFreeGraphPackageTestJson, sourceFreeGraphPackageStorePath, "package:source-free-graph-package@0.1.0", "direct-program-graph", false, "missing");
|
|
assert.equal(sourceFreeGraphPackageTestJson.testBackend, "direct-program-graph");
|
|
assert.equal(sourceFreeGraphPackageTestJson.selectedTests, 3);
|
|
const sourceFreeGraphPackageMemJson = json(["mem", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assertSourceGraph(sourceFreeGraphPackageMemJson, sourceFreeGraphPackageStorePath, "package:source-free-graph-package@0.1.0", "mapped-final-mir", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeGraphPackageMemJson, sourceFreeGraphPackageStorePath);
|
|
const sourceFreeGraphPackageStatus = json(["status", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageStatus.repositoryGraph.semanticValidity, "shape-valid");
|
|
assert.equal(sourceFreeGraphPackageStatus.repositoryGraph.projectionValidity, "missing");
|
|
const sourceFreeGraphPackageVerify = json(["verify-projection", "--json", sourceFreeGraphPackageRoot], { allowFailure: true });
|
|
assert.notEqual(sourceFreeGraphPackageVerify.code, 0);
|
|
assert.equal(sourceFreeGraphPackageVerify.body.ok, false);
|
|
assert.equal(sourceFreeGraphPackageVerify.body.diagnostics[0].code, "RGP006");
|
|
assert.equal(sourceFreeGraphPackageVerify.body.diagnostics[0].actual, "missing source projection file");
|
|
const sourceFreeGraphPackageExport = json(["export", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageExport.ok, true);
|
|
assert.deepEqual(sourceFreeGraphPackageExport.changedPaths, [
|
|
join(sourceFreeGraphPackageRoot, "src", "helper.0"),
|
|
join(sourceFreeGraphPackageRoot, "src", "main.0"),
|
|
]);
|
|
assert.equal(readFileSync(join(sourceFreeGraphPackageRoot, "src", "main.0"), "utf8"), readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
assert.equal(readFileSync(join(sourceFreeGraphPackageRoot, "src", "helper.0"), "utf8"), readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
const sourceFreeGraphPackageVerifyAfter = json(["verify-projection", "--json", sourceFreeGraphPackageRoot]).body;
|
|
assert.equal(sourceFreeGraphPackageVerifyAfter.ok, true);
|
|
assert.equal(sourceFreeGraphPackageVerifyAfter.repositoryGraph.projectionValidity, "clean");
|
|
assert.deepEqual(json(["export", "--json", sourceFreeGraphPackageRoot]).body.changedPaths, []);
|
|
const graphTargetWebbitsRoot = join(outDir, "repo-graph-target-webbits");
|
|
const graphTargetIncompatibleRoot = join(outDir, "repo-graph-target-incompatible-app");
|
|
rmSync(graphTargetWebbitsRoot, { recursive: true, force: true });
|
|
rmSync(graphTargetIncompatibleRoot, { recursive: true, force: true });
|
|
mkdirSync(join(graphTargetIncompatibleRoot, "src"), { recursive: true });
|
|
mkdirSync(graphTargetWebbitsRoot, { recursive: true });
|
|
writeFileSync(join(graphTargetWebbitsRoot, "zero.toml"), readFileSync("conformance/packages/target-webbits/zero.toml", "utf8"));
|
|
writeZeroTomlSync(graphTargetIncompatibleRoot, {
|
|
package: { name: "repo-graph-target-incompatible-app", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
dependencies: { "target-webbits": { path: "../repo-graph-target-webbits", version: "0.1.0", targets: ["win32-x64.exe"] } },
|
|
});
|
|
writeFileSync(join(graphTargetIncompatibleRoot, "src", "main.0"), `pub fn main(world: World) -> Void raises {
|
|
check world.out.write("target incompatible\\n")
|
|
}
|
|
`);
|
|
assert.equal(json(["import", "--format", "text", "--json", graphTargetIncompatibleRoot]).body.ok, true);
|
|
const graphTargetIncompatibleCheck = json(["check", "--json", "--target", "linux-musl-x64", graphTargetIncompatibleRoot], { allowFailure: true });
|
|
assert.notEqual(graphTargetIncompatibleCheck.code, 0);
|
|
assert.equal(graphTargetIncompatibleCheck.body.diagnostics[0].code, "PKG004");
|
|
assert.match(graphTargetIncompatibleCheck.body.diagnostics[0].actual, /target-webbits targets/);
|
|
const graphTargetCapabilityRoot = join(outDir, "repo-graph-target-capability-app");
|
|
rmSync(graphTargetCapabilityRoot, { recursive: true, force: true });
|
|
mkdirSync(graphTargetCapabilityRoot, { recursive: true });
|
|
writeZeroTomlSync(graphTargetCapabilityRoot, {
|
|
package: { name: "repo-graph-target-capability-app", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(graphTargetCapabilityRoot, "main.0"), `pub fn main(world: World) -> Void raises {
|
|
let fs: Fs = std.fs.host()
|
|
if std.fs.writeFile(fs, ".zero/out/repo-graph-target-capability.txt", "ok\\n") {
|
|
check world.out.write("ok\\n")
|
|
}
|
|
}
|
|
`);
|
|
assert.equal(json(["import", "--format", "text", "--json", graphTargetCapabilityRoot]).body.ok, true);
|
|
const graphTargetCapabilityCheck = json(["check", "--json", "--target", "linux-arm64", graphTargetCapabilityRoot], { allowFailure: true });
|
|
assert.notEqual(graphTargetCapabilityCheck.code, 0);
|
|
assert.equal(graphTargetCapabilityCheck.body.diagnostics[0].code, "TAR002");
|
|
assert.match(graphTargetCapabilityCheck.body.diagnostics[0].actual, /lacks Fs/);
|
|
const graphTargetBackendMismatchCheck = json(["check", "--json", "--backend", "zero-coff-x64", "--target", "linux-musl-x64", checkedInGraphPackageDir]);
|
|
assert.equal(graphTargetBackendMismatchCheck.body.ok, true);
|
|
assert.equal(graphTargetBackendMismatchCheck.body.targetReadiness.ok, false);
|
|
assert.equal(graphTargetBackendMismatchCheck.body.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(graphTargetBackendMismatchCheck.body.targetReadiness.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
const sourceFreeStdGraphRoot = join(outDir, "source-free-std-str");
|
|
rmSync(sourceFreeStdGraphRoot, { recursive: true, force: true });
|
|
mkdirSync(sourceFreeStdGraphRoot, { recursive: true });
|
|
writeZeroTomlSync(sourceFreeStdGraphRoot, {
|
|
package: { name: "source-free-std-str", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(sourceFreeStdGraphRoot, "main.0"), readFileSync("examples/std-str.0", "utf8"));
|
|
const sourceFreeStdGraphSync = json(["import", "--format", "text", "--json", sourceFreeStdGraphRoot]);
|
|
assert.equal(sourceFreeStdGraphSync.body.ok, true);
|
|
rmSync(join(sourceFreeStdGraphRoot, "main.0"), { force: true });
|
|
const sourceFreeStdGraphCheckJson = json(["check", "--json", sourceFreeStdGraphRoot]).body;
|
|
assert.equal(sourceFreeStdGraphCheckJson.ok, true);
|
|
assertSourceGraph(sourceFreeStdGraphCheckJson, join(sourceFreeStdGraphRoot, "zero.graph"), "package:source-free-std-str@0.1.0", "graph-native-check", false, "missing");
|
|
assertProgramGraphCompilerInput(sourceFreeStdGraphCheckJson, join(sourceFreeStdGraphRoot, "zero.graph"));
|
|
assertRepositoryGraphNativeCheck(sourceFreeStdGraphCheckJson, "missing");
|
|
assert.equal(sourceFreeStdGraphCheckJson.targetReadiness.ok, true);
|
|
assert.equal(sourceFreeStdGraphCheckJson.targetReadiness.diagnostics.length, 0);
|
|
assert(sourceFreeStdGraphCheckJson.graphCompiler.semanticFacts.calls.some((call) => call.qualifiedName === "std.str.reverse" && call.contract.kind === "stdlib" && call.resolution.targetKind === "stdlib" && call.returnType === "Maybe<Span<u8>>"));
|
|
assert(sourceFreeStdGraphCheckJson.graphCompiler.tables.capability > 0);
|
|
const checkedInGraphPackageSizeJson = json(["size", "--json", "--target", "linux-musl-x64", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphPackageSizeJson.sourceFile, checkedInRepositoryGraphStorePath);
|
|
assertSourceGraph(checkedInGraphPackageSizeJson, checkedInRepositoryGraphStorePath, "package:program-graph-fixture@0.1.0", "mapped-final-mir", false);
|
|
assertProgramGraphCompilerInput(checkedInGraphPackageSizeJson, checkedInRepositoryGraphStorePath);
|
|
const checkedInGraphPackageSizeMir = checkedInGraphPackageSizeJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(checkedInGraphPackageSizeMir.codegenImmediate, checkedInGraphPackageSizeMir.hit === true);
|
|
assert.equal(checkedInGraphPackageSizeMir.programReconstructed, false);
|
|
const checkedInGraphPackageBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", checkedInGraphBuildPath, checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphPackageBuildJson.sourceFile, checkedInRepositoryGraphStorePath);
|
|
assertSourceGraph(checkedInGraphPackageBuildJson, checkedInRepositoryGraphStorePath, "package:program-graph-fixture@0.1.0", "mapped-final-mir", false);
|
|
assertProgramGraphCompilerInput(checkedInGraphPackageBuildJson, checkedInRepositoryGraphStorePath);
|
|
const checkedInGraphPackageBuildMir = checkedInGraphPackageBuildJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(checkedInGraphPackageBuildMir.hit, true);
|
|
assert.equal(checkedInGraphPackageBuildMir.codegenImmediate, true);
|
|
assert.equal(checkedInGraphPackageBuildMir.programReconstructed, false);
|
|
assert.equal(checkedInGraphPackageBuildJson.artifactPath, checkedInGraphBuildPath);
|
|
mkdirSync(graphRecordRoot, { recursive: true });
|
|
writeZeroTomlSync(graphRecordRoot, {
|
|
package: { name: "repository-graph-record", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "main.0" } },
|
|
});
|
|
writeFileSync(join(graphRecordRoot, "main.0"), [
|
|
"type Point {",
|
|
" x: i32,",
|
|
" y: i32,",
|
|
"}",
|
|
"",
|
|
"pub fn main(world: World) -> Void raises {",
|
|
" let point: Point = Point { x: 40, y: 2 }",
|
|
" if point.x == 40 {",
|
|
" check world.out.write(\"ok\\n\")",
|
|
" }",
|
|
"}",
|
|
].join("\n") + "\n");
|
|
assert.equal(json(["import", "--format", "text", "--json", graphRecordRoot]).body.ok, true);
|
|
const graphRecordCheckJson = json(["check", "--json", graphRecordRoot]).body;
|
|
assert.equal(graphRecordCheckJson.ok, true);
|
|
assertRepositoryGraphNativeCheck(graphRecordCheckJson);
|
|
assert.equal(graphRecordCheckJson.targetReadiness.ok, true);
|
|
assert.equal(graphRecordCheckJson.targetReadiness.diagnostics.length, 0);
|
|
assert.equal(graphRecordCheckJson.graphCompiler.defaultReadiness.compilerInputReady, true);
|
|
assert.equal(graphRecordCheckJson.graphCompiler.defaultReadiness.claim, "ready-for-repository-graph-input");
|
|
const graphRecordBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", graphRecordBuildPath, graphRecordRoot]).body;
|
|
assertSourceGraph(graphRecordBuildJson, join(graphRecordRoot, "zero.graph"), "package:repository-graph-record@0.1.0", "mapped-final-mir", false, "clean");
|
|
assert.equal(graphRecordBuildJson.artifactPath, graphRecordBuildPath);
|
|
assert.equal(existsSync(graphRecordBuildPath), true);
|
|
const graphRecordObjJson = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "--out", graphRecordObjPath, graphRecordRoot]).body;
|
|
assertSourceGraph(graphRecordObjJson, join(graphRecordRoot, "zero.graph"), "package:repository-graph-record@0.1.0", "mapped-final-mir", false, "clean");
|
|
assert.equal(graphRecordObjJson.artifactPath, graphRecordObjPath);
|
|
assert.equal(existsSync(graphRecordObjPath), true);
|
|
const graphRecordDirectLlvmIrJson = json(["build", "--json", "--emit", "llvm-ir", "--target", "linux-musl-x64", "--out", graphRecordDirectLlvmIrPath, graphRecordRoot], { allowFailure: true });
|
|
assert.notEqual(graphRecordDirectLlvmIrJson.code, 0);
|
|
assert.equal(graphRecordDirectLlvmIrJson.body.diagnostics[0].message, "direct backend does not support --emit llvm-ir");
|
|
assert.equal(graphRecordDirectLlvmIrJson.body.diagnostics[0].path, join(graphRecordRoot, "zero.graph"));
|
|
assert.equal(graphRecordDirectLlvmIrJson.body.diagnostics[0].backendBlocker.backend, "direct");
|
|
assert.equal(graphRecordDirectLlvmIrJson.body.diagnostics[0].backendBlocker.stage, "buildability");
|
|
assert.equal(graphRecordDirectLlvmIrJson.body.diagnostics[0].backendBlocker.unsupportedFeature, "llvm-ir");
|
|
assert.equal(existsSync(graphRecordDirectLlvmIrPath), false);
|
|
const graphRecordLlvmIrJson = json(["build", "--json", "--backend", "llvm", "--emit", "llvm-ir", "--target", "linux-musl-x64", "--out", graphRecordLlvmIrPath, graphRecordRoot], { allowFailure: true });
|
|
assert.notEqual(graphRecordLlvmIrJson.code, 0);
|
|
assert.equal(graphRecordLlvmIrJson.body.diagnostics[0].path, join(graphRecordRoot, "zero.graph"));
|
|
assert.equal(graphRecordLlvmIrJson.body.diagnostics[0].message, "LLVM IR backend local type is unsupported");
|
|
assert.equal(graphRecordLlvmIrJson.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert.equal(graphRecordLlvmIrJson.body.diagnostics[0].backendBlocker.stage, "lower");
|
|
assert.equal(graphRecordLlvmIrJson.body.diagnostics[0].backendBlocker.unsupportedFeature, "unsupported local type");
|
|
assert.equal(existsSync(graphRecordLlvmIrPath), false);
|
|
const checkedInGraphPackageDefaultBuildJson = json(["build", "--json", "--target", "linux-musl-x64", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphPackageDefaultBuildJson.artifactPath, checkedInGraphDefaultBuildPath);
|
|
assert.equal(zero(["run", "--out", checkedInGraphRunPath, checkedInGraphPackageDir]).stdout, "hello from zero\n");
|
|
const checkedInGraphPackageTestJson = json(["test", "--json", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInGraphPackageTestJson.ok, true);
|
|
assert.equal(checkedInGraphPackageTestJson.sourceFile, checkedInRepositoryGraphStorePath);
|
|
assertSourceGraph(checkedInGraphPackageTestJson, checkedInRepositoryGraphStorePath, "package:program-graph-fixture@0.1.0", "direct-program-graph", false);
|
|
assert.equal(checkedInGraphPackageTestJson.testBackend, "direct-program-graph");
|
|
assert.equal(checkedInGraphPackageTestJson.testDiscovery.mode, "package-graph");
|
|
assert.equal(checkedInGraphPackageTestJson.selectedTests, 0);
|
|
const checkedInRepositoryGraphStoreBytes = readFileSync(checkedInRepositoryGraphStorePath);
|
|
assert.equal(checkedInRepositoryGraphStoreBytes.subarray(0, 8).toString("binary"), "ZRGBIN1\0");
|
|
const sourceLocationOnlyGraphRoot = join(outDir, "repository-graph-source-location-only");
|
|
rmSync(sourceLocationOnlyGraphRoot, { recursive: true, force: true });
|
|
mkdirSync(sourceLocationOnlyGraphRoot, { recursive: true });
|
|
writeFileSync(join(sourceLocationOnlyGraphRoot, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(join(sourceLocationOnlyGraphRoot, "hello.0"), checkedInGraphSource);
|
|
zero(["import", "--format", "text", sourceLocationOnlyGraphRoot]);
|
|
const sourceLocationOnlyStoreText = readFileSync(join(sourceLocationOnlyGraphRoot, "zero.graph"), "utf8");
|
|
writeFileSync(join(sourceLocationOnlyGraphRoot, "zero.graph"), sourceLocationOnlyStoreText.replace("line:1 column:1", "line:99 column:77"));
|
|
const sourceLocationOnlyVerify = json(["verify-projection", "--json", sourceLocationOnlyGraphRoot]).body;
|
|
assert.equal(sourceLocationOnlyVerify.ok, true);
|
|
assert.equal(sourceLocationOnlyVerify.repositoryGraph.projectionState, "clean");
|
|
const checkedInRepositoryGraphStatus = json(["status", "--json", "--target", "linux-musl-x64", checkedInGraphPackageDir]).body;
|
|
assert.equal(checkedInRepositoryGraphStatus.repositoryGraph.storePresent, true);
|
|
assert.equal(checkedInRepositoryGraphStatus.repositoryGraph.storeValid, true);
|
|
assert.equal(checkedInRepositoryGraphStatus.repositoryGraph.projectionState, "clean");
|
|
assert.equal(checkedInRepositoryGraphStatus.repositoryGraph.compilerInput, "repository-graph");
|
|
const checkedInRepositoryGraphVerify = json(["verify-projection", "--json", "--target", "linux-musl-x64", checkedInGraphPackageDir]);
|
|
assert.equal(checkedInRepositoryGraphVerify.body.ok, true);
|
|
assert.equal(checkedInRepositoryGraphVerify.body.writes, false);
|
|
const checkedInRepositoryGraphExport = json(["export", "--json", "--target", "linux-musl-x64", checkedInGraphPackageDir]);
|
|
assert.equal(checkedInRepositoryGraphExport.body.ok, true);
|
|
assert.deepEqual(checkedInRepositoryGraphExport.body.changedPaths, []);
|
|
assert.equal(readFileSync(checkedInGraphSourcePath, "utf8"), checkedInGraphSource);
|
|
assert.equal(Buffer.compare(readFileSync(checkedInRepositoryGraphStorePath), checkedInRepositoryGraphStoreBytes), 0);
|
|
const checkedInRepositoryGraphScript = repositoryGraphVerifyScript(checkedInGraphPackageDir, { target: "linux-musl-x64" });
|
|
assert.equal(checkedInRepositoryGraphScript.code, 0);
|
|
assert.match(checkedInRepositoryGraphScript.stdout, /repository graph verify-projection ok \(1 store\)/);
|
|
const checkedInGraphDriftRoot = join(outDir, "repository-graph-drift-package");
|
|
rmSync(checkedInGraphDriftRoot, { recursive: true, force: true });
|
|
mkdirSync(checkedInGraphDriftRoot, { recursive: true });
|
|
writeFileSync(join(checkedInGraphDriftRoot, "zero.toml"), readFileSync(join(checkedInGraphPackageDir, "zero.toml"), "utf8"));
|
|
writeFileSync(join(checkedInGraphDriftRoot, "zero.graph"), checkedInRepositoryGraphStoreBytes);
|
|
writeFileSync(join(checkedInGraphDriftRoot, "hello.0"), checkedInGraphSource.replace("hello from zero", "hello from drift"));
|
|
const checkedInGraphDriftVerify = json(["verify-projection", "--json", checkedInGraphDriftRoot], { allowFailure: true });
|
|
assert.notEqual(checkedInGraphDriftVerify.code, 0);
|
|
assert.equal(checkedInGraphDriftVerify.body.ok, false);
|
|
assert.equal(checkedInGraphDriftVerify.body.mode, "verify-projection");
|
|
assert.equal(checkedInGraphDriftVerify.body.repositoryGraph.compilerInput, "repository-graph");
|
|
assert.equal(checkedInGraphDriftVerify.body.diagnostics[0].code, "RGP006");
|
|
assert.match(checkedInGraphDriftVerify.body.repairCommands.join("\n"), /zero import/);
|
|
assert.match(checkedInGraphDriftVerify.body.repairCommands.join("\n"), /zero export/);
|
|
const checkedInGraphDriftCheck = json(["check", "--json", checkedInGraphDriftRoot]);
|
|
assert.equal(checkedInGraphDriftCheck.body.ok, true);
|
|
assertSourceGraph(checkedInGraphDriftCheck.body, join(checkedInGraphDriftRoot, "zero.graph"), "package:program-graph-fixture@0.1.0", "graph-native-check", false, "clean");
|
|
assertProgramGraphCompilerInput(checkedInGraphDriftCheck.body, join(checkedInGraphDriftRoot, "zero.graph"));
|
|
assertRepositoryGraphNativeCheck(checkedInGraphDriftCheck.body, "clean");
|
|
assert.match(zero(["view", join(checkedInGraphDriftRoot, "zero.graph")]).stdout, /hello from drift/);
|
|
const checkedInGraphDriftVerifyAfterRefresh = json(["verify-projection", "--json", checkedInGraphDriftRoot]);
|
|
assert.equal(checkedInGraphDriftVerifyAfterRefresh.body.ok, true);
|
|
const graphView = zero(["view", graphDumpPath]).stdout;
|
|
assert.equal(zero(["view", graphDumpPath]).stdout, graphView);
|
|
assert.equal(zero(["diff", graphDumpPath]).stdout, graphView);
|
|
assert.match(graphView, /^pub fn main\(world: World\) -> Void raises \{\n/);
|
|
assert.match(graphView, /check world\.out\.write\("hello from zero\\n"\)/);
|
|
const graphViewJson = json(["view", "--json", graphDumpPath]).body;
|
|
assert.equal(graphViewJson.ok, true);
|
|
assert.equal(graphViewJson.canonicalSource, false);
|
|
assert.equal(graphViewJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphViewJson.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphViewJson.view, graphView);
|
|
assert.equal(zero(["view", "--out", graphViewPath, graphDumpPath]).stdout, "");
|
|
assert.equal(readFileSync(graphViewPath, "utf8"), graphView);
|
|
const graphViewOutJson = json(["view", "--json", "--out", graphViewPath, graphDumpPath]).body;
|
|
assert.equal(graphViewOutJson.ok, true);
|
|
assert.equal(graphViewOutJson.saved.path, graphViewPath);
|
|
assert.equal(graphViewOutJson.view, null);
|
|
assert.equal(readFileSync(graphViewPath, "utf8"), graphView);
|
|
const graphViewWrongOutJson = json(["view", "--json", "--out", graphViewWrongOutPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphViewWrongOutJson.code, 0);
|
|
assert.equal(graphViewWrongOutJson.body.diagnostics[0].message, "graph view output must use .0 extension");
|
|
assert.equal(graphViewWrongOutJson.body.diagnostics[0].expected, "zero view --out <file.0> [graph-input]");
|
|
assert.equal(existsSync(graphViewWrongOutPath), false);
|
|
writeFileSync(graphViewParentFilePath, "");
|
|
const graphViewParentFileJson = json(["view", "--json", "--out", graphViewParentFileOutPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphViewParentFileJson.code, 0);
|
|
assert.equal(graphViewParentFileJson.body.diagnostics[0].path, graphViewParentFileOutPath);
|
|
assert.equal(graphViewParentFileJson.body.diagnostics[0].message, `path component is not a directory: '${graphViewParentFilePath}'`);
|
|
assert.equal(existsSync(graphViewParentFileOutPath), false);
|
|
const graphDiffOutJson = json(["diff", "--json", "--out", graphViewPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphDiffOutJson.code, 0);
|
|
assert.equal(graphDiffOutJson.body.diagnostics[0].message, "diff textconv output does not support --out");
|
|
assert.equal(graphDiffOutJson.body.diagnostics[0].expected, "zero diff [--fn <name>] [graph-input]");
|
|
assert.equal(zero(["check", graphDumpPath]).stdout, "ok\n");
|
|
const graphCheckJson = json(["check", "--json", graphDumpPath]).body;
|
|
assert.equal(graphCheckJson.ok, true);
|
|
assert.equal(graphCheckJson.canonicalSource, false);
|
|
assert.equal(graphCheckJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphCheckJson.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphCheckJson.check.ok, true);
|
|
assert.equal(graphCheckJson.check.phase, "typecheck");
|
|
assert.match(graphCheckJson.check.target, /^(darwin|linux|win32)-/);
|
|
assert.equal(graphCheckJson.check.lowering, "graph-native-check");
|
|
assert.equal(graphCheckJson.check.sourcePath, null);
|
|
assert.equal(graphCheckJson.targetReadiness.ok, true);
|
|
assert.equal(graphCheckJson.targetReadiness.languageOk, true);
|
|
assert.equal(graphCheckJson.targetReadiness.buildable, true);
|
|
assert.equal(graphCheckJson.graphCompiler.graphNativeCheckerUsed, true);
|
|
assert.equal(graphCheckJson.graphCompiler.graphHirToMirUsed, true);
|
|
assert.equal(graphCheckJson.graphCompiler.input, "program-graph-artifact");
|
|
assert.equal(graphCheckJson.safetyFacts.schemaVersion, 1);
|
|
assert.equal(graphCheckJson.safetyFacts.bounds.runtimeTraps, true);
|
|
assert.equal(graphCheckJson.safetyFacts.bounds.optimizerElision, false);
|
|
assert.equal(graphCheckJson.safetyFacts.overflow.runtimeArithmetic, "unchecked-machine-wrap");
|
|
assert.equal(graphCheckJson.safetyFacts.overflow.unchecked, true);
|
|
assert.equal(graphCheckJson.safetyFacts.initialization.maybePayloadReads, "guard-checked");
|
|
assert.equal(graphCheckJson.safetyFacts.mir.invalidMemoryContractsBlockEmission, true);
|
|
assert.deepEqual(graphCheckJson.diagnostics, []);
|
|
assert.equal(graphCheckJson.saved, null);
|
|
assert.equal(graphCheckJson.view, null);
|
|
const graphDirectImportCheckJson = json(["check", "--json", "examples/direct-package-arrays"]).body;
|
|
assert.equal(graphDirectImportCheckJson.ok, true);
|
|
assert.equal(graphDirectImportCheckJson.graph.canonicalSource, false);
|
|
assert.equal(graphDirectImportCheckJson.graph.lowering, "graph-native-check");
|
|
assert.equal(graphDirectImportCheckJson.graphCompiler.input, "repository-graph-store");
|
|
assert.equal(graphDirectImportCheckJson.targetReadiness.ok, true);
|
|
assert.equal(graphDirectImportCheckJson.safetyFacts.initialization.locals, "initializer-required");
|
|
assert.deepEqual(graphDirectImportCheckJson.diagnostics, []);
|
|
const graphDirectImportView = zero(["view", "examples/direct-package-arrays"]).stdout;
|
|
assert.match(graphDirectImportView, /fn package_sum\(\) -> i32/);
|
|
assert.match(graphDirectImportView, /export c fn main\(\) -> i32/);
|
|
const graphDirectStdCheckJson = json(["check", "--json", "examples/std-str.graph"]).body;
|
|
assert.equal(graphDirectStdCheckJson.ok, true);
|
|
assert.equal(graphDirectStdCheckJson.artifact, "examples/std-str.graph");
|
|
assert.equal(graphDirectStdCheckJson.canonicalSource, false);
|
|
assert.equal(graphDirectStdCheckJson.check.lowering, "graph-native-check");
|
|
assert.equal(graphDirectStdCheckJson.graphCompiler.input, "program-graph-artifact");
|
|
assert.equal(graphDirectStdCheckJson.targetReadiness.ok, true);
|
|
assert.deepEqual(graphDirectStdCheckJson.diagnostics, []);
|
|
const graphCheckOutJson = json(["check", "--json", "--out", graphCheckViewPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphCheckOutJson.code, 0);
|
|
assert.equal(graphCheckOutJson.body.diagnostics[0].message, "zero check does not support --out");
|
|
assert.equal(graphCheckOutJson.body.diagnostics[0].expected, "zero view --out <file.0> [graph-input]");
|
|
const graphSizeJson = json(["size", "--json", "--target", "linux-musl-x64", graphDumpPath]).body;
|
|
assert.equal(graphSizeJson.schemaVersion, 1);
|
|
assert.equal(graphSizeJson.sourceFile, graphDumpPath);
|
|
assert.equal(graphSizeJson.graph.artifact, graphDumpPath);
|
|
assert.equal(graphSizeJson.graph.canonicalSource, false);
|
|
assert.equal(graphSizeJson.graph.moduleIdentity, "module:hello");
|
|
assert.equal(graphSizeJson.graph.graphHash, graphInspectJson.programGraph.graphHash);
|
|
assert.equal(graphSizeJson.graph.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphSizeJson.graph.lowering, "mapped-final-mir");
|
|
assert.equal(graphSizeJson.target, "linux-musl-x64");
|
|
assert.equal(graphSizeJson.generatedCBytes, 0);
|
|
assert.equal(graphSizeJson.cBridgeFallback, false);
|
|
assert.equal(graphSizeJson.sizeBreakdown.target, "linux-musl-x64");
|
|
assert.equal(graphSizeJson.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(graphSizeJson.artifactPath, null);
|
|
assertProgramGraphCompilerInput(graphSizeJson, graphDumpPath);
|
|
const graphSizeMirCache = graphSizeJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(graphSizeMirCache.codegenImmediate, graphSizeMirCache.hit === true);
|
|
assert.equal(graphSizeMirCache.programReconstructed, false);
|
|
assert.equal(graphSizeJson.incrementalInvalidation.changedInputs.graphArtifact, graphDumpPath);
|
|
assert.equal(graphSizeJson.incrementalInvalidation.interfaceFingerprints.sourceKind, "program-graph");
|
|
assert.equal(graphSizeJson.incrementalInvalidation.interfaceFingerprints.graphHash, graphSizeJson.graph.graphHash);
|
|
const graphSizeHelloInterface = graphSizeJson.incrementalInvalidation.interfaceFingerprints.modules.find((item) => item.name === "hello");
|
|
assert(graphSizeHelloInterface);
|
|
assert.equal(graphSizeHelloInterface.publicSymbolCount, 1);
|
|
assert.deepEqual(graphSizeHelloInterface.publicSymbols, [{ name: "main", kind: "function" }]);
|
|
const graphSizeOutJson = json(["size", "--json", "--target", "linux-musl-x64", "--out", graphSizePath, graphDumpPath]).body;
|
|
assert.equal(graphSizeOutJson.graph.graphHash, graphSizeJson.graph.graphHash);
|
|
assert.equal(graphSizeOutJson.artifactPath, graphSizePath);
|
|
assert.equal(graphSizeOutJson.artifactBytes, statSync(graphSizePath).size);
|
|
assert.match(readFileSync(graphSizePath, "utf8"), /"kind": "zero-size-metadata"/);
|
|
const graphBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", graphBuildPath, graphDumpPath]).body;
|
|
assert.equal(graphBuildJson.schemaVersion, 1);
|
|
assert.equal(graphBuildJson.sourceFile, graphDumpPath);
|
|
assert.equal(graphBuildJson.graph.artifact, graphDumpPath);
|
|
assert.equal(graphBuildJson.graph.canonicalSource, false);
|
|
assert.equal(graphBuildJson.graph.moduleIdentity, "module:hello");
|
|
assert.equal(graphBuildJson.graph.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphBuildJson.graph.lowering, "mapped-final-mir");
|
|
assert.equal(graphBuildJson.emit, "exe");
|
|
assert.equal(graphBuildJson.target, "linux-musl-x64");
|
|
assert.equal(graphBuildJson.generatedCBytes, 0);
|
|
assert.equal(graphBuildJson.artifactPath, graphBuildPath);
|
|
assert.equal(graphBuildJson.artifactBytes, statSync(graphBuildPath).size);
|
|
assertProgramGraphCompilerInput(graphBuildJson, graphDumpPath);
|
|
const graphBuildMirCache = graphBuildJson.compilerCaches.find((cache) => cache.name === "mappedFinalMir");
|
|
assert.equal(graphBuildMirCache.hit, true);
|
|
assert.equal(graphBuildMirCache.codegenImmediate, true);
|
|
assert.equal(graphBuildMirCache.programReconstructed, false);
|
|
const graphObjJson = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "--out", graphObjPath, graphDumpPath]).body;
|
|
assert.equal(graphObjJson.sourceFile, graphDumpPath);
|
|
assert.equal(graphObjJson.graph.graphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphObjJson.graph.lowering, "mapped-final-mir");
|
|
assert.equal(graphObjJson.emit, "obj");
|
|
assert.equal(graphObjJson.target, "linux-musl-x64");
|
|
assert.equal(graphObjJson.generatedCBytes, 0);
|
|
assert.equal(graphObjJson.artifactPath, graphObjPath);
|
|
assert.equal(graphObjJson.artifactBytes, statSync(graphObjPath).size);
|
|
assertProgramGraphCompilerInput(graphObjJson, graphDumpPath);
|
|
assert.equal(zero(["run", "--out", graphRunPath, graphDumpPath]).stdout, "hello from zero\n");
|
|
assert.equal(existsSync(graphRunPath), true);
|
|
assert.equal(zero(["dump", "--out", graphArgsDumpPath, "conformance/native/pass/std-args.0"]).stdout, "");
|
|
assert.equal(zero(["run", "--out", graphArgsRunPath, graphArgsDumpPath, "--", "alpha", "beta"]).stdout, "alpha\n");
|
|
assert.equal(existsSync(graphArgsRunPath), true);
|
|
const graphRunJson = json(["run", "--json", graphDumpPath], { allowFailure: true });
|
|
assert.equal(graphRunJson.code, 1);
|
|
assert.equal(graphRunJson.body.diagnostics[0].message, "zero run does not support --json");
|
|
assert.equal(zero(["dump", "--out", graphTestDumpPath, "conformance/native/pass/test-blocks.0"]).stdout, "");
|
|
assert.equal(zero(["test", graphTestDumpPath]).stdout, "1 test(s) ok\n");
|
|
const graphTestOutJson = json(["test", "--json", "--out", graphCheckViewPath, graphTestDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphTestOutJson.code, 0);
|
|
assert.equal(graphTestOutJson.body.diagnostics[0].message, "zero test does not support --out");
|
|
assert.equal(graphTestOutJson.body.diagnostics[0].expected, "zero test [--json] [--filter <name>] [--target <target>] [graph-input]");
|
|
const graphTestJson = json(["test", "--json", "--filter", "addition", graphTestDumpPath]).body;
|
|
assert.equal(graphTestJson.ok, true);
|
|
assert.equal(graphTestJson.sourceFile, graphTestDumpPath);
|
|
assert.equal(graphTestJson.graph.artifact, graphTestDumpPath);
|
|
assert.equal(graphTestJson.graph.canonicalSource, false);
|
|
assert.equal(graphTestJson.graph.lowering, "direct-program-graph");
|
|
assert.match(graphTestJson.graph.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
assert.equal(graphTestJson.testBackend, "direct-program-graph");
|
|
assert.equal(graphTestJson.fixtures.snapshotKey, "zero-test-graph-native-v1");
|
|
assert.equal(graphTestJson.testDiscovery.mode, "program-graph");
|
|
assert.equal(graphTestJson.testDiscovery.filter, "addition");
|
|
assert.equal(graphTestJson.selectedTests, 1);
|
|
assert.equal(graphTestJson.results[0].status, "passed");
|
|
assert.equal(graphTestJson.results[0].location.sourceFile, "test-blocks.0");
|
|
assert.equal(graphTestJson.results[0].location.line, 5);
|
|
assert.equal(zero(["dump", "--out", graphPackageTestDumpPath, "conformance/packages/test-app"]).stdout, "");
|
|
const graphPackageTestJson = json(["test", "--json", graphPackageTestDumpPath]).body;
|
|
assert.equal(graphPackageTestJson.ok, true);
|
|
assert.equal(graphPackageTestJson.graph.artifact, graphPackageTestDumpPath);
|
|
assert.equal(graphPackageTestJson.graph.moduleIdentity, "package:test-app@0.1.0");
|
|
assert.equal(graphPackageTestJson.testDiscovery.mode, "package-graph");
|
|
assert.equal(graphPackageTestJson.testDiscovery.sourceFileCount, 2);
|
|
assert.equal(graphPackageTestJson.selectedTests, 3);
|
|
assert(graphPackageTestJson.fixtures.sourceFiles.includes("src/helper.0"));
|
|
assert(graphPackageTestJson.fixtures.sourceFiles.includes("src/main.0"));
|
|
const graphPackageHelperTest = graphPackageTestJson.results.find((item) => item.name === "package helper double");
|
|
assert(graphPackageHelperTest);
|
|
assert.equal(graphPackageHelperTest.location.sourceFile, "src/helper.0");
|
|
assert.equal(graphPackageHelperTest.location.line, 5);
|
|
const graphPackageExpectedFail = graphPackageTestJson.results.find((item) => item.status === "expected-fail");
|
|
assert(graphPackageExpectedFail);
|
|
assert.equal(graphPackageExpectedFail.location.sourceFile, "src/helper.0");
|
|
assert.equal(graphPackageExpectedFail.location.line, 9);
|
|
assert.equal(graphPackageExpectedFail.failure.sourceFile, "src/helper.0");
|
|
assert.equal(graphPackageExpectedFail.failure.line, 10);
|
|
mkdirSync(join(graphManifestPackageDir, "src"), { recursive: true });
|
|
mkdirSync(join(graphManifestPackageDir, "artifacts"), { recursive: true });
|
|
writeFileSync(join(graphManifestPackageDir, "src", "main.0"), readFileSync("conformance/packages/test-app/src/main.0", "utf8"));
|
|
writeFileSync(join(graphManifestPackageDir, "src", "helper.0"), readFileSync("conformance/packages/test-app/src/helper.0", "utf8"));
|
|
writeZeroTomlSync(graphManifestPackageDir, {
|
|
package: { name: "graph-manifest-package", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0", graph: "artifacts/test-app.program-graph" } },
|
|
});
|
|
assert.equal(zero(["dump", "--out", graphManifestArtifactPath, "conformance/packages/test-app"]).stdout, "");
|
|
assert.equal(zero(["import", graphManifestPackageDir]).stdout, `repository graph import ok\nwrote: ${graphManifestStorePath}\n`);
|
|
assert.equal(zero(["validate", graphManifestPackageDir]).stdout, "program graph ok\n");
|
|
const graphManifestCheckJson = json(["check", "--json", graphManifestPackageDir]).body;
|
|
assert.equal(graphManifestCheckJson.ok, true);
|
|
assert.equal(graphManifestCheckJson.graph.artifact, graphManifestStorePath);
|
|
assert.equal(graphManifestCheckJson.graph.moduleIdentity, "package:graph-manifest-package@0.1.0");
|
|
assert.equal(graphManifestCheckJson.graph.lowering, "graph-native-check");
|
|
const graphManifestSizeJson = json(["size", "--json", "--target", "linux-musl-x64", graphManifestPackageDir]).body;
|
|
assertSourceGraph(graphManifestSizeJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "mapped-final-mir", false, "clean");
|
|
assertProgramGraphCompilerInput(graphManifestSizeJson, graphManifestStorePath);
|
|
assert.equal(graphManifestSizeJson.sourceFile, graphManifestStorePath);
|
|
const graphManifestBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", graphManifestBuildPath, graphManifestPackageDir]).body;
|
|
assertSourceGraph(graphManifestBuildJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "mapped-final-mir", false, "clean");
|
|
assertProgramGraphCompilerInput(graphManifestBuildJson, graphManifestStorePath);
|
|
assert.equal(graphManifestBuildJson.sourceFile, graphManifestStorePath);
|
|
assert.equal(zero(["run", "--out", graphManifestRunPath, graphManifestPackageDir]).stdout, "package tests\n");
|
|
const graphManifestTestJson = json(["test", "--json", graphManifestPackageDir]).body;
|
|
assert.equal(graphManifestTestJson.ok, true);
|
|
assertSourceGraph(graphManifestTestJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "direct-program-graph", false, "clean");
|
|
assert.equal(graphManifestTestJson.testDiscovery.mode, "package-graph");
|
|
const graphManifestRoundtripJson = json(["roundtrip", "--json", graphManifestPackageDir]).body;
|
|
assert.equal(graphManifestRoundtripJson.ok, true);
|
|
assert.equal(graphManifestRoundtripJson.artifact, graphManifestStorePath);
|
|
assert.equal(graphManifestRoundtripJson.semanticStable, true);
|
|
assert.equal(graphManifestRoundtripJson.lowering, "direct-program-graph");
|
|
assert.equal(graphManifestRoundtripJson.moduleIdentity, "package:graph-manifest-package@0.1.0");
|
|
assert.equal(graphManifestRoundtripJson.roundtripModuleIdentity, "package:graph-manifest-package@0.1.0");
|
|
assert.equal(graphManifestRoundtripJson.view, null);
|
|
const directGraphManifestCheckJson = json(["check", "--json", graphManifestPackageDir]).body;
|
|
assert.equal(directGraphManifestCheckJson.ok, true);
|
|
assertSourceGraph(directGraphManifestCheckJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "graph-native-check", false, "clean");
|
|
assert.equal(directGraphManifestCheckJson.sourceFile, graphManifestStorePath);
|
|
assert.equal(directGraphManifestCheckJson.package.name, "graph-manifest-package");
|
|
assert.equal(directGraphManifestCheckJson.package.manifestPath, join(graphManifestPackageDir, "zero.toml"));
|
|
assert.notEqual(directGraphManifestCheckJson.package.manifestHash, "0000000000000000");
|
|
assertProgramGraphCompilerInput(directGraphManifestCheckJson, graphManifestStorePath);
|
|
assert.equal(directGraphManifestCheckJson.incrementalInvalidation.changedInputs.manifestPath, join(graphManifestPackageDir, "zero.toml"));
|
|
const directGraphManifestSizeJson = json(["size", "--json", "--target", "linux-musl-x64", graphManifestPackageDir]).body;
|
|
assertSourceGraph(directGraphManifestSizeJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "mapped-final-mir", false, "clean");
|
|
assertProgramGraphCompilerInput(directGraphManifestSizeJson, graphManifestStorePath);
|
|
assert.equal(directGraphManifestSizeJson.sourceFile, graphManifestStorePath);
|
|
const directGraphManifestMemJson = json(["mem", "--json", graphManifestPackageDir]).body;
|
|
assertSourceGraph(directGraphManifestMemJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "mapped-final-mir", false, "clean");
|
|
assertProgramGraphCompilerInput(directGraphManifestMemJson, graphManifestStorePath);
|
|
assert.equal(directGraphManifestMemJson.sourceFile, graphManifestStorePath);
|
|
const directGraphManifestBuildJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", directGraphManifestBuildPath, graphManifestPackageDir]).body;
|
|
assertSourceGraph(directGraphManifestBuildJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "mapped-final-mir", false, "clean");
|
|
assertProgramGraphCompilerInput(directGraphManifestBuildJson, graphManifestStorePath);
|
|
assert.equal(directGraphManifestBuildJson.sourceFile, graphManifestStorePath);
|
|
assert.equal(zero(["run", "--out", directGraphManifestRunPath, graphManifestPackageDir]).stdout, "package tests\n");
|
|
const directGraphManifestTestJson = json(["test", "--json", graphManifestPackageDir]).body;
|
|
assert.equal(directGraphManifestTestJson.ok, true);
|
|
assertSourceGraph(directGraphManifestTestJson, graphManifestStorePath, "package:graph-manifest-package@0.1.0", "direct-program-graph", false, "clean");
|
|
assert.equal(directGraphManifestTestJson.testDiscovery.mode, "package-graph");
|
|
const sourcePackageCheckJson = json(["check", "--json", "conformance/packages/test-app"]).body;
|
|
assert.equal(sourcePackageCheckJson.ok, true);
|
|
assertSourceGraph(sourcePackageCheckJson, "conformance/packages/test-app/zero.graph", "package:test-app@0.1.0", "graph-native-check", false);
|
|
mkdirSync(join(directGraphTargetGatePackageDir, "src"), { recursive: true });
|
|
mkdirSync(join(directGraphTargetGatePackageDir, "artifacts"), { recursive: true });
|
|
mkdirSync(join(directGraphTargetGateDepDir, "src"), { recursive: true });
|
|
writeFileSync(join(directGraphTargetGatePackageDir, "src", "main.0"), "pub fn main(world: World) -> Void raises {\n check world.out.write(\"target gate\\n\")\n}\n");
|
|
writeFileSync(join(directGraphTargetGateDepDir, "src", "main.0"), "pub fn main(world: World) -> Void raises {\n check world.out.write(\"webbits\\n\")\n}\n");
|
|
writeZeroTomlSync(directGraphTargetGateDepDir, {
|
|
package: { name: "target-webbits", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
});
|
|
writeZeroTomlSync(directGraphTargetGatePackageDir, {
|
|
package: { name: "direct-graph-target-gate", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0", graph: "artifacts/app.program-graph" } },
|
|
dependencies: {
|
|
"target-webbits": {
|
|
path: "../target-webbits",
|
|
version: "0.1.0",
|
|
targets: ["win32-x64.exe"],
|
|
},
|
|
},
|
|
});
|
|
assert.equal(zero(["import", directGraphTargetGateDepDir]).stdout, `repository graph import ok\nwrote: ${join(directGraphTargetGateDepDir, "zero.graph")}\n`);
|
|
assert.equal(zero(["import", directGraphTargetGatePackageDir]).stdout, `repository graph import ok\nwrote: ${join(directGraphTargetGatePackageDir, "zero.graph")}\n`);
|
|
assert.equal(zero(["dump", "--out", directGraphTargetGateArtifactPath, directGraphTargetGatePackageDir]).stdout, "");
|
|
const directGraphTargetGateJson = json(["check", "--json", "--target", "linux-musl-x64", directGraphTargetGatePackageDir], { allowFailure: true });
|
|
assert.equal(directGraphTargetGateJson.code, 1);
|
|
assert.equal(directGraphTargetGateJson.body.diagnostics[0].code, "PKG004");
|
|
assert.equal(directGraphTargetGateJson.body.diagnostics[0].message, "package dependency is not compatible with target");
|
|
mkdirSync(join(directGraphHostLeakPackageDir, "src"), { recursive: true });
|
|
mkdirSync(join(directGraphHostLeakPackageDir, "artifacts"), { recursive: true });
|
|
writeFileSync(join(directGraphHostLeakPackageDir, "src", "main.0"), "pub fn main(world: World) -> Void raises {\n check world.out.write(\"host leak\\n\")\n}\n");
|
|
writeZeroTomlSync(directGraphHostLeakPackageDir, {
|
|
package: { name: "direct-graph-host-leak", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0", graph: "artifacts/app.program-graph" } },
|
|
c: {
|
|
libs: {
|
|
hostonly: {
|
|
headers: ["hostonly.h"],
|
|
include: ["/usr/include"],
|
|
lib: ["/usr/lib"],
|
|
link: ["hostonly"],
|
|
pkg_config: "hostonly",
|
|
},
|
|
},
|
|
},
|
|
});
|
|
assert.equal(zero(["import", directGraphHostLeakPackageDir]).stdout, `repository graph import ok\nwrote: ${join(directGraphHostLeakPackageDir, "zero.graph")}\n`);
|
|
assert.equal(zero(["dump", "--out", directGraphHostLeakArtifactPath, directGraphHostLeakPackageDir]).stdout, "");
|
|
const directGraphHostLeakJson = json(["build", "--json", "--target", "linux-musl-x64", "--out", directGraphHostLeakBuildPath, directGraphHostLeakPackageDir], { allowFailure: true });
|
|
assert.equal(directGraphHostLeakJson.code, 1);
|
|
assert.equal(directGraphHostLeakJson.body.diagnostics[0].code, "CIMP003");
|
|
assert.equal(directGraphHostLeakJson.body.diagnostics[0].message, "foreign target C dependency would use host discovery");
|
|
const graphPackageSourceCheckJson = json(["check", "--json", "conformance/packages/test-app"]).body;
|
|
assert.equal(graphPackageSourceCheckJson.ok, true);
|
|
assert.equal(graphPackageSourceCheckJson.graph.moduleIdentity, "package:test-app@0.1.0");
|
|
assert.equal(graphPackageSourceCheckJson.graph.lowering, "graph-native-check");
|
|
writeFileSync(graphSizeNoisePatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insertEdge from="${graphHelloLiteralNode.id}" to="${graphHelloLiteralNode.typeId}" edge="sizeProbeType" target="type" order="0"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphSizeNoisePatchJson = json(["patch", "--json", "--out", graphSizeNoisePath, graphDumpPath, graphSizeNoisePatchPath]).body;
|
|
assert.equal(graphSizeNoisePatchJson.ok, true);
|
|
assert.equal(zero(["check", graphSizeNoisePath]).stdout, "ok\n");
|
|
const graphSizeNoiseJson = json(["size", "--json", "--target", "linux-musl-x64", graphSizeNoisePath]).body;
|
|
const graphSizeNoiseInterface = graphSizeNoiseJson.incrementalInvalidation.interfaceFingerprints.modules.find((item) => item.name === "hello");
|
|
assert(graphSizeNoiseInterface);
|
|
assert.deepEqual(graphSizeNoiseInterface.publicSymbols, [{ name: "main", kind: "function" }]);
|
|
writeFileSync(graphPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="hello patched\\n"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphPatchedPath, graphDumpPath, graphPatchPath]).stdout, graphPatchedPath);
|
|
const graphPatchedStdout = zero(["patch", graphDumpPath, graphPatchPath]).stdout;
|
|
assert.match(graphPatchedStdout, /^zero-graph v1\n/);
|
|
assert.match(graphPatchedStdout, /value:"hello patched\\n"/);
|
|
assert.equal(readFileSync(graphPatchedPath, "utf8"), graphPatchedStdout);
|
|
const graphPatchJson = json(["patch", "--json", "--out", graphPatchedPath, graphDumpPath, graphPatchPath]).body;
|
|
assert.equal(graphPatchJson.ok, true);
|
|
assert.equal(graphPatchJson.canonicalSource, false);
|
|
assert.equal(graphPatchJson.patch, graphPatchPath);
|
|
assert.equal(graphPatchJson.originalGraphHash, graphDumpJson.graphHash);
|
|
assert.match(graphPatchJson.patchedGraphHash, /^graph:[0-9a-f]{16}$/);
|
|
assert.notEqual(graphPatchJson.patchedGraphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphPatchJson.operationCount, 1);
|
|
assert.equal(graphPatchJson.operations[0].ok, true);
|
|
assert.equal(graphPatchJson.operations[0].node, graphHelloLiteralNode.id);
|
|
assert.equal(graphPatchJson.operations[0].field, "value");
|
|
assert.equal(graphPatchJson.operations[0].actual, "hello from zero\n");
|
|
assert.equal(graphPatchJson.operations[0].value, "hello patched\n");
|
|
assert.equal(graphPatchJson.diagnostic, null);
|
|
assert.equal(graphPatchJson.saved.path, graphPatchedPath);
|
|
mkdirSync(graphPatchDirectoryPath, { recursive: true });
|
|
const graphPatchDirectoryJson = json(["patch", "--json", "--out", graphPatchDirectoryOutPath, graphDumpPath, graphPatchDirectoryPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchDirectoryJson.code, 0);
|
|
assert.equal(graphPatchDirectoryJson.body.diagnostics[0].path, graphPatchDirectoryPath);
|
|
assert.match(graphPatchDirectoryJson.body.diagnostics[0].message, /^failed to read '.+hello\.program-graph\.patch-directory': /);
|
|
assert.equal(existsSync(graphPatchDirectoryOutPath), false);
|
|
assert.equal(zero(["validate", graphPatchedPath]).stdout, "program graph ok\n");
|
|
assert.match(zero(["view", graphPatchedPath]).stdout, /check world\.out\.write\("hello patched\\n"\)/);
|
|
assert.equal(zero(["check", graphPatchedPath]).stdout, "ok\n");
|
|
const graphSourcePatchPath = join(outDir, "hello.graph-sidecar.0");
|
|
writeProjectionFile(graphSourcePatchPath, graphView);
|
|
const graphSourcePatchSidecar = importProjectionSidecar(graphSourcePatchPath);
|
|
const graphSourcePatchDumpJson = json(["dump", "--json", graphSourcePatchPath]).body;
|
|
assert.equal(graphSourcePatchDumpJson.canonicalSource, false);
|
|
const graphSourceLiteralNode = graphSourcePatchDumpJson.nodes.find((node) => node.kind === "Literal" && node.type === "String" && node.value === "hello from zero\n");
|
|
assert(graphSourceLiteralNode);
|
|
const graphSourcePatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
"--out",
|
|
graphSourcePatchSidecar,
|
|
graphSourcePatchSidecar,
|
|
"--expect-graph-hash",
|
|
graphSourcePatchDumpJson.graphHash,
|
|
"--op",
|
|
`set node="${graphSourceLiteralNode.id}" field="value" expect="hello from zero\\n" value="hello sidecar graph\\n"`,
|
|
]).body;
|
|
assert.equal(graphSourcePatchJson.ok, true);
|
|
assert.equal(graphSourcePatchJson.canonicalSource, false);
|
|
assert.equal(graphSourcePatchJson.saved.path, graphSourcePatchSidecar);
|
|
zero(["view", "--out", graphSourcePatchPath, graphSourcePatchSidecar]);
|
|
assert.match(readFileSync(graphSourcePatchPath, "utf8"), /hello sidecar graph\\n/);
|
|
assertProjectionCheckOk(graphSourcePatchPath);
|
|
const graphSourceProjectionPatchRejected = json(["patch", "--json", graphSourcePatchPath, "--op", "addMain"], { allowFailure: true });
|
|
assert.notEqual(graphSourceProjectionPatchRejected.code, 0);
|
|
assert.equal(graphSourceProjectionPatchRejected.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(graphSourceProjectionPatchRejected.body.diagnostics[0].message, "graph patch requires graph input");
|
|
assert.equal(graphSourceProjectionPatchRejected.body.diagnostics[0].expected, "package zero.graph store, .graph store, or ProgramGraph artifact");
|
|
const graphSourcePackageDir = join(outDir, "graph-source-package");
|
|
const graphSourcePackageMain = join(graphSourcePackageDir, "src", "main.0");
|
|
const graphSourcePackageHelper = join(graphSourcePackageDir, "src", "helper.0");
|
|
rmSync(graphSourcePackageDir, { recursive: true, force: true });
|
|
mkdirSync(join(graphSourcePackageDir, "src"), { recursive: true });
|
|
writeZeroTomlSync(graphSourcePackageDir, {
|
|
package: { name: "graph-source-package", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.0" } },
|
|
});
|
|
writeProjectionFile(
|
|
graphSourcePackageHelper,
|
|
"pub fn value() -> i32 {\n" +
|
|
" return 41\n" +
|
|
"}\n",
|
|
);
|
|
writeProjectionFile(
|
|
graphSourcePackageMain,
|
|
"use helper\n\n" +
|
|
"pub fn main() -> i32 {\n" +
|
|
" return value() + 1\n" +
|
|
"}\n",
|
|
);
|
|
assert.match(zero(["import", graphSourcePackageDir]).stdout, /^repository graph import ok\n/);
|
|
const graphSourcePackageDumpJson = json(["dump", "--json", graphSourcePackageMain]).body;
|
|
const graphSourcePackageLiteralNode = graphSourcePackageDumpJson.nodes.find(
|
|
(node) => node.kind === "Literal" && node.value === "1",
|
|
);
|
|
assert(graphSourcePackageLiteralNode);
|
|
const graphSourcePackagePatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
graphSourcePackageDir,
|
|
"--expect-graph-hash",
|
|
graphSourcePackageDumpJson.graphHash,
|
|
"--op",
|
|
`set node="${graphSourcePackageLiteralNode.id}" field="value" expect="1" value="2"`,
|
|
]).body;
|
|
assert.equal(graphSourcePackagePatchJson.ok, true);
|
|
assert.equal(graphSourcePackagePatchJson.saved.path, join(graphSourcePackageDir, "zero.graph"));
|
|
assert.match(zero(["export", graphSourcePackageDir]).stdout, /^repository graph export ok\n/);
|
|
const graphSourcePackageMainText = readFileSync(graphSourcePackageMain, "utf8");
|
|
assert.match(graphSourcePackageMainText, /^use helper\n\n/);
|
|
assert.match(graphSourcePackageMainText, /return value\(\) \+ 2/);
|
|
assert.doesNotMatch(graphSourcePackageMainText, /pub fn value/);
|
|
assert.equal(readFileSync(graphSourcePackageHelper, "utf8"), "pub fn value() -> i32 {\n return 41\n}\n");
|
|
assert.equal(zero(["check", graphSourcePackageDir]).stdout, "ok\n");
|
|
const graphUserDerefSourcePath = join(outDir, "deref-member.0");
|
|
const graphUserDerefViewPath = join(outDir, "deref-member.view.0");
|
|
const graphPrefixDerefSourcePath = join(outDir, "prefix-deref-member.0");
|
|
const graphNestedCastSourcePath = join(outDir, "nested-cast.0");
|
|
const graphNestedCastViewPath = join(outDir, "nested-cast.view.0");
|
|
const graphPublicExportSourcePath = join(outDir, "public-export-c.0");
|
|
const graphPublicExportViewPath = join(outDir, "public-export-c.view.0");
|
|
const graphPublicInterfaceSourcePath = join(outDir, "public-interface-method.0");
|
|
const graphPublicInterfaceViewPath = join(outDir, "public-interface-method.view.0");
|
|
const graphPublicSumsSourcePath = join(outDir, "public-sums.0");
|
|
const graphExternFieldsSourcePath = join(outDir, "extern-fields.0");
|
|
const graphCommentsSourcePath = join(outDir, "comments.0");
|
|
const graphDerefMemberSource = [
|
|
"type Point {",
|
|
" x: i32,",
|
|
"}",
|
|
"",
|
|
"type Wrapper {",
|
|
" x: Point,",
|
|
"}",
|
|
"",
|
|
"fn deref(value: Wrapper) -> Point {",
|
|
" return value.x",
|
|
"}",
|
|
"",
|
|
"pub fn main() -> i32 {",
|
|
" let wrapped: Wrapper = Wrapper { x: Point { x: 7 } }",
|
|
" return deref(wrapped).x",
|
|
"}",
|
|
"",
|
|
].join("\n");
|
|
writeProjectionFile(graphUserDerefSourcePath, graphDerefMemberSource);
|
|
assertProjectionCheckOk(graphUserDerefSourcePath);
|
|
const graphUserDerefView = zero(["view", graphUserDerefSourcePath]).stdout;
|
|
assert.match(graphUserDerefView, /return deref\(wrapped\)\.x/);
|
|
assert.doesNotMatch(graphUserDerefView, /return \*wrapped\.x/);
|
|
assert.equal(zero(["view", "--out", graphUserDerefViewPath, graphUserDerefSourcePath]).stdout, "");
|
|
assertProjectionCheckOk(graphUserDerefViewPath);
|
|
writeProjectionFile(graphPrefixDerefSourcePath, graphDerefMemberSource.replace("return deref(wrapped).x", "return (*wrapped).x"));
|
|
assertProjectionCheckOk(graphPrefixDerefSourcePath);
|
|
const graphPrefixDerefView = zero(["view", graphPrefixDerefSourcePath]).stdout;
|
|
assert.match(graphPrefixDerefView, /return \(\*wrapped\)\.x/);
|
|
assert.equal(zero(["check", projectionSidecarGraphPath(graphPrefixDerefSourcePath)]).stdout, "ok\n");
|
|
writeProjectionFile(graphNestedCastSourcePath, [
|
|
"pub fn main() -> u32 {",
|
|
" let x: i32 = 1",
|
|
" return (x as u16) as u32",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assertProjectionCheckOk(graphNestedCastSourcePath);
|
|
const graphNestedCastView = zero(["view", graphNestedCastSourcePath]).stdout;
|
|
assert.match(graphNestedCastView, /return \(x as u16\) as u32/);
|
|
assert.equal(zero(["view", "--out", graphNestedCastViewPath, graphNestedCastSourcePath]).stdout, "");
|
|
assertProjectionCheckOk(graphNestedCastViewPath);
|
|
assert.equal(json(["roundtrip", "--json", graphNestedCastSourcePath]).body.view, null);
|
|
writeProjectionFile(graphPublicExportSourcePath, [
|
|
"pub export c fn main() -> i32 {",
|
|
" return 1",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assertProjectionCheckOk(graphPublicExportSourcePath);
|
|
assert.equal(zero(["view", "--out", graphPublicExportViewPath, graphPublicExportSourcePath]).stdout, "");
|
|
assertProjectionCheckOk(graphPublicExportViewPath);
|
|
assert.equal(json(["roundtrip", "--json", graphPublicExportSourcePath]).body.view, null);
|
|
writeProjectionFile(graphPublicInterfaceSourcePath, [
|
|
"interface Reader {",
|
|
" pub fn read() -> i32",
|
|
"}",
|
|
"",
|
|
"pub fn main() -> i32 {",
|
|
" return 1",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
assertProjectionCheckOk(graphPublicInterfaceSourcePath);
|
|
assert.equal(zero(["view", "--out", graphPublicInterfaceViewPath, graphPublicInterfaceSourcePath]).stdout, "");
|
|
assertProjectionCheckOk(graphPublicInterfaceViewPath);
|
|
assert.equal(json(["roundtrip", "--json", graphPublicInterfaceSourcePath]).body.view, null);
|
|
writeProjectionFile(graphPublicSumsSourcePath, [
|
|
"pub enum Mode: u8 {",
|
|
" ready,",
|
|
"}",
|
|
"",
|
|
"pub choice Result {",
|
|
" ok: i32,",
|
|
" err: String,",
|
|
"}",
|
|
"",
|
|
"pub fn main() -> i32 {",
|
|
" return 1",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
const graphPublicSumsSidecar = importProjectionSidecar(graphPublicSumsSourcePath);
|
|
const graphPublicSumsDumpJson = json(["dump", "--json", graphPublicSumsSourcePath]).body;
|
|
const graphPublicEnumNode = graphPublicSumsDumpJson.nodes.find((node) => node.kind === "Enum" && node.name === "Mode");
|
|
const graphPublicChoiceNode = graphPublicSumsDumpJson.nodes.find((node) => node.kind === "Choice" && node.name === "Result");
|
|
const graphPublicLiteralNode = graphPublicSumsDumpJson.nodes.find((node) => node.kind === "Literal" && node.value === "1");
|
|
assert.equal(graphPublicEnumNode?.public, true);
|
|
assert.equal(graphPublicChoiceNode?.public, true);
|
|
assert(graphPublicLiteralNode);
|
|
const graphPublicSumsPatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
"--out",
|
|
graphPublicSumsSidecar,
|
|
graphPublicSumsSidecar,
|
|
"--expect-graph-hash",
|
|
graphPublicSumsDumpJson.graphHash,
|
|
"--op",
|
|
`set node="${graphPublicLiteralNode.id}" field="value" expect="1" value="2"`,
|
|
]).body;
|
|
assert.equal(graphPublicSumsPatchJson.ok, true);
|
|
assert.equal(graphPublicSumsPatchJson.canonicalSource, false);
|
|
assert.equal(graphPublicSumsPatchJson.saved.path, graphPublicSumsSidecar);
|
|
zero(["view", "--out", graphPublicSumsSourcePath, graphPublicSumsSidecar]);
|
|
const graphPublicSumsText = readFileSync(graphPublicSumsSourcePath, "utf8");
|
|
assert.match(graphPublicSumsText, /^pub enum Mode/m);
|
|
assert.match(graphPublicSumsText, /^pub choice Result/m);
|
|
assert.match(graphPublicSumsText, /return 2/);
|
|
assertProjectionCheckOk(graphPublicSumsSourcePath);
|
|
writeProjectionFile(graphExternFieldsSourcePath, [
|
|
"extern type CPoint {",
|
|
" x: i32,",
|
|
" y: i32,",
|
|
"}",
|
|
"",
|
|
"pub fn main() -> i32 {",
|
|
" return 1",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
const graphExternFieldsSidecar = importProjectionSidecar(graphExternFieldsSourcePath);
|
|
const graphExternFieldsDumpJson = json(["dump", "--json", graphExternFieldsSourcePath]).body;
|
|
const graphExternFieldsLiteralNode = graphExternFieldsDumpJson.nodes.find((node) => node.kind === "Literal" && node.value === "1");
|
|
assert(graphExternFieldsLiteralNode);
|
|
const graphExternFieldsPatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
"--out",
|
|
graphExternFieldsSidecar,
|
|
graphExternFieldsSidecar,
|
|
"--expect-graph-hash",
|
|
graphExternFieldsDumpJson.graphHash,
|
|
"--op",
|
|
`set node="${graphExternFieldsLiteralNode.id}" field="value" expect="1" value="2"`,
|
|
]).body;
|
|
assert.equal(graphExternFieldsPatchJson.ok, true);
|
|
assert.equal(graphExternFieldsPatchJson.canonicalSource, false);
|
|
assert.equal(graphExternFieldsPatchJson.saved.path, graphExternFieldsSidecar);
|
|
zero(["view", "--out", graphExternFieldsSourcePath, graphExternFieldsSidecar]);
|
|
const graphExternFieldsText = readFileSync(graphExternFieldsSourcePath, "utf8");
|
|
assert.match(graphExternFieldsText, /^extern type CPoint \{/m);
|
|
assert.match(graphExternFieldsText, /^\s+x: i32,/m);
|
|
assert.match(graphExternFieldsText, /^\s+y: i32,/m);
|
|
assert.match(graphExternFieldsText, /return 2/);
|
|
assertProjectionCheckOk(graphExternFieldsSourcePath);
|
|
writeProjectionFile(graphCommentsSourcePath, [
|
|
"// module comment",
|
|
"",
|
|
"pub fn main() -> i32 {",
|
|
" // keep this comment",
|
|
" return 1",
|
|
"}",
|
|
"",
|
|
].join("\n"));
|
|
const graphCommentsOriginal = readFileSync(graphCommentsSourcePath, "utf8");
|
|
const graphCommentsPatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
graphCommentsSourcePath,
|
|
"--op",
|
|
"addMain",
|
|
], { allowFailure: true });
|
|
assert.notEqual(graphCommentsPatchJson.code, 0);
|
|
assert.equal(graphCommentsPatchJson.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(graphCommentsPatchJson.body.diagnostics[0].message, "graph patch requires graph input");
|
|
assert.equal(readFileSync(graphCommentsSourcePath, "utf8"), graphCommentsOriginal);
|
|
const graphInlinePatchJson = json([
|
|
"patch",
|
|
"--json",
|
|
"--out",
|
|
graphInlinePatchedPath,
|
|
graphDumpPath,
|
|
"--expect-graph-hash",
|
|
graphDumpJson.graphHash,
|
|
"--op",
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="hello inline\\n"`,
|
|
]).body;
|
|
assert.equal(graphInlinePatchJson.ok, true);
|
|
assert.equal(graphInlinePatchJson.patch, "<inline>");
|
|
assert.equal(graphInlinePatchJson.originalGraphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphInlinePatchJson.operationCount, 1);
|
|
assert.equal(graphInlinePatchJson.operations[0].node, graphHelloLiteralNode.id);
|
|
assert.equal(graphInlinePatchJson.operations[0].value, "hello inline\n");
|
|
assert.equal(graphInlinePatchJson.saved.path, graphInlinePatchedPath);
|
|
assert.match(zero(["view", graphInlinePatchedPath]).stdout, /check world\.out\.write\("hello inline\\n"\)/);
|
|
writeFileSync(graphPatchInsertPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insert node="#patch_check" kind="Check" parent="${graphMainBodyNode.id}" edge="statement" order="1" path="examples/hello.0" line="3" column="3"`,
|
|
`insert node="#patch_call" kind="MethodCall" parent="#patch_check" edge="expr" name="write" type="Void" path="examples/hello.0" line="3" column="25"`,
|
|
`insert node="#patch_write" kind="FieldAccess" parent="#patch_call" edge="left" order="0" name="write" path="examples/hello.0" line="3" column="18"`,
|
|
`insert node="#patch_out" kind="FieldAccess" parent="#patch_write" edge="left" order="0" name="out" path="examples/hello.0" line="3" column="14"`,
|
|
`insert node="#patch_world" kind="Identifier" parent="#patch_out" edge="left" order="0" name="world" path="examples/hello.0" line="3" column="9"`,
|
|
`insert node="#patch_lit" kind="Literal" parent="#patch_call" edge="arg" order="0" type="String" value="second line\\n" path="examples/hello.0" line="3" column="25"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphInsertPatchJson = json(["patch", "--json", "--out", graphInsertedPath, graphDumpPath, graphPatchInsertPath]).body;
|
|
assert.equal(graphInsertPatchJson.ok, true);
|
|
assert.equal(graphInsertPatchJson.operationCount, 6);
|
|
assert.equal(graphInsertPatchJson.operations[0].op, "insert");
|
|
assert.equal(graphInsertPatchJson.operations[0].parent, graphMainBodyNode.id);
|
|
assert.equal(graphInsertPatchJson.operations[0].edge, "statement");
|
|
assert.equal(graphInsertPatchJson.operations[0].order, 1);
|
|
assert.equal(graphInsertPatchJson.operations[1].order, 0);
|
|
assert.equal(graphInsertPatchJson.operations[5].kind, "Literal");
|
|
assert.equal(graphInsertPatchJson.operations[5].type, "String");
|
|
assert.equal(graphInsertPatchJson.operations[5].value, "second line\n");
|
|
assert.equal(graphInsertPatchJson.saved.path, graphInsertedPath);
|
|
const graphInsertedView = zero(["view", graphInsertedPath]).stdout;
|
|
assert.match(graphInsertedView, /check world\.out\.write\("hello from zero\\n"\)\n check world\.out\.write\("second line\\n"\)/);
|
|
assert.equal(zero(["check", graphInsertedPath]).stdout, "ok\n");
|
|
assert.equal(zero(["roundtrip", graphInsertedPath]).stdout, "program graph roundtrip ok\n");
|
|
const graphInsertedText = readFileSync(graphInsertedPath, "utf8");
|
|
const graphInsertedCheckLine = graphInsertedText.split("\n").find((line) => line.startsWith("node #patch_check ")) ?? "";
|
|
const graphInsertedCheckHash = graphQuotedField(graphInsertedCheckLine, "nodeHash") || graphNodeHash(graphInsertedCheckLine);
|
|
assert.match(graphInsertedCheckHash, /^nodehash:[0-9a-f]{16}$/);
|
|
writeFileSync(graphPatchDeletePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphInsertPatchJson.patchedGraphHash}"`,
|
|
`delete node="#patch_check" expect="${graphInsertedCheckHash}"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphDeletePatchJson = json(["patch", "--json", "--out", graphDeletedPath, graphInsertedPath, graphPatchDeletePath]).body;
|
|
assert.equal(graphDeletePatchJson.ok, true);
|
|
assert.equal(graphDeletePatchJson.operations[0].op, "delete");
|
|
assert.equal(graphDeletePatchJson.operations[0].actual, graphInsertedCheckHash);
|
|
assert.equal(readFileSync(graphDeletedPath, "utf8"), graphDump);
|
|
const graphOriginalCheckNode = graphDumpJson.nodes.find((node) => node.kind === "Check");
|
|
assert(graphOriginalCheckNode);
|
|
writeFileSync(graphPatchDeleteThenInsertPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphInsertPatchJson.patchedGraphHash}"`,
|
|
`delete node="${graphOriginalCheckNode.id}" expect="${graphOriginalCheckNode.nodeHash}"`,
|
|
`insert node="#patch_replacement_check" kind="Check" parent="${graphMainBodyNode.id}" edge="statement" order="0" path="examples/hello.0" line="2" column="3"`,
|
|
`insert node="#patch_replacement_call" kind="MethodCall" parent="#patch_replacement_check" edge="expr" order="0" name="write" type="Void" path="examples/hello.0" line="2" column="25"`,
|
|
`insert node="#patch_replacement_write" kind="FieldAccess" parent="#patch_replacement_call" edge="left" order="0" name="write" path="examples/hello.0" line="2" column="18"`,
|
|
`insert node="#patch_replacement_out" kind="FieldAccess" parent="#patch_replacement_write" edge="left" order="0" name="out" path="examples/hello.0" line="2" column="14"`,
|
|
`insert node="#patch_replacement_world" kind="Identifier" parent="#patch_replacement_out" edge="left" order="0" name="world" path="examples/hello.0" line="2" column="9"`,
|
|
`insert node="#patch_replacement_lit" kind="Literal" parent="#patch_replacement_call" edge="arg" order="0" type="String" value="replacement line\\n" path="examples/hello.0" line="2" column="25"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphDeleteThenInsertPatchJson = json(["patch", "--json", "--out", graphDeleteThenInsertedPath, graphInsertedPath, graphPatchDeleteThenInsertPath]).body;
|
|
assert.equal(graphDeleteThenInsertPatchJson.ok, true);
|
|
assert.equal(graphDeleteThenInsertPatchJson.operations[0].op, "delete");
|
|
assert.equal(graphDeleteThenInsertPatchJson.operations[1].op, "insert");
|
|
const graphDeleteThenInsertedView = zero(["view", graphDeleteThenInsertedPath]).stdout;
|
|
assert.match(graphDeleteThenInsertedView, /check world\.out\.write\("replacement line\\n"\)\n check world\.out\.write\("second line\\n"\)/);
|
|
assert.equal(zero(["check", graphDeleteThenInsertedPath]).stdout, "ok\n");
|
|
assert.equal(zero(["roundtrip", graphDeleteThenInsertedPath]).stdout, "program graph roundtrip ok\n");
|
|
writeFileSync(graphPatchDeleteNodeFactPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insert node="#patch_node_fact" kind="Check" parent="${graphMainBodyNode.id}" edge="statement" order="1"`,
|
|
`insertEdge from="#patch_node_fact" to="${graphModuleNode.id}" edge="backlink" target="node" order="0"`,
|
|
`delete node="#patch_node_fact"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphDeleteNodeFactPatchJson = json(["patch", "--json", "--out", graphDeletedNodeFactPath, graphDumpPath, graphPatchDeleteNodeFactPath]).body;
|
|
assert.equal(graphDeleteNodeFactPatchJson.ok, true);
|
|
assert.equal(graphDeleteNodeFactPatchJson.operationCount, 3);
|
|
assert.equal(graphDeleteNodeFactPatchJson.operations[1].op, "insertEdge");
|
|
assert.equal(graphDeleteNodeFactPatchJson.operations[1].target, "node");
|
|
assert.equal(graphDeleteNodeFactPatchJson.operations[2].op, "delete");
|
|
assert.equal(readFileSync(graphDeletedNodeFactPath, "utf8"), graphDump);
|
|
writeFileSync(graphPatchDeleteExternalRootRefPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insert node="#patch_external_root_ref" kind="Check" parent="${graphMainBodyNode.id}" edge="statement" order="1"`,
|
|
`insertEdge from="${graphModuleNode.id}" to="#patch_external_root_ref" edge="backlink" target="node" order="0"`,
|
|
`delete node="#patch_external_root_ref"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphDeleteExternalRootRefPatchJson = json(["patch", "--json", graphDumpPath, graphPatchDeleteExternalRootRefPath], { allowFailure: true });
|
|
assert.notEqual(graphDeleteExternalRootRefPatchJson.code, 0);
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.ok, false);
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.operations[0].ok, true);
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.operations[1].ok, true);
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.operations[2].ok, false);
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.operations[2].code, "GPH005");
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.operations[2].actual, "#patch_external_root_ref");
|
|
assert.equal(graphDeleteExternalRootRefPatchJson.body.saved, null);
|
|
writeFileSync(graphPatchDeleteExtraOwnerPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insert node="#patch_extra_owner" kind="Check" parent="${graphMainBodyNode.id}" edge="statement" order="1"`,
|
|
`insertEdge from="${graphModuleNode.id}" to="#patch_extra_owner" edge="function" target="node" order="1"`,
|
|
`delete node="#patch_extra_owner"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphDeleteExtraOwnerPatchJson = json(["patch", "--json", graphDumpPath, graphPatchDeleteExtraOwnerPath], { allowFailure: true });
|
|
assert.notEqual(graphDeleteExtraOwnerPatchJson.code, 0);
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.ok, false);
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.operations[0].ok, true);
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.operations[1].ok, true);
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.operations[2].ok, false);
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.operations[2].code, "GPH005");
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.operations[2].actual, "#patch_extra_owner");
|
|
assert.equal(graphDeleteExtraOwnerPatchJson.body.saved, null);
|
|
const graphLiteralNode = graphDumpJson.nodes.find((node) => node.kind === "Literal" && node.type === "String");
|
|
assert(graphLiteralNode);
|
|
writeFileSync(graphPatchReplacePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`replace node="${graphLiteralNode.id}" expect="${graphLiteralNode.nodeHash}" kind="Literal" type="String" value="hello replaced structurally\\n" public="true"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphReplacePatchJson = json(["patch", "--json", "--out", graphReplacedPath, graphDumpPath, graphPatchReplacePath]).body;
|
|
assert.equal(graphReplacePatchJson.ok, true);
|
|
assert.equal(graphReplacePatchJson.operations[0].op, "replace");
|
|
assert.equal(graphReplacePatchJson.operations[0].actual, graphLiteralNode.nodeHash);
|
|
assert.equal(graphReplacePatchJson.operations[0].value, "hello replaced structurally\n");
|
|
assert.equal(graphReplacePatchJson.operations[0].public, true);
|
|
assert.match(zero(["view", graphReplacedPath]).stdout, /check world\.out\.write\("hello replaced structurally\\n"\)/);
|
|
writeFileSync(graphPatchStaleReplacePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`replace node="${graphLiteralNode.id}" expect="${graphLiteralNode.nodeHash}" kind="Literal" type="String" value="first structural value\\n"`,
|
|
`replace node="${graphLiteralNode.id}" expect="${graphLiteralNode.nodeHash}" kind="Literal" type="String" value="second structural value\\n"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphStaleReplacePatchJson = json(["patch", "--json", graphDumpPath, graphPatchStaleReplacePath], { allowFailure: true });
|
|
assert.notEqual(graphStaleReplacePatchJson.code, 0);
|
|
assert.equal(graphStaleReplacePatchJson.body.ok, false);
|
|
assert.equal(graphStaleReplacePatchJson.body.operations[0].ok, true);
|
|
assert.equal(graphStaleReplacePatchJson.body.operations[1].ok, false);
|
|
assert.equal(graphStaleReplacePatchJson.body.operations[1].code, "GPH005");
|
|
assert.notEqual(graphStaleReplacePatchJson.body.operations[1].actual, graphLiteralNode.nodeHash);
|
|
writeFileSync(graphPatchInsertEdgePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insertEdge from="${graphLiteralNode.id}" to="${graphLiteralNode.typeId}" edge="resolvedType" target="type" order="0"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphInsertEdgePatchJson = json(["patch", "--json", "--out", graphInsertedEdgePath, graphDumpPath, graphPatchInsertEdgePath]).body;
|
|
assert.equal(graphInsertEdgePatchJson.ok, true);
|
|
assert.equal(graphInsertEdgePatchJson.operations[0].op, "insertEdge");
|
|
assert.equal(graphInsertEdgePatchJson.operations[0].from, graphLiteralNode.id);
|
|
assert.equal(graphInsertEdgePatchJson.operations[0].to, graphLiteralNode.typeId);
|
|
assert.equal(graphInsertEdgePatchJson.operations[0].target, "type");
|
|
assert.equal(zero(["validate", graphInsertedEdgePath]).stdout, "program graph ok\n");
|
|
writeFileSync(graphPatchEmptyTypeEdgePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`insertEdge from="${graphModuleNode.id}" to="" edge="resolvedType" target="type" order="0"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphEmptyTypeEdgePatchJson = json(["patch", "--json", graphDumpPath, graphPatchEmptyTypeEdgePath], { allowFailure: true });
|
|
assert.notEqual(graphEmptyTypeEdgePatchJson.code, 0);
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.ok, false);
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.diagnostic.code, "GPH004");
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.operations[0].ok, false);
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.operations[0].code, "GPH004");
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.operations[0].to, "");
|
|
assert.equal(graphEmptyTypeEdgePatchJson.body.saved, null);
|
|
const graphEmptyTypeEdgePatchText = zeroWithStderr(["patch", graphDumpPath, graphPatchEmptyTypeEdgePath]);
|
|
assert.notEqual(graphEmptyTypeEdgePatchText.code, 0);
|
|
assert.match(graphEmptyTypeEdgePatchText.stderr, /zero query --fn <name> --handles to list stmt and param patch handles/);
|
|
writeFileSync(graphPatchRenamePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`rename node="${graphMainFunctionNode.id}" expect="main" value="start"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphRenamePatchJson = json(["patch", "--json", "--out", graphRenamedPath, graphDumpPath, graphPatchRenamePath]).body;
|
|
assert.equal(graphRenamePatchJson.ok, true);
|
|
assert.equal(graphRenamePatchJson.operations[0].op, "rename");
|
|
assert.equal(graphRenamePatchJson.operations[0].actual, "main");
|
|
assert.match(zero(["view", graphRenamedPath]).stdout, /pub fn start\(world: World\) -> Void raises/);
|
|
const graphRenamedCheck = json(["check", "--json", graphRenamedPath]);
|
|
assert.equal(graphRenamedCheck.body.ok, true);
|
|
assert.equal(graphRenamedCheck.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphRenamedCheck.body.targetReadiness.ok, false);
|
|
assert.equal(graphRenamedCheck.body.targetReadiness.diagnostics[0].message, "typed graph MIR requires at least one exported C ABI entry function");
|
|
writeFileSync(graphPatchInvalidRenamePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`rename node="${graphMainFunctionNode.id}" expect="main" value="bad\\nname"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphInvalidRenamePatchJson = json(["patch", "--json", graphDumpPath, graphPatchInvalidRenamePath], { allowFailure: true });
|
|
assert.notEqual(graphInvalidRenamePatchJson.code, 0);
|
|
assert.equal(graphInvalidRenamePatchJson.body.ok, false);
|
|
assert.equal(graphInvalidRenamePatchJson.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphInvalidRenamePatchJson.body.operations[0].actual, "bad\nname");
|
|
assert.equal(graphInvalidRenamePatchJson.body.saved, null);
|
|
writeFileSync(graphUncheckedPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphMainFunctionNode.id}" field="type" expect="Void" value="u32"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphUncheckedPath, graphDumpPath, graphUncheckedPatchPath]).stdout, graphUncheckedPath);
|
|
const graphUncheckedInline = json(["check", "--json", graphUncheckedPath], { allowFailure: true });
|
|
assert.equal(graphUncheckedInline.code, 0);
|
|
assert.equal(graphUncheckedInline.body.ok, true);
|
|
assert.equal(graphUncheckedInline.body.canonicalSource, false);
|
|
assert.equal(graphUncheckedInline.body.check.ok, true);
|
|
assert.equal(graphUncheckedInline.body.check.phase, "typecheck");
|
|
assert.equal(graphUncheckedInline.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphUncheckedInline.body.check.sourcePath, null);
|
|
assert.equal(graphUncheckedInline.body.targetReadiness.ok, false);
|
|
assert.equal(graphUncheckedInline.body.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(graphUncheckedInline.body.targetReadiness.diagnostics[0].actual, "no exported function");
|
|
assert.equal(graphUncheckedInline.body.saved, null);
|
|
assert.deepEqual(graphUncheckedInline.body.diagnostics, []);
|
|
assert.equal(graphUncheckedInline.body.view, null);
|
|
assert.doesNotMatch(JSON.stringify(graphUncheckedInline.body), /<generated-graph-view>|zero-graph-check/);
|
|
assert.equal(zero(["dump", "--out", graphBorrowDumpPath, "conformance/native/pass/borrow-field-independent-assignment.0"]).stdout, "");
|
|
const graphBorrowDumpJson = json(["dump", "--json", "conformance/native/pass/borrow-field-independent-assignment.0"]).body;
|
|
assert.match(graphBorrowDumpJson.graphHash, /^graph:[0-9a-f]{16}$/);
|
|
const graphBorrowRightFieldAccess = graphBorrowDumpJson.nodes.filter((node) => node.kind === "FieldAccess" && node.name === "right").at(-1);
|
|
assert(graphBorrowRightFieldAccess);
|
|
writeFileSync(graphBorrowConflictPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphBorrowDumpJson.graphHash}"`,
|
|
`set node="${graphBorrowRightFieldAccess.id}" field="name" expect="right" value="left"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphBorrowConflictPath, graphBorrowDumpPath, graphBorrowConflictPatchPath]).stdout, graphBorrowConflictPath);
|
|
const graphBorrowConflictInline = json(["check", "--json", graphBorrowConflictPath], { allowFailure: true });
|
|
assert.equal(graphBorrowConflictInline.code, 0);
|
|
assert.equal(graphBorrowConflictInline.body.ok, true);
|
|
assert.equal(graphBorrowConflictInline.body.check.ok, true);
|
|
assert.equal(graphBorrowConflictInline.body.targetReadiness.ok, false);
|
|
assert.equal(graphBorrowConflictInline.body.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.deepEqual(graphBorrowConflictInline.body.diagnostics, []);
|
|
assert.equal(graphBorrowConflictInline.body.view, null);
|
|
assert.doesNotMatch(JSON.stringify(graphBorrowConflictInline.body), /<generated-graph-view>|zero-graph-check/);
|
|
writeFileSync(graphPatchEmptyPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value=""`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchEmpty = json(["patch", "--json", graphDumpPath, graphPatchEmptyPath]).body;
|
|
assert.equal(graphPatchEmpty.ok, true);
|
|
assert.equal(graphPatchEmpty.operations[0].value, "");
|
|
writeFileSync(graphPatchControlPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="\\u0001"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchControl = json(["patch", "--json", graphDumpPath, graphPatchControlPath]).body;
|
|
assert.equal(graphPatchControl.ok, true);
|
|
assert.equal(graphPatchControl.operations[0].value, "\u0001");
|
|
writeFileSync(graphPatchHighBytePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="\\u0080"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchHighByteStdout = execFileSync(zeroBin, ["patch", "--json", graphDumpPath, graphPatchHighBytePath], { stdio: ["ignore", "pipe", "pipe"] });
|
|
assert.equal(graphPatchHighByteStdout.includes(Buffer.from([0x80])), false);
|
|
const graphPatchHighByteText = graphPatchHighByteStdout.toString("utf8");
|
|
assert.match(graphPatchHighByteText, /"value": "\\u0080"/);
|
|
const graphPatchHighByte = JSON.parse(graphPatchHighByteText);
|
|
assert.equal(graphPatchHighByte.ok, true);
|
|
assert.equal(graphPatchHighByte.operations[0].value.charCodeAt(0), 0x80);
|
|
writeFileSync(graphPatchBadEscapePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="\\q"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchBadEscape = json(["patch", "--json", graphDumpPath, graphPatchBadEscapePath], { allowFailure: true });
|
|
assert.notEqual(graphPatchBadEscape.code, 0);
|
|
assert.equal(graphPatchBadEscape.body.ok, false);
|
|
assert.equal(graphPatchBadEscape.body.diagnostic.code, "GPH001");
|
|
writeFileSync(graphPatchNullEscapePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="\\u0000x"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchNullEscape = json(["patch", "--json", graphDumpPath, graphPatchNullEscapePath], { allowFailure: true });
|
|
assert.notEqual(graphPatchNullEscape.code, 0);
|
|
assert.equal(graphPatchNullEscape.body.ok, false);
|
|
assert.equal(graphPatchNullEscape.body.diagnostic.code, "GPH001");
|
|
writeFileSync(graphPatchRawNullPath, Buffer.concat([
|
|
Buffer.from([
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="hello from zero\\n" value="raw nul prefix"`,
|
|
"",
|
|
].join("\n")),
|
|
Buffer.from([0]),
|
|
Buffer.from(`set node="${graphHelloLiteralNode.id}" field="value" value="ignored"\n`),
|
|
]));
|
|
const graphPatchRawNull = json(["patch", "--json", graphDumpPath, graphPatchRawNullPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchRawNull.code, 0);
|
|
assert.equal(graphPatchRawNull.body.ok, false);
|
|
assert.equal(graphPatchRawNull.body.diagnostic.code, "GPH001");
|
|
assert.equal(graphPatchRawNull.body.diagnostic.message, "program graph patch contains NUL byte");
|
|
writeFileSync(graphPatchInvalidNamePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphMainFunctionNode.id}" field="name" expect="main" value="main\\npub fn injected Void"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchInvalidName = json(["patch", "--json", graphDumpPath, graphPatchInvalidNamePath], { allowFailure: true });
|
|
assert.notEqual(graphPatchInvalidName.code, 0);
|
|
assert.equal(graphPatchInvalidName.body.ok, false);
|
|
assert.equal(graphPatchInvalidName.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphPatchInvalidName.body.operations[0].field, "name");
|
|
assert.equal(graphPatchInvalidName.body.operations[0].value, "main\npub fn injected Void");
|
|
writeFileSync(graphPatchInvalidTypePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphMainFunctionNode.id}" field="type" expect="Void" value="Void\\npub fn injected Void"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchInvalidType = json(["patch", "--json", graphDumpPath, graphPatchInvalidTypePath], { allowFailure: true });
|
|
assert.notEqual(graphPatchInvalidType.code, 0);
|
|
assert.equal(graphPatchInvalidType.body.ok, false);
|
|
assert.equal(graphPatchInvalidType.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphPatchInvalidType.body.operations[0].field, "type");
|
|
assert.equal(graphPatchInvalidType.body.operations[0].value, "Void\npub fn injected Void");
|
|
assert.equal(zero(["dump", "--out", graphPayloadDumpPath, "conformance/check/pass/payload-match.0"]).stdout, "");
|
|
const graphPayloadDumpJson = json(["dump", "--json", "conformance/check/pass/payload-match.0"]).body;
|
|
const graphMatchNode = graphPayloadDumpJson.nodes.find((node) => node.kind === "Match");
|
|
const graphMatchArmNode = graphPayloadDumpJson.nodes.find((node) => node.kind === "MatchArm" && node.name === "ok");
|
|
assert(graphMatchNode);
|
|
assert(graphMatchArmNode);
|
|
writeFileSync(graphPatchInvalidMatchReplacePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPayloadDumpJson.graphHash}"`,
|
|
`replace node="${graphMatchArmNode.id}" expect="${graphMatchArmNode.nodeHash}" kind="MatchArm" value="payload\\nname"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchInvalidMatchReplace = json(["patch", "--json", graphPayloadDumpPath, graphPatchInvalidMatchReplacePath], { allowFailure: true });
|
|
assert.notEqual(graphPatchInvalidMatchReplace.code, 0);
|
|
assert.equal(graphPatchInvalidMatchReplace.body.ok, false);
|
|
assert.equal(graphPatchInvalidMatchReplace.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphPatchInvalidMatchReplace.body.diagnostic.message, "patch match payload value must be a Zero identifier path or operator");
|
|
assert.equal(graphPatchInvalidMatchReplace.body.operations[0].op, "replace");
|
|
assert.equal(graphPatchInvalidMatchReplace.body.operations[0].value, "payload\nname");
|
|
assert.equal(graphPatchInvalidMatchReplace.body.saved, null);
|
|
writeFileSync(graphPatchInvalidMatchInsertPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPayloadDumpJson.graphHash}"`,
|
|
`insert node="#patch_bad_match_arm" kind="MatchArm" parent="${graphMatchNode.id}" edge="arm" order="2" name="ok" value="payload\\nname"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchInvalidMatchInsert = json(["patch", "--json", graphPayloadDumpPath, graphPatchInvalidMatchInsertPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchInvalidMatchInsert.code, 0);
|
|
assert.equal(graphPatchInvalidMatchInsert.body.ok, false);
|
|
assert.equal(graphPatchInvalidMatchInsert.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphPatchInvalidMatchInsert.body.diagnostic.message, "patch match payload value must be a Zero identifier path or operator");
|
|
assert.equal(graphPatchInvalidMatchInsert.body.operations[0].op, "insert");
|
|
assert.equal(graphPatchInvalidMatchInsert.body.operations[0].value, "payload\nname");
|
|
assert.equal(graphPatchInvalidMatchInsert.body.saved, null);
|
|
const graphWorldParamNode = graphDumpJson.nodes.find((node) => node.kind === "Param" && node.name === "world");
|
|
assert(graphWorldParamNode);
|
|
writeFileSync(graphPatchReservedParamPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphWorldParamNode.id}" field="name" expect="world" value="pub"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphReservedParamPath, graphDumpPath, graphPatchReservedParamPath]).stdout, graphReservedParamPath);
|
|
const graphReservedParam = json(["check", "--json", graphReservedParamPath], { allowFailure: true });
|
|
assert.notEqual(graphReservedParam.code, 0);
|
|
assert.equal(graphReservedParam.body.ok, false);
|
|
assert.equal(graphReservedParam.body.check.phase, "lower");
|
|
assert.equal(graphReservedParam.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphReservedParam.body.diagnostics[0].message, "program graph parameter name is not valid Zero identifier syntax");
|
|
writeFileSync(graphPatchInternalFunctionPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphMainFunctionNode.id}" field="name" expect="main" value="__zero_bad"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphInternalFunctionPath, graphDumpPath, graphPatchInternalFunctionPath]).stdout, graphInternalFunctionPath);
|
|
const graphInternalFunction = json(["check", "--json", graphInternalFunctionPath], { allowFailure: true });
|
|
assert.notEqual(graphInternalFunction.code, 0);
|
|
assert.equal(graphInternalFunction.body.ok, false);
|
|
assert.equal(graphInternalFunction.body.check.phase, "lower");
|
|
assert.equal(graphInternalFunction.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphInternalFunction.body.diagnostics[0].message, "program graph declaration uses a reserved compiler-internal symbol name");
|
|
assert.equal(zero(["dump", "--out", graphPackageDumpPath, "examples/direct-package-call-order"]).stdout, "");
|
|
assert.equal(zero(["view", "--out", graphPackageViewPath, "examples/direct-package-call-order"]).stdout, "");
|
|
const graphPackageView = readFileSync(graphPackageViewPath, "utf8");
|
|
assert.match(graphPackageView, /fn right_score/);
|
|
assert.match(graphPackageView, /fn left_score/);
|
|
assert.doesNotMatch(graphPackageView, /^use (helpers|types)$/m);
|
|
assertProjectionCheckOk(graphPackageViewPath);
|
|
const graphPackageDumpJson = json(["dump", "--json", "examples/direct-package-call-order"]).body;
|
|
const graphStatusFunctionNode = graphPackageDumpJson.nodes.find((node) => node.kind === "Function" && node.name === "right_score");
|
|
assert(graphStatusFunctionNode);
|
|
writeFileSync(graphPackagePathMismatchPatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPackageDumpJson.graphHash}"`,
|
|
`replace node="${graphStatusFunctionNode.id}" expect="${graphStatusFunctionNode.nodeHash}" path="examples/direct-package-call-order/src/main.0" public="true"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphPackagePathMismatchPath, graphPackageDumpPath, graphPackagePathMismatchPatchPath]).stdout, graphPackagePathMismatchPath);
|
|
assert.equal(zero(["check", graphPackagePathMismatchPath]).stdout, "ok\n");
|
|
const graphPackagePathMismatchSize = json(["size", "--json", "--target", "linux-musl-x64", graphPackagePathMismatchPath]).body;
|
|
const graphHelpersInterface = graphPackagePathMismatchSize.incrementalInvalidation.interfaceFingerprints.modules.find((item) => item.name === "right");
|
|
assert(graphHelpersInterface);
|
|
assert(graphHelpersInterface.publicSymbols.some((item) => item.name === "right_score" && item.kind === "function"));
|
|
const graphMainInterface = graphPackagePathMismatchSize.incrementalInvalidation.interfaceFingerprints.modules.find((item) => item.name === "main");
|
|
assert(graphMainInterface);
|
|
assert(!graphMainInterface.publicSymbols.some((item) => item.name === "right_score"));
|
|
const graphImportNode = graphPackageDumpJson.nodes.find((node) => node.kind === "Import");
|
|
assert(graphImportNode);
|
|
writeFileSync(graphPatchInvalidImportAliasPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPackageDumpJson.graphHash}"`,
|
|
`set node="${graphImportNode.id}" field="value" value="alias\\npub fn injected Void\\n"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchInvalidImportAlias = json(["patch", "--json", graphPackageDumpPath, graphPatchInvalidImportAliasPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchInvalidImportAlias.code, 0);
|
|
assert.equal(graphPatchInvalidImportAlias.body.ok, false);
|
|
assert.equal(graphPatchInvalidImportAlias.body.diagnostic.code, "GPH003");
|
|
assert.equal(graphPatchInvalidImportAlias.body.diagnostic.message, "patch import alias value must be a Zero identifier");
|
|
assert.equal(graphPatchInvalidImportAlias.body.operations[0].field, "value");
|
|
assert.equal(graphPatchInvalidImportAlias.body.operations[0].value, "alias\npub fn injected Void\n");
|
|
assert.equal(graphPatchInvalidImportAlias.body.saved, null);
|
|
writeFileSync(graphPatchInvalidImportNamePath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPackageDumpJson.graphHash}"`,
|
|
`set node="${graphImportNode.id}" field="name" value="+"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphInvalidImportNamePath, graphPackageDumpPath, graphPatchInvalidImportNamePath]).stdout, graphInvalidImportNamePath);
|
|
const graphInvalidImportName = json(["check", "--json", graphInvalidImportNamePath], { allowFailure: true });
|
|
assert.notEqual(graphInvalidImportName.code, 0);
|
|
assert.equal(graphInvalidImportName.body.ok, false);
|
|
assert.equal(graphInvalidImportName.body.check.phase, "lower");
|
|
assert.equal(graphInvalidImportName.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphInvalidImportName.body.diagnostics[0].message, "program graph import module is not valid Zero import syntax");
|
|
writeFileSync(graphPatchMissingImportPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphPackageDumpJson.graphHash}"`,
|
|
`set node="${graphImportNode.id}" field="name" value="missing"`,
|
|
"",
|
|
].join("\n"));
|
|
assertPatchOkOutput(zero(["patch", "--out", graphMissingImportPath, graphPackageDumpPath, graphPatchMissingImportPath]).stdout, graphMissingImportPath);
|
|
const graphMissingImport = json(["check", "--json", graphMissingImportPath], { allowFailure: true });
|
|
assert.notEqual(graphMissingImport.code, 0);
|
|
assert.equal(graphMissingImport.body.ok, false);
|
|
assert.equal(graphMissingImport.body.check.phase, "lower");
|
|
assert.equal(graphMissingImport.body.check.lowering, "graph-native-check");
|
|
assert.equal(graphMissingImport.body.diagnostics[0].message, "program graph import target module is missing");
|
|
writeFileSync(graphPatchBadHashPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "graph:0000000000000000"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" value="unreachable\\n"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchBadHash = json(["patch", "--json", graphDumpPath, graphPatchBadHashPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchBadHash.code, 0);
|
|
assert.equal(graphPatchBadHash.body.ok, false);
|
|
assert.equal(graphPatchBadHash.body.diagnostic.code, "GPH002");
|
|
assert.equal(graphPatchBadHash.body.patchedGraphHash, null);
|
|
assert.equal(graphPatchBadHash.body.saved, null);
|
|
writeFileSync(graphPatchMismatchPath, [
|
|
"zero-program-graph-patch v1",
|
|
`expect graphHash "${graphDumpJson.graphHash}"`,
|
|
`set node="${graphHelloLiteralNode.id}" field="value" expect="not this" value="unreachable\\n"`,
|
|
"",
|
|
].join("\n"));
|
|
const graphPatchMismatch = json(["patch", "--json", graphDumpPath, graphPatchMismatchPath], { allowFailure: true });
|
|
assert.notEqual(graphPatchMismatch.code, 0);
|
|
assert.equal(graphPatchMismatch.body.ok, false);
|
|
assert.equal(graphPatchMismatch.body.diagnostic.code, "GPH005");
|
|
assert.equal(graphPatchMismatch.body.operations[0].ok, false);
|
|
assert.equal(graphPatchMismatch.body.operations[0].actual, "hello from zero\n");
|
|
assert.equal(graphPatchMismatch.body.saved, null);
|
|
assert.equal(zero(["roundtrip", "examples/hello.0"]).stdout, "program graph roundtrip ok\n");
|
|
const graphRoundtripJson = json(["roundtrip", "--json", "examples/hello.0"]).body;
|
|
assert.equal(graphRoundtripJson.ok, true);
|
|
assert.equal(graphRoundtripJson.canonicalSource, false);
|
|
assert.equal(graphRoundtripJson.semanticStable, true);
|
|
assert.equal(graphRoundtripJson.lowering, "direct-program-graph");
|
|
assert.equal(graphRoundtripJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphRoundtripJson.roundtripModuleIdentity, "module:hello");
|
|
assert.match(graphRoundtripJson.originalGraphHash, /^graph:[0-9a-f]{16}$/);
|
|
assert.equal(graphRoundtripJson.roundtripGraphHash, graphRoundtripJson.originalGraphHash);
|
|
assert.deepEqual(graphRoundtripJson.counts.original, { nodes: 13, edges: 12 });
|
|
assert.deepEqual(graphRoundtripJson.counts.roundtrip, { nodes: 13, edges: 12 });
|
|
assert.deepEqual(graphRoundtripJson.semanticCounts.original, { nodes: 13, edges: 12 });
|
|
assert.deepEqual(graphRoundtripJson.semanticCounts.roundtrip, { nodes: 13, edges: 12 });
|
|
assert.equal(graphRoundtripJson.comparison.ok, true);
|
|
assert.equal(graphRoundtripJson.saved, null);
|
|
assert.equal(graphRoundtripJson.view, null);
|
|
assert.equal(zero(["roundtrip", graphDumpPath]).stdout, "program graph roundtrip ok\n");
|
|
const graphArtifactRoundtripJson = json(["roundtrip", "--json", graphDumpPath]).body;
|
|
assert.equal(graphArtifactRoundtripJson.ok, true);
|
|
assert.equal(graphArtifactRoundtripJson.artifact, graphDumpPath);
|
|
assert.equal(graphArtifactRoundtripJson.canonicalSource, false);
|
|
assert.equal(graphArtifactRoundtripJson.semanticStable, true);
|
|
assert.equal(graphArtifactRoundtripJson.lowering, "direct-program-graph");
|
|
assert.equal(graphArtifactRoundtripJson.moduleIdentity, "module:hello");
|
|
assert.equal(graphArtifactRoundtripJson.roundtripModuleIdentity, "module:hello");
|
|
assert.equal(graphArtifactRoundtripJson.originalGraphHash, graphDumpJson.graphHash);
|
|
assert.equal(graphArtifactRoundtripJson.roundtripGraphHash, graphDumpJson.graphHash);
|
|
assert.deepEqual(graphArtifactRoundtripJson.semanticCounts.original, graphArtifactRoundtripJson.semanticCounts.roundtrip);
|
|
assert.equal(graphArtifactRoundtripJson.comparison.ok, true);
|
|
assert.equal(graphArtifactRoundtripJson.view, null);
|
|
assert.equal(zero(["roundtrip", "--out", graphArtifactRoundtripPath, graphDumpPath]).stdout, "program graph roundtrip ok\n");
|
|
assert.equal(readFileSync(graphArtifactRoundtripPath, "utf8"), graphDump);
|
|
const graphArtifactRoundtripOutJson = json(["roundtrip", "--json", "--out", graphArtifactRoundtripPath, graphDumpPath]).body;
|
|
assert.equal(graphArtifactRoundtripOutJson.ok, true);
|
|
assert.equal(graphArtifactRoundtripOutJson.saved.path, graphArtifactRoundtripPath);
|
|
assert.equal(graphArtifactRoundtripOutJson.saved.kind, "program-graph");
|
|
assert.equal(graphArtifactRoundtripOutJson.view, null);
|
|
assert.equal(readFileSync(graphArtifactRoundtripPath, "utf8"), graphDump);
|
|
const graphArtifactRoundtripSourceTextJson = json(["roundtrip", "--json", "--out", graphArtifactRoundtripSourceTextPath, graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(graphArtifactRoundtripSourceTextJson.code, 0);
|
|
assert.equal(graphArtifactRoundtripSourceTextJson.body.diagnostics[0].message, "program graph output must not use source text extension");
|
|
assert.equal(graphArtifactRoundtripSourceTextJson.body.diagnostics[0].expected, "zero roundtrip --out <program-graph-artifact> [graph-input]");
|
|
assert.equal(existsSync(graphArtifactRoundtripSourceTextPath), false);
|
|
assert.equal(zero(["roundtrip", "--out", graphSourceRoundtripPath, "examples/hello.0"]).stdout, "program graph roundtrip ok\n");
|
|
assert.match(readFileSync(graphSourceRoundtripPath, "utf8"), /^zero-graph v1\n/);
|
|
assert.equal(zero(["validate", graphSourceRoundtripPath]).stdout, "program graph ok\n");
|
|
const graphRoundtripOutJson = json(["roundtrip", "--json", "--out", graphSourceRoundtripPath, "examples/hello.0"]).body;
|
|
assert.equal(graphRoundtripOutJson.ok, true);
|
|
assert.equal(graphRoundtripOutJson.saved.path, graphSourceRoundtripPath);
|
|
assert.equal(graphRoundtripOutJson.saved.kind, "program-graph");
|
|
assert.equal(graphRoundtripOutJson.view, null);
|
|
assert.match(readFileSync(graphSourceRoundtripPath, "utf8"), /^zero-graph v1\n/);
|
|
assert.equal(zero(["validate", graphSourceRoundtripPath]).stdout, "program graph ok\n");
|
|
const graphRoundtripSourceTextOutJson = json(["roundtrip", "--json", "--out", graphSourceRoundtripSourceTextPath, "examples/hello.0"], { allowFailure: true });
|
|
assert.notEqual(graphRoundtripSourceTextOutJson.code, 0);
|
|
assert.equal(graphRoundtripSourceTextOutJson.body.diagnostics[0].message, "program graph output must not use source text extension");
|
|
assert.equal(graphRoundtripSourceTextOutJson.body.diagnostics[0].expected, "zero roundtrip --out <program-graph-artifact> [graph-input]");
|
|
assert.equal(existsSync(graphSourceRoundtripSourceTextPath), false);
|
|
const graphPackageRoundtripJson = json(["roundtrip", "--json", "examples/systems-package"]).body;
|
|
assert.equal(graphPackageRoundtripJson.ok, true);
|
|
assert.equal(graphPackageRoundtripJson.semanticStable, true);
|
|
assert.equal(graphPackageRoundtripJson.moduleIdentity, "package:systems-package@0.1.0");
|
|
assert.equal(graphPackageRoundtripJson.roundtripModuleIdentity, graphPackageRoundtripJson.moduleIdentity);
|
|
assert.equal(graphPackageRoundtripJson.comparison.ok, true);
|
|
assert.deepEqual(graphPackageRoundtripJson.semanticCounts.original, graphPackageRoundtripJson.semanticCounts.roundtrip);
|
|
const graphTestBlockRoundtripJson = json(["roundtrip", "--json", "conformance/native/pass/test-blocks.0"]).body;
|
|
assert.equal(graphTestBlockRoundtripJson.ok, true);
|
|
assert.equal(graphTestBlockRoundtripJson.semanticStable, true);
|
|
assert.equal(graphTestBlockRoundtripJson.roundtripModuleIdentity, graphTestBlockRoundtripJson.moduleIdentity);
|
|
assert.equal(graphTestBlockRoundtripJson.comparison.ok, true);
|
|
let sparseOrderGraph = graphDump.replace(`edge ${graphModuleNode.id} function ${graphMainFunctionNode.id} order:0`, `edge ${graphModuleNode.id} function ${graphMainFunctionNode.id} order:1000000000000`);
|
|
sparseOrderGraph = sparseOrderGraph.replace(/hash "graph:[0-9a-f]{16}"/, `hash "${recomputeGraphHash(sparseOrderGraph)}"`);
|
|
writeFileSync(graphSparseOrderPath, sparseOrderGraph);
|
|
const sparseOrderValidate = json(["validate", "--json", graphSparseOrderPath], { allowFailure: true });
|
|
assert.notEqual(sparseOrderValidate.code, 0);
|
|
assert.match(sparseOrderValidate.body.diagnostics[0].actual, /^GRF013\b/);
|
|
assert.match(sparseOrderValidate.body.diagnostics[0].message, /ordered edge group is sparse/);
|
|
let sparseArgGraph = graphDump.replace(/edge (#[^ ]+) arg (#[^ ]+) order:0/, "edge $1 arg $2 order:1000000000000");
|
|
sparseArgGraph = sparseArgGraph.replace(/hash "graph:[0-9a-f]{16}"/, `hash "${recomputeGraphHash(sparseArgGraph)}"`);
|
|
writeFileSync(graphSparseArgPath, sparseArgGraph);
|
|
const sparseArgValidate = json(["validate", "--json", graphSparseArgPath], { allowFailure: true });
|
|
assert.notEqual(sparseArgValidate.code, 0);
|
|
assert.match(sparseArgValidate.body.diagnostics[0].actual, /^GRF013\b/);
|
|
assert.match(sparseArgValidate.body.diagnostics[0].message, /ordered edge group is sparse/);
|
|
const graphWrongSchemaPath = join(outDir, "wrong-schema.program-graph");
|
|
writeFileSync(graphWrongSchemaPath, "zero-graph v2\n");
|
|
const graphWrongSchema = json(["validate", "--json", graphWrongSchemaPath], { allowFailure: true });
|
|
assert(graphWrongSchema.code);
|
|
assert.equal(graphWrongSchema.body.diagnostics[0].message, "unknown program graph schema version");
|
|
const graphFailedArtifactPath = join(outDir, "failed-validation.program-graph");
|
|
writeFileSync(graphFailedArtifactPath, [
|
|
"zero-graph v1",
|
|
"origin source-text",
|
|
"module \"main\"",
|
|
"hash \"\"",
|
|
"validation \"decoded\" failed",
|
|
"diagnostic code:\"GRF001\" message:\"program graph construction failed\"",
|
|
"",
|
|
].join("\n"));
|
|
const graphFailedArtifact = json(["validate", "--json", graphFailedArtifactPath], { allowFailure: true });
|
|
assert(graphFailedArtifact.code);
|
|
assert.equal(graphFailedArtifact.body.diagnostics[0].message, "program graph input reports failed validation");
|
|
const graphTrailingArtifactPath = join(outDir, "trailing-content.program-graph");
|
|
writeFileSync(graphTrailingArtifactPath, `${graphDump}\nextra\n`);
|
|
const graphTrailingArtifact = json(["validate", "--json", graphTrailingArtifactPath], { allowFailure: true });
|
|
assert(graphTrailingArtifact.code);
|
|
assert.equal(graphTrailingArtifact.body.diagnostics[0].message, "unexpected content after graph header");
|
|
|
|
const skillsList = json(["skills", "list", "--json"]).body;
|
|
assert.equal(skillsList.success, true);
|
|
assert(skillsList.data.some((skill) => skill.name === "zero" && /Zero/.test(skill.description)));
|
|
const skillNames = new Set(skillsList.data.map((skill) => skill.name));
|
|
for (const name of [
|
|
"zero",
|
|
"agent",
|
|
"builds",
|
|
"diagnostics",
|
|
"graph",
|
|
"language",
|
|
"packages",
|
|
"stdlib",
|
|
"testing",
|
|
]) {
|
|
assert(skillNames.has(name), `missing bundled skill ${name}`);
|
|
}
|
|
|
|
const zeroSkill = json(["skills", "get", "zero", "--full", "--json"]).body;
|
|
assert.equal(zeroSkill.success, true);
|
|
assert.match(zeroSkill.data[0].content, /# Zero/);
|
|
assert.match(zeroSkill.data[0].content, /zero skills get zero --full/);
|
|
assert.match(zeroSkill.data[0].content, /zero check \[graph-or-package\]/);
|
|
assert.doesNotMatch(zeroSkill.data[0].content, /<file-or-package>/);
|
|
assert.equal(zeroSkill.data[0].files, undefined);
|
|
assert.match(zeroSkill.data[0].content, /at most once per session/);
|
|
for (const skillName of skillsList.data.map((skill) => skill.name)) {
|
|
assert(zeroSkill.data[0].content.includes(`\`${skillName}\` (~`), `zero stub should index topic ${skillName} with a size`);
|
|
}
|
|
|
|
const agentSkill = json(["skills", "get", "agent", "--json"]).body;
|
|
assert.equal(agentSkill.success, true);
|
|
assert.match(agentSkill.data[0].content, /zero query --fn <name> --handles/);
|
|
assert.match(agentSkill.data[0].content, /--replace-in-fn handleLine/);
|
|
assert.match(agentSkill.data[0].content, /addParamTo fn="scan" name="bias" type="i32" default="0"/);
|
|
assert.match(agentSkill.data[0].content, /setConst name="limit" value="64"/);
|
|
assert.match(agentSkill.data[0].content, /upsertFunction handle/);
|
|
assert.match(agentSkill.data[0].content, /addReturnExpr fn="maybe" expr="null"/);
|
|
assert.match(agentSkill.data[0].content, /appendStmt fn="main" stmt="check std\.http\.listen\(world, 3000_u16\)"/);
|
|
assert.match(agentSkill.data[0].content, /addTestBody name="api add"/);
|
|
assert.match(agentSkill.data[0].content, /deleteTest name="api add"/);
|
|
assert.match(agentSkill.data[0].content, /--patch-text -/);
|
|
assert.match(agentSkill.data[0].content, /--no-help/);
|
|
assert.match(agentSkill.data[0].content, /validated: check-equivalent/);
|
|
assert.match(agentSkill.data[0].content, /zero skills get graph/);
|
|
assert.doesNotMatch(agentSkill.data[0].content, /--rewrite/);
|
|
const agentReplaceInFnIdx = agentSkill.data[0].content.indexOf("--replace-in-fn");
|
|
const agentReplaceFnIdx = agentSkill.data[0].content.indexOf("--replace-fn greet");
|
|
const agentDeclOpsIdx = agentSkill.data[0].content.indexOf("setConst");
|
|
assert(agentReplaceInFnIdx >= 0 && agentReplaceInFnIdx < agentReplaceFnIdx && agentReplaceFnIdx < agentDeclOpsIdx, "agent topic leads with --replace-in-fn, then --replace-fn, then decl ops");
|
|
assert.match(agentSkill.data[0].content, /Use JSON only when another tool must parse stable fields/);
|
|
assert.match(agentSkill.data[0].content, /zero skills get stdlib --topic std\.time/);
|
|
assert.match(agentSkill.data[0].content, /zero view --outline <module-or-file>/);
|
|
assert.doesNotMatch(agentSkill.data[0].content, /<file-or-package>/);
|
|
assert(agentSkill.data[0].content.length < 4096, `agent topic should stay compact, got ${agentSkill.data[0].content.length}`);
|
|
|
|
const languageSkill = json(["skills", "get", "language", "--json"]).body;
|
|
assert.equal(languageSkill.success, true);
|
|
assert.match(languageSkill.data[0].content, /# zerolang Language/);
|
|
assert.match(languageSkill.data[0].content, /pub fn main/);
|
|
assert.match(languageSkill.data[0].content, /human-readable projection syntax/);
|
|
assert.match(languageSkill.data[0].content, /not the package compiler input/);
|
|
assert.doesNotMatch(languageSkill.data[0].content, /\.0 source is canonical text/);
|
|
for (const typeName of [
|
|
"Bool",
|
|
"Void",
|
|
"String",
|
|
"Type",
|
|
"World",
|
|
"Maybe<T>",
|
|
"Span<T>",
|
|
"MutSpan<T>",
|
|
"ref<T>",
|
|
"mutref<T>",
|
|
"owned<T>",
|
|
]) {
|
|
assert.match(languageSkill.data[0].content, new RegExp(typeName.replace(/[<>]/g, "\\$&")));
|
|
}
|
|
|
|
const graphSkill = json(["skills", "get", "graph", "--json"]).body;
|
|
assert.equal(graphSkill.success, true);
|
|
assert.match(graphSkill.data[0].content, /# Zero Graph Authoring/);
|
|
assert.match(graphSkill.data[0].content, /primary agent authoring surface/);
|
|
assert.match(graphSkill.data[0].content, /zero query --find Block/);
|
|
assert.match(graphSkill.data[0].content, /zero dump --out \.zero\/agent\/app\.program-graph/);
|
|
assert.doesNotMatch(graphSkill.data[0].content, /<file-or-package>/);
|
|
for (const op of graphPatchHelpJson.operations) {
|
|
assert(graphSkill.data[0].content.includes(op), `graph skill should include patch operation ${op}`);
|
|
}
|
|
for (const lowLevelOp of [
|
|
"expect graphHash",
|
|
"insert node=",
|
|
"insertEdge from=",
|
|
"replace node=",
|
|
]) {
|
|
assert(graphSkill.data[0].content.includes(lowLevelOp), `graph skill should include low-level operation ${lowLevelOp}`);
|
|
}
|
|
|
|
const stdlibSkill = json(["skills", "get", "stdlib", "--json"]).body;
|
|
assert.equal(stdlibSkill.success, true);
|
|
assert.match(stdlibSkill.data[0].content, /std\.str/);
|
|
assert.match(stdlibSkill.data[0].content, /non-overlapping reverse/);
|
|
assert.match(stdlibSkill.data[0].content, /## Function Signatures/);
|
|
const stdSigText = readFileSync("native/zero-c/src/std_sig.c", "utf8");
|
|
const stdHelperNames = [...stdSigText.matchAll(/\{"(std\.[^"]+)",/g)].map((match) => match[1]);
|
|
const stdlibCatalog = stdlibSkill.data[0].content.split("## Function Signatures")[1].split("## Maybe Pattern")[0];
|
|
assert.equal((stdlibCatalog.match(/^[A-Za-z_][A-Za-z0-9_]*\(.*\) -> /gm) ?? []).length, stdHelperNames.length);
|
|
for (const helperName of stdHelperNames) {
|
|
const moduleName = helperName.split(".").slice(0, 2).join(".");
|
|
const shortName = helperName.slice(moduleName.length + 1);
|
|
assert(stdlibCatalog.includes(`### ${moduleName}`), `stdlib skill should include module ${moduleName}`);
|
|
assert(stdlibCatalog.includes(`${shortName}(`), `stdlib skill should include helper ${helperName}`);
|
|
}
|
|
|
|
const stdlibTopicSkill = json(["skills", "get", "stdlib", "--topic", "std.time", "--json"]).body;
|
|
assert.equal(stdlibTopicSkill.success, true);
|
|
assert.equal(stdlibTopicSkill.data[0].topic, "std.time");
|
|
assert.match(stdlibTopicSkill.data[0].content, /^### std\.time/);
|
|
assert.match(stdlibTopicSkill.data[0].content, /isRfc3339DateTime/);
|
|
assert.doesNotMatch(stdlibTopicSkill.data[0].content, /### std\.args/);
|
|
assert(stdlibTopicSkill.data[0].content.length < 4096, `stdlib --topic std.time should serve one section, got ${stdlibTopicSkill.data[0].content.length}`);
|
|
assert.equal(zero(["skills", "get", "stdlib", "--topic", "std.time"]).stdout, stdlibTopicSkill.data[0].content);
|
|
const stdlibTopicMiss = zero(["skills", "get", "stdlib", "--topic", "std.nosuch"], { allowFailure: true });
|
|
assert.notEqual(stdlibTopicMiss.code, 0);
|
|
assert.match(stdlibTopicMiss.stderr, /No section in skill 'stdlib' matches --topic std\.nosuch/);
|
|
assert.match(stdlibTopicMiss.stderr, /std\.time/);
|
|
assert.match(zeroSkill.data[0].content, /zero skills get stdlib --topic std\.time/);
|
|
|
|
const diagnosticSkill = json(["skills", "get", "diagnostics", "--json"]).body;
|
|
assert.equal(diagnosticSkill.success, true);
|
|
assert.match(diagnosticSkill.data[0].content, /fixSafety/);
|
|
|
|
const missingSkill = zero(["skills", "get", "missing", "--json"], { allowFailure: true });
|
|
assert.notEqual(missingSkill.code, 0);
|
|
assert.equal(JSON.parse(missingSkill.stdout).success, false);
|
|
|
|
const removedSkillsPath = zero(["skills", "path", "zero", "--json"], { allowFailure: true });
|
|
assert.notEqual(removedSkillsPath.code, 0);
|
|
assert.match(JSON.parse(removedSkillsPath.stdout).error, /Unknown skills subcommand: path/);
|
|
|
|
const badSkillsFlag = zero(["skills", "-x"], { allowFailure: true });
|
|
assert.notEqual(badSkillsFlag.code, 0);
|
|
assert.match(badSkillsFlag.stderr, /Unknown skills flag: -x/);
|
|
|
|
const badSkillsListFlag = zero(["skills", "list", "--unknown", "--json"], { allowFailure: true });
|
|
assert.notEqual(badSkillsListFlag.code, 0);
|
|
assert.match(JSON.parse(badSkillsListFlag.stdout).error, /Unknown skills flag: --unknown/);
|
|
|
|
const badSkillsGetFlag = zero(["skills", "get", "language", "--unknown", "--json"], { allowFailure: true });
|
|
assert.notEqual(badSkillsGetFlag.code, 0);
|
|
assert.match(JSON.parse(badSkillsGetFlag.stdout).error, /Unknown skills flag: --unknown/);
|
|
|
|
const lexerTokens = json(["tokens", "--json", "conformance/lexer/compiler-smoke.0"]).body;
|
|
assert.equal(lexerTokens.schemaVersion, 1);
|
|
assert.equal(lexerTokens.syntax, "canonical");
|
|
assert.match(lexerTokens.sourceFile, /compiler-smoke\.0$/);
|
|
assert.deepEqual(lexerTokens.tokens.slice(0, 4).map((token) => `${token.kind}:${token.text}`), [
|
|
"word:use",
|
|
"word:std",
|
|
"symbol:.",
|
|
"word:mem",
|
|
]);
|
|
assert.deepEqual(lexerTokens.tokens.filter((token) => token.kind === "number").map((token) => token.text), ["123", "0xff", "0b101", "42_u8"]);
|
|
assert.deepEqual(lexerTokens.tokens.filter((token) => token.kind === "string" || token.kind === "char").map((token) => `${token.kind}:${token.text}`), [
|
|
'string:"hi"',
|
|
"char:'x'",
|
|
]);
|
|
assert.equal(lexerTokens.tokens[0].line, 1);
|
|
assert.equal(lexerTokens.tokens[0].column, 1);
|
|
assert.equal(lexerTokens.tokens[0].offset, 0);
|
|
assert.equal(lexerTokens.tokens[0].length, 3);
|
|
assert.equal(lexerTokens.tokens[5].offset, 12);
|
|
assert.equal(lexerTokens.tokens[5].length, 1);
|
|
assert.equal(lexerTokens.tokens[8].kind, "word");
|
|
assert.equal(lexerTokens.tokens[8].text, "main");
|
|
assert.equal(lexerTokens.tokens[8].line, 3);
|
|
assert.equal(lexerTokens.tokens[8].column, 8);
|
|
assert.equal(lexerTokens.tokens.at(-1).kind, "eof");
|
|
assert.equal(lexerTokens.tokens.at(-1).length, 0);
|
|
|
|
const parseTree = json(["parse", "--json", "conformance/format/functions-blocks.0"]).body;
|
|
assert.equal(parseTree.schemaVersion, 1);
|
|
assert.equal(parseTree.root.kind, "module");
|
|
assert.equal(parseTree.root.shapeCount, 0);
|
|
assert.equal(parseTree.root.enumCount, 0);
|
|
assert.equal(parseTree.root.choiceCount, 0);
|
|
assert.equal(parseTree.root.functionCount, 2);
|
|
assert.equal(parseTree.functions[0].name, "helper");
|
|
assert.equal(parseTree.functions[0].paramCount, 1);
|
|
assert.deepEqual(parseTree.functions[0].bodyKinds, ["if"]);
|
|
assert.equal(parseTree.functions[1].name, "main");
|
|
assert.equal(parseTree.functions[1].paramCount, 0);
|
|
assert.deepEqual(parseTree.functions[1].bodyKinds, ["let", "while"]);
|
|
|
|
const unsupportedSourceFixture = join(outDir, "unsupported-source.txt");
|
|
const unsupportedSourceText =
|
|
"# command fixture\n" +
|
|
"fn inc i32 value i32\n" +
|
|
" ret + value 1\n" +
|
|
"\n" +
|
|
"pub fn main Void\n" +
|
|
" let total i32 inc 41\n";
|
|
rmSync(unsupportedSourceFixture, { force: true });
|
|
writeFileSync(unsupportedSourceFixture, unsupportedSourceText);
|
|
for (const args of [
|
|
["check", "--json", unsupportedSourceFixture],
|
|
["build", "--json", unsupportedSourceFixture],
|
|
["fix", "--plan", "--json", unsupportedSourceFixture],
|
|
] as string[][]) {
|
|
const rejected = json(args, { allowFailure: true });
|
|
assert.notEqual(rejected.code, 0);
|
|
assert.equal(rejected.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(rejected.body.diagnostics[0].message, "compiler command requires graph input");
|
|
assert.equal(rejected.body.diagnostics[0].expected, "package zero.graph store, .graph store, or ProgramGraph artifact");
|
|
}
|
|
const rawProjectionWithGraph = join(outDir, "raw-projection-with-graph.0");
|
|
writeProjectionFile(rawProjectionWithGraph, "pub fn main() -> Void { }\n");
|
|
importProjectionSidecar(rawProjectionWithGraph);
|
|
const rawProjectionWithGraphRejected = jsonRaw(["check", "--json", rawProjectionWithGraph], { allowFailure: true });
|
|
assert.notEqual(rawProjectionWithGraphRejected.code, 0);
|
|
assert.equal(rawProjectionWithGraphRejected.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(rawProjectionWithGraphRejected.body.diagnostics[0].message, "compiler command requires graph input");
|
|
assert.equal(rawProjectionWithGraphRejected.body.diagnostics[0].expected, "package zero.graph store, .graph store, or ProgramGraph artifact");
|
|
const rawProjectionNoGraph = join(outDir, "raw-projection-no-graph.0");
|
|
rmSync(rawProjectionNoGraph, { force: true });
|
|
writeFileSync(rawProjectionNoGraph, "pub fn main() -> Void { }\n");
|
|
for (const args of [
|
|
["check", "--json", rawProjectionNoGraph],
|
|
["build", "--json", rawProjectionNoGraph],
|
|
["test", "--json", rawProjectionNoGraph],
|
|
["size", "--json", rawProjectionNoGraph],
|
|
["doc", "--json", rawProjectionNoGraph],
|
|
["dev", "--json", rawProjectionNoGraph],
|
|
["abi", "dump", "--json", rawProjectionNoGraph],
|
|
["fix", "--plan", "--json", rawProjectionNoGraph],
|
|
] as string[][]) {
|
|
const rejected = jsonRaw(args, { allowFailure: true });
|
|
assert.notEqual(rejected.code, 0);
|
|
assert.equal(rejected.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(rejected.body.diagnostics[0].message, "compiler command requires graph input");
|
|
assert.equal(rejected.body.diagnostics[0].expected, "package zero.graph store, .graph store, or ProgramGraph artifact");
|
|
}
|
|
const rawProjectionRunRejected = zeroRaw(["run", rawProjectionNoGraph], { allowFailure: true });
|
|
assert.notEqual(rawProjectionRunRejected.code, 0);
|
|
assert.match(rawProjectionRunRejected.stderr, /compiler command requires graph input/);
|
|
assert.match(rawProjectionRunRejected.stderr, /package zero\.graph store, \.graph store, or ProgramGraph artifact/);
|
|
for (const args of [
|
|
["tokens", "--json", unsupportedSourceFixture],
|
|
["parse", "--json", unsupportedSourceFixture],
|
|
] as string[][]) {
|
|
const rejected = json(args, { allowFailure: true });
|
|
assert.notEqual(rejected.code, 0);
|
|
assert.equal(rejected.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(rejected.body.diagnostics[0].message, "expected Zero source file or package");
|
|
assert.equal(rejected.body.diagnostics[0].expected, ".0 source file, zero.toml, zero.json, or package directory");
|
|
}
|
|
for (const args of [
|
|
["view", "--json", unsupportedSourceFixture],
|
|
] as string[][]) {
|
|
const rejected = json(args, { allowFailure: true });
|
|
assert.notEqual(rejected.code, 0);
|
|
assert.equal(rejected.body.diagnostics[0].code, "PAR100");
|
|
assert.equal(rejected.body.diagnostics[0].message, "expected zero-graph v1 header");
|
|
}
|
|
const unsupportedFmtRejected = zero(["fmt", "--check", unsupportedSourceFixture], { allowFailure: true });
|
|
assert.notEqual(unsupportedFmtRejected.code, 0);
|
|
assert.match(unsupportedFmtRejected.stderr, /expected Zero source file or package/);
|
|
assert.match(unsupportedFmtRejected.stderr, /\.0 source file, zero\.toml, zero\.json, or package directory/);
|
|
|
|
const unsupportedSourcePackage = join(outDir, "unsupported-source-package");
|
|
rmSync(unsupportedSourcePackage, { recursive: true, force: true });
|
|
mkdirSync(join(unsupportedSourcePackage, "src"), { recursive: true });
|
|
writeZeroTomlSync(unsupportedSourcePackage, {
|
|
package: { name: "unsupported-source-package", version: "0.1.0" },
|
|
targets: { cli: { kind: "exe", main: "src/main.txt" } },
|
|
});
|
|
writeFileSync(join(unsupportedSourcePackage, "src", "main.txt"), unsupportedSourceText);
|
|
const unsupportedPackageRejected = json(["check", "--json", unsupportedSourcePackage], { allowFailure: true });
|
|
assert.notEqual(unsupportedPackageRejected.code, 0);
|
|
assert.equal(unsupportedPackageRejected.body.diagnostics[0].code, "RGP001");
|
|
assert.equal(unsupportedPackageRejected.body.diagnostics[0].message, "repository graph store is missing");
|
|
assert.equal(unsupportedPackageRejected.body.diagnostics[0].expected, "checked-in zero.graph repository graph store");
|
|
|
|
const testJson = json(["test", "--json", "--filter", "addition", "conformance/native/pass/test-blocks.graph"]).body;
|
|
assert.equal(testJson.schemaVersion, 1);
|
|
assert.equal(testJson.ok, true);
|
|
assert.match(testJson.stdout, /1 test\(s\) ok/);
|
|
assert.equal(testJson.testBackend, "direct-program-graph");
|
|
assertSourceGraph(testJson, "conformance/native/pass/test-blocks.graph", "module:test-blocks", "direct-program-graph", false);
|
|
assert.equal(testJson.testDiscovery.mode, "program-graph");
|
|
assert.equal(testJson.testDiscovery.filter, "addition");
|
|
assert.equal(testJson.fixtures.snapshotKey, "zero-test-graph-native-v1");
|
|
assert.equal(testJson.targetFacts.capabilitySupport.status, "supported");
|
|
assert.equal(testJson.results[0].status, "passed");
|
|
|
|
const packageTestJson = json(["test", "--json", "conformance/packages/test-app"]).body;
|
|
assert.equal(packageTestJson.ok, true);
|
|
assertSourceGraph(packageTestJson, "conformance/packages/test-app/zero.graph", "package:test-app@0.1.0", "direct-program-graph", false);
|
|
assert.equal(packageTestJson.testDiscovery.mode, "package-graph");
|
|
assert.equal(packageTestJson.discoveredTests, 3);
|
|
assert.equal(packageTestJson.expectedFailures, 1);
|
|
assert(packageTestJson.fixtures.sourceFiles.some((path) => path.endsWith("helper.0")));
|
|
|
|
const expectedFailTestJson = json(["test", "--json", "conformance/native/pass/test-expected-fail.graph"]).body;
|
|
assert.equal(expectedFailTestJson.ok, true);
|
|
assert.equal(expectedFailTestJson.expectedFailures, 1);
|
|
assert.equal(expectedFailTestJson.results[0].status, "expected-fail");
|
|
|
|
assert.match(zero(["fmt", "--check", "conformance/native/pass/test-blocks.0"]).stdout, /fmt ok/);
|
|
|
|
const unknownFlag = zero(["check", "--jsoon", "examples/hello.graph"], { allowFailure: true });
|
|
assert.notEqual(unknownFlag.code, 0);
|
|
assert.match(unknownFlag.stderr, /unknown flag: --jsoon/);
|
|
assert.match(unknownFlag.stderr, /--json/);
|
|
assert.equal(hasAnsiControlBytes(unknownFlag.stderr), false);
|
|
|
|
const cleanProbe = join(".zero", "out", "contract-clean", "tmp.txt");
|
|
mkdirSync(join(".zero", "out", "contract-clean"), { recursive: true });
|
|
writeFileSync(cleanProbe, "tmp");
|
|
assert(existsSync(cleanProbe));
|
|
const clean = zero(["clean"]).stdout;
|
|
assert.match(clean, /removed:/);
|
|
assert(!existsSync(cleanProbe));
|
|
|
|
for (const kind of ["cli", "lib", "package"]) {
|
|
const project = join(outDir, `init-template-${kind}`);
|
|
rmSync(project, { recursive: true, force: true });
|
|
const created = zero(["init", "--template", kind, project]).stdout;
|
|
assert.match(created, /graph template init ok/);
|
|
assert.match(created, new RegExp(`template: ${kind}`));
|
|
assert(existsSync(join(project, "zero.toml")));
|
|
assert(!existsSync(join(project, "zero.json")));
|
|
const manifest = readGeneratedManifest(project);
|
|
const readme = readFileSync(join(project, "README.md"), "utf8");
|
|
readFileSync(join(project, ".gitignore"), "utf8");
|
|
assertTemplateManifest(kind, manifest, readme);
|
|
zero(["check", project]);
|
|
zero(["test", project]);
|
|
assert.match(zero(["fmt", "--check", project]).stdout, /fmt ok/);
|
|
if (kind !== "lib") {
|
|
const templateRun = zero(["run", "--out", join(project, "run-app"), project]).stdout;
|
|
assert.match(templateRun, kind === "cli" ? /hello from zero\n/ : /package ok\n/);
|
|
}
|
|
const devReport = json(["dev", "--json", "--target", "linux-musl-x64", project]).body;
|
|
assertDevReport(devReport, kind);
|
|
if (kind === "lib") {
|
|
const docReport = json(["doc", "--json", project]).body;
|
|
assert.equal(docReport.schemaVersion, 1);
|
|
assert.equal(docReport.generatedCBytes, 0);
|
|
}
|
|
if (kind === "lib") {
|
|
removeInlineTests(join(project, "src", "lib.0"));
|
|
zero(["parse", "--json", join(project, "src", "lib.0")]);
|
|
} else {
|
|
const buildOut = join(project, "app");
|
|
const templateBuild = json(["build", "--json", "--emit", "exe", "--target", "linux-musl-x64", project, "--out", buildOut]).body;
|
|
assert.equal(templateBuild.generatedCBytes, 0);
|
|
assert.equal(templateBuild.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
}
|
|
}
|
|
|
|
const tinyHello = join(outDir, "tiny-hello");
|
|
rmSync(tinyHello, { force: true });
|
|
zero(["build", "--release", "tiny", "--target", "linux-musl-x64", "examples/hello.graph", "--out", tinyHello]);
|
|
assert(statSync(tinyHello).size < 10 * 1024);
|
|
const profileCacheCheckSource = join(outDir, "profile-cache-check.0");
|
|
writeProjectionFile(profileCacheCheckSource, `pub fn main(world: World) -> Void raises {
|
|
check world.out.write("profile cache ${process.pid}\\n")
|
|
}
|
|
`);
|
|
const profileCacheCheckGraph = importProjectionSidecar(profileCacheCheckSource);
|
|
const profileCacheCheck = json(["size", "--json", "--profile", "fast", profileCacheCheckGraph]).body;
|
|
assert.equal(profileCacheCheck.graph.artifact, profileCacheCheckGraph);
|
|
const profileCacheSpecialization = profileCacheCheck.compilerCaches.find((cache) => cache.name === "specialization");
|
|
assert(profileCacheSpecialization);
|
|
assert.equal(profileCacheCheck.incrementalInvalidation.profileDependency, "fast");
|
|
assert.equal(existsSync(join(".zero", "cache", "native", `specialization-${profileCacheSpecialization.key}.cache`)), true);
|
|
const buildReport = json(["build", "--json", "--target", "linux-musl-x64", "examples/hello.graph", "--out", join(outDir, "hello-linux-report")]).body;
|
|
assert.equal(buildReport.schemaVersion, 1);
|
|
assert.equal(buildReport.emit, "exe");
|
|
assert.equal(buildReport.hostTarget, version.host);
|
|
assert.equal(buildReport.target, "linux-musl-x64");
|
|
assert.equal(buildReport.compiler, "zero-elf64");
|
|
assert(buildReport.artifactBytes > 0);
|
|
assert.equal(buildReport.generatedCBytes, 0);
|
|
assert(buildReport.loweredIrBytes > 0);
|
|
assert.equal(buildReport.targetSupport.fsAvailable, true);
|
|
assert.equal(buildReport.profileSemantics.profileKey, "small");
|
|
assert.equal(buildReport.profileSemantics.profileBudget.generatedCBytes, 0);
|
|
assert.equal(buildReport.safetyFacts.profileKey, "small");
|
|
assert.equal(buildReport.safetyFacts.bounds.policy, "checked");
|
|
assert.equal(buildReport.safetyFacts.bounds.optimizerElision, false);
|
|
assert.equal(buildReport.safetyFacts.overflow.policy, "literal-range-checked-runtime-unchecked");
|
|
assert.equal(buildReport.safetyFacts.initialization.locals, "initializer-required");
|
|
assert.equal(buildReport.safetyFacts.initialization.maybePayloadReads, "guard-checked");
|
|
assert.equal(buildReport.safetyFacts.aliasing.mutableAliases, "diagnostic");
|
|
assert.equal(buildReport.safetyFacts.mir.invalidMemoryContractsBlockEmission, true);
|
|
assert.equal(buildReport.profileBudget.cBridgeFallback, false);
|
|
assert.equal(buildReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert.equal(buildReport.objectBackend.linking.externalToolchain, "none");
|
|
assertReleaseTargetContract(buildReport, {
|
|
target: "linux-musl-x64",
|
|
emit: "exe",
|
|
objectFormat: "elf",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "elf64",
|
|
targetLibcMode: "bundled-libc",
|
|
});
|
|
repeatBuildHash(["build", "--json", "--target", "linux-musl-x64", "examples/hello.graph", "--out", join(outDir, "hello-linux-report")], join(outDir, "hello-linux-report"), join(outDir, "hello-linux-report.repeat"));
|
|
|
|
const runArtifact = join(outDir, "run-add");
|
|
rmSync(runArtifact, { force: true });
|
|
rmSync(`${runArtifact}.exe`, { force: true });
|
|
rmSync(`${runArtifact}.c`, { force: true });
|
|
const runResult = zero(["run", "--out", runArtifact, "examples/add.graph"]);
|
|
assert.match(runResult.stdout, /math works\n/);
|
|
assert(existsSync(version.host.startsWith("win32") ? `${runArtifact}.exe` : runArtifact));
|
|
assert.equal(existsSync(`${runArtifact}.c`), false);
|
|
|
|
for (const [requestedProfile, canonicalProfile, profileKey] of [
|
|
["debug", "debug", "debug"],
|
|
["fast", "release-fast", "fast"],
|
|
["small", "release-small", "small"],
|
|
["tiny", "tiny", "tiny"],
|
|
]) {
|
|
const profileOut = join(outDir, `profile-${requestedProfile}-hello`);
|
|
const profileReport = json(["build", "--json", "--profile", requestedProfile, "--target", "linux-musl-x64", "examples/hello.graph", "--out", profileOut]).body;
|
|
assert.equal(profileReport.generatedCBytes, 0);
|
|
assert.equal(profileReport.profileSemantics.canonical, canonicalProfile);
|
|
assert.equal(profileReport.profileSemantics.profileKey, profileKey);
|
|
assert.equal(profileReport.profileSemantics.boundsPolicy, "checked");
|
|
assert.equal(profileReport.profileSemantics.overflowPolicy, "literal-range-checked-runtime-unchecked");
|
|
assert.equal(profileReport.profileSemantics.profileBudget.generatedCBytes, 0);
|
|
assert.equal(profileReport.safetyFacts.profile, canonicalProfile);
|
|
assert.equal(profileReport.safetyFacts.profileKey, profileKey);
|
|
assert.equal(profileReport.profileBudget.helperBudgetPolicy, profileReport.profileSemantics.profileBudget.helperBudgetPolicy);
|
|
repeatBuildHash(["build", "--json", "--profile", requestedProfile, "--target", "linux-musl-x64", "examples/hello.graph", "--out", profileOut], profileOut, `${profileOut}.repeat`);
|
|
}
|
|
|
|
const profileSizeReport = json(["size", "--json", "--profile", "debug", "--target", "linux-musl-x64", "examples/hello.graph"]).body;
|
|
assert.equal(profileSizeReport.generatedCBytes, 0);
|
|
assert.equal(profileSizeReport.graph.artifact, "examples/hello.graph");
|
|
assert.equal(profileSizeReport.graph.lowering, "mapped-final-mir");
|
|
assert.equal(profileSizeReport.profileSemantics.profileKey, "debug");
|
|
assert.equal(profileSizeReport.safetyFacts.profileKey, "debug");
|
|
assert.equal(profileSizeReport.safetyFacts.uncheckedSurfaces[0].policy, "externally-trusted");
|
|
assert.equal(profileSizeReport.sizeBreakdown.profileKey, "debug");
|
|
assert(Array.isArray(profileSizeReport.sizeBreakdown.functions));
|
|
assert(profileSizeReport.sizeBreakdown.sections.some((item) => item.name === "debug-metadata"));
|
|
assert(Array.isArray(profileSizeReport.sizeBreakdown.stdlibHelpers));
|
|
assert(Array.isArray(profileSizeReport.sizeBreakdown.imports));
|
|
assert(Array.isArray(profileSizeReport.sizeBreakdown.runtimeShims));
|
|
assert(profileSizeReport.sizeBreakdown.debugMetadata.bytes > 0);
|
|
assert(profileSizeReport.compilerCaches.some((item) => item.name === "mappedFinalMir" && item.sourceKind === "program-graph" && item.programReconstructed === false));
|
|
assert(profileSizeReport.retentionReasons.some((item) => item.kind === "debugMetadata"));
|
|
assert(profileSizeReport.optimizationHints.some((item) => item.id === "profile-debug-metadata"));
|
|
assert.equal(profileSizeReport.profileBudget.debugMetadataAllowed, true);
|
|
|
|
const directObjPath = join(outDir, "direct-obj-add.o");
|
|
rmSync(directObjPath, { force: true });
|
|
const directObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-obj-add.graph", "--out", directObjPath]).body;
|
|
const directObjBytes = readFileSync(directObjPath);
|
|
assert.equal(directObjReport.emit, "obj");
|
|
assert.equal(directObjReport.compiler, "zero-elf64");
|
|
assert.equal(directObjReport.generatedCBytes, 0);
|
|
assert(directObjReport.loweredIrBytes > 0);
|
|
assert.equal(directObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directObjReport.objectBackend.linking.externalToolchain, "none");
|
|
assert.equal(directObjBytes[0], 0x7f);
|
|
assert.equal(directObjBytes[1], 0x45);
|
|
assert.equal(directObjBytes[2], 0x4c);
|
|
assert.equal(directObjBytes[3], 0x46);
|
|
assert.equal(directObjBytes.readUInt16LE(16), 1);
|
|
assert.equal(directObjBytes.readUInt16LE(18), 62);
|
|
const directI64ObjPath = join(outDir, "direct-i64-return.o");
|
|
rmSync(directI64ObjPath, { force: true });
|
|
const directI64ObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-i64-return.graph", "--out", directI64ObjPath]).body;
|
|
const directI64ObjBytes = readFileSync(directI64ObjPath);
|
|
assert.equal(directI64ObjReport.emit, "obj");
|
|
assert.equal(directI64ObjReport.compiler, "zero-elf64");
|
|
assert.equal(directI64ObjReport.generatedCBytes, 0);
|
|
assert.equal(directI64ObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert(directI64ObjBytes.includes(Buffer.from([0x48, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f])));
|
|
assert(directI64ObjBytes.includes(Buffer.from([0x48, 0x01, 0xc8])));
|
|
const directShapeObjPath = join(outDir, "direct-token-shape.o");
|
|
rmSync(directShapeObjPath, { force: true });
|
|
const directShapeObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-token-shape.graph", "--out", directShapeObjPath]).body;
|
|
const directShapeObjBytes = readFileSync(directShapeObjPath);
|
|
assert.equal(directShapeObjReport.emit, "obj");
|
|
assert.equal(directShapeObjReport.compiler, "zero-elf64");
|
|
assert.equal(directShapeObjReport.generatedCBytes, 0);
|
|
assert.equal(directShapeObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directShapeObjBytes[0], 0x7f);
|
|
assert.equal(directShapeObjBytes[1], 0x45);
|
|
const directSpanReadObjPath = join(outDir, "direct-span-read.o");
|
|
rmSync(directSpanReadObjPath, { force: true });
|
|
const directSpanReadObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-span-read.graph", "--out", directSpanReadObjPath]).body;
|
|
const directSpanReadObjBytes = readFileSync(directSpanReadObjPath);
|
|
assert.equal(directSpanReadObjReport.emit, "obj");
|
|
assert.equal(directSpanReadObjReport.compiler, "zero-elf64");
|
|
assert.equal(directSpanReadObjReport.generatedCBytes, 0);
|
|
assert.equal(directSpanReadObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directSpanReadObjReport.objectBackend.objectEmission.dataSections, true);
|
|
assert.equal(directSpanReadObjReport.objectBackend.directFacts.readonlyDataBytes, 6);
|
|
assert.equal(directSpanReadObjBytes[0], 0x7f);
|
|
assert.equal(directSpanReadObjBytes[1], 0x45);
|
|
const directByteViewLocalsObjPath = join(outDir, "direct-byte-view-reloc.o");
|
|
rmSync(directByteViewLocalsObjPath, { force: true });
|
|
const directByteViewLocalsObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-byte-view-reloc.graph", "--out", directByteViewLocalsObjPath]).body;
|
|
const directByteViewLocalsObjBytes = readFileSync(directByteViewLocalsObjPath);
|
|
assert.equal(directByteViewLocalsObjReport.emit, "obj");
|
|
assert.equal(directByteViewLocalsObjReport.compiler, "zero-elf64");
|
|
assert.equal(directByteViewLocalsObjReport.generatedCBytes, 0);
|
|
assert.equal(directByteViewLocalsObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directByteViewLocalsObjReport.objectBackend.objectEmission.dataSections, true);
|
|
assert.equal(directByteViewLocalsObjReport.objectBackend.directFacts.readonlyDataBytes, 6);
|
|
assert(directByteViewLocalsObjBytes.includes(Buffer.from(".rodata\0")));
|
|
assert(directByteViewLocalsObjBytes.includes(Buffer.from(".rela.text\0")));
|
|
const directRescueObjPath = join(outDir, "direct-rescue-basic.o");
|
|
rmSync(directRescueObjPath, { force: true });
|
|
const directRescueObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-rescue-basic.graph", "--out", directRescueObjPath]).body;
|
|
const directRescueObjBytes = readFileSync(directRescueObjPath);
|
|
assert.equal(directRescueObjReport.emit, "obj");
|
|
assert.equal(directRescueObjReport.compiler, "zero-elf64");
|
|
assert.equal(directRescueObjReport.generatedCBytes, 0);
|
|
assert.equal(directRescueObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directRescueObjBytes[0], 0x7f);
|
|
assert.equal(directRescueObjBytes[1], 0x45);
|
|
const directExePath = join(outDir, "direct-exe-return");
|
|
rmSync(directExePath, { force: true });
|
|
const directExeReport = json(["build", "--json", "--emit", "exe", "--target", "linux-musl-x64", "examples/direct-exe-return.graph", "--out", directExePath]).body;
|
|
const directExeBytes = readFileSync(directExePath);
|
|
assert.equal(directExeReport.emit, "exe");
|
|
assert.equal(directExeReport.compiler, "zero-elf64");
|
|
assert.equal(directExeReport.generatedCBytes, 0);
|
|
assert(directExeReport.loweredIrBytes > 0);
|
|
assert(directExeReport.artifactBytes < 512);
|
|
assert.equal(directExeReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert.equal(directExeReport.objectBackend.objectEmission.dataSections, false);
|
|
assert.equal(directExeReport.objectBackend.linking.externalToolchain, "none");
|
|
assert.equal(directExeBytes[0], 0x7f);
|
|
assert.equal(directExeBytes[1], 0x45);
|
|
assert.equal(directExeBytes[2], 0x4c);
|
|
assert.equal(directExeBytes[3], 0x46);
|
|
assert.equal(directExeBytes.readUInt16LE(16), 2);
|
|
assert.equal(directExeBytes.readUInt16LE(18), 62);
|
|
assert.equal(directExeBytes.readUInt16LE(54), 56);
|
|
assert.equal(directExeBytes.readUInt16LE(56), 1);
|
|
const removedEmitC = json(["build", "--json", "--emit", "c", "--target", "linux-musl-x64", "examples/direct-exe-return.graph", "--out", join(outDir, "removed-c-backend.c")], { allowFailure: true });
|
|
assert.notEqual(removedEmitC.code, 0);
|
|
assert.equal(removedEmitC.body.diagnostics[0].code, "BLD003");
|
|
assert.equal(removedEmitC.body.diagnostics[0].repair.id, "use-direct-emitter");
|
|
const removedLegacyFlag = json(["build", "--json", "--legacy-backend", "--target", "linux-musl-x64", "examples/direct-exe-return.graph", "--out", join(outDir, "removed-legacy-flag")], { allowFailure: true });
|
|
assert.notEqual(removedLegacyFlag.code, 0);
|
|
assert.equal(removedLegacyFlag.body.diagnostics[0].code, "BLD003");
|
|
assert.equal(removedLegacyFlag.body.diagnostics[0].repair.id, "use-direct-emitter");
|
|
const directMachOExePath = join(outDir, "direct-macho-exe-return");
|
|
rmSync(directMachOExePath, { force: true });
|
|
const directMachOExeReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-macho64", "--target", "darwin-arm64", "examples/direct-exe-return.graph", "--out", directMachOExePath]).body;
|
|
const directMachOExeBytes = readFileSync(directMachOExePath);
|
|
assert.equal(directMachOExeReport.emit, "exe");
|
|
assert.equal(directMachOExeReport.compiler, "zero-macho64");
|
|
assert.equal(directMachOExeReport.generatedCBytes, 0);
|
|
assert.equal(directMachOExeReport.objectBackend.objectEmission.path, "direct-macho64-exe");
|
|
assert.equal(directMachOExeReport.objectBackend.targetFacts.status, "native-exe");
|
|
assertReleaseTargetContract(directMachOExeReport, {
|
|
target: "darwin-arm64",
|
|
emit: "exe",
|
|
objectFormat: "macho",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "macho64",
|
|
targetLibcMode: "host-default",
|
|
});
|
|
repeatBuildHash(["build", "--json", "--emit", "exe", "--backend", "zero-macho64", "--target", "darwin-arm64", "examples/direct-exe-return.graph", "--out", directMachOExePath], directMachOExePath, `${directMachOExePath}.repeat`);
|
|
assert.equal(directMachOExeBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOExeBytes.readUInt32LE(12), 2);
|
|
const directMachOExeUuid = assertMachOLoadCommand(directMachOExeBytes, 0x1b, 24);
|
|
assert(!directMachOExeUuid.subarray(8, 24).every((byte) => byte === 0));
|
|
assert(directMachOExeBytes.includes(Buffer.from("/usr/lib/dyld")));
|
|
assert(directMachOExeBytes.includes(Buffer.from("zero-direct")));
|
|
const directMachOX64ExePath = join(outDir, "direct-macho-x64-hello");
|
|
rmSync(directMachOX64ExePath, { force: true });
|
|
const directMachOX64ExeReport = json(["build", "--json", "--emit", "exe", "--target", "darwin-x64", "examples/hello.graph", "--out", directMachOX64ExePath]).body;
|
|
const directMachOX64ExeBytes = readFileSync(directMachOX64ExePath);
|
|
assert.equal(directMachOX64ExeReport.emit, "exe");
|
|
assert.equal(directMachOX64ExeReport.compiler, "zero-macho-x64");
|
|
assert.equal(directMachOX64ExeReport.generatedCBytes, 0);
|
|
assert.equal(directMachOX64ExeReport.objectBackend.objectEmission.path, "direct-macho-x64-exe");
|
|
assert.equal(directMachOX64ExeReport.objectBackend.targetFacts.status, "native-exe");
|
|
assertReleaseTargetContract(directMachOX64ExeReport, {
|
|
target: "darwin-x64",
|
|
emit: "exe",
|
|
objectFormat: "macho",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "macho64",
|
|
targetLibcMode: "sysroot",
|
|
});
|
|
repeatBuildHash(["build", "--json", "--emit", "exe", "--target", "darwin-x64", "examples/hello.graph", "--out", directMachOX64ExePath], directMachOX64ExePath, `${directMachOX64ExePath}.repeat`);
|
|
assert.equal(directMachOX64ExeBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOX64ExeBytes.readUInt32LE(4), 0x01000007);
|
|
assert.equal(directMachOX64ExeBytes.readUInt32LE(8), 3);
|
|
assert.equal(directMachOX64ExeBytes.readUInt32LE(12), 2);
|
|
const directMachOX64ExeUuid = assertMachOLoadCommand(directMachOX64ExeBytes, 0x1b, 24);
|
|
assert(!directMachOX64ExeUuid.subarray(8, 24).every((byte) => byte === 0));
|
|
assert(directMachOX64ExeBytes.includes(Buffer.from("/usr/lib/dyld")));
|
|
assert(directMachOX64ExeBytes.includes(Buffer.from("zero-direct-x64")));
|
|
assert(directMachOX64ExeBytes.includes(Buffer.from("hello from zero")));
|
|
const directMachOX64UnhandledPath = join(outDir, "direct-macho-x64-unhandled-error");
|
|
rmSync(directMachOX64UnhandledPath, { force: true });
|
|
const directMachOX64UnhandledReport = json(["build", "--json", "--emit", "exe", "--target", "darwin-x64", "examples/direct-unhandled-error-exit.graph", "--out", directMachOX64UnhandledPath]).body;
|
|
const directMachOX64UnhandledBytes = readFileSync(directMachOX64UnhandledPath);
|
|
assert.equal(directMachOX64UnhandledReport.emit, "exe");
|
|
assert.equal(directMachOX64UnhandledReport.compiler, "zero-macho-x64");
|
|
assert.equal(directMachOX64UnhandledReport.generatedCBytes, 0);
|
|
assert.equal(directMachOX64UnhandledReport.objectBackend.objectEmission.path, "direct-macho-x64-exe");
|
|
assert.equal(directMachOX64UnhandledReport.objectBackend.directFacts.runtimeHelperCount, 0);
|
|
assertReleaseTargetContract(directMachOX64UnhandledReport, {
|
|
target: "darwin-x64",
|
|
emit: "exe",
|
|
objectFormat: "macho",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "macho64",
|
|
targetLibcMode: "sysroot",
|
|
});
|
|
assert.equal(directMachOX64UnhandledBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOX64UnhandledBytes.readUInt32LE(4), 0x01000007);
|
|
assert.equal(directMachOX64UnhandledBytes.readUInt32LE(8), 3);
|
|
assert.equal(directMachOX64UnhandledBytes.readUInt32LE(12), 2);
|
|
assert(directMachOX64UnhandledBytes.includes(Buffer.from("/usr/lib/dyld")));
|
|
assert(directMachOX64UnhandledBytes.includes(Buffer.from("zero-direct-x64")));
|
|
const directMachOU8ExePath = join(outDir, "direct-macho-u8-return");
|
|
rmSync(directMachOU8ExePath, { force: true });
|
|
const directMachOU8ExeReport = json(["build", "--json", "--emit", "exe", "--target", "darwin-arm64", "examples/direct-string-literal.graph", "--out", directMachOU8ExePath]).body;
|
|
assert.equal(directMachOU8ExeReport.emit, "exe");
|
|
assert.equal(directMachOU8ExeReport.compiler, "zero-macho64");
|
|
assert.equal(directMachOU8ExeReport.generatedCBytes, 0);
|
|
assert.equal(directMachOU8ExeReport.objectBackend.objectEmission.path, "direct-macho64-exe");
|
|
const directCoffExePath = join(outDir, "direct-coff-exe-return");
|
|
rmSync(`${directCoffExePath}.exe`, { force: true });
|
|
const directCoffExeReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-coff-x64", "--target", "win32-x64.exe", "examples/direct-exe-return.graph", "--out", directCoffExePath]).body;
|
|
const directCoffExeBytes = readFileSync(`${directCoffExePath}.exe`);
|
|
const directCoffPeOffset = directCoffExeBytes.readUInt32LE(0x3c);
|
|
assert.equal(directCoffExeReport.emit, "exe");
|
|
assert.equal(directCoffExeReport.compiler, "zero-coff-x64");
|
|
assert.equal(directCoffExeReport.generatedCBytes, 0);
|
|
assert.equal(directCoffExeReport.objectBackend.objectEmission.path, "direct-coff-x64-exe");
|
|
assert.equal(directCoffExeReport.objectBackend.targetFacts.status, "native-exe");
|
|
assertReleaseTargetContract(directCoffExeReport, {
|
|
target: "win32-x64.exe",
|
|
emit: "exe",
|
|
objectFormat: "coff",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "coff",
|
|
targetLibcMode: "sysroot",
|
|
});
|
|
assert.equal(directCoffExeReport.releaseTargetContract.sysroot.requiredByTarget, true);
|
|
assert.equal(directCoffExeReport.releaseTargetContract.sysroot.status, "not-used-by-direct-artifact");
|
|
repeatBuildHash(["build", "--json", "--emit", "exe", "--backend", "zero-coff-x64", "--target", "win32-x64.exe", "examples/direct-exe-return.graph", "--out", directCoffExePath], `${directCoffExePath}.exe`, `${directCoffExePath}.repeat`, `${directCoffExePath}.repeat.exe`);
|
|
assert.equal(directCoffExeBytes.toString("ascii", directCoffPeOffset, directCoffPeOffset + 4), "PE\u0000\u0000");
|
|
assert.equal(directCoffExeBytes.readUInt16LE(directCoffPeOffset + 4), 0x8664);
|
|
assert(directCoffExeBytes.includes(Buffer.from("KERNEL32.dll")));
|
|
const directCoffArm64ExePath = join(outDir, "direct-coff-arm64-exe-return");
|
|
rmSync(`${directCoffArm64ExePath}.exe`, { force: true });
|
|
const directCoffArm64ExeReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-coff-aarch64", "--target", "win32-arm64.exe", "examples/direct-exe-return.graph", "--out", directCoffArm64ExePath]).body;
|
|
const directCoffArm64ExeBytes = readFileSync(`${directCoffArm64ExePath}.exe`);
|
|
const directCoffArm64PeOffset = directCoffArm64ExeBytes.readUInt32LE(0x3c);
|
|
assert.equal(directCoffArm64ExeReport.emit, "exe");
|
|
assert.equal(directCoffArm64ExeReport.compiler, "zero-coff-aarch64");
|
|
assert.equal(directCoffArm64ExeReport.generatedCBytes, 0);
|
|
assert.equal(directCoffArm64ExeReport.objectBackend.objectEmission.path, "direct-coff-aarch64-exe");
|
|
assert.equal(directCoffArm64ExeReport.objectBackend.targetFacts.status, "native-exe");
|
|
assertReleaseTargetContract(directCoffArm64ExeReport, {
|
|
target: "win32-arm64.exe",
|
|
emit: "exe",
|
|
objectFormat: "coff",
|
|
artifactKind: "native-executable",
|
|
linkerFlavor: "coff",
|
|
targetLibcMode: "sysroot",
|
|
});
|
|
assert.equal(directCoffArm64ExeReport.releaseTargetContract.sysroot.requiredByTarget, true);
|
|
assert.equal(directCoffArm64ExeReport.releaseTargetContract.sysroot.status, "not-used-by-direct-artifact");
|
|
assert.equal(directCoffArm64ExeBytes.toString("ascii", directCoffArm64PeOffset, directCoffArm64PeOffset + 4), "PE\u0000\u0000");
|
|
assert.equal(directCoffArm64ExeBytes.readUInt16LE(directCoffArm64PeOffset + 4), 0xaa64);
|
|
assert(directCoffArm64ExeBytes.includes(Buffer.from("KERNEL32.dll")));
|
|
const directCoffArm64HelloPath = join(outDir, "direct-coff-arm64-hello");
|
|
rmSync(`${directCoffArm64HelloPath}.exe`, { force: true });
|
|
const directCoffArm64HelloReport = json(["build", "--json", "--emit", "exe", "--target", "win32-arm64.exe", "examples/hello.graph", "--out", directCoffArm64HelloPath]).body;
|
|
const directCoffArm64HelloBytes = readFileSync(`${directCoffArm64HelloPath}.exe`);
|
|
assert.equal(directCoffArm64HelloReport.compiler, "zero-coff-aarch64");
|
|
assert.equal(directCoffArm64HelloReport.generatedCBytes, 0);
|
|
assert.equal(directCoffArm64HelloReport.objectBackend.objectEmission.path, "direct-coff-aarch64-exe");
|
|
assert.equal(directCoffArm64HelloReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert(directCoffArm64HelloBytes.includes(Buffer.from("hello from zero")));
|
|
assert(hasAarch64Instruction(directCoffArm64HelloBytes, 0xf90017fe));
|
|
assert(hasAarch64Instruction(directCoffArm64HelloBytes, 0xf94017fe));
|
|
const directCoffU8ExePath = join(outDir, "direct-coff-u8-return");
|
|
rmSync(`${directCoffU8ExePath}.exe`, { force: true });
|
|
const directCoffU8ExeReport = json(["build", "--json", "--emit", "exe", "--target", "win32-x64.exe", "examples/direct-string-literal.graph", "--out", directCoffU8ExePath]).body;
|
|
assert.equal(directCoffU8ExeReport.emit, "exe");
|
|
assert.equal(directCoffU8ExeReport.compiler, "zero-coff-x64");
|
|
assert.equal(directCoffU8ExeReport.generatedCBytes, 0);
|
|
assert.equal(directCoffU8ExeReport.objectBackend.objectEmission.path, "direct-coff-x64-exe");
|
|
const directAarch64ExePath = join(outDir, "direct-aarch64-exe-return");
|
|
rmSync(directAarch64ExePath, { force: true });
|
|
const directAarch64ExeReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf-aarch64", "--target", "linux-musl-arm64", "examples/direct-exe-return.graph", "--out", directAarch64ExePath]).body;
|
|
const directAarch64ExeBytes = readFileSync(directAarch64ExePath);
|
|
assert.equal(directAarch64ExeReport.emit, "exe");
|
|
assert.equal(directAarch64ExeReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directAarch64ExeReport.generatedCBytes, 0);
|
|
assert(directAarch64ExeReport.artifactBytes < 512);
|
|
assert.equal(directAarch64ExeReport.objectBackend.objectEmission.path, "direct-elf-aarch64-exe");
|
|
const directAarch64HelloPath = join(outDir, "direct-aarch64-hello");
|
|
rmSync(directAarch64HelloPath, { force: true });
|
|
const directAarch64HelloReport = json(["build", "--json", "--emit", "exe", "--target", "linux-musl-arm64", "examples/hello.graph", "--out", directAarch64HelloPath]).body;
|
|
const directAarch64HelloBytes = readFileSync(directAarch64HelloPath);
|
|
assert.equal(directAarch64HelloReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directAarch64HelloReport.generatedCBytes, 0);
|
|
assert.equal(directAarch64HelloReport.objectBackend.objectEmission.path, "direct-elf-aarch64-exe");
|
|
assert.equal(directAarch64HelloReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert(directAarch64HelloBytes.includes(Buffer.from("hello from zero")));
|
|
assert(hasAarch64VoidReturnEpilogue(directAarch64HelloBytes));
|
|
const directAarch64VoidImplicitSource = join(outDir, "direct-aarch64-void-implicit.0");
|
|
const directAarch64VoidImplicitPath = join(outDir, "direct-aarch64-void-implicit");
|
|
writeProjectionFile(directAarch64VoidImplicitSource, `export c fn main() -> Void {
|
|
let ok: Bool = true
|
|
}
|
|
`);
|
|
const directAarch64VoidImplicitGraph = importProjectionSidecar(directAarch64VoidImplicitSource);
|
|
rmSync(directAarch64VoidImplicitPath, { force: true });
|
|
const directAarch64VoidImplicitReport = json(["build", "--json", "--emit", "exe", "--target", "linux-musl-arm64", directAarch64VoidImplicitGraph, "--out", directAarch64VoidImplicitPath]).body;
|
|
const directAarch64VoidImplicitBytes = readFileSync(directAarch64VoidImplicitPath);
|
|
assert.equal(directAarch64VoidImplicitReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directAarch64VoidImplicitReport.generatedCBytes, 0);
|
|
assert(hasAarch64VoidReturnEpilogue(directAarch64VoidImplicitBytes));
|
|
assert.equal(directAarch64ExeReport.objectBackend.targetFacts.status, "native-exe");
|
|
assert.equal(directAarch64ExeBytes.readUInt16LE(16), 2);
|
|
assert.equal(directAarch64ExeBytes.readUInt16LE(18), 183);
|
|
assert(directAarch64ExeBytes.includes(Buffer.from([0x40, 0x05, 0x80, 0x52, 0xc0, 0x03, 0x5f, 0xd6])));
|
|
assert(directAarch64ExeBytes.includes(Buffer.from([0xa8, 0x0b, 0x80, 0xd2, 0x01, 0x00, 0x00, 0xd4])));
|
|
const directCallObjPath = join(outDir, "direct-call-add.o");
|
|
rmSync(directCallObjPath, { force: true });
|
|
const directCallObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-call-add.graph", "--out", directCallObjPath]).body;
|
|
const directCallObjBytes = readFileSync(directCallObjPath);
|
|
assert.equal(directCallObjReport.emit, "obj");
|
|
assert.equal(directCallObjReport.generatedCBytes, 0);
|
|
assert.equal(directCallObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directCallObjBytes.readUInt16LE(16), 1);
|
|
assert.equal(directCallObjBytes.readUInt16LE(18), 62);
|
|
const directArrayObjPath = join(outDir, "direct-array-fill.o");
|
|
rmSync(directArrayObjPath, { force: true });
|
|
const directArrayObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/direct-array-fill.graph", "--out", directArrayObjPath]).body;
|
|
const directArrayObjBytes = readFileSync(directArrayObjPath);
|
|
assert.equal(directArrayObjReport.emit, "obj");
|
|
assert.equal(directArrayObjReport.generatedCBytes, 0);
|
|
assert(directArrayObjReport.objectBackend.directFacts.maxFrameBytes > 0);
|
|
assert.equal(directArrayObjReport.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert.equal(directArrayObjBytes.readUInt16LE(16), 1);
|
|
assert.equal(directArrayObjBytes.readUInt16LE(18), 62);
|
|
const directArm64ObjPath = join(outDir, "direct-arm64-return.o");
|
|
rmSync(directArm64ObjPath, { force: true });
|
|
const directArm64ObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-arm64", "examples/direct-exe-return.graph", "--out", directArm64ObjPath]).body;
|
|
const directArm64ObjBytes = readFileSync(directArm64ObjPath);
|
|
assert.equal(directArm64ObjReport.emit, "obj");
|
|
assert.equal(directArm64ObjReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directArm64ObjReport.generatedCBytes, 0);
|
|
assert.equal(directArm64ObjReport.objectBackend.objectEmission.path, "direct-elf-aarch64-object");
|
|
assert.equal(directArm64ObjReport.objectBackend.targetFacts.status, "native-exe");
|
|
assert.equal(directArm64ObjBytes.readUInt16LE(16), 1);
|
|
assert.equal(directArm64ObjBytes.readUInt16LE(18), 183);
|
|
assert(directArm64ObjBytes.includes(Buffer.from([0x40, 0x05, 0x80, 0x52, 0xc0, 0x03, 0x5f, 0xd6])));
|
|
const directArm64IndexStoreSource = join(outDir, "direct-arm64-index-store-scratch.0");
|
|
const directArm64IndexStoreObjPath = join(outDir, "direct-arm64-index-store-scratch.o");
|
|
writeProjectionFile(directArm64IndexStoreSource, `export c fn main() -> u32 {
|
|
var values: [4]u32 = [0, 0, 0, 0]
|
|
values[5_u32 % 4_u32] = 7_u32
|
|
return values[1]
|
|
}
|
|
`);
|
|
const directArm64IndexStoreGraph = importProjectionSidecar(directArm64IndexStoreSource);
|
|
rmSync(directArm64IndexStoreObjPath, { force: true });
|
|
const directArm64IndexStoreObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-arm64", directArm64IndexStoreGraph, "--out", directArm64IndexStoreObjPath]).body;
|
|
const directArm64IndexStoreObjBytes = readFileSync(directArm64IndexStoreObjPath);
|
|
assert.equal(directArm64IndexStoreObjReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directArm64IndexStoreObjReport.generatedCBytes, 0);
|
|
assert(hasAarch64Instruction(directArm64IndexStoreObjBytes, 0xb90003ea));
|
|
assert(hasAarch64Instruction(directArm64IndexStoreObjBytes, 0xb94003ea));
|
|
const directWhilePath = join(outDir, "direct-while-sum");
|
|
rmSync(directWhilePath, { force: true });
|
|
const directWhileReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf64", "--target", "linux-musl-x64", "examples/direct-while-sum.graph", "--out", directWhilePath]).body;
|
|
const directWhileBytes = readFileSync(directWhilePath);
|
|
assert.equal(directWhileReport.emit, "exe");
|
|
assert.equal(directWhileReport.compiler, "zero-elf64");
|
|
assert.equal(directWhileReport.generatedCBytes, 0);
|
|
assert.equal(directWhileReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert.equal(directWhileBytes.readUInt16LE(16), 2);
|
|
assert.equal(directWhileBytes.readUInt16LE(18), 62);
|
|
const directCallLoopPath = join(outDir, "direct-call-loop");
|
|
rmSync(directCallLoopPath, { force: true });
|
|
const directCallLoopReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf64", "--target", "linux-musl-x64", "examples/direct-call-loop.graph", "--out", directCallLoopPath]).body;
|
|
const directCallLoopBytes = readFileSync(directCallLoopPath);
|
|
assert.equal(directCallLoopReport.emit, "exe");
|
|
assert.equal(directCallLoopReport.compiler, "zero-elf64");
|
|
assert.equal(directCallLoopReport.generatedCBytes, 0);
|
|
assert.equal(directCallLoopReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert.equal(directCallLoopBytes.readUInt16LE(16), 2);
|
|
assert.equal(directCallLoopBytes.readUInt16LE(18), 62);
|
|
const directPackagePath = join(outDir, "direct-package-arrays");
|
|
rmSync(directPackagePath, { force: true });
|
|
const directPackageReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf64", "--target", "linux-musl-x64", "examples/direct-package-arrays", "--out", directPackagePath]).body;
|
|
const directPackageBytes = readFileSync(directPackagePath);
|
|
assert.equal(directPackageReport.emit, "exe");
|
|
assert.equal(directPackageReport.compiler, "zero-elf64");
|
|
assert.equal(directPackageReport.generatedCBytes, 0);
|
|
assert.equal(directPackageReport.objectBackend.directFacts.moduleCount, 2);
|
|
assert.equal(directPackageReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert.equal(directPackageBytes.readUInt16LE(16), 2);
|
|
assert.equal(directPackageBytes.readUInt16LE(18), 62);
|
|
const directLinuxGnuObjPath = join(outDir, "direct-linux-gnu.o");
|
|
rmSync(directLinuxGnuObjPath, { force: true });
|
|
const directLinuxGnuObjReport = json(["build", "--json", "--emit", "obj", "--target", "linux-x64", "examples/direct-call-add.graph", "--out", directLinuxGnuObjPath]).body;
|
|
const directLinuxGnuObjBytes = readFileSync(directLinuxGnuObjPath);
|
|
assert.equal(directLinuxGnuObjReport.target, "linux-x64");
|
|
assert.equal(directLinuxGnuObjReport.compiler, "zero-elf64");
|
|
assert.equal(directLinuxGnuObjReport.generatedCBytes, 0);
|
|
assert.equal(directLinuxGnuObjReport.objectBackend.targetFacts.selectedEmitter, "zero-elf64");
|
|
assert.equal(directLinuxGnuObjBytes[0], 0x7f);
|
|
assert.equal(directLinuxGnuObjBytes[1], 0x45);
|
|
assert.equal(directLinuxGnuObjBytes.readUInt16LE(16), 1);
|
|
assert.equal(directLinuxGnuObjBytes.readUInt16LE(18), 62);
|
|
const directStringEqlTargets: Array<{ target: string; outName: string; compiler: string; emissionPath: string; magic: Buffer }> = [
|
|
{ target: "linux-musl-x64", outName: "direct-string-eql-linux-musl.o", compiler: "zero-elf64", emissionPath: "direct-elf64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-x64", outName: "direct-string-eql-linux-gnu.o", compiler: "zero-elf64", emissionPath: "direct-elf64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-arm64", outName: "direct-string-eql-linux-arm64.o", compiler: "zero-elf-aarch64", emissionPath: "direct-elf-aarch64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-musl-arm64", outName: "direct-string-eql-linux-musl-arm64.o", compiler: "zero-elf-aarch64", emissionPath: "direct-elf-aarch64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "darwin-arm64", outName: "direct-string-eql-darwin-arm64.o", compiler: "zero-macho64", emissionPath: "direct-macho64-object", magic: Buffer.from([0xcf, 0xfa, 0xed, 0xfe]) },
|
|
{ target: "darwin-x64", outName: "direct-string-eql-darwin-x64.o", compiler: "zero-macho-x64", emissionPath: "direct-macho-x64-object", magic: Buffer.from([0xcf, 0xfa, 0xed, 0xfe]) },
|
|
{ target: "win32-x64.exe", outName: "direct-string-eql-win-x64.obj", compiler: "zero-coff-x64", emissionPath: "direct-coff-x64-object", magic: Buffer.from([0x64, 0x86]) },
|
|
{ target: "win32-arm64.exe", outName: "direct-string-eql-win-arm64.obj", compiler: "zero-coff-aarch64", emissionPath: "direct-coff-aarch64-object", magic: Buffer.from([0x64, 0xaa]) },
|
|
];
|
|
for (const { target, outName, compiler, emissionPath, magic } of directStringEqlTargets) {
|
|
const directStringEqlPath = join(outDir, outName);
|
|
rmSync(directStringEqlPath, { force: true });
|
|
const directStringEqlReport = json(["build", "--json", "--emit", "obj", "--target", target, "examples/direct-string-eql.graph", "--out", directStringEqlPath]).body;
|
|
const directStringEqlBytes = readFileSync(directStringEqlPath);
|
|
assert.equal(directStringEqlReport.compiler, compiler);
|
|
assert.equal(directStringEqlReport.generatedCBytes, 0);
|
|
assert.equal(directStringEqlReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStringEqlBytes.subarray(0, magic.length).equals(magic));
|
|
assert(directStringEqlBytes.includes(Buffer.from("token")));
|
|
}
|
|
const directArm64DynamicStringEqlSource = join(outDir, "direct-arm64-dynamic-string-eql.0");
|
|
writeProjectionFile(directArm64DynamicStringEqlSource, `export c fn main() -> u8 {
|
|
let text: String = "token"
|
|
let start: usize = 0
|
|
let end: usize = 5
|
|
if std.mem.eqlBytes(text[(start % 1_usize)..end], "token"[(start % 1_usize)..end]) {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directArm64DynamicStringEqlGraph = importProjectionSidecar(directArm64DynamicStringEqlSource);
|
|
for (const { target, outName, compiler, emissionPath, magic } of [
|
|
{ target: "linux-arm64", outName: "direct-dynamic-string-eql-linux-arm64.o", compiler: "zero-elf-aarch64", emissionPath: "direct-elf-aarch64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "darwin-arm64", outName: "direct-dynamic-string-eql-darwin-arm64.o", compiler: "zero-macho64", emissionPath: "direct-macho64-object", magic: Buffer.from([0xcf, 0xfa, 0xed, 0xfe]) },
|
|
{ target: "win32-arm64.exe", outName: "direct-dynamic-string-eql-win-arm64.obj", compiler: "zero-coff-aarch64", emissionPath: "direct-coff-aarch64-object", magic: Buffer.from([0x64, 0xaa]) },
|
|
]) {
|
|
const directArm64DynamicStringEqlPath = join(outDir, outName);
|
|
rmSync(directArm64DynamicStringEqlPath, { force: true });
|
|
const directArm64DynamicStringEqlReport = json(["build", "--json", "--emit", "obj", "--target", target, directArm64DynamicStringEqlGraph, "--out", directArm64DynamicStringEqlPath]).body;
|
|
const directArm64DynamicStringEqlBytes = readFileSync(directArm64DynamicStringEqlPath);
|
|
assert.equal(directArm64DynamicStringEqlReport.compiler, compiler);
|
|
assert.equal(directArm64DynamicStringEqlReport.generatedCBytes, 0);
|
|
assert.equal(directArm64DynamicStringEqlReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directArm64DynamicStringEqlBytes.subarray(0, magic.length).equals(magic));
|
|
assert(hasAarch64Instruction(directArm64DynamicStringEqlBytes, 0xb94003ea));
|
|
}
|
|
const directByteCopyFillTargets: Array<{ target: string; outName: string; compiler: string; emissionPath: string; magic: Buffer }> = [
|
|
{ target: "linux-musl-x64", outName: "direct-byte-copy-fill-linux-musl.o", compiler: "zero-elf64", emissionPath: "direct-elf64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-x64", outName: "direct-byte-copy-fill-linux-gnu.o", compiler: "zero-elf64", emissionPath: "direct-elf64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-arm64", outName: "direct-byte-copy-fill-linux-arm64.o", compiler: "zero-elf-aarch64", emissionPath: "direct-elf-aarch64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "linux-musl-arm64", outName: "direct-byte-copy-fill-linux-musl-arm64.o", compiler: "zero-elf-aarch64", emissionPath: "direct-elf-aarch64-object", magic: Buffer.from([0x7f, 0x45, 0x4c, 0x46]) },
|
|
{ target: "darwin-arm64", outName: "direct-byte-copy-fill-darwin-arm64.o", compiler: "zero-macho64", emissionPath: "direct-macho64-object", magic: Buffer.from([0xcf, 0xfa, 0xed, 0xfe]) },
|
|
{ target: "darwin-x64", outName: "direct-byte-copy-fill-darwin-x64.o", compiler: "zero-macho-x64", emissionPath: "direct-macho-x64-object", magic: Buffer.from([0xcf, 0xfa, 0xed, 0xfe]) },
|
|
{ target: "win32-x64.exe", outName: "direct-byte-copy-fill-win-x64.obj", compiler: "zero-coff-x64", emissionPath: "direct-coff-x64-object", magic: Buffer.from([0x64, 0x86]) },
|
|
{ target: "win32-arm64.exe", outName: "direct-byte-copy-fill-win-arm64.obj", compiler: "zero-coff-aarch64", emissionPath: "direct-coff-aarch64-object", magic: Buffer.from([0x64, 0xaa]) },
|
|
];
|
|
for (const { target, outName, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directByteCopyFillPath = join(outDir, outName);
|
|
rmSync(directByteCopyFillPath, { force: true });
|
|
const directByteCopyFillReport = json(["build", "--json", "--emit", "obj", "--target", target, "examples/direct-byte-copy-fill.graph", "--out", directByteCopyFillPath]).body;
|
|
const directByteCopyFillBytes = readFileSync(directByteCopyFillPath);
|
|
assert.equal(directByteCopyFillReport.compiler, compiler);
|
|
assert.equal(directByteCopyFillReport.generatedCBytes, 0);
|
|
assert.equal(directByteCopyFillReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directByteCopyFillBytes.subarray(0, magic.length).equals(magic));
|
|
assert(directByteCopyFillBytes.includes(Buffer.from("token")));
|
|
}
|
|
const directStdPathSource = join(outDir, "direct-std-path-matrix.0");
|
|
writeProjectionFile(directStdPathSource, `export c fn main() -> u8 {
|
|
var norm: [32]u8 = [0_u8; 32]
|
|
let normalized: Maybe<String> = std.path.normalize(norm, "src//./main.0/")
|
|
var parent: [32]u8 = [0_u8; 32]
|
|
let parent_normalized: Maybe<String> = std.path.normalize(parent, "src/a/../main.0")
|
|
var joined_buf: [32]u8 = [0_u8; 32]
|
|
let joined: Maybe<String> = std.path.join(joined_buf, "src/", "/main.0")
|
|
let root_expected: Span<u8> = "/x"[..1]
|
|
var empty_abs_join_buf: [32]u8 = [0_u8; 32]
|
|
let empty_abs_joined: Maybe<String> = std.path.join(empty_abs_join_buf, "", "/main.0")
|
|
var rel: [32]u8 = [0_u8; 32]
|
|
let relative: Maybe<String> = std.path.relative(rel, "src", "src/main.0")
|
|
var fallback_buf: [32]u8 = [0_u8; 32]
|
|
let fallback: Maybe<String> = std.path.relative(fallback_buf, "other", "src/main.0")
|
|
var small: [3]u8 = [0_u8; 3]
|
|
let overflow: Maybe<String> = std.path.normalize(small, "abcd")
|
|
var root: [32]u8 = [0_u8; 32]
|
|
let root_normalized: Maybe<String> = std.path.normalize(root, "/src//./main.0/")
|
|
var root_parent_buf: [32]u8 = [0_u8; 32]
|
|
let root_parent: Maybe<String> = std.path.normalize(root_parent_buf, "/../src")
|
|
var leading_parent_buf: [32]u8 = [0_u8; 32]
|
|
let leading_parent: Maybe<String> = std.path.normalize(leading_parent_buf, "../src")
|
|
var nested_parent_buf: [32]u8 = [0_u8; 32]
|
|
let nested_parent: Maybe<String> = std.path.normalize(nested_parent_buf, "a/../../b")
|
|
var trim_fit_buf: [1]u8 = [0_u8; 1]
|
|
let trim_fit: Maybe<String> = std.path.normalize(trim_fit_buf, "a/")
|
|
var ok: Bool = true
|
|
if !normalized.has {
|
|
ok = false
|
|
}
|
|
if normalized.has {
|
|
if !std.mem.eql(normalized.value, "src/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !parent_normalized.has {
|
|
ok = false
|
|
}
|
|
if parent_normalized.has {
|
|
if !std.mem.eql(parent_normalized.value, "src/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !joined.has {
|
|
ok = false
|
|
}
|
|
if joined.has {
|
|
if !std.mem.eql(joined.value, "src/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !empty_abs_joined.has {
|
|
ok = false
|
|
}
|
|
if empty_abs_joined.has {
|
|
if !std.mem.eql(empty_abs_joined.value, "/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !relative.has {
|
|
ok = false
|
|
}
|
|
if relative.has {
|
|
if !std.mem.eql(relative.value, "main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !fallback.has {
|
|
ok = false
|
|
}
|
|
if fallback.has {
|
|
if !std.mem.eql(fallback.value, "src/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if overflow.has {
|
|
ok = false
|
|
}
|
|
if !root_normalized.has {
|
|
ok = false
|
|
}
|
|
if root_normalized.has {
|
|
if !std.mem.eql(root_normalized.value, "/src/main.0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !root_parent.has {
|
|
ok = false
|
|
}
|
|
if root_parent.has {
|
|
if !std.mem.eql(root_parent.value, "/src") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !leading_parent.has {
|
|
ok = false
|
|
}
|
|
if leading_parent.has {
|
|
if !std.mem.eql(leading_parent.value, "../src") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !nested_parent.has {
|
|
ok = false
|
|
}
|
|
if nested_parent.has {
|
|
if !std.mem.eql(nested_parent.value, "../b") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !trim_fit.has {
|
|
ok = false
|
|
}
|
|
if trim_fit.has {
|
|
if !std.mem.eql(trim_fit.value, "a") {
|
|
ok = false
|
|
}
|
|
}
|
|
if normalized.has {
|
|
if !std.mem.eql(std.path.basename(normalized.value), "main.0") {
|
|
ok = false
|
|
}
|
|
if !std.mem.eql(std.path.dirname(normalized.value), "src") {
|
|
ok = false
|
|
}
|
|
}
|
|
if !std.mem.eql(std.path.dirname("/main.0"), root_expected) {
|
|
ok = false
|
|
}
|
|
if !std.mem.eql(std.path.dirname(root_expected), root_expected) {
|
|
ok = false
|
|
}
|
|
if normalized.has {
|
|
if !std.mem.eql(std.path.extension(normalized.value), "0") {
|
|
ok = false
|
|
}
|
|
}
|
|
if ok {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directStdPathGraph = importProjectionSidecar(directStdPathSource);
|
|
for (const { target, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directStdPathPath = join(outDir, `direct-std-path-${target.replace(/[^a-z0-9]+/gi, "-")}.o`);
|
|
rmSync(directStdPathPath, { force: true });
|
|
const directStdPathReport = json(["build", "--json", "--emit", "obj", "--target", target, directStdPathGraph, "--out", directStdPathPath]).body;
|
|
const directStdPathBytes = readFileSync(directStdPathPath);
|
|
assert.equal(directStdPathReport.compiler, compiler);
|
|
assert.equal(directStdPathReport.generatedCBytes, 0);
|
|
assert.equal(directStdPathReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStdPathBytes.subarray(0, magic.length).equals(magic));
|
|
assert(directStdPathBytes.includes(Buffer.from("src/main.0")));
|
|
}
|
|
const directStdStrSource = join(outDir, "direct-std-str-matrix.0");
|
|
writeProjectionFile(directStdStrSource, `export c fn main() -> u8 {
|
|
var reversed_buf: [6]u8 = [0_u8; 6]
|
|
let reversed: Maybe<Span<u8>> = std.str.reverse(reversed_buf, "drawer")
|
|
let trimmed: Span<u8> = std.str.trimAscii(" zero text ")
|
|
var small: [3]u8 = [0_u8; 3]
|
|
let overflow: Maybe<Span<u8>> = std.str.reverse(small, "drawer")
|
|
var ok: Bool = true
|
|
if !reversed.has {
|
|
ok = false
|
|
}
|
|
if reversed.has {
|
|
if !std.mem.eql(reversed.value, "reward") {
|
|
ok = false
|
|
}
|
|
}
|
|
if overflow.has {
|
|
ok = false
|
|
}
|
|
if std.str.countByte("banana", 97_u8) != 3 {
|
|
ok = false
|
|
}
|
|
if !std.str.startsWith("zero text syntax", "zero") {
|
|
ok = false
|
|
}
|
|
if !std.str.endsWith("zero text syntax", "syntax") {
|
|
ok = false
|
|
}
|
|
if !std.str.contains("zero text syntax", "text") {
|
|
ok = false
|
|
}
|
|
if std.str.contains("zero text syntax", "column") {
|
|
ok = false
|
|
}
|
|
if !std.str.contains("zero", "") {
|
|
ok = false
|
|
}
|
|
if !std.mem.eql(trimmed, "zero text") {
|
|
ok = false
|
|
}
|
|
if std.str.wordCountAscii("zero text syntax") != 3 {
|
|
ok = false
|
|
}
|
|
if ok {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directStdStrGraph = importProjectionSidecar(directStdStrSource);
|
|
for (const { target, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directStdStrPath = join(outDir, `direct-std-str-${target.replace(/[^a-z0-9]+/gi, "-")}.o`);
|
|
rmSync(directStdStrPath, { force: true });
|
|
const directStdStrReport = json(["build", "--json", "--emit", "obj", "--target", target, directStdStrGraph, "--out", directStdStrPath]).body;
|
|
const directStdStrBytes = readFileSync(directStdStrPath);
|
|
assert.equal(directStdStrReport.compiler, compiler);
|
|
assert.equal(directStdStrReport.generatedCBytes, 0);
|
|
assert.equal(directStdStrReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStdStrBytes.subarray(0, magic.length).equals(magic));
|
|
assert(directStdStrBytes.includes(Buffer.from("zero text syntax")));
|
|
}
|
|
const directStdMathSource = join(outDir, "direct-std-math-matrix.0");
|
|
writeProjectionFile(directStdMathSource, `export c fn main() -> u8 {
|
|
var ok: Bool = true
|
|
if std.math.minU32(8, 3) != 3 {
|
|
ok = false
|
|
}
|
|
if std.math.minU32(4000000000_u32, 3) != 3 {
|
|
ok = false
|
|
}
|
|
if std.math.minI32(0_i32 - 8_i32, 3) != 0_i32 - 8_i32 {
|
|
ok = false
|
|
}
|
|
if std.math.minUsize(8_usize, 3_usize) != 3_usize {
|
|
ok = false
|
|
}
|
|
if std.math.minI64(8_i64, 3_i64) != 3_i64 {
|
|
ok = false
|
|
}
|
|
if std.math.minU64(8_u64, 3_u64) != 3_u64 {
|
|
ok = false
|
|
}
|
|
if std.math.maxU32(8, 3) != 8 {
|
|
ok = false
|
|
}
|
|
if std.math.maxU32(4000000000_u32, 3) != 4000000000_u32 {
|
|
ok = false
|
|
}
|
|
if std.math.maxI32(0_i32 - 8_i32, 3) != 3 {
|
|
ok = false
|
|
}
|
|
if std.math.maxUsize(8_usize, 3_usize) != 8_usize {
|
|
ok = false
|
|
}
|
|
if std.math.maxI64(8_i64, 3_i64) != 8_i64 {
|
|
ok = false
|
|
}
|
|
if std.math.maxU64(8_u64, 3_u64) != 8_u64 {
|
|
ok = false
|
|
}
|
|
if std.math.clampU32(10, 2, 7) != 7 {
|
|
ok = false
|
|
}
|
|
if std.math.clampU32(4000000000_u32, 2, 7) != 7 {
|
|
ok = false
|
|
}
|
|
if std.math.clampU32(1, 7, 2) != 2 {
|
|
ok = false
|
|
}
|
|
if std.math.clampI32(0_i32 - 10_i32, 0_i32 - 5_i32, 7) != 0_i32 - 5_i32 {
|
|
ok = false
|
|
}
|
|
if std.math.clampUsize(1_usize, 7_usize, 2_usize) != 2_usize {
|
|
ok = false
|
|
}
|
|
if std.math.clampI64(10_i64, 2_i64, 7_i64) != 7_i64 {
|
|
ok = false
|
|
}
|
|
if std.math.clampU64(1_u64, 7_u64, 2_u64) != 2_u64 {
|
|
ok = false
|
|
}
|
|
if std.math.absI32(0_i32 - 7_i32) != 7_u32 {
|
|
ok = false
|
|
}
|
|
if std.math.absI64(0_i64 - 9_i64) != 9_u64 {
|
|
ok = false
|
|
}
|
|
let checked_add_u32: Maybe<u32> = std.math.checkedAddU32(40_u32, 2_u32)
|
|
let checked_sub_u32: Maybe<u32> = std.math.checkedSubU32(44_u32, 2_u32)
|
|
let checked_mul_u32: Maybe<u32> = std.math.checkedMulU32(6_u32, 7_u32)
|
|
let checked_add_usize: Maybe<usize> = std.math.checkedAddUsize(40_usize, 2_usize)
|
|
let checked_sub_usize: Maybe<usize> = std.math.checkedSubUsize(44_usize, 2_usize)
|
|
let checked_mul_usize: Maybe<usize> = std.math.checkedMulUsize(6_usize, 7_usize)
|
|
let checked_add_i32: Maybe<i32> = std.math.checkedAddI32(40, 2)
|
|
let checked_sub_i32: Maybe<i32> = std.math.checkedSubI32(40, 0_i32 - 2_i32)
|
|
let checked_mul_i32: Maybe<i32> = std.math.checkedMulI32(6, 7)
|
|
if !checked_add_u32.has || !checked_sub_u32.has || !checked_mul_u32.has || !checked_add_usize.has || !checked_sub_usize.has || !checked_mul_usize.has || !checked_add_i32.has || !checked_sub_i32.has || !checked_mul_i32.has {
|
|
ok = false
|
|
}
|
|
let checked_add_u32_overflow: Maybe<u32> = std.math.checkedAddU32(4294967295_u32, 1_u32)
|
|
let checked_sub_u32_overflow: Maybe<u32> = std.math.checkedSubU32(1_u32, 2_u32)
|
|
let checked_mul_u32_overflow: Maybe<u32> = std.math.checkedMulU32(4000000000_u32, 2_u32)
|
|
if checked_add_u32_overflow.has || checked_sub_u32_overflow.has || checked_mul_u32_overflow.has {
|
|
ok = false
|
|
}
|
|
if std.math.saturatingAddU32(4294967295_u32, 1_u32) != 4294967295_u32 || std.math.saturatingSubU32(1_u32, 2_u32) != 0_u32 || std.math.saturatingMulU32(4000000000_u32, 2_u32) != 4294967295_u32 {
|
|
ok = false
|
|
}
|
|
if std.math.saturatingAddUsize(18446744073709551615_usize, 1_usize) != 18446744073709551615_usize || std.math.saturatingSubUsize(1_usize, 2_usize) != 0_usize || std.math.saturatingMulUsize(18446744073709551615_usize, 2_usize) != 18446744073709551615_usize {
|
|
ok = false
|
|
}
|
|
if std.math.saturatingAddI32(2147483647, 1) != 2147483647 || std.math.saturatingSubI32(0_i32 - 2147483647_i32 - 1_i32, 1) != 0_i32 - 2147483647_i32 - 1_i32 || std.math.saturatingMulI32(2147483647, 2) != 2147483647 {
|
|
ok = false
|
|
}
|
|
if std.math.gcdU32(84, 30) != 6 {
|
|
ok = false
|
|
}
|
|
if std.math.lcmU32(21, 6) != 42 {
|
|
ok = false
|
|
}
|
|
let checked_lcm: Maybe<u32> = std.math.checkedLcmU32(21_u32, 6_u32)
|
|
if !checked_lcm.has {
|
|
ok = false
|
|
}
|
|
if std.math.powU32(3, 4) != 81 {
|
|
ok = false
|
|
}
|
|
let checked_pow: Maybe<u32> = std.math.checkedPowU32(2_u32, 10_u32)
|
|
if !checked_pow.has {
|
|
ok = false
|
|
}
|
|
if std.math.modPowU32(4, 13, 497) != 445 {
|
|
ok = false
|
|
}
|
|
if std.math.modPowU32(65536_u32, 2_u32, 4294967295_u32) != 1_u32 {
|
|
ok = false
|
|
}
|
|
if std.math.modPowU32(9, 0, 1) != 0 {
|
|
ok = false
|
|
}
|
|
if !std.math.isPrimeU32(31) {
|
|
ok = false
|
|
}
|
|
if std.math.isPrimeU32(33) {
|
|
ok = false
|
|
}
|
|
if !std.math.isEvenU32(42) || !std.math.isOddU32(41) {
|
|
ok = false
|
|
}
|
|
if std.math.sqrtFloorU32(99) != 9 {
|
|
ok = false
|
|
}
|
|
let factorial: Maybe<u32> = std.math.factorialU32(5_u32)
|
|
let binomial: Maybe<u32> = std.math.binomialU32(5_u32, 2_u32)
|
|
if !factorial.has || !binomial.has {
|
|
ok = false
|
|
}
|
|
let larger_binomial: Maybe<u32> = std.math.binomialU32(31_u32, 15_u32)
|
|
if !larger_binomial.has {
|
|
ok = false
|
|
} else {
|
|
if larger_binomial.value != 300540195_u32 {
|
|
ok = false
|
|
}
|
|
}
|
|
if std.math.divisorCountU32(28) != 6 {
|
|
ok = false
|
|
}
|
|
if std.math.properDivisorSumU32(28) != 28 {
|
|
ok = false
|
|
}
|
|
if ok {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directStdMathGraph = importProjectionSidecar(directStdMathSource);
|
|
for (const { target, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directStdMathPath = join(outDir, `direct-std-math-${target.replace(/[^a-z0-9]+/gi, "-")}.o`);
|
|
rmSync(directStdMathPath, { force: true });
|
|
const directStdMathReport = json(["build", "--json", "--emit", "obj", "--target", target, directStdMathGraph, "--out", directStdMathPath]).body;
|
|
const directStdMathBytes = readFileSync(directStdMathPath);
|
|
assert.equal(directStdMathReport.compiler, compiler);
|
|
assert.equal(directStdMathReport.generatedCBytes, 0);
|
|
assert.equal(directStdMathReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStdMathBytes.subarray(0, magic.length).equals(magic));
|
|
if (compiler === "zero-coff-x64") {
|
|
assert(directStdMathBytes.includes(Buffer.from("zero_math_op")));
|
|
assert(directStdMathBytes.includes(Buffer.from("zero_math_usize_op")));
|
|
}
|
|
}
|
|
const directStdTimeRandSource = join(outDir, "direct-std-time-rand-matrix.0");
|
|
writeProjectionFile(directStdTimeRandSource, `export c fn main() -> u8 {
|
|
var ok: Bool = true
|
|
let duration: Duration = std.time.add(std.time.us(2500_i64), std.time.ms(1))
|
|
let window: Duration = std.time.add(std.time.minutes(1), std.time.seconds(30))
|
|
let clamped: Duration = std.time.clamp(std.time.hours(2), std.time.seconds(1), std.time.minutes(10))
|
|
let zero: Duration = std.time.zero()
|
|
if std.time.asNs(std.time.ns(42_i64)) != 42_i64 {
|
|
ok = false
|
|
}
|
|
if std.time.asUsFloor(std.time.ns(1999_i64)) != 1_i64 {
|
|
ok = false
|
|
}
|
|
if std.time.asMsFloor(duration) != 3 {
|
|
ok = false
|
|
}
|
|
if std.time.asSecondsFloor(window) != 90_i64 {
|
|
ok = false
|
|
}
|
|
if std.time.asSecondsFloor(clamped) != 600_i64 {
|
|
ok = false
|
|
}
|
|
let negative_tick: Duration = std.time.sub(std.time.zero(), std.time.ns(1_i64))
|
|
if std.time.asUsFloor(negative_tick) != 0_i64 - 1_i64 {
|
|
ok = false
|
|
}
|
|
if std.time.asMsFloor(negative_tick) != 0 - 1 {
|
|
ok = false
|
|
}
|
|
if std.time.asSecondsFloor(negative_tick) != 0_i64 - 1_i64 {
|
|
ok = false
|
|
}
|
|
if !std.time.lessThan(zero, duration) || !std.time.isZero(zero) {
|
|
ok = false
|
|
}
|
|
if std.time.asSecondsFloor(std.time.max(duration, window)) != 90_i64 {
|
|
ok = false
|
|
}
|
|
if std.time.asNs(std.time.min(duration, window)) != 3500000_i64 {
|
|
ok = false
|
|
}
|
|
var rng: RandSource = std.rand.seed(7_u32)
|
|
let first: u32 = std.rand.nextU32(&mut rng)
|
|
let bit: Bool = std.rand.nextBool(&mut rng)
|
|
let third: u32 = std.rand.nextU32(&mut rng)
|
|
if first != 1025555898_u32 || !bit || third != 2630631676_u32 {
|
|
ok = false
|
|
}
|
|
var bool_rng: RandSource = std.rand.seed(7_u32)
|
|
let bit_one: Bool = std.rand.nextBool(&mut bool_rng)
|
|
let bit_two: Bool = std.rand.nextBool(&mut bool_rng)
|
|
let bit_three: Bool = std.rand.nextBool(&mut bool_rng)
|
|
if bit_one || !bit_two || !bit_three {
|
|
ok = false
|
|
}
|
|
if ok {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directStdTimeRandGraph = importProjectionSidecar(directStdTimeRandSource);
|
|
for (const { target, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directStdTimeRandPath = join(outDir, `direct-std-time-rand-${target.replace(/[^a-z0-9]+/gi, "-")}.o`);
|
|
rmSync(directStdTimeRandPath, { force: true });
|
|
const directStdTimeRandReport = json(["build", "--json", "--emit", "obj", "--target", target, directStdTimeRandGraph, "--out", directStdTimeRandPath]).body;
|
|
const directStdTimeRandBytes = readFileSync(directStdTimeRandPath);
|
|
assert.equal(directStdTimeRandReport.compiler, compiler);
|
|
assert.equal(directStdTimeRandReport.generatedCBytes, 0);
|
|
assert.equal(directStdTimeRandReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStdTimeRandBytes.subarray(0, magic.length).equals(magic));
|
|
}
|
|
const directStdDataSource = join(outDir, "direct-std-codec-json-url-matrix.0");
|
|
writeProjectionFile(directStdDataSource, `export c fn main() -> u8 {
|
|
var ok: Bool = true
|
|
var b64_buf: [4]u8 = [0_u8; 4]
|
|
let b64: Maybe<Span<u8>> = std.codec.base64Decode(b64_buf, "emVybw==")
|
|
if !b64.has || !std.mem.eql(b64.value, "zero") {
|
|
ok = false
|
|
}
|
|
var hex_buf: [2]u8 = [0_u8; 2]
|
|
let hex: Maybe<Span<u8>> = std.codec.hexDecode(hex_buf, "417a")
|
|
if !hex.has || !std.mem.eql(hex.value, "Az") {
|
|
ok = false
|
|
}
|
|
var word_buf: [4]u8 = [0_u8; 4]
|
|
let word: Maybe<Span<u8>> = std.codec.writeU32Be(word_buf, 0x41424344_u32)
|
|
if !word.has {
|
|
ok = false
|
|
}
|
|
if word.has {
|
|
let read_word: Maybe<u32> = std.codec.readU32Be(word.value)
|
|
if !read_word.has || read_word.value != 0x41424344_u32 {
|
|
ok = false
|
|
}
|
|
}
|
|
let json: Span<u8> = "{\\"name\\":\\"zero\\",\\"count\\":42,\\"ok\\":true}"
|
|
var name_buf: [8]u8 = [0_u8; 8]
|
|
let name: Maybe<Span<u8>> = std.json.string(name_buf, json, "name")
|
|
let count: Maybe<u32> = std.json.u32(json, "count")
|
|
let flag: Maybe<Bool> = std.json.bool(json, "ok")
|
|
var json_out_buf: [16]u8 = [0_u8; 16]
|
|
let json_out: Maybe<Span<u8>> = std.json.writeObject1U32(json_out_buf, "count", 42_u32)
|
|
if !name.has || !std.mem.eql(name.value, "zero") || !count.has || count.value != 42_u32 || !flag.has || !flag.value || !json_out.has || std.json.validateError(json_out.value) != std.json.errorNone() {
|
|
ok = false
|
|
}
|
|
var query_param_buf: [16]u8 = [0_u8; 16]
|
|
let query_param: Maybe<Span<u8>> = std.url.writeQueryParam(query_param_buf, "q", "zero lang")
|
|
var url_buf: [48]u8 = [0_u8; 48]
|
|
var url: Maybe<Span<u8>> = null
|
|
if query_param.has {
|
|
url = std.url.appendQuery(url_buf, "https://example.com/path", query_param.value)
|
|
}
|
|
if !url.has || !std.mem.eql(url.value, "https://example.com/path?q=zero+lang") {
|
|
ok = false
|
|
}
|
|
if ok {
|
|
return 1_u8
|
|
}
|
|
return 0_u8
|
|
}
|
|
`);
|
|
const directStdDataGraph = importProjectionSidecar(directStdDataSource);
|
|
for (const { target, compiler, emissionPath, magic } of directByteCopyFillTargets) {
|
|
const directStdDataPath = join(outDir, `direct-std-codec-json-url-${target.replace(/[^a-z0-9]+/gi, "-")}.o`);
|
|
rmSync(directStdDataPath, { force: true });
|
|
const directStdDataReport = json(["build", "--json", "--emit", "obj", "--target", target, directStdDataGraph, "--out", directStdDataPath]).body;
|
|
const directStdDataBytes = readFileSync(directStdDataPath);
|
|
assert.equal(directStdDataReport.compiler, compiler);
|
|
assert.equal(directStdDataReport.generatedCBytes, 0);
|
|
assert.equal(directStdDataReport.objectBackend.objectEmission.path, emissionPath);
|
|
assert(directStdDataBytes.subarray(0, magic.length).equals(magic));
|
|
assert(directStdDataBytes.includes(Buffer.from("zero+lang")));
|
|
}
|
|
const directMachOPath = join(outDir, "direct-darwin-arm64.o");
|
|
rmSync(directMachOPath, { force: true });
|
|
const directMachOReport = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", "examples/direct-call-add.graph", "--out", directMachOPath]).body;
|
|
const directMachOBytes = readFileSync(directMachOPath);
|
|
assert.equal(directMachOReport.compiler, "zero-macho64");
|
|
assert.equal(directMachOReport.objectBackend.objectEmission.path, "direct-macho64-object");
|
|
assert.equal(directMachOReport.objectBackend.linking.objectFormat, "macho");
|
|
assert.equal(directMachOReport.objectBackend.directFacts.stackBytes, 544);
|
|
assert.equal(directMachOReport.objectBackend.directFacts.maxFrameBytes, 272);
|
|
assert.equal(directMachOBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOBytes.readUInt32LE(4), 0x0100000c);
|
|
assert.equal(directMachOBytes.readUInt32LE(12), 1);
|
|
assert(directMachOBytes.includes(Buffer.concat([Buffer.from("_main"), Buffer.from([0])])));
|
|
assert(directMachOBytes.includes(Buffer.concat([Buffer.from("_add"), Buffer.from([0])])));
|
|
assert(directMachOBytes.includes(Buffer.from([0x00, 0x01, 0x09, 0x0b])));
|
|
const directMachOSection = 32 + 72;
|
|
const directMachORelocOffset = directMachOBytes.readUInt32LE(directMachOSection + 56);
|
|
assert(directMachORelocOffset > 0);
|
|
assert(directMachOBytes.readUInt32LE(directMachOSection + 60) > 0);
|
|
assert.equal((directMachOBytes.readUInt32LE(directMachORelocOffset + 4) >>> 28) & 15, 2);
|
|
const directMachODataPath = join(outDir, "direct-darwin-arm64-data.o");
|
|
rmSync(directMachODataPath, { force: true });
|
|
const directMachODataReport = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", "examples/direct-byte-view-reloc.graph", "--out", directMachODataPath]).body;
|
|
const directMachODataBytes = readFileSync(directMachODataPath);
|
|
assert.equal(directMachODataReport.compiler, "zero-macho64");
|
|
assert.equal(directMachODataReport.objectBackend.objectEmission.path, "direct-macho64-object");
|
|
assert.equal(directMachODataReport.objectBackend.objectEmission.dataSections, true);
|
|
assert.equal(directMachODataReport.objectBackend.directFacts.readonlyDataBytes, 6);
|
|
assert(directMachODataBytes.includes(Buffer.from("__const\0")));
|
|
assert(directMachODataBytes.includes(Buffer.from("l_.zero_rodata\0")));
|
|
assert(directMachODataBytes.includes(Buffer.from("token")));
|
|
const directMachODataSection = 32 + 72;
|
|
const directMachODataRelocOffset = directMachODataBytes.readUInt32LE(directMachODataSection + 56);
|
|
const directMachODataRelocCount = directMachODataBytes.readUInt32LE(directMachODataSection + 60);
|
|
assert(directMachODataRelocOffset > 0);
|
|
assert(directMachODataRelocCount > 0);
|
|
let sawMachOPageReloc = false;
|
|
let sawMachOPageoffReloc = false;
|
|
for (let i = 0; i < directMachODataRelocCount; i++) {
|
|
const info = directMachODataBytes.readUInt32LE(directMachODataRelocOffset + i * 8 + 4);
|
|
sawMachOPageReloc ||= ((info >>> 28) & 15) === 3;
|
|
sawMachOPageoffReloc ||= ((info >>> 28) & 15) === 4;
|
|
}
|
|
assert.equal(sawMachOPageReloc, true);
|
|
assert.equal(sawMachOPageoffReloc, true);
|
|
const directMachOWorldPath = join(outDir, "direct-darwin-arm64-world.o");
|
|
rmSync(directMachOWorldPath, { force: true });
|
|
const directMachOWorldReport = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", "examples/hello.graph", "--out", directMachOWorldPath]).body;
|
|
const directMachOWorldBytes = readFileSync(directMachOWorldPath);
|
|
assert.equal(directMachOWorldReport.compiler, "zero-macho64");
|
|
assert.equal(directMachOWorldReport.generatedCBytes, 0);
|
|
assert.equal(directMachOWorldReport.objectBackend.objectEmission.path, "direct-macho64-object");
|
|
assert.equal(directMachOWorldReport.objectBackend.objectEmission.symbolCount, 3);
|
|
assert.equal(directMachOWorldReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert.equal(directMachOWorldBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOWorldBytes.readUInt32LE(4), 0x0100000c);
|
|
assert.equal(directMachOWorldBytes.readUInt32LE(12), 1);
|
|
assert(directMachOWorldBytes.includes(Buffer.from("hello from zero")));
|
|
assert(directMachOWorldBytes.includes(Buffer.from("_zero_world_write")));
|
|
const directMachOWorldSection = 32 + 72;
|
|
const directMachOWorldRelocOffset = directMachOWorldBytes.readUInt32LE(directMachOWorldSection + 56);
|
|
const directMachOWorldRelocCount = directMachOWorldBytes.readUInt32LE(directMachOWorldSection + 60);
|
|
assert(directMachOWorldRelocOffset > 0);
|
|
assert(directMachOWorldRelocCount >= 2);
|
|
let sawMachOWorldBranchReloc = false;
|
|
for (let i = 0; i < directMachOWorldRelocCount; i++) {
|
|
const info = directMachOWorldBytes.readUInt32LE(directMachOWorldRelocOffset + i * 8 + 4);
|
|
sawMachOWorldBranchReloc ||= ((info >>> 28) & 15) === 2;
|
|
}
|
|
assert.equal(sawMachOWorldBranchReloc, true);
|
|
const directMachOX64WorldPath = join(outDir, "direct-darwin-x64-world.o");
|
|
rmSync(directMachOX64WorldPath, { force: true });
|
|
const directMachOX64WorldReport = json(["build", "--json", "--emit", "obj", "--target", "darwin-x64", "examples/hello.graph", "--out", directMachOX64WorldPath]).body;
|
|
const directMachOX64WorldBytes = readFileSync(directMachOX64WorldPath);
|
|
assert.equal(directMachOX64WorldReport.compiler, "zero-macho-x64");
|
|
assert.equal(directMachOX64WorldReport.generatedCBytes, 0);
|
|
assert.equal(directMachOX64WorldReport.objectBackend.objectEmission.path, "direct-macho-x64-object");
|
|
assert.equal(directMachOX64WorldReport.objectBackend.objectEmission.symbolCount, 3);
|
|
assert.equal(directMachOX64WorldReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert.equal(directMachOX64WorldBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert.equal(directMachOX64WorldBytes.readUInt32LE(4), 0x01000007);
|
|
assert.equal(directMachOX64WorldBytes.readUInt32LE(8), 3);
|
|
assert.equal(directMachOX64WorldBytes.readUInt32LE(12), 1);
|
|
assert(directMachOX64WorldBytes.includes(Buffer.from("hello from zero")));
|
|
assert(directMachOX64WorldBytes.includes(Buffer.from("_zero_world_write")));
|
|
const directMachOX64WorldSection = 32 + 72;
|
|
const directMachOX64WorldRelocOffset = directMachOX64WorldBytes.readUInt32LE(directMachOX64WorldSection + 56);
|
|
const directMachOX64WorldRelocCount = directMachOX64WorldBytes.readUInt32LE(directMachOX64WorldSection + 60);
|
|
assert(directMachOX64WorldRelocOffset > 0);
|
|
assert(directMachOX64WorldRelocCount >= 2);
|
|
let sawMachOX64SignedReloc = false;
|
|
let sawMachOX64BranchReloc = false;
|
|
for (let i = 0; i < directMachOX64WorldRelocCount; i++) {
|
|
const info = directMachOX64WorldBytes.readUInt32LE(directMachOX64WorldRelocOffset + i * 8 + 4);
|
|
sawMachOX64SignedReloc ||= ((info >>> 28) & 15) === 1;
|
|
sawMachOX64BranchReloc ||= ((info >>> 28) & 15) === 2;
|
|
}
|
|
assert.equal(sawMachOX64SignedReloc, true);
|
|
assert.equal(sawMachOX64BranchReloc, true);
|
|
const directCoffPath = join(outDir, "direct-win-x64.obj");
|
|
rmSync(directCoffPath, { force: true });
|
|
const directCoffReport = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", "examples/direct-call-add.graph", "--out", directCoffPath]).body;
|
|
const directCoffBytes = readFileSync(directCoffPath);
|
|
assert.equal(directCoffReport.compiler, "zero-coff-x64");
|
|
assert.equal(directCoffReport.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(directCoffReport.objectBackend.linking.objectFormat, "coff");
|
|
assert.equal(directCoffBytes.readUInt16LE(0), 0x8664);
|
|
assert.equal(directCoffBytes.readUInt16LE(2), 1);
|
|
assert(directCoffBytes.includes(Buffer.concat([Buffer.from("main"), Buffer.from([0])])));
|
|
assert(directCoffBytes.includes(Buffer.concat([Buffer.from("add"), Buffer.from([0])])));
|
|
assert(directCoffBytes.includes(Buffer.from([0xe8])));
|
|
const directCoffRelocOffset = directCoffBytes.readUInt32LE(20 + 24);
|
|
const directCoffRelocCount = directCoffBytes.readUInt16LE(20 + 32);
|
|
assert(directCoffRelocOffset > 0);
|
|
assert(directCoffRelocCount > 0);
|
|
assert.equal(directCoffBytes.readUInt16LE(directCoffRelocOffset + 8), 4);
|
|
const directCoffDataPath = join(outDir, "direct-win-x64-data.obj");
|
|
rmSync(directCoffDataPath, { force: true });
|
|
const directCoffDataReport = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", "examples/direct-byte-view-reloc.graph", "--out", directCoffDataPath]).body;
|
|
const directCoffDataBytes = readFileSync(directCoffDataPath);
|
|
assert.equal(directCoffDataReport.compiler, "zero-coff-x64");
|
|
assert.equal(directCoffDataReport.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(directCoffDataReport.objectBackend.objectEmission.dataSections, true);
|
|
assert.equal(directCoffDataReport.objectBackend.directFacts.readonlyDataBytes, 6);
|
|
assert.equal(directCoffDataBytes.readUInt16LE(0), 0x8664);
|
|
assert.equal(directCoffDataBytes.readUInt16LE(2), 2);
|
|
assert(directCoffDataBytes.includes(Buffer.from(".rdata\0")));
|
|
assert(directCoffDataBytes.includes(Buffer.from("token")));
|
|
const directCoffDataRelocOffset = directCoffDataBytes.readUInt32LE(20 + 24);
|
|
const directCoffDataRelocCount = directCoffDataBytes.readUInt16LE(20 + 32);
|
|
assert(directCoffDataRelocOffset > 0);
|
|
assert(directCoffDataRelocCount > 0);
|
|
let sawCoffAddr64Reloc = false;
|
|
for (let i = 0; i < directCoffDataRelocCount; i++) {
|
|
sawCoffAddr64Reloc ||= directCoffDataBytes.readUInt16LE(directCoffDataRelocOffset + i * 10 + 8) === 1;
|
|
}
|
|
assert.equal(sawCoffAddr64Reloc, true);
|
|
const directCoffArm64DataPath = join(outDir, "direct-win-arm64-data.obj");
|
|
rmSync(directCoffArm64DataPath, { force: true });
|
|
const directCoffArm64DataReport = json(["build", "--json", "--emit", "obj", "--target", "win32-arm64.exe", "examples/direct-byte-view-reloc.graph", "--out", directCoffArm64DataPath]).body;
|
|
const directCoffArm64DataBytes = readFileSync(directCoffArm64DataPath);
|
|
assert.equal(directCoffArm64DataReport.compiler, "zero-coff-aarch64");
|
|
assert.equal(directCoffArm64DataReport.objectBackend.objectEmission.path, "direct-coff-aarch64-object");
|
|
assert.equal(directCoffArm64DataReport.objectBackend.objectEmission.dataSections, true);
|
|
assert.equal(directCoffArm64DataReport.objectBackend.directFacts.readonlyDataBytes, 6);
|
|
assert.equal(directCoffArm64DataBytes.readUInt16LE(0), 0xaa64);
|
|
assert.equal(directCoffArm64DataBytes.readUInt16LE(2), 2);
|
|
assert(directCoffArm64DataBytes.includes(Buffer.from(".rdata\0")));
|
|
assert(directCoffArm64DataBytes.includes(Buffer.from("token")));
|
|
const directCoffArm64DataRelocOffset = directCoffArm64DataBytes.readUInt32LE(20 + 24);
|
|
const directCoffArm64DataRelocCount = directCoffArm64DataBytes.readUInt16LE(20 + 32);
|
|
assert(directCoffArm64DataRelocOffset > 0);
|
|
assert(directCoffArm64DataRelocCount > 0);
|
|
let sawCoffArm64Addr64Reloc = false;
|
|
for (let i = 0; i < directCoffArm64DataRelocCount; i++) {
|
|
sawCoffArm64Addr64Reloc ||= directCoffArm64DataBytes.readUInt16LE(directCoffArm64DataRelocOffset + i * 10 + 8) === 0x000e;
|
|
}
|
|
assert.equal(sawCoffArm64Addr64Reloc, true);
|
|
const directCoffWorldPath = join(outDir, "direct-win-x64-world.obj");
|
|
rmSync(directCoffWorldPath, { force: true });
|
|
const directCoffWorldReport = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", "examples/hello.graph", "--out", directCoffWorldPath]).body;
|
|
const directCoffWorldBytes = readFileSync(directCoffWorldPath);
|
|
assert.equal(directCoffWorldReport.compiler, "zero-coff-x64");
|
|
assert.equal(directCoffWorldReport.generatedCBytes, 0);
|
|
assert.equal(directCoffWorldReport.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(directCoffWorldReport.objectBackend.objectEmission.symbolCount, 4);
|
|
assert.equal(directCoffWorldReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert.equal(directCoffWorldBytes.readUInt16LE(0), 0x8664);
|
|
assert.equal(directCoffWorldBytes.readUInt16LE(2), 2);
|
|
assert(directCoffWorldBytes.includes(Buffer.from("hello from zero")));
|
|
assert(directCoffWorldBytes.includes(Buffer.from("zero_world_write")));
|
|
const directCoffWorldRelocOffset = directCoffWorldBytes.readUInt32LE(20 + 24);
|
|
const directCoffWorldRelocCount = directCoffWorldBytes.readUInt16LE(20 + 32);
|
|
assert(directCoffWorldRelocOffset > 0);
|
|
assert(directCoffWorldRelocCount >= 2);
|
|
let sawCoffWorldRel32Reloc = false;
|
|
for (let i = 0; i < directCoffWorldRelocCount; i++) {
|
|
sawCoffWorldRel32Reloc ||= directCoffWorldBytes.readUInt16LE(directCoffWorldRelocOffset + i * 10 + 8) === 4;
|
|
}
|
|
assert.equal(sawCoffWorldRel32Reloc, true);
|
|
const directElfFsFallibleResourcesPath = join(outDir, "direct-std-fs-fallible-resources");
|
|
rmSync(directElfFsFallibleResourcesPath, { force: true });
|
|
const directElfFsFallibleResourcesReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf64", "--target", "linux-musl-x64", "conformance/native/pass/std-fs-fallible-resources.graph", "--out", directElfFsFallibleResourcesPath]).body;
|
|
const directElfFsFallibleResourcesBytes = readFileSync(directElfFsFallibleResourcesPath);
|
|
assert.equal(directElfFsFallibleResourcesReport.generatedCBytes, 0);
|
|
assert.equal(directElfFsFallibleResourcesReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert(directElfFsFallibleResourcesBytes.includes(elfPackedErrorBytes(2)));
|
|
assert(directElfFsFallibleResourcesBytes.includes(elfPackedErrorBytes(4)));
|
|
const directElfFsFalliblePath = join(outDir, "direct-std-fs-fallible");
|
|
rmSync(directElfFsFalliblePath, { force: true });
|
|
const directElfFsFallibleReport = json(["build", "--json", "--emit", "exe", "--backend", "zero-elf64", "--target", "linux-musl-x64", "conformance/native/pass/std-fs-fallible.graph", "--out", directElfFsFalliblePath]).body;
|
|
const directElfFsFallibleBytes = readFileSync(directElfFsFalliblePath);
|
|
assert.equal(directElfFsFallibleReport.generatedCBytes, 0);
|
|
assert.equal(directElfFsFallibleReport.objectBackend.objectEmission.path, "direct-elf64-exe");
|
|
assert(directElfFsFallibleBytes.includes(elfPackedErrorBytes(2, true)));
|
|
assert(directElfFsFallibleBytes.includes(elfPackedErrorBytes(3, true)));
|
|
assert(directElfFsFallibleBytes.includes(elfPackedErrorBytes(4, true)));
|
|
const directArm64ElfPath = join(outDir, "direct-arm64.o");
|
|
rmSync(directArm64ElfPath, { force: true });
|
|
const directArm64ElfReport = json(["build", "--json", "--emit", "obj", "--target", "linux-arm64", "examples/direct-call-add.graph", "--out", directArm64ElfPath]).body;
|
|
const directArm64ElfBytes = readFileSync(directArm64ElfPath);
|
|
assert.equal(directArm64ElfReport.compiler, "zero-elf-aarch64");
|
|
assert.equal(directArm64ElfReport.generatedCBytes, 0);
|
|
assert.equal(directArm64ElfReport.objectBackend.objectEmission.path, "direct-elf-aarch64-object");
|
|
assert(directArm64ElfReport.objectBackend.directFacts.functionCount >= 2);
|
|
assert(directArm64ElfBytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])));
|
|
assert(directArm64ElfBytes.includes(Buffer.from("main")));
|
|
const hostLeakGraph = json(["inspect", "--json", "--target", "linux-musl-x64", "conformance/c/host-leak-package"]).body;
|
|
assert.equal(hostLeakGraph.cLibraries[0].targetValidation.status, "blocked");
|
|
assert.equal(hostLeakGraph.cLibraries[0].linkPlan.hostDiscovery, "blocked");
|
|
const hostLeakReadiness = json(["check", "--json", "--target", "linux-musl-x64", "conformance/c/host-leak-package"]).body;
|
|
assert.equal(hostLeakReadiness.ok, true);
|
|
assert.equal(hostLeakReadiness.diagnostics.length, 0);
|
|
assert.equal(hostLeakReadiness.targetReadiness.ok, false);
|
|
assert.equal(hostLeakReadiness.targetReadiness.buildable, false);
|
|
assert.equal(hostLeakReadiness.targetReadiness.diagnostics[0].code, "CIMP003");
|
|
assert.match(hostLeakReadiness.targetReadiness.diagnostics[0].help, /target sysroot|vendored/);
|
|
const hostLeakBuild = json(["build", "--json", "--target", "linux-musl-x64", "conformance/c/host-leak-package", "--out", join(outDir, "host-leak-package")], { allowFailure: true });
|
|
assert.notEqual(hostLeakBuild.code, 0);
|
|
assert.equal(hostLeakBuild.body.diagnostics[0].code, "CIMP003");
|
|
const depGraph = json(["inspect", "--json", "--target", "linux-musl-x64", "conformance/packages/dep-app"]).body;
|
|
assert.equal(depGraph.package.name, "dep-app");
|
|
assert.equal(depGraph.package.resolver.deterministic, true);
|
|
assert(depGraph.package.dependencies.some((item) => item.name === "dep-lib" && item.status === "path-resolved"));
|
|
assert(depGraph.package.dependencies.some((item) => item.name === "remote-tools" && item.status === "registry-reference"));
|
|
assert.match(depGraph.package.lockfile.path, /\.zero\/package-locks\/[0-9a-f]+\.lock\.json/);
|
|
assert.match(depGraph.packageCache.cacheKeyInputs.dependencyGraphHash, /^[0-9a-f]{16}$/);
|
|
const depDoc = json(["doc", "--json", "conformance/packages/dep-app"]).body;
|
|
assert.equal(depDoc.package.name, "dep-app");
|
|
assert.equal(depDoc.publicationGate.requiresExamplesForPublicApi, true);
|
|
const depBuild = json(["build", "--json", "--target", "linux-musl-x64", "conformance/packages/dep-app", "--out", join(outDir, "dep-app")]).body;
|
|
assert.equal(depBuild.packageCache.invalidationReasons.includes("dependency graph changed"), true);
|
|
assert.equal(depBuild.compilerCaches.every((item) => item.compilerVersion === "0.3.4" && item.packageVersion === "0.1.0"), true);
|
|
const depDevTrace = json(["dev", "--json", "--trace", "--target", "linux-musl-x64", "conformance/packages/dep-app"]).body;
|
|
assert.equal(depDevTrace.trace.requested, true);
|
|
assert.equal(depDevTrace.partialDiagnostics.stable, true);
|
|
assert(depDevTrace.watch.files.some((item) => item.endsWith("src/main.0")));
|
|
assert.match(depDevTrace.watch.packageLocks[0], /\.zero\/package-locks\/[0-9a-f]+\.lock\.json/);
|
|
assert.equal(depDevTrace.interfaceFingerprints.algorithm, "fnv1a64-zero-interface-v1");
|
|
assert(depDevTrace.interfaceFingerprints.modules.some((item) => item.name === "main" && /^[0-9a-f]{16}$/.test(item.publicInterfaceHash)));
|
|
assert.equal(depDevTrace.incrementalInvalidation.partialDiagnosticsStable, true);
|
|
assert.equal(depDevTrace.incrementalInvalidation.interfaceFingerprints.importedPackageMetadataHash, depDevTrace.interfaceFingerprints.importedPackageMetadataHash);
|
|
const depTime = json(["time", "--json", "--target", "linux-musl-x64", "conformance/packages/dep-app"]).body;
|
|
assert.equal(depTime.interfaceFingerprints.algorithm, "fnv1a64-zero-interface-v1");
|
|
assert.match(depTime.interfaceFingerprints.targetFactsHash, /^[0-9a-f]{16}$/);
|
|
assert(depTime.cacheSummary.entries >= 5);
|
|
assert(depTime.incrementalInvalidation.changedInputs.sourceFiles.some((item) => item.endsWith("src/main.0")));
|
|
if (process.getuid?.() !== 0) {
|
|
const unreadableDepRoot = join("/tmp", `zero-unreadable-dep-manifest-${process.pid}`);
|
|
const unreadableDepManifest = join(unreadableDepRoot, "dep-lib", "zero.toml");
|
|
rmSync(unreadableDepRoot, { force: true, recursive: true });
|
|
cpSync("conformance/packages/dep-app", join(unreadableDepRoot, "dep-app"), { recursive: true });
|
|
cpSync("conformance/packages/dep-lib", join(unreadableDepRoot, "dep-lib"), { recursive: true });
|
|
rmSync(join(unreadableDepRoot, "dep-app", ".zero"), { force: true, recursive: true });
|
|
rmSync(join(unreadableDepRoot, "dep-lib", ".zero"), { force: true, recursive: true });
|
|
chmodSync(unreadableDepManifest, 0o000);
|
|
const unreadableDepCheck = json(["check", "--json", join(unreadableDepRoot, "dep-app")], { allowFailure: true });
|
|
assert.equal(unreadableDepCheck.code, 1);
|
|
assert.equal(unreadableDepCheck.body.ok, false);
|
|
assert.equal(unreadableDepCheck.body.diagnostics[0].code, "PAR100");
|
|
assert.equal(unreadableDepCheck.body.diagnostics[0].path, unreadableDepManifest);
|
|
assert.match(unreadableDepCheck.body.diagnostics[0].message, /failed to read '.*dep-lib\/zero\.toml'/);
|
|
chmodSync(unreadableDepManifest, 0o644);
|
|
rmSync(unreadableDepRoot, { force: true, recursive: true });
|
|
}
|
|
const zeroHashSize = json(["size", "--json", "--target", "linux-musl-x64", "examples/zero-hash", "--out", join(outDir, "zero-hash-sized")]).body;
|
|
assert.equal(zeroHashSize.generatedCBytes, 0);
|
|
assert(zeroHashSize.usedStdlibHelpers.some((helper) => helper.name === "std.codec.crc32Bytes"));
|
|
assert(zeroHashSize.artifactBytes < 100 * 1024);
|
|
const invalidCheckEmit = json(["check", "--json", "--emit", "bogus", "examples/hello.graph"], { allowFailure: true });
|
|
assert.equal(invalidCheckEmit.code, 1);
|
|
assert.equal(invalidCheckEmit.body.ok, false);
|
|
assert.equal(invalidCheckEmit.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(invalidCheckEmit.body.diagnostics[0].actual, "--emit bogus");
|
|
assert.equal(invalidCheckEmit.body.targetReadiness, undefined);
|
|
const unknownBackend = json(["check", "--json", "--backend", "bogus", "examples/hello.graph"], { allowFailure: true });
|
|
assert.equal(unknownBackend.code, 1);
|
|
assert.equal(unknownBackend.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(unknownBackend.body.diagnostics[0].actual, "--backend bogus");
|
|
assert.match(unknownBackend.body.diagnostics[0].expected, /direct, llvm/);
|
|
const unknownBackendWithLlvmEmit = json(["check", "--json", "--emit", "llvm-ir", "--backend", "bogus", "examples/hello.graph"], { allowFailure: true });
|
|
assert.equal(unknownBackendWithLlvmEmit.code, 1);
|
|
assert.equal(unknownBackendWithLlvmEmit.body.diagnostics[0].code, "BLD002");
|
|
assert.equal(unknownBackendWithLlvmEmit.body.diagnostics[0].actual, "--backend bogus");
|
|
const llvmReadiness = json(["check", "--json", "--backend", "llvm", "examples/add.graph"]).body;
|
|
assert.equal(llvmReadiness.ok, true);
|
|
const llvmHostReady = llvmReadiness.targetReadiness.ok;
|
|
assert.equal(llvmReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmReadiness.targetReadiness.emit, "exe");
|
|
assert.equal(llvmReadiness.targetReadiness.backendLifecycle.stability, "experimental");
|
|
assert.equal(llvmReadiness.targetReadiness.backendLifecycle.defaultEligible, false);
|
|
assert.equal(llvmReadiness.targetReadiness.backendLifecycle.releaseEligible, false);
|
|
if (llvmHostReady) {
|
|
assert.equal(llvmReadiness.targetReadiness.stage, "ready");
|
|
assert.equal(llvmReadiness.targetReadiness.diagnostics.length, 0);
|
|
} else {
|
|
assert.equal(llvmReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmReadiness.targetReadiness.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert(["toolchain", "target-selection"].includes(llvmReadiness.targetReadiness.stage));
|
|
}
|
|
const llvmMissingToolReadiness = json(["check", "--json", "--backend", "llvm", "examples/add.graph"], { env: { ZERO_LLVM_CLANG: "/tmp/zero-missing-clang" } }).body;
|
|
assert.equal(llvmMissingToolReadiness.ok, true);
|
|
assert.equal(llvmMissingToolReadiness.targetReadiness.ok, false);
|
|
assert.equal(llvmMissingToolReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmMissingToolReadiness.targetReadiness.stage, "toolchain");
|
|
assert.equal(llvmMissingToolReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmMissingToolReadiness.targetReadiness.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
const llvmNonExecutableToolPath = join(outDir, "not-executable-clang");
|
|
writeFileSync(llvmNonExecutableToolPath, "");
|
|
chmodSync(llvmNonExecutableToolPath, 0o644);
|
|
const llvmNonExecutableToolReadiness = json(["check", "--json", "--backend", "llvm", "examples/add.graph"], { env: { ZERO_LLVM_CLANG: llvmNonExecutableToolPath } }).body;
|
|
assert.equal(llvmNonExecutableToolReadiness.ok, true);
|
|
assert.equal(llvmNonExecutableToolReadiness.targetReadiness.ok, false);
|
|
assert.equal(llvmNonExecutableToolReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmNonExecutableToolReadiness.targetReadiness.stage, "toolchain");
|
|
assert.equal(llvmNonExecutableToolReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.match(llvmNonExecutableToolReadiness.targetReadiness.diagnostics[0].actual, /not executable or not found/);
|
|
assert.equal(llvmNonExecutableToolReadiness.targetReadiness.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
const llvmIrReadiness = json(["check", "--json", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph"]).body;
|
|
assert.equal(llvmIrReadiness.ok, true);
|
|
assert.equal(llvmIrReadiness.targetReadiness.ok, true);
|
|
assert.equal(llvmIrReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmIrReadiness.targetReadiness.emit, "llvm-ir");
|
|
assert.equal(llvmIrReadiness.targetReadiness.stage, "ready");
|
|
assert.equal(llvmIrReadiness.targetReadiness.diagnostics.length, 0);
|
|
const llvmPracticalSubsetExpected = "LLVM IR scalar, fixed-array, and byte-view MIR subset";
|
|
for (const fixture of [
|
|
"examples/direct-array-sum.graph",
|
|
"examples/direct-string-len.graph",
|
|
"examples/direct-byte-copy-fill.graph",
|
|
"examples/direct-string-eql.graph",
|
|
"examples/direct-byte-view-locals.graph",
|
|
"examples/direct-span-read.graph",
|
|
]) {
|
|
const readiness = json(["check", "--json", "--emit", "llvm-ir", "--backend", "llvm", fixture]).body;
|
|
assert.equal(readiness.ok, true);
|
|
assert.equal(readiness.targetReadiness.ok, true);
|
|
assert.equal(readiness.targetReadiness.backend, "llvm");
|
|
assert.equal(readiness.targetReadiness.stage, "ready");
|
|
assert.equal(readiness.targetReadiness.diagnostics.length, 0);
|
|
}
|
|
const llvmIrLoweringBlockedReadiness = json(["check", "--json", "--emit", "llvm-ir", "--backend", "llvm", "conformance/agent-surface/fixtures/owned-drop-direct-backend-unsupported.graph"]).body;
|
|
assert.equal(llvmIrLoweringBlockedReadiness.ok, true);
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.ok, false);
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.stage, "lower");
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.diagnostics[0].expected, "typed program graph MIR subset");
|
|
assert.equal(llvmIrLoweringBlockedReadiness.targetReadiness.diagnostics[0].actual, "owned<Tracked>");
|
|
assert.deepEqual(llvmIrLoweringBlockedReadiness.targetReadiness.diagnostics[0].backendBlocker, {
|
|
target: version.host,
|
|
objectFormat: version.host.startsWith("win32") ? "coff" : (version.host.startsWith("linux") ? "elf" : "macho"),
|
|
backend: "llvm",
|
|
stage: "lower",
|
|
unsupportedFeature: "owned<Tracked>",
|
|
});
|
|
const llvmNativeLoweringBlockedReadiness = json(["check", "--json", "--backend", "llvm", "conformance/agent-surface/fixtures/owned-drop-direct-backend-unsupported.graph"]).body;
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.ok, true);
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.ok, false);
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.stage, "lower");
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.diagnostics[0].expected, "typed program graph MIR subset");
|
|
assert.equal(llvmNativeLoweringBlockedReadiness.targetReadiness.diagnostics[0].actual, "owned<Tracked>");
|
|
assert.doesNotMatch(llvmNativeLoweringBlockedReadiness.targetReadiness.diagnostics[0].message, /direct backend/);
|
|
const llvmBuild = json(["build", "--json", "--backend", "llvm", "examples/add.graph", "--out", join(outDir, "add-llvm")], { allowFailure: !llvmHostReady });
|
|
if (llvmHostReady) {
|
|
assert.equal(llvmBuild.code, 0);
|
|
assert.equal(llvmBuild.body.emit, "exe");
|
|
assert.equal(llvmBuild.body.compiler, llvmBuild.body.toolchain.compiler);
|
|
assert.equal(llvmBuild.body.toolchain.driverKind, "clang");
|
|
assert.equal(llvmBuild.body.toolchain.status, "ready");
|
|
assert.equal(llvmBuild.body.toolchain.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmBuild.body.releaseTargetContract.backendFamily, "llvm");
|
|
assert.equal(llvmBuild.body.releaseTargetContract.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmBuild.body.releaseTargetContract.artifactKind, "native-executable");
|
|
assert.equal(llvmBuild.body.releaseTargetContract.selectedEmitter, "llvm-clang-exe");
|
|
assert.equal(llvmBuild.body.releaseTargetContract.fallbackPolicy, "none");
|
|
assert.equal(llvmBuild.body.releaseTargetContract.readiness.llvmArtifact, true);
|
|
assert.equal(llvmBuild.body.releaseTargetContract.readiness.releaseEligible, false);
|
|
assert.equal(llvmBuild.body.releaseTargetContract.determinism.reproducible, false);
|
|
assert.equal(llvmBuild.body.releaseTargetContract.determinism.repeatBuildHash, "external-toolchain-not-claimed");
|
|
assert.equal(llvmBuild.body.objectBackend.backendFamily, "llvm");
|
|
assert.equal(llvmBuild.body.objectBackend.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmBuild.body.objectBackend.targetFacts.status, "ready");
|
|
assert.equal(llvmBuild.body.objectBackend.linking.externalToolchain, llvmBuild.body.toolchain.compiler);
|
|
assert.equal(llvmBuild.body.objectBackend.linking.toolchainSource, "llvm-ir-clang-link-plan");
|
|
assert.deepEqual(llvmBuild.body.objectBackend.linkerPlan.staticLibraries, ["zero_runtime.o"]);
|
|
assert.equal(llvmBuild.body.objectBackend.linkerPlan.reproducible, false);
|
|
assert.equal(llvmBuild.body.targetSupport.backendFamily, "llvm");
|
|
assert.equal(llvmBuild.body.targetSupport.fallbackPolicy, "none");
|
|
assert.equal(llvmBuild.body.targetSupport.backendLifecycle.releaseEligible, false);
|
|
assert(llvmBuild.body.artifactBytes > 0);
|
|
assert.equal(execFileSync(llvmBuild.body.artifactPath, [], { encoding: "utf8" }), "math works\n");
|
|
} else {
|
|
assert.notEqual(llvmBuild.code, 0);
|
|
assert.equal(llvmBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmBuild.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
}
|
|
const llvmMissingToolBuild = json(["build", "--json", "--backend", "llvm", "examples/add.graph", "--out", join(outDir, "add-llvm-missing")], { allowFailure: true, env: { ZERO_LLVM_CLANG: "/tmp/zero-missing-clang" } });
|
|
assert.notEqual(llvmMissingToolBuild.code, 0);
|
|
assert.equal(llvmMissingToolBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmMissingToolBuild.body.diagnostics[0].backendBlocker.stage, "toolchain");
|
|
assert.equal(llvmMissingToolBuild.body.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
const llvmNativeLoweringBlockedBuild = json(["build", "--json", "--backend", "llvm", "conformance/agent-surface/fixtures/owned-drop-direct-backend-unsupported.graph", "--out", join(outDir, "owned-drop-llvm")], { allowFailure: true });
|
|
assert.notEqual(llvmNativeLoweringBlockedBuild.code, 0);
|
|
assert.equal(llvmNativeLoweringBlockedBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmNativeLoweringBlockedBuild.body.diagnostics[0].expected, "typed program graph MIR subset");
|
|
assert.equal(llvmNativeLoweringBlockedBuild.body.diagnostics[0].actual, "owned<Tracked>");
|
|
assert.doesNotMatch(llvmNativeLoweringBlockedBuild.body.diagnostics[0].message, /direct backend/);
|
|
assert.equal(llvmNativeLoweringBlockedBuild.body.diagnostics[0].backendBlocker.backend, directExeEmitterForTarget(version.host));
|
|
assert.equal(llvmNativeLoweringBlockedBuild.body.diagnostics[0].backendBlocker.stage, "lower");
|
|
const llvmFailingToolPath = join(outDir, "failing-clang");
|
|
writeFileSync(llvmFailingToolPath, "#!/bin/sh\nexit 1\n");
|
|
chmodSync(llvmFailingToolPath, 0o755);
|
|
const llvmFailingToolRuntimeBuild = json(["build", "--json", "--backend", "llvm", "examples/hello.graph", "--out", join(outDir, "hello-llvm-failing-tool")], { allowFailure: true, env: { ZERO_LLVM_CLANG: llvmFailingToolPath } });
|
|
assert.notEqual(llvmFailingToolRuntimeBuild.code, 0);
|
|
assert.equal(llvmFailingToolRuntimeBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.match(llvmFailingToolRuntimeBuild.body.diagnostics[0].message, /LLVM runtime object build failed/);
|
|
assert.equal(llvmFailingToolRuntimeBuild.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert.equal(llvmFailingToolRuntimeBuild.body.diagnostics[0].backendBlocker.stage, "toolchain");
|
|
assert.equal(llvmFailingToolRuntimeBuild.body.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
const llvmFailingToolLinkBuild = json(["build", "--json", "--backend", "llvm", "examples/direct-exe-return.graph", "--out", join(outDir, "return-llvm-failing-tool")], { allowFailure: true, env: { ZERO_LLVM_CLANG: llvmFailingToolPath } });
|
|
assert.notEqual(llvmFailingToolLinkBuild.code, 0);
|
|
assert.equal(llvmFailingToolLinkBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.match(llvmFailingToolLinkBuild.body.diagnostics[0].message, /LLVM executable link failed/);
|
|
assert.equal(llvmFailingToolLinkBuild.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert.equal(llvmFailingToolLinkBuild.body.diagnostics[0].backendBlocker.stage, "toolchain");
|
|
assert.equal(llvmFailingToolLinkBuild.body.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
const llvmNoOutputToolPath = join(outDir, "no-output-clang");
|
|
const llvmNoOutputArtifactPath = join(outDir, "return-llvm-no-output-tool");
|
|
writeFileSync(llvmNoOutputToolPath, "#!/bin/sh\nexit 0\n");
|
|
chmodSync(llvmNoOutputToolPath, 0o755);
|
|
writeFileSync(llvmNoOutputArtifactPath, "stale executable\n");
|
|
const llvmNoOutputToolBuild = json(["build", "--json", "--backend", "llvm", "examples/direct-exe-return.graph", "--out", llvmNoOutputArtifactPath], { allowFailure: true, env: { ZERO_LLVM_CLANG: llvmNoOutputToolPath } });
|
|
assert.notEqual(llvmNoOutputToolBuild.code, 0);
|
|
assert.equal(llvmNoOutputToolBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.match(llvmNoOutputToolBuild.body.diagnostics[0].message, /LLVM executable link failed/);
|
|
assert.equal(llvmNoOutputToolBuild.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert.equal(llvmNoOutputToolBuild.body.diagnostics[0].backendBlocker.stage, "toolchain");
|
|
assert.equal(llvmNoOutputToolBuild.body.diagnostics[0].backendBlocker.unsupportedFeature, "clang");
|
|
assert.equal(existsSync(llvmNoOutputArtifactPath), false);
|
|
const llvmIrBuild = json(["build", "--json", "--emit", "llvm-ir", "examples/add.graph", "--out", join(outDir, "add.ll")], { allowFailure: true });
|
|
assert.notEqual(llvmIrBuild.code, 0);
|
|
assert.equal(llvmIrBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrBuild.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const explicitLlvmIrBuild = json(["build", "--json", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph", "--out", join(outDir, "add-explicit.ll")]);
|
|
assert.equal(explicitLlvmIrBuild.code, 0);
|
|
assert.equal(explicitLlvmIrBuild.body.emit, "llvm-ir");
|
|
assert.equal(explicitLlvmIrBuild.body.compiler, "zero-c-llvm-ir");
|
|
assert.equal(explicitLlvmIrBuild.body.generatedCBytes, 0);
|
|
assert.equal(explicitLlvmIrBuild.body.toolchain.driverKind, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.toolchain.selectionSource, "not-required");
|
|
assert.equal(explicitLlvmIrBuild.body.targetSupport.backendFamily, "llvm");
|
|
assert.equal(explicitLlvmIrBuild.body.targetSupport.llvmStatus, "ir-only");
|
|
assert.equal(explicitLlvmIrBuild.body.targetSupport.backendLifecycle.releaseEligible, false);
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.backendFamily, "llvm");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.backendLifecycle.releaseEligible, false);
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.artifactKind, "llvm-ir");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.selectedEmitter, "llvm-ir");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.linkerFlavor, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.targetLinker, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.fallbackPolicy, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.libc.artifactMode, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.sysroot.requiredByArtifact, false);
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.readiness.status, "supported");
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.readiness.directArtifact, false);
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.readiness.llvmArtifact, true);
|
|
assert.equal(explicitLlvmIrBuild.body.releaseTargetContract.readiness.releaseEligible, false);
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.backendFamily, "llvm");
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.backendLifecycle.releaseEligible, false);
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.targetFacts.status, "ir-only");
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.linking.targetLibraries, "zero-runtime");
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.linking.externalToolchain, "none");
|
|
assert.equal(explicitLlvmIrBuild.body.objectBackend.linking.toolchainSource, "textual-llvm-ir-runtime-link-plan");
|
|
assert.deepEqual(explicitLlvmIrBuild.body.objectBackend.linkerPlan.staticLibraries, ["zero_runtime.o"]);
|
|
assert.match(explicitLlvmIrBuild.body.objectBackend.targetFacts.reason, /native host executable output/);
|
|
assert.equal(explicitLlvmIrBuild.body.artifactPath, join(outDir, "add-explicit.ll"));
|
|
assert(explicitLlvmIrBuild.body.artifactBytes > 0);
|
|
const explicitLlvmIrText = readFileSync(explicitLlvmIrBuild.body.artifactPath, "utf8");
|
|
assert.match(explicitLlvmIrText, /^; zero llvm-ir v1\n/);
|
|
assert.match(explicitLlvmIrText, /target triple = "/);
|
|
assert.match(explicitLlvmIrText, /define i32 @main\(\)/);
|
|
assert.match(explicitLlvmIrText, /declare i32 @zero_world_write\(i32, ptr, i32\)/);
|
|
assert.match(explicitLlvmIrText, /declare void @llvm\.trap\(\)/);
|
|
assert.match(explicitLlvmIrText, /call i32 @zero_world_write\(i32 1, ptr %v[0-9]+, i32 (?:11|%v[0-9]+)\)/);
|
|
assert.match(explicitLlvmIrText, /%v[0-9]+ = call i32 @zero_world_write\(i32 1, ptr %v[0-9]+, i32 (?:11|%v[0-9]+)\)\n %v[0-9]+ = icmp eq i32 %v[0-9]+, 0\n br i1 %v[0-9]+, label %L[0-9]+, label %L[0-9]+\nL[0-9]+:\n call void @llvm\.trap\(\)\n unreachable\nL[0-9]+:/);
|
|
const llvmIrLoweringBlockedBuild = json(["build", "--json", "--emit", "llvm-ir", "--backend", "llvm", "conformance/agent-surface/fixtures/owned-drop-direct-backend-unsupported.graph", "--out", join(outDir, "owned-drop.ll")], { allowFailure: true });
|
|
assert.notEqual(llvmIrLoweringBlockedBuild.code, 0);
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].expected, "typed program graph MIR subset");
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].actual, "owned<Tracked>");
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].backendBlocker.backend, directExeEmitterForTarget(version.host));
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].backendBlocker.stage, "lower");
|
|
assert.equal(llvmIrLoweringBlockedBuild.body.diagnostics[0].backendBlocker.unsupportedFeature, "owned<Tracked>");
|
|
const directLlvmIrReadiness = json(["check", "--json", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph"]).body;
|
|
assert.equal(directLlvmIrReadiness.ok, true);
|
|
assert.equal(directLlvmIrReadiness.targetReadiness.ok, false);
|
|
assert.equal(directLlvmIrReadiness.targetReadiness.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
assert.equal(directLlvmIrReadiness.targetReadiness.diagnostics[0].backendBlocker.backend, "direct");
|
|
assert.equal(directLlvmIrReadiness.targetReadiness.diagnostics[0].backendBlocker.stage, "buildability");
|
|
const directLlvmIrBuild = json(["build", "--json", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph", "--out", join(outDir, "add-direct.ll")], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrBuild.code, 0);
|
|
assert.equal(directLlvmIrBuild.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const llvmGraphCheck = json(["check", "--json", "--backend", "llvm", "examples/add.graph"]).body;
|
|
assert.equal(llvmGraphCheck.ok, true);
|
|
assert.equal(llvmGraphCheck.targetReadiness.ok, llvmHostReady);
|
|
assert.equal(llvmGraphCheck.targetReadiness.backend, "llvm");
|
|
if (llvmHostReady) {
|
|
assert.equal(llvmGraphCheck.targetReadiness.stage, "ready");
|
|
assert.equal(llvmGraphCheck.targetReadiness.diagnostics.length, 0);
|
|
} else {
|
|
assert.equal(llvmGraphCheck.targetReadiness.diagnostics[0].backendBlocker.backend, "llvm");
|
|
}
|
|
const llvmIrGraphCheck = json(["check", "--json", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph"]).body;
|
|
assert.equal(llvmIrGraphCheck.ok, true);
|
|
assert.equal(llvmIrGraphCheck.targetReadiness.ok, true);
|
|
assert.equal(llvmIrGraphCheck.targetReadiness.backend, "llvm");
|
|
assert.equal(llvmIrGraphCheck.targetReadiness.stage, "ready");
|
|
const directLlvmIrGraphCheck = json(["check", "--json", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph"]).body;
|
|
assert.equal(directLlvmIrGraphCheck.ok, true);
|
|
assert.equal(directLlvmIrGraphCheck.targetReadiness.ok, false);
|
|
assert.equal(directLlvmIrGraphCheck.targetReadiness.diagnostics[0].backendBlocker.backend, "direct");
|
|
const llvmSize = json(["size", "--json", "--backend", "llvm", "examples/add.graph"]);
|
|
assert.equal(llvmSize.body.targetSupport.backendFamily, "llvm");
|
|
assert.equal(llvmSize.body.targetSupport.fallbackPolicy, "none");
|
|
assert.equal(llvmSize.body.targetSupport.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmSize.body.backendProfile.backendFamily, "llvm");
|
|
assert.equal(llvmSize.body.backendProfile.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmSize.body.backendProfile.selectedEmitter, "llvm-clang-exe");
|
|
assert.equal(llvmSize.body.backendProfile.targetTriple, llvmSize.body.targetSupport.llvmTargetTriple);
|
|
assert.equal(llvmSize.body.backendProfile.optimizationLevel, "-Oz");
|
|
assert.equal(llvmSize.body.backendProfile.retained.functionCount + llvmSize.body.backendProfile.retained.runtimeHelperCount, llvmSize.body.objectBackend.objectEmission.symbolCount);
|
|
assert.equal(llvmSize.body.objectBackend.backendFamily, "llvm");
|
|
assert.equal(llvmSize.body.objectBackend.backendLifecycle.releaseEligible, false);
|
|
assert.equal(llvmSize.body.objectBackend.targetFacts.fallbackPolicy, "none");
|
|
assert.equal(llvmSize.body.backendComparison.rows.length, 4);
|
|
assert(llvmSize.body.backendComparison.rows.some((row) => row.id === "direct-debug" && row.backendFamily === "direct"));
|
|
assert(llvmSize.body.backendComparison.rows.some((row) => row.id === "llvm-no-opt" && row.backendFamily === "llvm" && row.optimizationLevel === "-O0"));
|
|
const llvmGraphSize = json(["size", "--json", "--backend", "llvm", graphDumpPath]);
|
|
assert.equal(llvmGraphSize.body.graph.artifact, graphDumpPath);
|
|
assert.equal(llvmGraphSize.body.targetSupport.backendFamily, "llvm");
|
|
assert.equal(llvmGraphSize.body.backendProfile.backendFamily, "llvm");
|
|
const llvmIrSize = json(["size", "--json", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(llvmIrSize.code, 0);
|
|
assert.equal(llvmIrSize.body.diagnostics[0].code, "BLD004");
|
|
assert.match(llvmIrSize.body.diagnostics[0].message, /writes artifacts only through zero build/);
|
|
assert.equal(llvmIrSize.body.diagnostics[0].actual, "size --backend llvm --emit llvm-ir");
|
|
assert.equal(llvmIrSize.body.diagnostics[0].backendBlocker.unsupportedFeature, "llvm-ir command");
|
|
const llvmIrGraphSize = json(["size", "--json", "--emit", "llvm-ir", "--backend", "llvm", graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(llvmIrGraphSize.code, 0);
|
|
assert.equal(llvmIrGraphSize.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrGraphSize.body.diagnostics[0].actual, "size --backend llvm --emit llvm-ir");
|
|
assert.equal(llvmIrGraphSize.body.diagnostics[0].backendBlocker.unsupportedFeature, "llvm-ir command");
|
|
const directLlvmIrSize = json(["size", "--json", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrSize.code, 0);
|
|
assert.equal(directLlvmIrSize.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const llvmMem = json(["mem", "--json", "--backend", "llvm", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(llvmMem.code, 0);
|
|
assert.equal(llvmMem.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmMem.body.diagnostics[0].backendBlocker.backend, "llvm");
|
|
assert.equal(llvmMem.body.diagnostics[0].backendBlocker.stage, "buildability");
|
|
const llvmIrMem = json(["mem", "--json", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(llvmIrMem.code, 0);
|
|
assert.equal(llvmIrMem.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrMem.body.diagnostics[0].actual, "mem --backend llvm --emit llvm-ir");
|
|
assert.equal(llvmIrMem.body.diagnostics[0].backendBlocker.unsupportedFeature, "llvm-ir command");
|
|
const directLlvmIrMem = json(["mem", "--json", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrMem.code, 0);
|
|
assert.equal(directLlvmIrMem.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const llvmIrRun = zero(["run", "--emit", "llvm-ir", "--backend", "llvm", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(llvmIrRun.code, 0);
|
|
assert.match(llvmIrRun.stderr, /BLD004: LLVM IR emission writes artifacts only through zero build/);
|
|
assert.match(llvmIrRun.stderr, /actual: run --backend llvm --emit llvm-ir/);
|
|
const directLlvmIrRun = zero(["run", "--emit", "llvm-ir", "--backend", "direct", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrRun.code, 0);
|
|
assert.match(directLlvmIrRun.stderr, /BLD004: direct backend does not support --emit llvm-ir/);
|
|
assert.match(directLlvmIrRun.stderr, /actual: backend=direct emit=llvm-ir/);
|
|
const llvmIrGraphRun = zero(["run", "--emit", "llvm-ir", "--backend", "llvm", graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(llvmIrGraphRun.code, 0);
|
|
assert.match(llvmIrGraphRun.stderr, /BLD004: LLVM IR emission writes artifacts only through zero build/);
|
|
assert.match(llvmIrGraphRun.stderr, /actual: run --backend llvm --emit llvm-ir/);
|
|
const llvmTest = json(["test", "--json", "--backend", "llvm", "conformance/native/pass/test-blocks.graph"], { allowFailure: true });
|
|
assert.equal(llvmTest.code, 0);
|
|
assert.equal(llvmTest.body.ok, true);
|
|
assert.equal(llvmTest.body.graph.artifact, "conformance/native/pass/test-blocks.graph");
|
|
assert.equal(llvmTest.body.testBackend, "direct-program-graph");
|
|
const llvmIrTest = json(["test", "--json", "--emit", "llvm-ir", "--backend", "llvm", "conformance/native/pass/test-blocks.graph"], { allowFailure: true });
|
|
assert.notEqual(llvmIrTest.code, 0);
|
|
assert.equal(llvmIrTest.body.diagnostics[0].code, "BLD004");
|
|
assert.equal(llvmIrTest.body.diagnostics[0].actual, "test --backend llvm --emit llvm-ir");
|
|
assert.equal(llvmIrTest.body.diagnostics[0].backendBlocker.unsupportedFeature, "llvm-ir command");
|
|
const directLlvmIrTest = json(["test", "--json", "--emit", "llvm-ir", "--backend", "direct", "conformance/native/pass/test-blocks.graph"], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrTest.code, 0);
|
|
assert.equal(directLlvmIrTest.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const mismatchedDirectSize = json(["size", "--json", "--backend", "zero-coff-x64", "--target", "linux-x64", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(mismatchedDirectSize.code, 0);
|
|
assert.equal(mismatchedDirectSize.body.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectSize.body.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
assert.equal(mismatchedDirectSize.body.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const mismatchedDirectMem = json(["mem", "--json", "--backend", "zero-coff-x64", "--target", "linux-x64", "examples/add.graph"], { allowFailure: true });
|
|
assert.notEqual(mismatchedDirectMem.code, 0);
|
|
assert.equal(mismatchedDirectMem.body.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectMem.body.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
assert.equal(mismatchedDirectMem.body.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const mismatchedDirectGraphSize = json(["size", "--json", "--backend", "zero-coff-x64", "--target", "linux-x64", graphDumpPath], { allowFailure: true });
|
|
assert.notEqual(mismatchedDirectGraphSize.code, 0);
|
|
assert.equal(mismatchedDirectGraphSize.body.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectGraphSize.body.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
assert.equal(mismatchedDirectGraphSize.body.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const mismatchedDirectTest = json(["test", "--json", "--backend", "zero-coff-x64", "--target", "linux-x64", "conformance/native/pass/test-blocks.graph"], { allowFailure: true });
|
|
assert.equal(mismatchedDirectTest.code, 0);
|
|
assert.equal(mismatchedDirectTest.body.ok, true);
|
|
assert.equal(mismatchedDirectTest.body.graph.artifact, "conformance/native/pass/test-blocks.graph");
|
|
assert.equal(mismatchedDirectTest.body.testBackend, "direct-program-graph");
|
|
const llvmGraphTest = json(["test", "--json", "--backend", "llvm", graphTestDumpPath], { allowFailure: true });
|
|
assert.equal(llvmGraphTest.code, 0);
|
|
assert.equal(llvmGraphTest.body.ok, true);
|
|
assert.equal(llvmGraphTest.body.testBackend, "direct-program-graph");
|
|
assert.equal(llvmGraphTest.body.graph.lowering, "direct-program-graph");
|
|
const directLlvmIrGraphTest = json(["test", "--json", "--emit", "llvm-ir", "--backend", "direct", graphTestDumpPath], { allowFailure: true });
|
|
assert.notEqual(directLlvmIrGraphTest.code, 0);
|
|
assert.equal(directLlvmIrGraphTest.body.diagnostics[0].actual, "backend=direct emit=llvm-ir");
|
|
const mismatchedDirectObjReadiness = json(["check", "--json", "--emit", "obj", "--backend", "zero-coff-x64", "--target", "linux-x64", "examples/add.graph"]).body;
|
|
assert.equal(mismatchedDirectObjReadiness.ok, true);
|
|
assert.equal(mismatchedDirectObjReadiness.targetReadiness.ok, false);
|
|
assert.equal(mismatchedDirectObjReadiness.targetReadiness.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectObjReadiness.targetReadiness.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
assert.equal(mismatchedDirectObjReadiness.targetReadiness.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const mismatchedDirectObjBuild = json(["build", "--json", "--emit", "obj", "--backend", "zero-coff-x64", "--target", "linux-x64", "examples/add.graph", "--out", join(outDir, "mismatch.obj")], { allowFailure: true });
|
|
assert.notEqual(mismatchedDirectObjBuild.code, 0);
|
|
assert.equal(mismatchedDirectObjBuild.body.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectObjBuild.body.diagnostics[0].backendBlocker.backend, "zero-coff-x64");
|
|
assert.equal(mismatchedDirectObjBuild.body.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const mismatchedDirectExeBuild = json(["build", "--json", "--emit", "exe", "--backend", "zero-coff-x64", "--target", "linux-musl-x64", "examples/direct-exe-return.graph", "--out", join(outDir, "mismatch-exe")], { allowFailure: true });
|
|
assert.notEqual(mismatchedDirectExeBuild.code, 0);
|
|
assert.equal(mismatchedDirectExeBuild.body.diagnostics[0].actual, "--backend zero-coff-x64");
|
|
assert.equal(mismatchedDirectExeBuild.body.diagnostics[0].expected, "direct emitter zero-elf64 for target linux-musl-x64");
|
|
assert.match(mismatchedDirectExeBuild.body.diagnostics[0].help, /--backend zero-elf64/);
|
|
assert.equal(mismatchedDirectExeBuild.body.diagnostics[0].backendBlocker.stage, "target-selection");
|
|
const backendBlockedReadiness = json(["check", "--json", "--emit", "obj", "--target", "linux-musl-x64", "conformance/agent-surface/fixtures/owned-drop-direct-backend-unsupported.graph"]).body;
|
|
assert.equal(backendBlockedReadiness.ok, true);
|
|
assert.equal(backendBlockedReadiness.diagnostics.length, 0);
|
|
assert.equal(backendBlockedReadiness.targetReadiness.ok, false);
|
|
assert.equal(backendBlockedReadiness.targetReadiness.buildable, false);
|
|
assert.equal(backendBlockedReadiness.targetReadiness.languageOk, true);
|
|
assert.equal(backendBlockedReadiness.targetReadiness.emit, "obj");
|
|
assert.equal(backendBlockedReadiness.targetReadiness.target, "linux-musl-x64");
|
|
assert.equal(backendBlockedReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.deepEqual(backendBlockedReadiness.targetReadiness.diagnostics[0].backendBlocker, {
|
|
target: "linux-musl-x64",
|
|
objectFormat: "elf",
|
|
backend: "zero-elf64",
|
|
stage: "lower",
|
|
unsupportedFeature: "owned<Tracked>",
|
|
});
|
|
const directExeBlockedReadiness = json(["check", "--json", "--emit", "exe", "--target", "linux-musl-x64", "examples/direct-call-add.graph"]).body;
|
|
assert.equal(directExeBlockedReadiness.ok, true);
|
|
assert.equal(directExeBlockedReadiness.diagnostics.length, 0);
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.ok, false);
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.buildable, false);
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.languageOk, true);
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.emit, "exe");
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.target, "linux-musl-x64");
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(directExeBlockedReadiness.targetReadiness.diagnostics[0].backendBlocker.stage, "buildability");
|
|
assert.match(directExeBlockedReadiness.targetReadiness.diagnostics[0].message, /main must not take parameters/);
|
|
const directExeBlockedBuild = json(["build", "--json", "--emit", "exe", "--target", "linux-musl-x64", "examples/direct-call-add.graph", "--out", join(outDir, "direct-call-add-blocked")], { allowFailure: true });
|
|
assert.notEqual(directExeBlockedBuild.code, 0);
|
|
for (const key of ["code", "path", "line", "column", "length", "expected", "actual", "help"]) {
|
|
assert.equal(directExeBlockedBuild.body.diagnostics[0][key], directExeBlockedReadiness.targetReadiness.diagnostics[0][key]);
|
|
}
|
|
assert.equal(directExeBlockedBuild.body.diagnostics[0].backendBlocker.stage, "buildability");
|
|
const directExeBlockedGraph = json(["inspect", "--json", "--emit", "exe", "--target", "linux-musl-x64", "examples/direct-call-add.0"]).body;
|
|
assert.equal(directExeBlockedGraph.targetReadiness.ok, false);
|
|
assert.equal(directExeBlockedGraph.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(directExeBlockedGraph.targetReadiness.diagnostics[0].path, "direct-call-add.0");
|
|
assert.equal(directExeBlockedGraph.targetReadiness.diagnostics[0].actual, "unsupported construct");
|
|
assert.equal(directExeBlockedGraph.targetReadiness.diagnostics[0].backendBlocker.stage, "lower");
|
|
const coffMaybeByteViewFixture = "conformance/native/pass/coff-maybe-byte-view-buildable.graph";
|
|
const coffMaybeByteViewReadiness = json(["check", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffMaybeByteViewFixture]).body;
|
|
assert.equal(coffMaybeByteViewReadiness.ok, true);
|
|
assert.equal(coffMaybeByteViewReadiness.targetReadiness.ok, true);
|
|
assert.equal(coffMaybeByteViewReadiness.targetReadiness.buildable, true);
|
|
assert.equal(coffMaybeByteViewReadiness.targetReadiness.backend, "zero-coff-x64");
|
|
const coffMaybeByteViewBuild = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffMaybeByteViewFixture, "--out", join(outDir, "coff-maybe-byte-view.obj")]).body;
|
|
assert.equal(coffMaybeByteViewBuild.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(coffMaybeByteViewBuild.generatedCBytes, 0);
|
|
const coffDynamicSliceFixture = "conformance/native/pass/coff-dynamic-byte-slice.graph";
|
|
const coffDynamicSliceReadiness = json(["check", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffDynamicSliceFixture]).body;
|
|
assert.equal(coffDynamicSliceReadiness.ok, true);
|
|
assert.equal(coffDynamicSliceReadiness.diagnostics.length, 0);
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.ok, true);
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.buildable, true);
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.languageOk, true);
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.emit, "obj");
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.target, "win32-x64.exe");
|
|
assert.equal(coffDynamicSliceReadiness.targetReadiness.backend, "zero-coff-x64");
|
|
const coffDynamicSlicePath = join(outDir, "coff-dynamic-byte-slice.obj");
|
|
const coffDynamicSliceBuild = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffDynamicSliceFixture, "--out", coffDynamicSlicePath]).body;
|
|
assert.equal(coffDynamicSliceBuild.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(coffDynamicSliceBuild.generatedCBytes, 0);
|
|
const coffDynamicSliceBytes = readFileSync(coffDynamicSlicePath);
|
|
assert.equal(coffDynamicSliceBytes.readUInt16LE(0), 0x8664);
|
|
const coffBoolCopyFixture = "conformance/native/pass/std-mem-bool-copy-items.graph";
|
|
const coffBoolCopyReadiness = json(["check", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffBoolCopyFixture]).body;
|
|
assert.equal(coffBoolCopyReadiness.ok, true);
|
|
assert.equal(coffBoolCopyReadiness.targetReadiness.ok, true);
|
|
assert.equal(coffBoolCopyReadiness.targetReadiness.buildable, true);
|
|
assert.equal(coffBoolCopyReadiness.targetReadiness.backend, "zero-coff-x64");
|
|
const coffBoolCopyPath = join(outDir, "coff-bool-copy-items.obj");
|
|
const coffBoolCopyBuild = json(["build", "--json", "--emit", "obj", "--target", "win32-x64.exe", coffBoolCopyFixture, "--out", coffBoolCopyPath]).body;
|
|
assert.equal(coffBoolCopyBuild.objectBackend.objectEmission.path, "direct-coff-x64-object");
|
|
assert.equal(coffBoolCopyBuild.generatedCBytes, 0);
|
|
const coffBoolCopyBytes = readFileSync(coffBoolCopyPath);
|
|
assert.equal(coffBoolCopyBytes.readUInt16LE(0), 0x8664);
|
|
function assertMachOObjectBuildabilityBlocked(fixture: string, outName: string, expectedMessage: RegExp) {
|
|
const readiness = json(["check", "--json", "--emit", "obj", "--target", "darwin-arm64", fixture]).body;
|
|
assert.equal(readiness.ok, true);
|
|
assert.equal(readiness.diagnostics.length, 0);
|
|
assert.equal(readiness.targetReadiness.ok, false);
|
|
assert.equal(readiness.targetReadiness.buildable, false);
|
|
assert.equal(readiness.targetReadiness.languageOk, true);
|
|
assert.equal(readiness.targetReadiness.emit, "obj");
|
|
assert.equal(readiness.targetReadiness.target, "darwin-arm64");
|
|
assert.equal(readiness.targetReadiness.diagnostics[0].code, "BLD004");
|
|
assert.equal(readiness.targetReadiness.diagnostics[0].backendBlocker.backend, "zero-macho64");
|
|
assert.equal(readiness.targetReadiness.diagnostics[0].backendBlocker.stage, "buildability");
|
|
assert.match(readiness.targetReadiness.diagnostics[0].message, expectedMessage);
|
|
const build = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", fixture, "--out", join(outDir, outName)], { allowFailure: true });
|
|
assert.notEqual(build.code, 0);
|
|
for (const key of ["code", "path", "line", "column", "length", "expected", "actual", "help"]) {
|
|
assert.equal(build.body.diagnostics[0][key], readiness.targetReadiness.diagnostics[0][key]);
|
|
}
|
|
assert.equal(build.body.diagnostics[0].backendBlocker.backend, "zero-macho64");
|
|
assert.equal(build.body.diagnostics[0].backendBlocker.stage, "buildability");
|
|
}
|
|
assertMachOObjectBuildabilityBlocked(
|
|
"conformance/native/pass/macho-large-byte-slice-blocked.graph",
|
|
"macho-large-byte-slice.o",
|
|
/constant start/,
|
|
);
|
|
assertMachOObjectBuildabilityBlocked(
|
|
"conformance/native/pass/macho-nested-call-scratch-blocked.graph",
|
|
"macho-nested-call-scratch.o",
|
|
/scratch spill capacity/,
|
|
);
|
|
const machoOpenByteSliceFixture = "conformance/native/pass/macho-open-byte-slice.graph";
|
|
const machoOpenByteSliceReadiness = json(["check", "--json", "--emit", "obj", "--target", "darwin-arm64", machoOpenByteSliceFixture]).body;
|
|
assert.equal(machoOpenByteSliceReadiness.ok, true);
|
|
assert.equal(machoOpenByteSliceReadiness.diagnostics.length, 0);
|
|
assert.equal(machoOpenByteSliceReadiness.targetReadiness.ok, true);
|
|
assert.equal(machoOpenByteSliceReadiness.targetReadiness.buildable, true);
|
|
assert.equal(machoOpenByteSliceReadiness.targetReadiness.backend, "zero-macho64");
|
|
const machoOpenByteSlicePath = join(outDir, "macho-open-byte-slice.o");
|
|
const machoOpenByteSliceBuild = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", machoOpenByteSliceFixture, "--out", machoOpenByteSlicePath]).body;
|
|
const machoOpenByteSliceBytes = readFileSync(machoOpenByteSlicePath);
|
|
assert.equal(machoOpenByteSliceBuild.compiler, "zero-macho64");
|
|
assert.equal(machoOpenByteSliceBuild.generatedCBytes, 0);
|
|
assert.equal(machoOpenByteSliceBuild.objectBackend.objectEmission.path, "direct-macho64-object");
|
|
assert.equal(machoOpenByteSliceBytes.readUInt32LE(0), 0xfeedfacf);
|
|
const aarch64OpenSliceBoundsFixture = join(outDir, "aarch64-open-byte-slice-bounds.0");
|
|
writeProjectionFile(aarch64OpenSliceBoundsFixture, `export c fn main() -> u32 {
|
|
let words: [2]u16 = [1_u16, 2_u16]
|
|
let suffix: Span<u16> = words[3_usize..]
|
|
return (std.mem.len(suffix)) as u32
|
|
}
|
|
`);
|
|
const aarch64OpenSliceBoundsGraph = importProjectionSidecar(aarch64OpenSliceBoundsFixture);
|
|
const aarch64OpenSliceBoundsPath = join(outDir, "aarch64-open-byte-slice-bounds.o");
|
|
json(["build", "--json", "--emit", "obj", "--target", "linux-arm64", aarch64OpenSliceBoundsGraph, "--out", aarch64OpenSliceBoundsPath]);
|
|
const aarch64OpenSliceBoundsBytes = readFileSync(aarch64OpenSliceBoundsPath);
|
|
assert.equal(aarch64OpenSliceBoundsBytes.readUInt16LE(16), 1);
|
|
assert.equal(aarch64OpenSliceBoundsBytes.readUInt16LE(18), 183);
|
|
assert(hasAarch64CondBranch(aarch64OpenSliceBoundsBytes, 9));
|
|
assert(hasAarch64Instruction(aarch64OpenSliceBoundsBytes, 0xd4200000));
|
|
const machoOpenSliceBoundsPath = join(outDir, "macho-open-byte-slice-bounds.o");
|
|
json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", aarch64OpenSliceBoundsGraph, "--out", machoOpenSliceBoundsPath]);
|
|
const machoOpenSliceBoundsBytes = readFileSync(machoOpenSliceBoundsPath);
|
|
assert.equal(machoOpenSliceBoundsBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert(hasAarch64CondBranch(machoOpenSliceBoundsBytes, 9));
|
|
assert(hasAarch64Instruction(machoOpenSliceBoundsBytes, 0xd4200000));
|
|
const machOMemoryPackageReadiness = json(["check", "--json", "--emit", "obj", "--target", "darwin-arm64", "examples/memory-package"]).body;
|
|
assert.equal(machOMemoryPackageReadiness.ok, true);
|
|
assert.equal(machOMemoryPackageReadiness.diagnostics.length, 0);
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.ok, true);
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.buildable, true);
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.languageOk, true);
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.emit, "obj");
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.target, "darwin-arm64");
|
|
assert.equal(machOMemoryPackageReadiness.targetReadiness.backend, "zero-macho64");
|
|
const machOMemoryPackagePath = join(outDir, "direct-darwin-arm64-memory-package.o");
|
|
rmSync(machOMemoryPackagePath, { force: true });
|
|
const machOMemoryPackageReport = json(["build", "--json", "--emit", "obj", "--target", "darwin-arm64", "examples/memory-package", "--out", machOMemoryPackagePath]).body;
|
|
const machOMemoryPackageBytes = readFileSync(machOMemoryPackagePath);
|
|
assert.equal(machOMemoryPackageReport.compiler, "zero-macho64");
|
|
assert.equal(machOMemoryPackageReport.generatedCBytes, 0);
|
|
assert.equal(machOMemoryPackageReport.objectBackend.objectEmission.path, "direct-macho64-object");
|
|
assert.equal(machOMemoryPackageReport.objectBackend.directFacts.moduleCount, 3);
|
|
assert.equal(machOMemoryPackageReport.objectBackend.directFacts.runtimeHelperCount, 1);
|
|
assert.equal(machOMemoryPackageBytes.readUInt32LE(0), 0xfeedfacf);
|
|
assert(machOMemoryPackageBytes.includes(Buffer.from("memory package ok")));
|
|
|
|
// Package builds must be byte-deterministic: emitting the same package through
|
|
// the store-backed manifest pipeline twice must produce identical object bytes,
|
|
// so toolchain or allocation randomness can never leak into emitted artifacts.
|
|
const crmApiDeterminismPath = join(outDir, "determinism-crm-api.o");
|
|
rmSync(crmApiDeterminismPath, { force: true });
|
|
const crmApiDeterminismReport = json(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/crm-api", "--out", crmApiDeterminismPath]).body;
|
|
assert.equal(crmApiDeterminismReport.generatedCBytes, 0);
|
|
assert.equal(crmApiDeterminismReport.cBridgeFallback ?? false, false);
|
|
repeatBuildHash(["build", "--json", "--emit", "obj", "--target", "linux-musl-x64", "examples/crm-api", "--out", crmApiDeterminismPath], crmApiDeterminismPath, join(outDir, "determinism-crm-api.repeat.o"));
|
|
|
|
const graph = json(["inspect", "--json", "--target", "linux-musl-x64", "examples/memory-package"]).body;
|
|
assert.equal(graph.schemaVersion, 1);
|
|
assert.equal(graph.targetSupport.target, "linux-musl-x64");
|
|
assert.equal(typeof graph.targetSupport.hostTarget, "string");
|
|
assert.equal(graph.targetSupport.fsAvailable, true);
|
|
assert(graph.modules.some((module) => module.name === "main"));
|
|
assert.equal(graph.imports.length, 0);
|
|
assert(graph.importEdges.some((edge) => edge.from === "main" && edge.to === "buffer"));
|
|
assert(graph.functions.some((fun) => fun.name === "main"));
|
|
assert(graph.functions.some((fun) => fun.name === "prepare" && fun.requiresCapabilities.includes("memory")));
|
|
assert(graph.stdlibHelpers.some((helper) => helper.name === "std.mem.copy" && helper.targetSupport === "target-neutral"));
|
|
assert(graph.stdlibHelpers.some((helper) => helper.name === "std.mem.byteBuf" && /explicit allocator/.test(helper.allocationBehavior)));
|
|
assert(graph.stdlibHelpers.some((helper) => helper.name === "std.fs.createOrRaise" && helper.targetSupport === "host"));
|
|
const graphMemCopyHelper = graph.stdlibHelpers.find((helper) => helper.name === "std.mem.copy");
|
|
assert.equal(graphMemCopyHelper.module, "std.mem");
|
|
assert(graphMemCopyHelper.effects.includes("memory"));
|
|
assert.equal(graphMemCopyHelper.errorBehavior, "infallible");
|
|
assert.match(graphMemCopyHelper.ownershipNotes, /caller-owned storage/);
|
|
assert.equal(graphMemCopyHelper.example, "examples/memory-primitives.0");
|
|
assert.equal(graphMemCopyHelper.apiStability, "bootstrap-stable");
|
|
|
|
const agentToolsGraph = json(["inspect", "--json", "examples/std-testing-log.0"]).body;
|
|
const graphTestingHelper = agentToolsGraph.stdlibHelpers.find((helper) => helper.name === "std.testing.equalBytes");
|
|
assert.equal(graphTestingHelper.module, "std.testing");
|
|
assert.equal(graphTestingHelper.targetSupport, "target-neutral");
|
|
assert.equal(graphTestingHelper.errorBehavior, "infallible");
|
|
assert.equal(graphTestingHelper.example, "examples/std-testing-log.0");
|
|
const graphLogHelper = agentToolsGraph.stdlibHelpers.find((helper) => helper.name === "std.log.keyValue");
|
|
assert.equal(graphLogHelper.module, "std.log");
|
|
assert(graphLogHelper.effects.includes("memory"));
|
|
assert.match(graphLogHelper.allocationBehavior, /caller buffer/);
|
|
assert.equal(graphLogHelper.errorBehavior, "returns null on failure");
|
|
assert.match(graphLogHelper.ownershipNotes, /caller-owned storage/);
|
|
assert.equal(graphLogHelper.example, "examples/std-testing-log.0");
|
|
|
|
const stdDataSize = json(["size", "--json", "conformance/native/pass/std-codec-json-url.graph"]).body;
|
|
const sizeUrlHostHelper = stdDataSize.stdlibHelpers.find((helper) => helper.name === "std.url.host");
|
|
assert.equal(sizeUrlHostHelper.module, "std.url");
|
|
assert.equal(sizeUrlHostHelper.example, "conformance/native/pass/std-codec-json-url.0");
|
|
|
|
const agentToolsSize = json(["size", "--json", "examples/std-testing-log.graph"]).body;
|
|
assert(agentToolsSize.usedStdlibHelpers.some((helper) => helper.name === "std.log.keyValue" && helper.module === "std.log"));
|
|
assert(agentToolsSize.usedStdlibHelpers.some((helper) => helper.name === "std.testing.containsBytes" && helper.module === "std.testing"));
|
|
assert(agentToolsSize.usedStdlibHelpers.every((helper) => helper.module && helper.effects && helper.allocationBehavior && helper.targetSupport && helper.errorBehavior && helper.ownershipNotes && helper.example && helper.apiStability));
|
|
|
|
const stdTestingTestJson = json(["test", "--json", "conformance/native/pass/std-testing-helpers-test.graph"]).body;
|
|
assert.equal(stdTestingTestJson.ok, true);
|
|
assert.equal(stdTestingTestJson.passedTests, 1);
|
|
|
|
const crcOnlySource = join(outDir, "std-codec-crc-only.0");
|
|
writeProjectionFile(crcOnlySource, `export c fn main() -> u32 {
|
|
return std.codec.crc32("zero")
|
|
}
|
|
`);
|
|
const crcOnlySourceGraph = importProjectionSidecar(crcOnlySource);
|
|
const crcOnlyGraph = json(["inspect", "--json", crcOnlySource]).body;
|
|
assert(!crcOnlyGraph.sourceFiles.some((path) => path.endsWith("std/codec.0")));
|
|
assert(!crcOnlyGraph.requiresCapabilities.includes("parse"));
|
|
const crcOnlySize = json(["size", "--json", crcOnlySourceGraph]).body;
|
|
assert(!crcOnlySize.incrementalInvalidation.changedInputs.sourceFiles.some((path) => path.endsWith("std/codec.0")));
|
|
assert(!crcOnlySize.retentionReasons.some((item) => item.name === "__zero_std_codec_hex_decode"));
|
|
|
|
const codecReadOnlySource = join(outDir, "std-codec-read-only.0");
|
|
writeProjectionFile(codecReadOnlySource, `export c fn main() -> i32 {
|
|
let value: Maybe<u16> = std.codec.readU16Le("AB")
|
|
if value.has {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
const codecReadOnlySourceGraph = importProjectionSidecar(codecReadOnlySource);
|
|
const codecReadOnlyGraph = json(["inspect", "--json", codecReadOnlySource]).body;
|
|
assert(codecReadOnlyGraph.sourceFiles.some((path) => path.endsWith("std/codec.0")));
|
|
assert(!codecReadOnlyGraph.sourceFiles.some((path) => path.endsWith("std/ascii.0")));
|
|
assert(codecReadOnlyGraph.requiresCapabilities.includes("codec"));
|
|
assert(!codecReadOnlyGraph.requiresCapabilities.includes("parse"));
|
|
const codecReadOnlySize = json(["size", "--json", codecReadOnlySourceGraph]).body;
|
|
assert.equal(codecReadOnlySize.sizeBreakdown.summary.functionCount, 2);
|
|
assert.equal(codecReadOnlySize.sizeBreakdown.summary.stdlibHelperCount, 2);
|
|
assert(codecReadOnlySize.topLargestEmittedHelpers.some((helper) => helper.name === "std.codec.readU16Le"));
|
|
assert(!codecReadOnlySize.retentionReasons.some((item) => item.name === "__zero_std_codec_hex_decode"));
|
|
assert(!codecReadOnlySize.retentionReasons.some((item) => item.name === "std.ascii.hexValue"));
|
|
assert(!codecReadOnlySize.retentionReasons.some((item) => item.name === "std.url.percentEncode"));
|
|
|
|
const jsonStatusOnlySource = join(outDir, "std-json-status-only.0");
|
|
writeProjectionFile(jsonStatusOnlySource, `export c fn main() -> i32 {
|
|
let status: u32 = std.json.errorNone()
|
|
if status == 0_u32 {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
const jsonStatusOnlySourceGraph = importProjectionSidecar(jsonStatusOnlySource);
|
|
const jsonStatusOnlyGraph = json(["inspect", "--json", jsonStatusOnlySource]).body;
|
|
assert(!jsonStatusOnlyGraph.sourceFiles.some((path) => path.endsWith("std/json.0")));
|
|
assert(!jsonStatusOnlyGraph.sourceFiles.some((path) => path.endsWith("std/ascii.0")));
|
|
assert(!jsonStatusOnlyGraph.sourceFiles.some((path) => path.endsWith("std/fmt.0")));
|
|
assert(!jsonStatusOnlyGraph.sourceFiles.some((path) => path.endsWith("std/parse.0")));
|
|
assert(jsonStatusOnlyGraph.callResolution.calls.some((call) => call.kind === "stdlib" && call.calleeName === "std.json.errorNone"));
|
|
const jsonStatusOnlySize = json(["size", "--json", jsonStatusOnlySourceGraph]).body;
|
|
assert.equal(jsonStatusOnlySize.objectBackend.directFacts.functionCount, 1);
|
|
assert(!jsonStatusOnlySize.retentionReasons.some((item) => item.name === "__zero_std_json_validate_error"));
|
|
assert(!jsonStatusOnlySize.retentionReasons.some((item) => item.name === "std.parse.parseU32"));
|
|
|
|
const httpErrorNameOnlySource = join(outDir, "std-http-error-name-only.0");
|
|
writeProjectionFile(httpErrorNameOnlySource, `export c fn main() -> i32 {
|
|
let name: String = std.http.errorName(std.http.errorTimeout())
|
|
if std.mem.len(name) > 0_usize {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
const httpErrorNameOnlyGraphPath = importProjectionSidecar(httpErrorNameOnlySource);
|
|
const httpErrorNameOnlyGraph = json(["inspect", "--json", "--target", "linux-musl-x64", httpErrorNameOnlySource]).body;
|
|
assert.deepEqual(httpErrorNameOnlyGraph.requiresCapabilities, ["memory"]);
|
|
assert.equal(json(["check", "--json", "--target", "linux-musl-x64", httpErrorNameOnlyGraphPath]).body.ok, true);
|
|
|
|
const testingEqualU32OnlySource = join(outDir, "std-testing-equal-u32-only.0");
|
|
writeProjectionFile(testingEqualU32OnlySource, `export c fn main() -> i32 {
|
|
if std.testing.equalU32(42_u32, 42_u32) {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
importProjectionSidecar(testingEqualU32OnlySource);
|
|
const testingEqualU32OnlyGraph = json(["inspect", "--json", testingEqualU32OnlySource]).body;
|
|
assert.deepEqual(testingEqualU32OnlyGraph.requiresCapabilities, []);
|
|
|
|
const logMessageOnlySource = join(outDir, "std-log-message-only.0");
|
|
writeProjectionFile(logMessageOnlySource, `export c fn main() -> i32 {
|
|
var storage: [64]u8 = [0_u8; 64]
|
|
let entry: Maybe<Span<u8>> = std.log.message(storage, "info", "ready")
|
|
if entry.has {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
importProjectionSidecar(logMessageOnlySource);
|
|
const logMessageOnlyGraph = json(["inspect", "--json", logMessageOnlySource]).body;
|
|
assert.deepEqual(logMessageOnlyGraph.requiresCapabilities, ["memory"]);
|
|
|
|
const logMessageFieldSource = join(outDir, "std-log-message-field.0");
|
|
writeProjectionFile(logMessageFieldSource, `export c fn main() -> i32 {
|
|
var storage: [96]u8 = [0_u8; 96]
|
|
let entry: Maybe<Span<u8>> = std.log.messageField(storage, "info", "ready", "\\"event\\":\\"startup\\"")
|
|
if entry.has {
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
`);
|
|
importProjectionSidecar(logMessageFieldSource);
|
|
const logMessageFieldGraph = json(["inspect", "--json", logMessageFieldSource]).body;
|
|
assert.deepEqual(logMessageFieldGraph.requiresCapabilities, ["memory", "parse"]);
|
|
|
|
const httpErrorsGraph = json(["inspect", "--json", "conformance/native/pass/std-http-errors.0"]).body;
|
|
assert.deepEqual(httpErrorsGraph.requiresCapabilities, ["memory"]);
|
|
assert.equal(json(["check", "--json", "--target", "linux-musl-x64", "conformance/native/pass/std-http-errors.graph"]).body.ok, true);
|
|
const httpTimeoutHelper = httpErrorsGraph.stdlibHelpers.find((helper) => helper.name === "std.http.errorTimeout");
|
|
assert.equal(httpTimeoutHelper.returnType, "HttpError");
|
|
assert.equal(httpTimeoutHelper.capability, "none");
|
|
assert.deepEqual(httpTimeoutHelper.effects, []);
|
|
assert.equal(httpTimeoutHelper.allocationBehavior, "no allocation");
|
|
assert.equal(httpTimeoutHelper.ownershipNotes, "no ownership transfer");
|
|
const httpErrorNameHelper = httpErrorsGraph.stdlibHelpers.find((helper) => helper.name === "std.http.errorName");
|
|
assert.equal(httpErrorNameHelper.returnType, "String");
|
|
assert.equal(httpErrorNameHelper.capability, "none");
|
|
assert.equal(httpErrorNameHelper.targetSupport, "target-neutral");
|
|
|
|
const coreGraph = json(["inspect", "--json", "examples/static-method.0"]).body;
|
|
const counterShape = coreGraph.shapes.find((shape) => shape.name === "Counter");
|
|
assert(counterShape);
|
|
assert(counterShape.fields.some((field) => field.name === "value" && field.hasDefault === false));
|
|
assert(counterShape.methods.some((method) => method.name === "add" && method.staticDispatch === true));
|
|
|
|
const interfaceGraph = json(["inspect", "--json", "examples/static-interface.0"]).body;
|
|
assert(interfaceGraph.interfaces.some((item) => item.name === "Readable" && item.staticOnly === true));
|
|
assert(interfaceGraph.functions.some((item) => item.name === "readValue" && item.constraints.some((constraint) => constraint.interface === "Readable<T>")));
|
|
|
|
const staticValueGraph = json(["inspect", "--json", "examples/static-value-params.0"]).body;
|
|
const fixedVecShape = staticValueGraph.shapes.find((shape) => shape.name === "FixedVec");
|
|
assert(fixedVecShape);
|
|
assert(fixedVecShape.staticParams.some((param) => param.name === "N" && param.type === "usize"));
|
|
assert(staticValueGraph.functions.some((fun) => fun.name === "first" && fun.staticParams.some((param) => param.name === "N")));
|
|
|
|
const fixedVecMethodsGraph = json(["inspect", "--json", "examples/fixed-vec.0"]).body;
|
|
const fixedVecMethodsShape = fixedVecMethodsGraph.shapes.find((shape) => shape.name === "FixedVec");
|
|
assert(fixedVecMethodsShape);
|
|
assert(fixedVecMethodsShape.methods.some((method) => method.name === "push" && method.inheritedShapeParams === true && method.shapeStaticParams.some((param) => param.name === "N")));
|
|
assert(fixedVecMethodsShape.methods.some((method) => method.name === "push" && typeof method.doc === "string"));
|
|
assert(fixedVecMethodsShape.fields.some((field) => field.name === "len" && field.hasDefault === true));
|
|
|
|
const aliasGraph = json(["inspect", "--json", "examples/type-alias.0"]).body;
|
|
assert(aliasGraph.aliases.some((alias) => alias.name === "BytePair" && alias.target === "Pair<u8, u8>"));
|
|
|
|
const constGraph = json(["inspect", "--json", "examples/const-arithmetic.0"]).body;
|
|
assert(constGraph.consts.some((item) => item.name === "answer" && item.type === "i32"));
|
|
|
|
const errorGraph = json(["inspect", "--json", "conformance/native/pass/fallibility-error-sets.0"]).body;
|
|
const maybeFail = errorGraph.functions.find((item) => item.name === "maybe_fail");
|
|
assert(maybeFail);
|
|
assert.equal(maybeFail.errorSetKind, "explicit");
|
|
assert(maybeFail.errorNames.includes("BadInput"));
|
|
const inferredGraph = json(["inspect", "--json", "conformance/native/pass/check-maybe-fallibility.0"]).body;
|
|
const inferredPrivate = inferredGraph.functions.find((item) => item.name === "first_or_none");
|
|
assert(inferredPrivate);
|
|
assert.equal(inferredPrivate.errorSetKind, "inferred");
|
|
|
|
const size = json(["size", "--json", "--target", "linux-musl-x64", "examples/memory-package"]).body;
|
|
assert.equal(size.schemaVersion, 1);
|
|
assert(size.stdlibHelpers.some((helper) => helper.name === "std.mem.copy"));
|
|
assert(size.usedStdlibHelpers.some((helper) => helper.name === "std.mem.copy"));
|
|
assert(size.usedStdlibHelpers.every((helper) => helper.module && helper.effects?.length && helper.errorBehavior && helper.ownershipNotes && helper.example && helper.apiStability));
|
|
assert(size.requiresCapabilities.includes("memory"));
|
|
assert.equal(size.generatedCBytes, 0);
|
|
assert.equal(size.cBridgeFallback, false);
|
|
assert(size.loweredIrBytes > 0);
|
|
assert(size.sections.some((section) => section.name === "lowered-ir" && section.bytes === size.loweredIrBytes));
|
|
assert(size.sections.some((section) => section.name === "direct-size-metadata" && section.kind === "metadata"));
|
|
assert(size.topLargestEmittedHelpers.some((helper) => helper.name === "std.mem.copy" && helper.estimatedDirectBytes > 0));
|
|
assert.equal(size.objectBackend.objectEmission.path, "direct-elf64-object");
|
|
assert(size.compilerRuntimeHelpers.every((helper) => helper.payAsUsed === true && helper.emitted === false));
|
|
const sizedArtifact = join(outDir, "sized-memory-package");
|
|
rmSync(sizedArtifact, { force: true });
|
|
rmSync(`${sizedArtifact}.c`, { force: true });
|
|
const sizeWithArtifact = json(["size", "--json", "--out", sizedArtifact, "examples/memory-package"]).body;
|
|
assert.equal(sizeWithArtifact.artifactPath, sizedArtifact);
|
|
assert(sizeWithArtifact.artifactBytes > 0);
|
|
assert(existsSync(sizedArtifact));
|
|
const sizeBlockedParent = join(outDir, "size-output-not-dir");
|
|
const sizeBlockedOut = join(sizeBlockedParent, "report.json");
|
|
rmSync(sizeBlockedParent, { force: true, recursive: true });
|
|
writeFileSync(sizeBlockedParent, "not a directory\n");
|
|
const sizeBlocked = json(["size", "--json", "--out", sizeBlockedOut, "examples/hello.graph"], { allowFailure: true });
|
|
assert.notEqual(sizeBlocked.code, 0);
|
|
assert.equal(sizeBlocked.body.diagnostics[0].path, sizeBlockedOut);
|
|
const explainRepairId = (code: string) => json(["explain", "--json", code]).body.repair.id;
|
|
const explainRepairs = {
|
|
ERR001: explainRepairId("ERR001"),
|
|
ERR003: explainRepairId("ERR003"),
|
|
TYP025: explainRepairId("TYP025"),
|
|
TYP009: explainRepairId("TYP009"),
|
|
FLD002: explainRepairId("FLD002"),
|
|
PUB001: explainRepairId("PUB001"),
|
|
};
|
|
assert.equal(explainRepairs.ERR001, "add-fallible-marker-or-rescue");
|
|
assert.equal(explainRepairs.ERR003, "check-or-rescue-fallible-call");
|
|
assert.equal(explainRepairs.TYP025, "add-explicit-generic-type-arguments");
|
|
assert.equal(explainRepairs.TYP009, "make-binding-mutable");
|
|
assert.equal(explainRepairs.FLD002, "initialize-missing-field");
|
|
assert.equal(explainRepairs.PUB001, "add-public-api-type");
|
|
const generatedCBytesAfterReadOnlyCommands = json(["size", "--json", "examples/memory-package"]).body.generatedCBytes;
|
|
assert.equal(generatedCBytesAfterReadOnlyCommands, generatedCBytesBeforeReadOnlyCommands);
|
|
|
|
const targets = json(["targets"]).body;
|
|
assert.equal(targets.schemaVersion, 1);
|
|
assert.equal(typeof targets.host, "string");
|
|
const publicTargetNames = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-musl-arm64", "linux-musl-x64", "linux-x64", "win32-arm64.exe", "win32-x64.exe"];
|
|
assert.deepEqual([...targets.targets.map((target) => target.name)].sort(), [...publicTargetNames].sort());
|
|
for (const targetName of publicTargetNames) {
|
|
assert(targets.targets.some((target) => target.name === targetName), `${targetName} should be listed`);
|
|
}
|
|
assert(targets.targets.some((target) => target.hosted === true && target.capabilities.includes("fs")));
|
|
assert(targets.targets.some((target) => target.hosted === false && !target.capabilities.includes("fs")));
|
|
const linuxGnuTarget = targets.targets.find((target) => target.name === "linux-x64");
|
|
const linuxMuslTarget = targets.targets.find((target) => target.name === "linux-musl-x64");
|
|
const darwinArm64Target = targets.targets.find((target) => target.name === "darwin-arm64");
|
|
const darwinX64Target = targets.targets.find((target) => target.name === "darwin-x64");
|
|
const winX64Target = targets.targets.find((target) => target.name === "win32-x64.exe");
|
|
const winArm64Target = targets.targets.find((target) => target.name === "win32-arm64.exe");
|
|
const linuxArm64Target = targets.targets.find((target) => target.name === "linux-arm64");
|
|
const hostTarget = targets.targets.find((target) => target.name === targets.host);
|
|
assert(hostTarget);
|
|
for (const target of targets.targets) {
|
|
assert.deepEqual(target.backendFamilies.known, ["direct", "llvm"]);
|
|
assert.equal(target.backendFamilies.fallbackPolicy, "none");
|
|
assert(target.backendFamilies.llvm.emit.includes("llvm-ir"));
|
|
assert(["ready", "tool-missing", "unsupported-target"].includes(target.backendFamilies.llvm.status));
|
|
assert.equal(target.backendFamilies.llvm.backendLifecycle.stability, "experimental");
|
|
assert.equal(target.backendFamilies.llvm.backendLifecycle.defaultEligible, false);
|
|
assert.equal(target.backendFamilies.llvm.backendLifecycle.releaseEligible, false);
|
|
}
|
|
assert.equal(hostTarget.backendFamilies.llvm.status, doctor.llvmToolchain.status);
|
|
assert.equal(hostTarget.backendFamilies.llvm.buildable, doctor.llvmToolchain.nativeExecutable);
|
|
if (doctor.llvmToolchain.nativeExecutable) assert(hostTarget.backendFamilies.llvm.emit.includes("exe"));
|
|
assert.equal(winX64Target.backendFamilies.llvm.emit.includes("exe"), false);
|
|
assert.equal(winArm64Target.backendFamilies.llvm.emit.includes("exe"), false);
|
|
assert.equal(linuxMuslTarget.directBackend.exeSupported, true);
|
|
assert.equal(linuxMuslTarget.directBackend.exeEmitter, "zero-elf64-exe");
|
|
assert.equal(linuxGnuTarget.directBackend.objectEmitter, "zero-elf64");
|
|
assert.equal(linuxGnuTarget.directBackend.exeSupported, true);
|
|
assert.equal(linuxGnuTarget.directBackend.exeEmitter, "zero-elf64-exe");
|
|
assert.equal(darwinArm64Target.directBackend.objectEmitter, "zero-macho64");
|
|
assert.equal(darwinArm64Target.directBackend.exeSupported, true);
|
|
assert.equal(darwinArm64Target.directBackend.exeEmitter, "zero-macho64-exe");
|
|
assert.equal(darwinX64Target.directBackend.objectEmitter, "zero-macho-x64");
|
|
assert.equal(darwinX64Target.directBackend.exeSupported, true);
|
|
assert.equal(darwinX64Target.directBackend.exeEmitter, "zero-macho-x64-exe");
|
|
assert.equal(winX64Target.directBackend.objectEmitter, "zero-coff-x64");
|
|
assert.equal(winX64Target.directBackend.objectSupported, true);
|
|
assert.equal(winX64Target.directBackend.exeSupported, true);
|
|
assert.equal(winX64Target.directBackend.exeEmitter, "zero-coff-x64-exe");
|
|
assert.equal(winArm64Target.directBackend.status, "native-exe");
|
|
assert.equal(winArm64Target.directBackend.objectEmitter, "zero-coff-aarch64");
|
|
assert.equal(winArm64Target.directBackend.exeEmitter, "zero-coff-aarch64-exe");
|
|
assert.match(winArm64Target.directBackend.reason, /direct object and executable backend available/);
|
|
assert.equal(linuxArm64Target.directBackend.status, "native-exe");
|
|
assert.equal(linuxArm64Target.directBackend.objectEmitter, "zero-elf-aarch64");
|
|
assert.equal(linuxArm64Target.directBackend.exeEmitter, "zero-elf-aarch64-exe");
|
|
assert.match(linuxArm64Target.directBackend.reason, /direct object and executable backend available/);
|
|
const cAbiExport = zero(["check", "conformance/native/pass/c-abi-export.graph"]);
|
|
assert.match(cAbiExport.stdout, /ok/);
|
|
const cAbiDump = json(["abi", "dump", "--json", "conformance/native/pass/c-abi-export.graph"]).body;
|
|
assert(cAbiDump.cExports.some((item) => item.name === "zero_add" && item.cReturnType === "int32_t"));
|
|
assert.match(cAbiDump.generatedHeader.text, /int32_t zero_add\(int32_t a, int32_t b\);/);
|
|
const report = {
|
|
generatedAt: new Date().toISOString(),
|
|
productShell: {
|
|
version: version.version,
|
|
host: version.host,
|
|
backend: version.backend,
|
|
doctorStatus: doctor.status,
|
|
cleanRemovedOut: !existsSync(cleanProbe),
|
|
},
|
|
diagnostics: {
|
|
explainRepairs,
|
|
},
|
|
graph: {
|
|
target: graph.targetSupport.target,
|
|
requiresCapabilities: graph.requiresCapabilities,
|
|
stdlibHelperCount: graph.stdlibHelpers.length,
|
|
coreMethodCount: counterShape.methods.length,
|
|
interfaceCount: interfaceGraph.interfaces.length,
|
|
aliasCount: aliasGraph.aliases.length,
|
|
constCount: constGraph.consts.length,
|
|
errorFunction: maybeFail.errorNames,
|
|
},
|
|
size: {
|
|
generatedCBytes: size.generatedCBytes,
|
|
stdlibHelperCount: size.stdlibHelpers.length,
|
|
usedStdlibHelperCount: size.usedStdlibHelpers.length,
|
|
artifactBytes: sizeWithArtifact.artifactBytes,
|
|
unchangedByReadOnlyCommands: generatedCBytesAfterReadOnlyCommands === generatedCBytesBeforeReadOnlyCommands,
|
|
},
|
|
noCDefaultRouteSentinels: {
|
|
defaultNoC: [
|
|
{
|
|
id: "direct-linux-exe",
|
|
generatedCBytes: directExeReport.generatedCBytes,
|
|
cBridgeFallback: directExeReport.selfHostRouting?.cBridge?.required ?? false,
|
|
objectEmissionPath: directExeReport.objectBackend.objectEmission.path,
|
|
},
|
|
],
|
|
knownDefaultCGap: {
|
|
id: "hello-linux-default",
|
|
generatedCBytes: buildReport.generatedCBytes,
|
|
cBridgeFallback: buildReport.selfHostRouting?.cBridge?.required ?? false,
|
|
objectEmissionPath: buildReport.objectBackend.objectEmission.path,
|
|
},
|
|
removedGeneratedC: {
|
|
emitCDiagnostic: removedEmitC.body.diagnostics[0].code,
|
|
legacyFlagDiagnostic: removedLegacyFlag.body.diagnostics[0].code,
|
|
repair: removedEmitC.body.diagnostics[0].repair.id,
|
|
},
|
|
directLinkedExecutables: {
|
|
darwin: {
|
|
compiler: directMachOExeReport.compiler,
|
|
generatedCBytes: directMachOExeReport.generatedCBytes,
|
|
objectEmissionPath: directMachOExeReport.objectBackend.objectEmission.path,
|
|
},
|
|
windows: {
|
|
compiler: directCoffExeReport.compiler,
|
|
generatedCBytes: directCoffExeReport.generatedCBytes,
|
|
objectEmissionPath: directCoffExeReport.objectBackend.objectEmission.path,
|
|
},
|
|
},
|
|
},
|
|
targets: {
|
|
host: targets.host,
|
|
count: targets.targets.length,
|
|
},
|
|
generatedCAudit: null,
|
|
};
|
|
|
|
writeFileSync(join(outDir, "summary.json"), `${JSON.stringify(report, null, 2)}\n`);
|
|
finishAggregateAssert(assert, { suite: "command contract snapshots", reportPath: join(outDir, "failures.json") });
|
|
console.log("command contract snapshots ok");
|