Adds the ability to use absolute paths for bazel managed artifacts

refresh.template.py

@@ -49,6 +49,11 @@ class SGR(enum.Enum):
     FG_BLUE = '\033[0;34m'
 
 
+class BazelInfo(typing.NamedTuple):
+    output_path: pathlib.Path
+    external_path: pathlib.Path
+
+
 def _log_with_sgr(sgr, colored_message, uncolored_message=''):
     """Log a message to stderr wrapped in an SGR context."""
     print(sgr.value, colored_message, SGR.RESET.value, uncolored_message, sep='', file=sys.stderr, flush=True)
@@ -765,7 +770,42 @@ def _all_platform_patch(compile_args: typing.List[str]):
     return compile_args
 
 
-def _get_cpp_command_for_files(compile_action):
+def _path_replacement_for_arg(arg: str, replacements: typing.Mapping[str, str]):
+    for (prefix, replacement) in replacements.items():
+        # Some commands are output with the argument name and the argument value
+        # split across two arguments. This condition checks for these cases by
+        # detecting arguments that start with e.g. bazel-out/.
+        #
+        # Example: -o, bazel-out/...
+        if arg.startswith(prefix):
+            return replacement + arg[len(prefix):]
+        # Bazel adds directories to include search paths using -I options. This
+        # condition checks for these cases.
+        #
+        # See: https://clang.llvm.org/docs/ClangCommandLineReference.html#cmdoption-clang-I-dir
+        #
+        # Example: -Ibazel-out/...
+        elif arg.startswith('-I' + prefix):
+            return replacement + arg[2 + len(prefix):]
+        # Some commands are output with the argument name and the argument value
+        # combined within the same argument, seperated by an equals sign.
+        #
+        # Example: -frandom-seed=bazel-out/...
+        elif '={}'.format(prefix) in arg:
+            return arg.replace('={}'.format(prefix), '={}'.format(replacement))
+    return arg
+
+
+def _apply_path_replacements(compile_args: typing.List[str], bazel_info: BazelInfo):
+    replacements = {
+        "bazel-out/": os.fspath(bazel_info.output_path) + "/",
+        "external/": os.fspath(bazel_info.external_path) + "/",
+    }
+
+    return [_path_replacement_for_arg(arg, replacements) for arg in compile_args]
+
+
+def _get_cpp_command_for_files(compile_action, bazel_info):
     """Reformat compile_action into a compile command clangd can understand.
 
     Undo Bazel-isms and figures out which files clangd should apply the command to.
@@ -775,12 +815,15 @@ def _get_cpp_command_for_files(compile_action):
     compile_action.arguments = _apple_platform_patch(compile_action.arguments)
     # Android and Linux and grailbio LLVM toolchains: Fine as is; no special patching needed.
 
+    if {rewrite_bazel_paths}:
+        compile_action.arguments = _apply_path_replacements(compile_action.arguments, bazel_info)
+
     source_files, header_files = _get_files(compile_action)
 
     return source_files, header_files, compile_action.arguments
 
 
-def _convert_compile_commands(aquery_output):
+def _convert_compile_commands(aquery_output, bazel_info):
     """Converts from Bazel's aquery format to de-Bazeled compile_commands.json entries.
 
     Input: jsonproto output from aquery, pre-filtered to (Objective-)C(++) compile actions for a given build.
@@ -799,12 +842,15 @@ def _convert_compile_commands(aquery_output):
             assert not target.startswith('//external'), f"Expecting external targets will start with @. Found //external for action {action}, target {target}"
             action.is_external = target.startswith('@') and not target.startswith('@//')
 
+    def worker(compile_action):
+        return _get_cpp_command_for_files(compile_action, bazel_info)
+
     # Process each action from Bazelisms -> file paths and their clang commands
     # Threads instead of processes because most of the execution time is farmed out to subprocesses. No need to sidestep the GIL. Might change after https://github.com/clangd/clangd/issues/123 resolved
     with concurrent.futures.ThreadPoolExecutor(
         max_workers=min(32, (os.cpu_count() or 1) + 4) # Backport. Default in MIN_PY=3.8. See "using very large resources implicitly on many-core machines" in https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor
     ) as threadpool:
