gnbuild 0.1.0__py3-none-any.whl

gnbuild/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

gnbuild/build/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

gnbuild/build/cmake.py

@@ -0,0 +1,562 @@
+from __future__ import annotations
+
+import fnmatch
+import hashlib
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Sequence, Tuple
+
+from gnbuild.build import compdb
+from gnbuild.util import LAUNCHER, GnbError, find_tool, ninja_escape, ninja_paths, ninja_unescape, run, write_if_changed
+
+# Compiler, source location or fetched content changes require a clean CMake cache.
+IDENTITY_KEYS = ("cc", "cxx", "ar", "triple", "system", "sysroot", "clang_target", "source_dir", "pkg_source_dir", "source_identity")
+LANGS = (("C", "cflags_c"), ("CXX", "cflags_cc"), ("ASM", "asmflags"))
+# Compilers and target metadata come from toolchain descriptors; flags and launchers come from the profile.
+FORBIDDEN_OPTION_PATTERNS = ("CMAKE_*_FLAGS*", "CMAKE_*_COMPILER*", "CMAKE_AR", "CMAKE_BUILD_TYPE",
+                             "CMAKE_TOOLCHAIN_FILE", "CMAKE_SYSTEM_*", "CMAKE_SYSROOT*", "CMAKE_*_LAUNCHER")
+LIBRARY_KINDS = ("STATIC_LIBRARY", "SHARED_LIBRARY")
+
+# CMake evaluates the public interface after all subdirectories and target relationships exist.
+INTERFACE_HOOK = r'''function(gnb_export_interfaces directory)
+  if(directory STREQUAL CMAKE_SOURCE_DIR)
+    get_property(languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+    file(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/gnb_interfaces/languages.txt" CONTENT "${languages}")
+  endif()
+  get_property(targets DIRECTORY "${directory}" PROPERTY BUILDSYSTEM_TARGETS)
+  foreach(target IN LISTS targets)
+    get_target_property(kind "${target}" TYPE)
+    if(kind STREQUAL "STATIC_LIBRARY" OR kind STREQUAL "SHARED_LIBRARY")
+      string(SHA256 key "${target}")
+      foreach(property IN ITEMS INTERFACE_INCLUDE_DIRECTORIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES)
+        file(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/gnb_interfaces/${key}/${property}-$<COMPILE_LANGUAGE>.txt"
+          CONTENT "$<JOIN:$<TARGET_PROPERTY:${target},${property}>,\n>" TARGET "${target}")
+      endforeach()
+    endif()
+  endforeach()
+  get_property(children DIRECTORY "${directory}" PROPERTY SUBDIRECTORIES)
+  foreach(child IN LISTS children)
+    gnb_export_interfaces("${child}")
+  endforeach()
+endfunction()
+get_property(scheduled GLOBAL PROPERTY gnb_interfaces_scheduled)
+if(NOT scheduled)
+  set_property(GLOBAL PROPERTY gnb_interfaces_scheduled TRUE)
+  cmake_language(DEFER DIRECTORY "${CMAKE_SOURCE_DIR}" CALL gnb_export_interfaces "${CMAKE_SOURCE_DIR}")
+endif()
+'''
+
+
+def check_options(options: Dict[str, Any]) -> None:
+    for key in options:
+        if any(fnmatch.fnmatchcase(key, pat) for pat in FORBIDDEN_OPTION_PATTERNS):
+            raise GnbError(f"package option {key} sets build intent; put flags in profile cflags or ldflags, "
+                           "and compiler/target/sysroot fields in the toolchain descriptor instead")
+
+
+def check_build_dir(path: Path) -> None:
+    # shortcut: quoted CMake build paths are unsupported; revisit after verifying a fixed stock release.
+    if '"' in str(path):
+        raise GnbError(f"CMake build directory contains a double quote: {path}; "
+                       "use an output directory and profile name without double quotes")
+
+
+def dep_var_name(name: str) -> str:
+    # GNB_DEP_<NAME>_* for a dependency package: uppercase, every non-alphanumeric character replaced by _
+    return re.sub(r"[^A-Za-z0-9]", "_", name).upper()
+
+
+def toolchain_file_text(pkg: dict) -> str:
+    lines = [f'set(CMAKE_C_COMPILER "{pkg["cc"]}")',
+             f'set(CMAKE_CXX_COMPILER "{pkg["cxx"]}")',
+             f'set(CMAKE_ASM_COMPILER "{pkg["cc"]}")',
+             f'set(CMAKE_AR "{pkg["ar"]}")']
+    if pkg["system"] == "Emscripten":
+        sdk = Path(find_tool(pkg["cc"])).resolve().parent / "cmake/Modules/Platform/Emscripten.cmake"
+        if not sdk.is_file():
+            raise GnbError(f"Emscripten SDK toolchain file missing: {sdk}; install a complete SDK and add emcc to PATH")
+        sdk_path = sdk.as_posix().replace('"', '\\"')
+        lines.insert(0, f'include("{sdk_path}")')
+    if pkg["system"]:
+        lines.append(f'set(CMAKE_SYSTEM_NAME {pkg["system"]})')
+    if pkg["clang_target"]:
+        lines += [f'set(CMAKE_{lang}_COMPILER_TARGET {pkg["clang_target"]})' for lang, _ in LANGS]
+    if pkg["sysroot"]:
+        lines.append(f'set(CMAKE_SYSROOT "{pkg["sysroot"]}")')
+    if pkg["system"] == "Generic":
+        # try_compile cannot link in a bare-metal environment
+        lines.append("set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)")
+    return "\n".join(lines) + "\n"
+
+
+def _read_interface(out: Path, build_dir: Path, name: str) -> dict:
+    directory = build_dir / "gnb_interfaces"
+    key = hashlib.sha256(name.encode()).hexdigest()
+    variants = {}
+    try:
+        for language in (directory / "languages.txt").read_text().split(";"):
+            paths = (directory / key / f"INTERFACE_INCLUDE_DIRECTORIES-{language}.txt").read_text().splitlines()
+            system = set((directory / key / f"INTERFACE_SYSTEM_INCLUDE_DIRECTORIES-{language}.txt").read_text().splitlines())
+            variants[language] = {
+                "include_dirs": list(dict.fromkeys(p for p in paths if p not in system)),
+                "system_include_dirs": list(dict.fromkeys(p for p in paths if p in system)),
+            }
+    except OSError as e:
+        raise GnbError(f"CMake target {name} did not export its public headers; reconfigure {build_dir}: {e}") from e
+    first = next(iter(variants.values()))
+    uniform = all(value == first for value in variants.values())
+    common = {field: [p for p in paths if all(p in value[field] for value in variants.values())]
+              for field, paths in first.items()}
+    exported = {}
+    for field in first:
+        exported[field] = (first[field] if uniform else
+            [f"$<$<COMPILE_LANGUAGE:{language}>:{p}>" for language, value in variants.items() for p in value[field]] +
+            [f"$<$<NOT:$<COMPILE_LANGUAGE:{','.join(variants)}>>:{p}>" for p in common[field]])
+    for language, field in LANGS:
+        value = variants.get(language, first if uniform else common)
+        exported[f"include_{field}"] = ([f"-I{Path(os.path.relpath(p, out)).as_posix()}" for p in value["include_dirs"]] +
+                                       [f"-isystem{Path(os.path.relpath(p, out)).as_posix()}" for p in value["system_include_dirs"]])
+    return exported
+
+
+def read_exports(out: Path, build_dir: Path) -> dict:
+    """Read CMake's codemodel-v2 reply, retaining native names and actual artifacts."""
+    reply = build_dir / ".cmake/api/v1/reply"
+    indexes = sorted(reply.glob("index-*.json"))
+    if not indexes:
+        raise GnbError(f"CMake did not publish a File API reply for {build_dir}")
+    index = json.loads(indexes[-1].read_text())
+    response = index.get("reply", {}).get("codemodel-v2", {})
+    if "jsonFile" not in response:
+        raise GnbError(f"CMake codemodel-v2 reply unavailable for {build_dir}: {response}")
+    model = json.loads((reply / response["jsonFile"]).read_text())
+    version = model.get("version", {})
+    if version.get("major") != 2 or version.get("minor", 0) < 9:
+        raise GnbError(f"CMake codemodel 2.9 or newer (CMake 4.2+) is required for {build_dir}")
+    configurations = model.get("configurations", [])
+    if len(configurations) != 1:
+        raise GnbError(f"expected one Ninja CMake configuration for {build_dir}")
+    records = configurations[0]["targets"]
+    native = {record["id"]: json.loads((reply / record["jsonFile"]).read_text())
+              for record in [*records, *configurations[0].get("abstractTargets", [])]}
+    artifacts, system_libs, link_flags, links = {}, {}, {}, {}
+    for identity, target in native.items():
+        kind = target["type"]
+        paths = []
+        if kind in LIBRARY_KINDS:
+            for artifact in target.get("artifacts", []):
+                path = Path(artifact["path"])
+                if not path.is_absolute():
+                    path = build_dir / path
+                if kind == "SHARED_LIBRARY" and path.suffix.lower() == ".dll":
+                    raise GnbError(f"CMake native target {target['name']} exports a DLL runtime artifact; "
+                                   "DLL/import-library selection is unsupported")
+                paths.append(Path(os.path.relpath(path, out)).as_posix())
+            if not paths and not target.get("imported"):
+                raise GnbError(f"CMake native library target {target['name']} has no File API artifacts")
+        artifacts[identity], system_libs[identity], link_flags[identity] = paths, [], []
+        links[identity] = []
+
+    for identity, target in native.items():
+        items = list(target.get("interfaceLinkLibraries", []))
+        if target["type"] == "STATIC_LIBRARY":
+            items = [*target.get("linkLibraries", []), *items]
+        for item in items:
+            if "id" in item:
+                child = item["id"]
+                if child not in native:
+                    raise GnbError(f"CMake native target {target['name']} links unknown native target {child}")
+            else:
+                fragment = item["fragment"]
+                if fragment.startswith("-"):
+                    child = ("flag", fragment)
+                    link_flags[child] = [fragment]
+                    artifacts[child], system_libs[child] = [], []
+                elif Path(fragment).is_absolute():
+                    path = Path(os.path.relpath(fragment, out)).as_posix()
+                    child = ("path", path)
+                    artifacts[child] = [path]
+                    system_libs[child], link_flags[child] = [], []
+                else:
+                    if (not fragment or "$<" in fragment or fragment.startswith("<")
+                            or "/" in fragment or "\\" in fragment or any(c.isspace() for c in fragment)):
+                        raise GnbError(f"CMake native target {target['name']} has unsupported link fragment {fragment!r}")
+                    child = ("library", fragment)
+                    system_libs[child] = [fragment]
+                    artifacts[child], link_flags[child] = [], []
+                links[child] = []
+            if child not in links[identity]:
+                links[identity].append(child)
+
+    targets = []
+    for record in records:
+        identity = record["id"]
+        target = native[identity]
+        exported = {"name": target["name"], "kind": target["type"], "paths": [],
+                    "rescan": False, "system_libs": [], "link_flags": []}
+        if target["type"] in LIBRARY_KINDS and not target.get("imported"):
+            exported.update(_read_interface(out, build_dir, target["name"]))
+            seen, active, order = set(), set(), []
+
+            def visit(identity):
+                if identity in active:
+                    exported["rescan"] = True
+                if identity in seen:
+                    return
+                seen.add(identity)
+                active.add(identity)
+                for child in reversed(links[identity]):
+                    visit(child)
+                active.remove(identity)
+                order.append(identity)
+
+            # Consumers precede providers; cycles are rescanned as one complete link group.
+            visit(identity)
+            for member in reversed(order):
+                dependency = native.get(member)
+                if dependency and dependency["type"] in LIBRARY_KINDS and not artifacts[member]:
+                    raise GnbError(f"CMake linked target {dependency['name']} has no File API artifacts; "
+                                   "imported library artifact selection is unsupported")
+                if dependency and dependency["type"] not in (*LIBRARY_KINDS, "INTERFACE_LIBRARY", "OBJECT_LIBRARY"):
+                    raise GnbError(f"CMake linked target {dependency['name']} ({dependency['type']}) is unsupported")
+                exported["paths"].extend(artifacts[member])
+                exported["system_libs"].extend(system_libs[member])
+                exported["link_flags"].extend(link_flags[member])
+            for field in ("paths", "system_libs", "link_flags"):
+                exported[field] = list(dict.fromkeys(reversed(exported[field])))[::-1]
+        targets.append(exported)
+    return {"index": indexes[-1].name, "ready": True,
+            "targets": sorted(targets, key=lambda target: target["name"])}
+
+
+def publish_exports(path: Path, model: dict) -> None:
+    text = json.dumps(model, sort_keys=True)
+    if path.is_file() and path.read_text() == text:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, temporary = tempfile.mkstemp(prefix=".gnb_exports-", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w") as stream:
+            stream.write(text)
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+
+
+def ensure_exports(path: Path) -> None:
+    # GN must validate selections against the current native configuration, not a stale target list.
+    if path.is_file():
+        model = json.loads(path.read_text())
+        if not model["ready"]:
+            return
+        bdir = path.parent
+        out = bdir.parents[2]
+        manifest = bdir / "gnb_package.json"
+        indexes = sorted((bdir / ".cmake/api/v1/reply").glob("index-*.json"))
+        inputs_file = bdir / "gnb_inputs.txt"
+        if manifest.is_file() and indexes and inputs_file.is_file():
+            pkg = json.loads(manifest.read_text())
+            if (model.get("index") == indexes[-1].name and "profile_file" in pkg
+                    and "toolchain_file" in pkg):
+                configured = indexes[-1].stat().st_mtime_ns
+                inputs = [Path(name) for name in inputs_file.read_text().splitlines()]
+                inputs += [Path(__file__).resolve(), manifest, Path(pkg["profile_file"]),
+                           Path(pkg["toolchain_file"]), out / "args.gn",
+                           out / "gnb_pkgs" / bdir.name / "BUILD.gn",
+                           out / "gnb_pkgs" / bdir.name / "options.json", bdir / "gnb_gn_libs.json"]
+                if all(item.exists() and item.stat().st_mtime_ns <= configured for item in inputs):
+                    return
+    publish_exports(path, {"ready": False, "targets": []})
+
+
+def selected_targets(model: dict, names: list, package: str) -> list:
+    if not model.get("ready"):
+        raise GnbError(f"CMake exports for dependency {package} are not ready")
+    targets = {target["name"]: target for target in model["targets"]}
+    selected = []
+    for name in names:
+        target = targets.get(name)
+        if target is None or target["kind"] not in LIBRARY_KINDS:
+            available = ", ".join(f"{t['name']} ({t['kind']})" for t in model["targets"])
+            actual = f" ({target['kind']})" if target else ""
+            raise GnbError(f"CMake dependency {package} native target {name}{actual} is not a linkable library; "
+                           f"available targets: {available}")
+        selected.append(target)
+    return selected
+
+
+def normalize_artifact_nodes(text: str, out: Path, model: dict, dependencies: Sequence[str] = ()) -> str:
+    # Ninja distinguishes absolute and relative nodes even when they name the same native artifact.
+    artifacts = [path for target in model["targets"] for path in target["paths"]]
+    paths = {os.path.abspath(out / path): path for path in [*artifacts, *dependencies]}
+
+    def replace(token: re.Match) -> str:
+        original = token.group(0)
+        relative = paths.get(ninja_unescape(original))
+        return ninja_escape(relative) if relative is not None else original
+
+    lines = []
+    for line in text.split("\n"):
+        if line.startswith("build "):
+            outputs, separator, inputs = line[6:].partition(": ")
+            outputs = re.sub(r"(?:\$[ $:]|[^ ])+", replace, outputs)
+            inputs = re.sub(r"(?:\$[ $:]|[^ ])+", replace, inputs)
+            line = "build " + outputs + separator + inputs
+        lines.append(line)
+    return "\n".join(lines)
+
+
+def fix_package_ninja(text: str, prefix: str, dep_libs: List[str], config_inputs: Sequence[str] = ()) -> Tuple[str, List[str]]:
+    # CMake does not prefix the output of this phony target, so it would collide across packages/instances
+    text = re.sub(r"(?<![\w/])cmake_object_order_depends_target_",
+                  prefix + "/cmake_object_order_depends_target_", text)
+    order_edge = f"build {prefix}/cmake_object_order_depends_target_"
+    pkg_json = f"{prefix}/gnb_package.json"
+    # Configuration inputs: a change to either reconfigures this package exactly once
+    pkg_inputs = " ".join(ninja_escape(p) for p in [pkg_json, f"{prefix}/gnb_gn_libs.json", *config_inputs])
+    keep, inputs = [], []
+    rerun = False
+    for ln in text.split("\n"):
+        if ln.startswith("build "):
+            rerun = ln.startswith(f"build {prefix}/build.ninja ") and ": RERUN_CMAKE" in ln
+        if rerun and ln.startswith("  pool = "):
+            ln = "  pool = gnb_cmake_configure_pool"
+        if ln.startswith("default "):
+            continue  # CMake's default would build every package library; only gn-selected libraries get built
+        if ln.startswith("build /") and ln.endswith(": phony"):
+            # Absolute paths (CMake modules, sources) are shared by all packages; move them to the merged file to dedupe; prefixed in-package files stay put
+            paths = ninja_paths(ln[len("build "):-len(": phony")])
+            inputs += [p for p in paths if p.startswith("/")]
+            local = [p for p in paths if not p.startswith("/")]
+            if local:
+                keep.append("build " + " ".join(ninja_escape(p) for p in local) + ": phony")
+            continue
+        if ln.startswith(f"build {prefix}/build.ninja ") and ": RERUN_CMAKE |" in ln and pkg_json not in ln:
+            ln = ln.replace(": RERUN_CMAKE |", f": RERUN_CMAKE | {pkg_inputs}", 1)
+        if dep_libs and ln.startswith(order_edge):
+            # Every compile of this package waits for the dependency packages' libraries (and headers they generate)
+            main, _, order = ln.partition(" || ")
+            have = order.split()
+            ln = f"{main} || " + " ".join(have + [ninja_escape(lib) for lib in dep_libs if ninja_escape(lib) not in have])
+        keep.append(ln)
+    return "\n".join(keep), inputs
+
+
+def fix_link_depfile(out: Path, prefix: str, depfile: Path) -> None:
+    bdir = out / prefix
+    model = json.loads((bdir / "gnb_exports.json").read_text())
+    paths = [path for target in model["targets"] for path in target["paths"]]
+    pkg = json.loads((bdir / "gnb_package.json").read_text())
+    gn_exports = json.loads((bdir / "gnb_gn_libs.json").read_text())
+    for dep in pkg["deps"]:
+        paths += [path for label in dep["gn_libs"] for path in gn_exports[label]["paths"]]
+        if dep["cmake_prefix"]:
+            child = json.loads((out / dep["cmake_prefix"] / "gnb_exports.json").read_text())
+            paths += [path for target in selected_targets(child, dep["targets"], dep["name"]) for path in target["paths"]]
+
+    def escape(path: str) -> str:
+        return path.replace("\\", "\\\\").replace("$", "$$").replace("#", "\\#").replace(" ", "\\ ").replace(":", "\\:")
+
+    replacements = {}
+    for path in paths:
+        for spelling in (path, os.path.abspath(out / path)):
+            replacements[spelling] = replacements[escape(spelling)] = escape(path)
+    if replacements:
+        # GNU ld leaves spaces unescaped; keep known artifacts as single, out-relative Ninja dependencies.
+        pattern = r"(?<!\S)(?:" + "|".join(re.escape(key) for key in sorted(replacements, key=len, reverse=True)) + r")(?=\s|:|$)"
+        text = re.sub(pattern, lambda match: replacements[match[0]], depfile.read_text())
+        write_if_changed(depfile, text)
+
+
+def fix_rules_ninja(text: str, configure_cmd: str, depfile_cmd: str) -> str:
+    def replace(rule: re.Match) -> str:
+        lines = [ln for ln in rule.group(0).splitlines() if not ln.startswith("  pool = ")]
+        lines[1] = "  command = " + configure_cmd
+        lines.append("  pool = gnb_cmake_configure_pool")
+        return "\n".join(lines) + "\n"
+
+    text = re.sub(r"(?m)^rule RERUN_CMAKE\n(?:  [^\n]*(?:\n|$))*", replace, text)
+
+    def fix_link(rule: re.Match) -> str:
+        lines = rule[0].splitlines()
+        if "  depfile = $DEP_FILE" in lines:
+            for index, line in enumerate(lines):
+                if line.startswith("  command = ") and not line.endswith(" && " + depfile_cmd):
+                    lines[index] = line + " && " + depfile_cmd
+        return "\n".join(lines) + "\n"
+
+    return re.sub(r"(?m)^rule \S*LINKER\S*\n(?:  [^\n]*(?:\n|$))*", fix_link, text)
+
+
+def configure_cmd(out: Path, prefix: str) -> str:
+    return shlex.join([sys.executable, str(LAUNCHER), "_cmake_configure", str(out), prefix]).replace("$", "$$")
+
+
+def depfile_cmd(out: Path, prefix: str) -> str:
+    command = shlex.join([sys.executable, str(LAUNCHER), "_cmake_depfile", str(out), prefix]).replace("$", "$$")
+    return command + ' "$DEP_FILE"'
+
+
+def stub_text(out: Path, prefix: str) -> str:
+    pkg = json.loads((out / prefix / "gnb_package.json").read_text())
+    inputs = [f"{prefix}/gnb_package.json", f"{prefix}/gnb_gn_libs.json"]
+    inputs += [f"{dep['cmake_prefix']}/build.ninja" for dep in pkg["deps"] if dep["cmake_prefix"]]
+    inputs += [f"{header['cmake_prefix']}/build.ninja" for dep in pkg["deps"] for header in dep["header_deps"]]
+    return (
+        "rule gnb_cmake_configure\n"
+        f"  command = {configure_cmd(out, prefix)}\n"
+        f"  description = CMAKE CONFIGURE {prefix}\n"
+        "  generator = 1\n"
+        "  pool = gnb_cmake_configure_pool\n"
+        f"build {prefix}/build.ninja: gnb_cmake_configure | " + " ".join(ninja_escape(p) for p in inputs) + "\n"
+    )
+
+
+def write_stub(out: Path, prefix: str) -> None:
+    sub = out / prefix / "build.ninja"
+    write_if_changed(sub, stub_text(out, prefix))
+    os.utime(sub, (0, 0))  # make ninja consider it stale so configuration runs when the dependency graph loads
+
+
+def write_inputs(out: Path, prefixes: List[str]) -> None:
+    inputs = set()
+    for prefix in prefixes:
+        f = out / prefix / "gnb_inputs.txt"
+        if f.is_file():
+            inputs.update(f.read_text().splitlines())
+    write_if_changed(out / "gnb_cmake_inputs.ninja",
+                     "build " + " ".join(ninja_escape(p) for p in sorted(inputs)) + ": phony\n" if inputs else "")
+
+
+def configure(out: Path, prefix: str) -> None:
+    out = out.absolute()
+    bdir = out / prefix
+    check_build_dir(bdir)
+    pkg = json.loads((bdir / "gnb_package.json").read_text())
+    check_options(pkg["options"])
+    cmake_tool = find_tool("cmake")
+    version = subprocess.run([cmake_tool, "--version"], text=True, capture_output=True)
+    match = re.search(r"^cmake version (\d+)\.(\d+)", version.stdout)
+    if version.returncode != 0 or not match or tuple(map(int, match.groups())) < (4, 2):
+        raise GnbError("native CMake package exports require CMake >= 4.2; install it and add it to PATH")
+
+    if pkg["system"] == "Emscripten":
+        pkg = dict(pkg)
+        for key in ("cc", "cxx", "ar"):
+            pkg[key] = os.path.abspath(find_tool(pkg[key]))
+    toolchain_text = toolchain_file_text(pkg)  # Validate the SDK before clearing an existing cache.
+    identity_fields = {k: pkg[k] for k in IDENTITY_KEYS}
+    if pkg["system"] == "Emscripten":
+        identity_fields["emscripten_compilers"] = {key: str(Path(pkg[key]).resolve()) for key in ("cc", "cxx", "ar")}
+    identity = json.dumps(identity_fields, sort_keys=True)
+    id_file = bdir / "gnb_identity.json"
+    if (bdir / "CMakeCache.txt").is_file() and (not id_file.is_file() or id_file.read_text() != identity):
+        print(f"gnb: toolchain or source changed, clearing {prefix}", flush=True)
+        for e in bdir.iterdir():
+            if e.name in ("gnb_package.json", "gnb_gn_libs.json", "gnb_exports.json"):
+                continue
+            if e.is_dir() and not e.is_symlink():
+                shutil.rmtree(e)
+            else:
+                e.unlink()
+
+    tc = bdir / "gnb_toolchain.cmake"
+    write_if_changed(tc, toolchain_text)
+    query = bdir / ".cmake/api/v1/query/codemodel-v2"
+    write_if_changed(query, "")
+    hook = bdir / "gnb_interfaces.cmake"
+    write_if_changed(hook, INTERFACE_HOOK)
+
+    cmd = [cmake_tool, "-G", "Ninja", "-S", pkg["source_dir"], "-B", str(bdir),
+           f"-DCMAKE_NINJA_OUTPUT_PATH_PREFIX={prefix}/",
+           f"-DCMAKE_TOOLCHAIN_FILE={tc}",
+           "-DCMAKE_BUILD_TYPE="]
+    cmd += [f"-DCMAKE_{lang}_FLAGS={shlex.join(pkg[key])}" for lang, key in LANGS]
+    cmd.append(f"-DCMAKE_EXE_LINKER_FLAGS={shlex.join(pkg['ldflags'])}")
+    cmd += [f"-DCMAKE_{lang}_COMPILER_LAUNCHER={pkg['launcher']}" for lang, _ in LANGS]
+    cmd.append("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON")
+    if pkg["pkg_source_dir"]:
+        cmd.append(f"-DGNB_PKG_SOURCE_DIR={pkg['pkg_source_dir']}")
+    # Option keys and GNB_DEP_* variables possibly in the cache: journaled before the attempt because CMake saves -D
+    # values even when configuration fails; removed keys are reset with -U so they return to the upstream default
+    defs = {k: ("ON" if v else "OFF") if isinstance(v, bool) else v for k, v in pkg["options"].items()}
+    hooks = [defs["CMAKE_PROJECT_INCLUDE"]] if defs.get("CMAKE_PROJECT_INCLUDE") else []
+    defs["CMAKE_PROJECT_INCLUDE"] = ";".join([*hooks, str(hook)])
+    # A GN dependency's libraries are the outputs gn evaluated for its targets (postgen resolves them after gn gen)
+    gn_libs = json.loads((bdir / "gnb_gn_libs.json").read_text()) if any(d["gn_libs"] for d in pkg["deps"]) else {}
+    dep_libs = {}
+    dep_rescan = {}
+    dep_system_libs, dep_link_flags = {}, {}
+    config_inputs = [str(Path(__file__).resolve())]
+    dep_includes = {}
+    for dep in pkg["deps"]:
+        paths = [path for label in dep["gn_libs"] for path in gn_libs[label]["paths"]]
+        dep_rescan[dep["name"]] = False
+        dep_system_libs[dep["name"]] = [lib for label in dep["gn_libs"] for lib in gn_libs[label]["system_libs"]]
+        dep_link_flags[dep["name"]] = []
+        dep_includes[dep["name"]] = []
+        if dep["cmake_prefix"]:
+            exports_path = f"{dep['cmake_prefix']}/gnb_exports.json"
+            config_inputs += [f"{dep['cmake_prefix']}/build.ninja", exports_path]
+            model = json.loads((out / exports_path).read_text())
+            selected = selected_targets(model, dep["targets"], dep["name"])
+            paths += [path for target in selected for path in target["paths"]]
+            dep_rescan[dep["name"]] = any(target["rescan"] for target in selected)
+            dep_system_libs[dep["name"]] += [lib for target in selected for lib in target["system_libs"]]
+            dep_link_flags[dep["name"]] += [flag for target in selected for flag in target["link_flags"]]
+            dep_includes[dep["name"]] += [path for target in selected
+                                          for field in ("include_dirs", "system_include_dirs") for path in target[field]]
+        for header in dep["header_deps"]:
+            exports_path = f"{header['cmake_prefix']}/gnb_exports.json"
+            config_inputs += [f"{header['cmake_prefix']}/build.ninja", exports_path]
+            selected = selected_targets(json.loads((out / exports_path).read_text()), header["targets"], header["name"])
+            dep_includes[dep["name"]] += [path for target in selected
+                                          for field in ("include_dirs", "system_include_dirs") for path in target[field]]
+        dep_includes[dep["name"]] += dep["include_dirs"]
+        dep_libs[dep["name"]] = paths
+    for dep in pkg["deps"]:
+        # Paths only: the libraries are built after configuration, before this package's compiles
+        var = f"GNB_DEP_{dep_var_name(dep['name'])}"
+        defs[f"{var}_INCLUDE_DIRS"] = ";".join(dict.fromkeys(dep_includes[dep["name"]]))
+        libraries = [str(out / path) for path in dep_libs[dep["name"]]]
+        # Keep providers after the last consumer occurrence when native closures overlap.
+        libraries = list(dict.fromkeys(reversed([*libraries, *dep_system_libs[dep["name"]]])))[::-1]
+        if dep_rescan[dep["name"]]:
+            libraries = ["$<LINK_GROUP:RESCAN," + ",".join(lib.replace(",", "$<COMMA>") for lib in libraries) + ">"]
+        libraries += list(dict.fromkeys(reversed(dep_link_flags[dep["name"]])))[::-1]
+        defs[f"{var}_LIBRARIES"] = ";".join(libraries)
+    keys_file = bdir / "gnb_option_keys.json"
+    old_keys = json.loads(keys_file.read_text()) if keys_file.is_file() else []
+    write_if_changed(keys_file, json.dumps(sorted(set(old_keys) | set(defs))))
+    cmd += [f"-U{k}" for k in sorted(set(old_keys) - set(defs))]
+    cmd += [f"-D{k}={v}" for k, v in defs.items()]
+    try:
+        run(cmd, quiet=True)
+    except GnbError:
+        if not (bdir / "build.ninja").is_file():
+            write_stub(out, prefix)  # package dir was cleared: leave a stub so the ninja graph loads; the next build retries configuration
+        raise
+    print(f"gnb: cmake configure {prefix}", flush=True)
+
+    build_ninja = bdir / "build.ninja"
+    order = [lib for libs in dep_libs.values() for lib in libs]
+    exports = read_exports(out, bdir)
+    native = normalize_artifact_nodes(build_ninja.read_text(), out, exports, order)
+    text, inputs = fix_package_ninja(native, prefix, order, config_inputs)
+    write_if_changed(build_ninja, text)
+    write_if_changed(bdir / "gnb_inputs.txt", "\n".join(inputs) + "\n")
+    rules = bdir / "CMakeFiles" / "rules.ninja"
+    write_if_changed(rules, fix_rules_ninja(rules.read_text(), configure_cmd(out, prefix), depfile_cmd(out, prefix)))
+    write_inputs(out, (out / "gnb_packages.txt").read_text().split())
+    compdb.merge(out)
+    write_if_changed(keys_file, json.dumps(sorted(defs)))
+    write_if_changed(id_file, identity)
+    publish_exports(bdir / "gnb_exports.json", exports)

gnbuild/build/compdb.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import List
+
+from gnbuild.util import GnbError, find_tool, write_if_changed
+
+
+def snapshot_gn(out: Path, rules: List[str]) -> None:
+    # Ninja owns expansion and JSON serialization; snapshot only GN compile rules before CMake subninjas are injected.
+    entries = []
+    if rules:
+        result = subprocess.run([find_tool("ninja"), "-t", "compdb", *rules], cwd=out, text=True, capture_output=True)
+        if result.returncode != 0:
+            raise GnbError(f"cannot get GN compilation commands in {out}: {result.stdout}{result.stderr}")
+        try:
+            entries = json.loads(result.stdout)
+        except json.JSONDecodeError as e:
+            raise GnbError(f"cannot parse Ninja compilation commands in {out}: {e}")
+    write_if_changed(out / "gnb_compdb_gn.json", json.dumps(entries, indent=2) + "\n")
+
+
+def merge(out: Path) -> None:
+    parts = [out / "gnb_compdb_gn.json"]
+    parts += [out / p / "compile_commands.json" for p in (out / "gnb_packages.txt").read_text().split()]
+    merged = []
+    for f in parts:
+        if f.is_file():
+            try:
+                merged += json.loads(f.read_text())
+            except (json.JSONDecodeError, OSError) as e:
+                raise GnbError(f"cannot parse {f}: {e}")
+    write_if_changed(out / "compile_commands.json", json.dumps(merged, indent=2) + "\n")