| #!/usr/bin/env python3 |
| # SPDX-FileCopyrightText: The Eigen Authors |
| # SPDX-License-Identifier: MPL-2.0 |
| |
| """Shared plumbing for the added-line style checks. |
| |
| Both ``check_style.py`` (textual conventions) and ``clang_tidy_hook.py`` |
| (clang-tidy conventions) need the same two things: the set of line numbers a |
| change ADDED to each file, and the ability to turn a Claude Code PostToolUse |
| payload into that set. That logic lives here so the two checkers cannot drift |
| apart in what they consider an added line. |
| |
| Run directly to emit a clang-tidy ``--line-filter`` argument for the files a |
| diff touches, which is how ``ci/scripts/run-clang-tidy.sh`` restricts an MR's |
| diagnostics to its own lines: |
| |
| python3 scripts/style_common.py --line-filter BASE [--] [path ...] |
| """ |
| |
| import argparse |
| import json |
| import os |
| import re |
| import subprocess |
| import sys |
| |
| REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| CXX_EXT = {".h", ".hpp", ".hxx", ".cpp", ".cc", ".cxx", ".cu", ".cuh", ".inc"} |
| EXTENSIONLESS_HEADER_TREES = ("Eigen/", "unsupported/Eigen/") |
| |
| |
| def is_cxx_path(rel_path): |
| """Return whether ``rel_path`` is C++ source, including Eigen's |
| extensionless public module headers such as ``Eigen/Core``.""" |
| return (os.path.splitext(rel_path)[1].lower() in CXX_EXT |
| or (not os.path.splitext(os.path.basename(rel_path))[1] |
| and rel_path.startswith(EXTENSIONLESS_HEADER_TREES))) |
| |
| |
| def git(root, *args): |
| return subprocess.run(["git"] + list(args), cwd=root, capture_output=True, text=True) |
| |
| |
| def read_post_image(root, rel_path): |
| try: |
| with open(os.path.join(root, rel_path), encoding="utf-8", errors="replace") as handle: |
| return handle.read() |
| except OSError: |
| return None |
| |
| |
| def added_lines_from_diff(diff_text): |
| """Parse ``git diff -U0`` output into {relative_path: set(added line numbers)}.""" |
| files = {} |
| path, new_line = None, 0 |
| for raw in diff_text.splitlines(): |
| if raw.startswith("+++ "): |
| name = raw[4:] |
| path = None if name == "/dev/null" else name[2:] if name.startswith("b/") else name |
| elif raw.startswith("@@"): |
| m = re.search(r"\+(\d+)(?:,(\d+))?", raw) |
| new_line = int(m.group(1)) if m else 0 |
| elif raw.startswith("+") and not raw.startswith("+++"): |
| if path is not None: |
| files.setdefault(path, set()).add(new_line) |
| new_line += 1 |
| elif not raw.startswith("-") and not raw.startswith("\\"): |
| # "\ No newline at end of file" is a marker, not a context line. |
| new_line += 1 |
| return files |
| |
| |
| def added_from_structured_patch(tool_response): |
| """Derive added line numbers from the tool response's structured patch, |
| which records the exact edited hunks. A valid deletion-only patch returns |
| an empty set; None means absent or malformed data and enables fallback.""" |
| try: |
| added = set() |
| for hunk in tool_response["structuredPatch"]: |
| line_no = int(hunk["newStart"]) |
| for entry in hunk["lines"]: |
| if entry.startswith("+"): |
| added.add(line_no) |
| line_no += 1 |
| elif not entry.startswith("-") and not entry.startswith("\\"): |
| # "\ No newline at end of file" is a marker, not a context line. |
| line_no += 1 |
| return added |
| except Exception: |
| return None |
| |
| |
| def hook_added_line_numbers(content, snippets): |
| """Map the strings an edit added onto post-image line numbers. |
| |
| Each snippet must occur exactly once — a repeated occurrence cannot be |
| told apart from pre-existing identical text, and would mark unrelated |
| lines. A snippet's span excludes the line after its trailing newline. |
| Returns None when any snippet is absent or ambiguous; the caller then |
| checks the snippet text standalone.""" |
| added = set() |
| for snippet in snippets: |
| if not snippet: |
| continue |
| start = content.find(snippet) |
| if start < 0 or content.find(snippet, start + 1) >= 0: |
| return None |
| first = content.count("\n", 0, start) + 1 |
| span = snippet.count("\n") + (0 if snippet.endswith("\n") else 1) |
| added.update(range(first, first + max(span, 1))) |
| return added |
| |
| |
| def hook_edit_snippets(payload): |
| """Return (rel_path, snippets) for an edit payload, or (None, None) when |
| the tool call is not an in-repository C++ edit this checker handles.""" |
| tool_input = payload.get("tool_input", {}) or {} |
| tool_name = payload.get("tool_name", "") |
| path = tool_input.get("file_path", "") or "" |
| if not path: |
| return None, None |
| rel_path = os.path.relpath(os.path.abspath(path), REPO_ROOT).replace(os.sep, "/") |
| if rel_path.startswith(".."): |
| return None, None |
| if tool_name == "Write": |
| snippets = [tool_input.get("content", "")] |
| elif tool_name == "Edit": |
| snippets = [tool_input.get("new_string", "")] |
| elif tool_name == "MultiEdit": |
| snippets = [e.get("new_string", "") for e in tool_input.get("edits", [])] |
| else: |
| return None, None |
| if not any(s.strip() for s in snippets): |
| return None, None |
| return rel_path, snippets |
| |
| |
| def hook_post_image_and_added(payload, rel_path, snippets): |
| """Resolve the post-image lines and added line numbers for an edit. |
| |
| The hook runs after the edit, so the file on disk is the post-image. The |
| edited lines come from the tool response's structured patch when present, |
| else from locating a uniquely occurring added string. Returns |
| (lines, added, exact): ``exact`` is False when the lines could not be |
| located in the real file and the snippet text is being checked standalone. |
| """ |
| text = read_post_image(REPO_ROOT, rel_path) |
| added = None |
| lines = None |
| if text is not None: |
| lines = text.splitlines() |
| added = added_from_structured_patch(payload.get("tool_response") or {}) |
| if added is None: |
| if payload.get("tool_name") == "Write": |
| added = set(range(1, len(lines) + 1)) |
| else: |
| added = hook_added_line_numbers(text, snippets) |
| if added is None: |
| lines = "\n".join(snippets).splitlines() |
| return lines, set(range(1, len(lines) + 1)), False |
| return lines, added, True |
| |
| |
| def diff_added_lines(base, root=REPO_ROOT, include_untracked=True): |
| """Return {rel_path: set(added line numbers)} for everything added since |
| merge-base(base, HEAD), optionally including whole untracked C++ files.""" |
| merge_base = git(root, "merge-base", base, "HEAD") |
| resolved = merge_base.stdout.strip() if merge_base.returncode == 0 else base |
| diff = git(root, "diff", "-U0", "--no-color", resolved) |
| if diff.returncode not in (0, 1): |
| sys.stderr.write(diff.stderr) |
| raise SystemExit(2) |
| per_file = added_lines_from_diff(diff.stdout) |
| if include_untracked: |
| untracked = git(root, "ls-files", "--others", "--exclude-standard") |
| for rel_path in untracked.stdout.splitlines(): |
| if is_cxx_path(rel_path): |
| text = read_post_image(root, rel_path) |
| if text is not None: |
| per_file.setdefault(rel_path, set()).update(range(1, len(text.splitlines()) + 1)) |
| return per_file |
| |
| |
| def as_ranges(numbers): |
| """Collapse a set of line numbers into sorted inclusive [start, end] pairs.""" |
| ranges = [] |
| for number in sorted(numbers): |
| if ranges and number == ranges[-1][1] + 1: |
| ranges[-1][1] = number |
| else: |
| ranges.append([number, number]) |
| return ranges |
| |
| |
| def line_filter_json(per_file): |
| """Build clang-tidy's --line-filter argument from {rel_path: line numbers}. |
| |
| clang-tidy matches ``name`` as a path suffix and, when the filter is |
| non-empty, reports nothing for files it does not list — so the filter |
| doubles as the file filter. Repository-relative paths are used rather |
| than bare basenames, which would collide across modules. |
| """ |
| return json.dumps([{"name": rel_path, "lines": as_ranges(lines)} |
| for rel_path, lines in sorted(per_file.items()) if lines]) |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--line-filter", metavar="BASE", required=True, |
| help="emit a clang-tidy --line-filter for lines added since merge-base(BASE, HEAD)") |
| parser.add_argument("paths", nargs="*", help="restrict the filter to these repository-relative paths") |
| args = parser.parse_args() |
| per_file = diff_added_lines(args.line_filter, include_untracked=False) |
| if args.paths: |
| wanted = set(args.paths) |
| per_file = {p: lines for p, lines in per_file.items() if p in wanted} |
| print(line_filter_json(per_file)) |
| return 0 |
| |
| |
| if __name__ == "__main__": |
| sys.exit(main()) |
