fix: let pip resolve --version and check every file clang-tidy gets

README.md

@@ -62,18 +62,20 @@ Choose the clang tool version with `--version`:
   clang-tidy wheels are released separately from clang-format wheels and skip some releases, so
   give clang-tidy the major version.
 - clang-format wheels cover LLVM 6 to 23 and clang-tidy wheels LLVM 13 to 23. For a version without
-  a wheel, the hook fails and lists some of the versions that exist.
+  a wheel, the hook fails and shows pip's list of the versions that exist.
 - Each version is installed once, the first time the hook runs with it, and later runs use it
-  without contacting pypi.org. pre-commit shares the hook between all your projects that use the
+  without network access. pre-commit shares the hook between all your projects that use the
   same `rev`, and projects that ask for different versions each keep their own copy.
+- pip installs the wheels, so a package index set in your pip configuration (`PIP_INDEX_URL`,
+  `pip.conf`) is used, for example a company mirror.
 
 #### Without network access
 
 clang-format without `--version` is installed together with the hook and runs offline. clang-tidy
 without `--version`, and any `--version` that is not installed yet, is installed the first time
 the hook runs, which needs network access. On [pre-commit.ci](https://pre-commit.ci/), which runs
-hooks without network access, or where pypi.org is blocked, pin the version with pre-commit's own
-`additional_dependencies` instead of `--version`. pre-commit installs it together with the hook, through the package index it uses for
+hooks without network access, pin the version with pre-commit's own `additional_dependencies`
+instead of `--version`. pre-commit installs it together with the hook, through the package index it uses for
 the hook itself:
 
 ```yaml
@@ -232,7 +234,8 @@ to clang-tidy automatically — no configuration needed for most projects. It lo
 `build-*/`, `build/*/` and `out/build/*/` (CMake presets, Visual Studio), where the most recently
 written one wins. Without `-p`, clang-tidy also finds a `compile_commands.json` or
 `compile_flags.txt` next to each file or in its parent directories, so a database in the
-repository root works too.
+repository root works too. With only a `compile_flags.txt`, clang reads `.h` files as C, so a C++
+project adds `-xc++` to it; otherwise a flag such as `-std=c++17` fails on every header.
 
 ```yaml
 repos:
@@ -258,8 +261,8 @@ problems in your code, so the hook:
 - **fails in CI**, when the `CI` environment variable is set (GitHub Actions, GitLab CI and most CI
   services set it), so a broken setup does not pass unnoticed.
 
-The hook runs clang-tidy anyway when `args` tell it how to compile: `-p`, `--extra-arg` or
-`--extra-arg-before`.
+The hook runs clang-tidy anyway when `args` tell it how to compile: `-p`, `--extra-arg`,
+`--extra-arg-before`, or `--` followed by the compiler flags, as in `args: ["--", "-std=c++17"]`.
 
 To disable auto-detection and always run clang-tidy without a database (e.g. in a monorepo where
 auto-detect might pick the wrong database, or for code that needs no compiler flags):

cpp_linter_hooks/clang_tidy.py

@@ -49,6 +49,7 @@
     ".ipp",
     ".inl",
     ".ixx",
+    ".m",
     ".mm",
     ".tpp",
     ".txx",
@@ -595,15 +596,23 @@ def _looks_like_source_file(path: str) -> bool:
 
 
 def _split_source_files(args: list[str]) -> tuple[list[str], list[str]]:
-    """Split clang-tidy options from trailing source file arguments."""
+    """Split clang-tidy options from the source files pre-commit appends.
+
+    Going back from the end, an argument is a source file when it has a C or
+    C++ suffix, or when it is an existing file that does not follow an option,
+    which could take it as its value (``--export-fixes fixes.yaml``). The
+    second case covers suffixes added with ``types_or`` or ``files``.
+    """
     split_idx = len(args)
-    source_files: list[str] = []
-    for idx in range(len(args) - 1, -1, -1):
-        if not _looks_like_source_file(args[idx]):
+    while split_idx > 0:
+        arg = args[split_idx - 1]
+        previous = args[split_idx - 2] if split_idx > 1 else ""
+        if not _looks_like_source_file(arg) and (
+            previous.startswith("-") or not os.path.isfile(arg)
+        ):
             break
-        source_files.append(args[idx])
-        split_idx = idx
-    return args[:split_idx], list(reversed(source_files))
+        split_idx -= 1
+    return args[:split_idx], args[split_idx:]
 
 
 def _combine_outputs(results: list[tuple[int, str]]) -> str:
@@ -621,16 +630,23 @@ def _exec_serial_clang_tidy(
     command_prefix: list[str],
     source_files: list[str],
     lines: dict[str, LineRanges] | None,
+    compiler_args: tuple[str, ...] = (),
 ) -> tuple[int, str]:
-    """Run clang-tidy over all source files, in one command when possible."""
+    """Run clang-tidy over all source files, in one command when possible.
+
+    *compiler_args* is ``--`` and the compiler arguments after it, which go
+    after the source files.
+    """
     if lines is None:
-        return _exec_clang_tidy(command_prefix + source_files)
+        return _exec_clang_tidy([*command_prefix, *source_files, *compiler_args])
     # Several commands only for very large commits; they run one after another,
     # so -fix stays safe.
     return _combine_results(
         [
-            _exec_clang_tidy(command_prefix + batch)
-            for batch in _line_filter_batches(command_prefix, source_files, lines)
+            _exec_clang_tidy([*command_prefix, *batch, *compiler_args])
+            for batch in _line_filter_batches(
+                [*command_prefix, *compiler_args], source_files, lines
+            )
         ]
     )
 
@@ -640,6 +656,7 @@ def _exec_parallel_clang_tidy(
     source_files: list[str],
     jobs: int,
     lines: dict[str, LineRanges] | None = None,
+    compiler_args: tuple[str, ...] = (),
 ) -> tuple[int, str]:
     """Run clang-tidy over source files in parallel and combine the results."""
 
@@ -650,7 +667,9 @@ def run_file(source_file: str) -> tuple[int, str]:
             if lines is None
             else [_line_filter_option({source_file: lines[source_file]})]
         )