-        outputs = threadpool.map(_get_cpp_command_for_files, aquery_output.actions)
+        outputs = threadpool.map(worker, aquery_output.actions)
 
     # Yield as compile_commands.json entries
     header_files_already_written = set()
@@ -924,7 +970,25 @@ def _get_commands(target: str, flags: str):
     Continuing gracefully...""")
         return
 
-    yield from _convert_compile_commands(parsed_aquery_output)
+    output_path_process = subprocess.run(
+        ['bazel', 'info', 'output_path'],
+        capture_output=True,
+        encoding=locale.getpreferredencoding(),
+    )
+
+    output_path = pathlib.Path(output_path_process.stdout.strip())
+
+    output_base_process = subprocess.run(
+        ['bazel', 'info', 'output_base'],
+        capture_output=True,
+        encoding=locale.getpreferredencoding(),
+    )
+
+    output_base = pathlib.Path(output_base_process.stdout.strip())
+    external_path = output_base.joinpath("external")
+
+    bazel_info = BazelInfo(output_path, external_path)
+    yield from _convert_compile_commands(parsed_aquery_output, bazel_info)
 
 
     # Log clear completion messages

refresh_compile_commands.bzl

@@ -55,6 +55,9 @@ refresh_compile_commands(
 
     # refresh_compile_commands will automatically create a symlink for external workspaces at /external.
         # You can disable this behavior with link_external = False.
+
+    # refresh_compile_commands does not work with --experimental_convenience_symlinks=ignore.
+        # For these workspaces, you can use absolute paths to the bazel build artifacts by setting rewrite_bazel_paths = True.
 ```
 """
 
@@ -71,6 +74,7 @@ def refresh_compile_commands(
         exclude_external_sources = False,
         update_gitignore = True,
         link_external = True,
+        rewrite_bazel_paths = False,
         **kwargs):  # For the other common attributes. Tags, compatible_with, etc. https://docs.bazel.build/versions/main/be/common-definitions.html#common-attributes.
     # Convert the various, acceptable target shorthands into the dictionary format
     # In Python, `type(x) == y` is an antipattern, but [Starlark doesn't support inheritance](https://bazel.build/rules/language), so `isinstance` doesn't exist, and this is the correct way to switch on type.
@@ -103,6 +107,7 @@ def refresh_compile_commands(
         exclude_external_sources = exclude_external_sources,
         update_gitignore = update_gitignore,
         link_external = link_external,
+        rewrite_bazel_paths = rewrite_bazel_paths,
         **kwargs
     )
 
@@ -133,6 +138,7 @@ def _expand_template_impl(ctx):
             "{exclude_external_sources}": repr(ctx.attr.exclude_external_sources),
             "{update_gitignore}": repr(ctx.attr.update_gitignore),
             "{link_external}": repr(ctx.attr.link_external),
+            "{rewrite_bazel_paths}": repr(ctx.attr.rewrite_bazel_paths),
         },
     )
     return DefaultInfo(files = depset([script]))
@@ -144,6 +150,7 @@ _expand_template = rule(
         "exclude_headers": attr.string(values = ["all", "external", ""]),  # "" needed only for compatibility with Bazel < 3.6.0
         "update_gitignore": attr.bool(default = True),
         "link_external": attr.bool(default = True),
+        "rewrite_bazel_paths": attr.bool(default = False),
         "_script_template": attr.label(allow_single_file = True, default = "refresh.template.py"),
         # For Windows INCLUDE. If this were eliminated, for example by the resolution of https://github.com/clangd/clangd/issues/123, we'd be able to just use a macro and skylib's expand_template rule: https://github.com/bazelbuild/bazel-skylib/pull/330
         # Once https://github.com/bazelbuild/bazel/pull/17108 is widely released, we should be able to eliminate this and get INCLUDE directly. Perhaps for 7.0? Should be released in the sucessor to 6.0