From c133b75df9a61efac7e3101a398a53e4ce454c2c Mon Sep 17 00:00:00 2001 From: bong-water-water-bong Date: Sun, 8 Nov 2026 20:02:51 -0400 Subject: [PATCH] ci: a gate on ci.yml's --target list, so a guarded target cannot red the build MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit #1583 added embeds_equiv_probe to ci.yml's 'cmake --build build --target …' list. That target is inside if(ONEBIT_NPU), and ci.yml configures without the private NPU runtime, so ninja got ninja: error: unknown target 'embeds_equiv_probe' and that is not 'one target is missing': ninja rejects the whole command line before building anything, so onebit stopped being compiled too and the Build step went red for that branch. This checks the two files instead of configuring (a configure wants the 177 MB + 189 MB submodules): read the names out of ci.yml's --target list, read the if()/endif() nesting around every add_executable/add_library, and fail a target whose guard ci.yml does not satisfy -- naming the option, which is the sentence the ninja error does not give. main: ci_targets_check: all 28 target(s) ci.yml builds exist in the configuration it creates #1583: ci_targets_check: ci.yml builds 'embeds_equiv_probe', which is inside if(ONEBIT_NPU) and ci.yml does not configure ONEBIT_NPU -- ninja rejects the whole --target list before building anything An option that defaults ON needs no -D (ONEBIT_NPU_HOST is that shape, and its default is a ${variable}, so option_defaults() leaves it out and the check treats it as satisfied rather than guessing); e.targets in an else() branch are left to a human, because the guard there is a negation this scan does not model. --self-test: 6 cases, registered as its own ctest. --- CMakeLists.txt | 6 + tools/ci/ci_targets_check.py | 302 +++++++++++++++++++++++++++++++++++ 2 files changed, 308 insertions(+) create mode 100755 tools/ci/ci_targets_check.py diff --git a/CMakeLists.txt b/CMakeLists.txt index d6a68bd00..6ec5d06dd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -249,6 +249,12 @@ add_test(NAME seal_manifest COMMAND ${CMAKE_SOURCE_DIR}/tests/seal_manifest_test # engine#1564: which files the copyright gate looks at -- a staged file is seen, an untracked one is seen (that is why # running it before `git add` is useful), an ignored one is not. A throwaway repo in a temp dir: no build, no device. add_test(NAME copyright_gate COMMAND ${CMAKE_SOURCE_DIR}/tests/copyright_gate_test.sh) +# engine#1594: every target ci.yml's `cmake --build --target …` list names must exist in the configuration ci.yml +# creates. #1583 added one name for a target defined inside if(ONEBIT_NPU), which CI does not configure -- and ninja +# rejects the whole command line before building anything, so `onebit` stopped being compiled for every PR. Reads the +# two files, no build and no submodules; --self-test drives it. +add_test(NAME ci_targets COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/ci/ci_targets_check.py --check --root ${CMAKE_SOURCE_DIR}) +add_test(NAME ci_targets_self COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/ci/ci_targets_check.py --self-test) # engine #1279: the version a package is built with (scripts/pack-version.sh) -- a release tag as # it stands, a candidate mapped into the ISO week of its own date with a suffix that sorts below that # release, and the ordering a candidate needs: previous release < candidate < its release. The diff --git a/tools/ci/ci_targets_check.py b/tools/ci/ci_targets_check.py new file mode 100755 index 000000000..2a6452e89 --- /dev/null +++ b/tools/ci/ci_targets_check.py @@ -0,0 +1,302 @@ +#!/usr/bin/env python3 +# Copyright 2026 bong-water-water-bong +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Every target ci.yml asks ninja to build must exist in the configuration ci.yml creates. + +Why this exists (engine#1591's neighbour, engine#1583): a PR added one name to +`ci.yml`'s `cmake --build build --target …` list for a target defined inside +`if(ONEBIT_NPU)`. CI configures without the private NPU runtime, so ninja got + + ninja: error: unknown target 'embeds_equiv_probe' + +and that is not "one target is missing" -- ninja rejects the whole command line +before building anything, so `onebit` stopped being compiled too and every PR's +build step went red. + +A configure would answer this exactly, but a configure here needs the +third_party submodules (177 MB + 189 MB) and 20-30 s; this reads the two files +instead. It tracks the CMake `if()`/`endif()` nesting around each +`add_executable`/`add_library`, reads the `-D` flags CI configures with, and +fails a target whose guard CI does not satisfy -- naming the option, which is +the sentence the ninja error does not give. + + tools/ci/ci_targets_check.py --check [--root .] + tools/ci/ci_targets_check.py --self-test +""" +import argparse +import os +import re +import sys + +CI = ".github/workflows/ci.yml" +CMAKE = "CMakeLists.txt" + +# `add_executable(name …)` / `add_library(name …)`, and CMake's if()/endif() nesting. +ADD = re.compile(r"^\s*add_(?:executable|library)\s*\(\s*([A-Za-z0-9_.+-]+)", re.IGNORECASE) +IF = re.compile(r"^\s*if\s*\(\s*([^)]*)\)", re.IGNORECASE) +ENDIF = re.compile(r"^\s*endif\s*\(", re.IGNORECASE) +DEFINE = re.compile(r"-D([A-Za-z0-9_]+)=([^\s\"]*)") + + +def continued_lines(text): + """The lines of a YAML `run:` block, with backslash continuations joined.""" + out, buf = [], "" + for line in text.splitlines(): + stripped = line.rstrip() + if stripped.endswith("\\"): + buf += stripped[:-1] + " " + continue + out.append(buf + stripped) + buf = "" + if buf: + out.append(buf) + return out + + +def ci_targets(ci_text): + """The target names in ci.yml's `cmake --build … --target …` command.""" + names = [] + for line in continued_lines(ci_text): + if "cmake --build" not in line or "--target" not in line: + continue + words = line.split("--target", 1)[1].split() + for w in words: + if w in ("-j",) or w.startswith("-") or not w: + continue + names.append(w) + return names + + +def ci_defines(ci_text): + """The -D flags ci.yml configures with, as {NAME: VALUE}.""" + out = {} + for line in ci_text.splitlines(): + if "cmake -B" in line or "cmake -S" in line: + for k, v in DEFINE.findall(line): + out[k] = v + return out + + +def cmake_targets(cmake_text): + """{target: [guard conditions enclosing it]} for every add_executable/add_library. + + A paren-aware scan, because the real tree has both shapes this has to survive: + a condition spanning lines (`if(ONEBIT_X AND\n ONEBIT_Y)`) and `else()` / + `elseif()` inside a block. `else()` marks the entry unknown rather than + negating it: a target in an else-branch is guarded by the negation, and this + check would rather leave that to a human than guess (the message prints the + guard it saw, so a false positive costs one line to read). + """ + targets = {} + stack = [] # each entry: {"cond": str|None, "buf": str|None} + pending = None # accumulating a multi-line if()/elseif() + for raw in cmake_text.splitlines(): + line = raw.strip() + if pending is not None: + pending[1] += " " + line + if pending[1].count("(") <= pending[1].count(")"): + _open_guard(stack, pending[0], pending[1]) + pending = None + continue + m = re.match(r"^(if|elseif|else|endif)\s*\((.*)$", line, re.IGNORECASE) + if m: + kw, rest = m.group(1).lower(), m.group(2) + if kw in ("if", "elseif"): + if rest.count(")") == 0: + pending = [kw, rest] + else: + _open_guard(stack, kw, rest) + elif kw == "else": + if stack: + stack[-1] = {"cond": None} + else: # endif() + if stack: + stack.pop() + continue + m = ADD.match(line) + if m: + guards = [e["cond"] for e in stack if e["cond"]] + unknown = any(e["cond"] is None for e in stack) + targets.setdefault(m.group(1), {"guards": guards, "unknown": unknown}) + return targets + + +def _open_guard(stack, kw, text): + """Push/replace the top of the guard stack for if()/elseif().""" + body = text.split("(", 1)[1] if "(" in text else text + body = body.rsplit(")", 1)[0].strip() + if kw == "elseif" and stack: + stack[-1] = {"cond": body} + else: + stack.append({"cond": body}) + + +def option_defaults(cmake_text): + """{OPTION: "ON"|"OFF"} for `option(NAME "doc" ON|OFF)`; other defaults are left out. + + A target under `if(OPTION)` is fine when the option defaults ON, and CI does + not have to pass -D for that: ONEBIT_NPU_HOST defaults ON except on APPLE + (its default is `${_onebit_npu_host_default}`, so it is *not* in this map and + `satisfied()` treats it as unknown-and-therefore-fine). ONEBIT_NPU is a plain + OFF, which is the case engine#1583 tripped over. + """ + out = {} + for m in re.finditer(r"^\s*option\s*\(\s*([A-Za-z0-9_]+)\s+\"[^\"]*\"\s+([A-Za-z0-9_]+)\s*\)", + cmake_text, re.MULTILINE): + name, default = m.group(1), m.group(2).upper() + if default in ("ON", "OFF"): + out[name] = default + return out + + +def satisfied(guard, defines, defaults): + """True when CI's -D flags satisfy one `if()` condition, or the check cannot tell. + + Known shapes only, and anything else is treated as satisfied so this check + never fails a tree over a condition it does not model: + ONEBIT_X -> needs -DONEBIT_X=ON (or any non-OFF value) + NOT ONEBIT_X -> needs ONEBIT_X absent or OFF + """ + guard = guard.strip() + negated = False + if guard.upper().startswith("NOT "): + negated = True + guard = guard[4:].strip() + if not re.fullmatch(r"[A-Za-z0-9_]+", guard): + return True, "" + value = defines.get(guard) + if value is None: + # no -D in ci.yml: the option's own default decides, and a default this + # scan cannot see (a ${variable}) counts as satisfied -- see option_defaults(). + value = defaults.get(guard) + if value is None: + return True, guard + configured = value.upper() not in ("OFF", "0", "NO", "FALSE", "") + ok = (not configured) if negated else configured + return ok, guard + + +def check(root): + ci_path = os.path.join(root, CI) + cmake_path = os.path.join(root, CMAKE) + for p in (ci_path, cmake_path): + if not os.path.isfile(p): + print(f"ci_targets_check: no {p}", file=sys.stderr) + return 2 + names = ci_targets(open(ci_path, encoding="utf-8").read()) + defines = ci_defines(open(ci_path, encoding="utf-8").read()) + cmake_text = open(cmake_path, encoding="utf-8").read() + targets = cmake_targets(cmake_text) + defaults = option_defaults(cmake_text) + if not names: + print("ci_targets_check: ci.yml names no targets (the parse found nothing)", file=sys.stderr) + return 2 + + bad = 0 + for name in names: + info = targets.get(name) + if info is None: + print(f"ci_targets_check: ci.yml builds '{name}', which no add_executable/add_library defines") + bad += 1 + continue + if info["unknown"]: + continue # an else()-branch: not modelled, see cmake_targets() + for guard in info["guards"]: + ok, option = satisfied(guard, defines, defaults) + if not ok: + print(f"ci_targets_check: ci.yml builds '{name}', which is inside if({guard}) and ci.yml does not " + f"configure {option} -- ninja rejects the whole --target list before building anything") + bad += 1 + if bad: + return 1 + print(f"ci_targets_check: all {len(names)} target(s) ci.yml builds exist in the configuration it creates") + return 0 + + +SELF_CI = """ + - name: Configure + run: cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=gcc-16 + - name: Build + run: | + cmake --build build --target onebit \\ + plain_test \\ + hidden_test -j +""" + +SELF_CMAKE = """ +option(ONEBIT_NPU "x" OFF) +add_executable(onebit main.cpp) +add_executable(plain_test plain.cpp) +if(ONEBIT_NPU) + add_executable(hidden_test hidden.cpp) +endif() +""" + + +def self_test(): + import tempfile + fails = 0 + + def case(what, ci, cmake, want): + nonlocal fails + with tempfile.TemporaryDirectory() as d: + os.makedirs(os.path.join(d, ".github", "workflows")) + open(os.path.join(d, CI), "w", encoding="utf-8").write(ci) + open(os.path.join(d, CMAKE), "w", encoding="utf-8").write(cmake) + got = check(d) + ok = got == want + print(f" {'ok ' if ok else 'FAIL'} {what} (rc {got}, wanted {want})") + if not ok: + fails += 1 + + # The shape #1583 shipped: a target under a guard CI does not configure. + case("a target under if(ONEBIT_NPU) fails when ci.yml does not set it", + SELF_CI, SELF_CMAKE, 1) + # … and passes once CI configures the option. + case("the same target passes when ci.yml sets -DONEBIT_NPU=ON", + SELF_CI.replace("-DCMAKE_C_COMPILER", "-DONEBIT_NPU=ON -DCMAKE_C_COMPILER"), SELF_CMAKE, 0) + # A name nobody defines: the other way the list can be wrong. + case("a name with no add_executable is reported", + SELF_CI.replace("plain_test", "no_such_target"), SELF_CMAKE, 1) + # An option that defaults ON needs no -D: ONEBIT_NPU_HOST is that shape in the real tree. + case("a target under an option that defaults ON passes without a -D", + SELF_CI, SELF_CMAKE.replace("if(ONEBIT_NPU)", "if(ONEBIT_HOST)") + "option(ONEBIT_HOST \"x\" ON)\n", 0) + # Unrelated guards must not fail a tree. + case("a target under a non-option guard is left alone", + SELF_CI, SELF_CMAKE.replace("if(ONEBIT_NPU)", "if(NOT WIN32)"), 0) + # And the clean case. + case("a plain target list passes", + SELF_CI.replace("hidden_test ", ""), SELF_CMAKE, 0) + + print(f"ci_targets_check --self-test: {fails} failure(s)") + return 1 if fails else 0 + + +def main(argv): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("--check", action="store_true") + ap.add_argument("--self-test", action="store_true") + ap.add_argument("--root", default=".") + a = ap.parse_args(argv[1:]) + if a.self_test: + return self_test() + if a.check: + return check(a.root) + ap.print_help() + return 2 + + +if __name__ == "__main__": + sys.exit(main(sys.argv))