-        return _exec_clang_tidy(command_prefix + line_filter + [source_file])
+        return _exec_clang_tidy(
+            [*command_prefix, *line_filter, source_file, *compiler_args]
+        )
 
     with ThreadPoolExecutor(max_workers=min(jobs, len(source_files))) as executor:
         results = list(executor.map(run_file, source_files))
@@ -669,6 +688,13 @@ def run_clang_tidy(args=None) -> tuple[int, str]:
     clang_tidy_args, source_files = _split_source_files(other_args)
     source_files = [file_argument(f) for f in source_files]
     clang_tidy_args, notes = _repair_check_args(clang_tidy_args)
+    # clang-tidy reads everything after "--" as compiler arguments, so the
+    # source files and the hook's own options go before it.
+    compiler_args: tuple[str, ...] = ()
+    if "--" in clang_tidy_args:
+        split_idx = clang_tidy_args.index("--")
+        compiler_args = tuple(clang_tidy_args[split_idx:])
+        clang_tidy_args = clang_tidy_args[:split_idx]
 
     lines = None
     if not hook_args.all_lines and not _has_option(
@@ -695,7 +721,7 @@ def run_clang_tidy(args=None) -> tuple[int, str]:
         clang_tidy_args = ["-p", compile_db_path] + clang_tidy_args
     elif (
         not hook_args.no_compile_commands
-        and not _gives_compile_flags(clang_tidy_args)
+        and not _gives_compile_flags([*clang_tidy_args, *compiler_args])
         and not _has_compilation_database(source_files)
     ):
         retval, message = _missing_compile_db_result()
@@ -733,11 +759,15 @@ def run_clang_tidy(args=None) -> tuple[int, str]:
 
     if hook_args.jobs > 1 and len(source_files) > 1 and not unsafe_parallel:
         retval, output = _exec_parallel_clang_tidy(
-            [executable] + clang_tidy_args, source_files, hook_args.jobs, lines
+            [executable] + clang_tidy_args,
+            source_files,
+            hook_args.jobs,
+            lines,
+            compiler_args,
         )
     else:
         retval, output = _exec_serial_clang_tidy(
-            [executable] + clang_tidy_args, source_files, lines
+            [executable] + clang_tidy_args, source_files, lines, compiler_args
         )
 
     if NO_CHECKS_ERROR in output: