Files
PX4-Autopilot/Tools/ci/clang-tidy-diff-filter.py
T
Jacob Dahl a4697ed08e ci(clang-tidy): stop false positives in the inline review comments (#29013)
* ci(clang-tidy): stop false positives in the inline review comments

Of the 828 inline comments the clang-tidy job posted on 98 PRs since May, only 328 were unique: COMMENT reviews can't be dismissed, so every push posted every finding again. Most of the rest were artifacts of how the diff step runs:

- It parses against the test build dir, which is only configured, so the uORB, events and parameter headers don't exist and every TU stops at a missing include. clang-tidy then reports on the half-parsed AST: events::send<T>(...) as a chained comparison, sizeof on uORB arrays as sizeof of a pointer.
- It parses every changed .h on its own as C++, including board configs, NuttX headers and headers shared with C. The gating run never lints .h.
- .clang-tidy disabled macro-parentheses, incorrect-roundings and misplaced-widening-cast under their old misc- names, which clang-tidy 18 no longer knows, so all three were on.

Generate the test dir's headers, skip .h and board/NuttX files, drop clang-diagnostic-error (the build jobs report real compile errors), skip findings already posted on the PR, and disable four checks that only produced noise: googletest underscore names, virtual-class-destructor on gtest fixtures and singletons, suspicious-call-argument, and not-null-terminated-result on binary packet buffers.

Assisted-by: Claude:claude-opus-5-5

* ci(clang-tidy): keep the gating checks and skip the fuzztest header

.clang-tidy also configures the gating run, which enabled incorrect-roundings, macro-parentheses and virtual-class-destructor on purpose, with code fixes. Drop the stale misc- names instead of renaming them, and turn virtual-class-destructor, suspicious-call-argument and not-null-terminated-result off for the inline comments only.

Header generation also built fuzztest's json_grammar.h, which pulls in abseil and the antlr4 runtime: 336 ninja edges and 39 s in CI instead of 22 edges and 4 s.

Match already-posted comments on the line too, so a second finding with the same message elsewhere in a file is still posted. Drop only headers under boards/ and platforms/nuttx/, so SITL's own board sources are still linted.

Assisted-by: Claude:claude-opus-5-5
2026-10-06 19:52:54 -06:00

119 lines
3.9 KiB
Python

#!/usr/bin/env python3
"""
Filter a git diff for consumption by clang-tidy-diff.
Produces a unified diff containing only files that clang-tidy can
actually analyze against the current compilation database:
- C/C++ source files (.c, .cpp, .cc, .cxx, .m, .mm) must be present
in compile_commands.json. Files absent from the database are test
files, excluded code, or platform-specific sources that were not
compiled. Feeding them to clang-tidy-diff produces spurious
"header not found" errors (gtest/gtest.h in particular).
- C++ headers (.hpp, .hxx) pass through. clang-tidy-diff parses each
one on its own, with flags borrowed from a nearby source file.
Those under boards/ or platforms/nuttx/ are dropped: they are not
built for SITL, so the borrowed flags are not theirs.
- .h headers are dropped. Many are shared with C or are board/NuttX
configuration, and parsed alone as C++ they draw findings that do
not apply. The gating clang-tidy run's header filter only matches
.hpp, so it never lints them either.
- All other files (CMakeLists.txt, .yml, .md, etc.) are dropped.
Output is a unified diff suitable for piping into clang-tidy-diff.py.
If nothing remains, the output file is empty.
Used by .github/workflows/clang-tidy.yml as a pre-filter for the
`pr-review` artifact producer. Python stdlib only.
"""
import argparse
import json
import os
import subprocess
import sys
SOURCE_EXTS = {'.c', '.cpp', '.cc', '.cxx', '.m', '.mm'}
HEADER_EXTS = {'.hpp', '.hxx'}
EXCLUDED_HEADER_DIRS = ('boards/', 'platforms/nuttx/')
def load_db_files(build_dir):
"""Return the set of source paths (repo-relative) in compile_commands.json."""
path = os.path.join(build_dir, 'compile_commands.json')
with open(path) as f:
db = json.load(f)
root = os.path.abspath('.')
prefix = root + os.sep
paths = set()
for entry in db:
p = entry.get('file', '')
if p.startswith(prefix):
paths.add(p[len(prefix):])
else:
# Relative or external path; record as-is
paths.add(p)
return paths
def changed_files(base_ref):
out = subprocess.check_output(
['git', 'diff', '--name-only', '{}...HEAD'.format(base_ref)],
text=True,
)
return [line.strip() for line in out.splitlines() if line.strip()]
def keep_file(path, db_files):
"""Decide whether to keep this path in the filtered diff."""
ext = os.path.splitext(path)[1].lower()
if ext in HEADER_EXTS:
return not path.startswith(EXCLUDED_HEADER_DIRS)
if ext in SOURCE_EXTS:
return path in db_files
return False
def filtered_diff(base_ref, keep_paths):
if not keep_paths:
return ''
cmd = ['git', 'diff', '-U0', '{}...HEAD'.format(base_ref), '--'] + sorted(keep_paths)
return subprocess.check_output(cmd, text=True)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--build-dir', required=True,
help='CMake build dir containing compile_commands.json')
parser.add_argument('--base-ref', required=True,
help='Git ref to diff against (e.g. origin/main)')
parser.add_argument('--out', required=True,
help='Output path for the filtered unified diff')
args = parser.parse_args()
db_files = load_db_files(args.build_dir)
changed = changed_files(args.base_ref)
keep = [p for p in changed if keep_file(p, db_files)]
dropped = [p for p in changed if p not in keep]
print('clang-tidy-diff-filter: kept {} of {} changed files'.format(
len(keep), len(changed)))
if dropped:
print(' dropped (not in compile_commands.json or not source/header):')
for p in dropped:
print(' {}'.format(p))
diff = filtered_diff(args.base_ref, keep)
with open(args.out, 'w') as f:
f.write(diff)
return 0
if __name__ == '__main__':
sys.exit(main())