Nuri Amari

This commit **fixes a bug** in the **Cxx build rules** by refining the logic for **shared library interface generation** for **prebuilt libraries**. Previously, a generic check for `cxx_use_shlib_intfs` incorrectly triggered interface generation in unintended modes, leading to unsafe behavior when other shared library interface modes were enabled globally. The change **refactors** the `_create_prebuilt_library_outputs` and `prebuilt_cxx_library_group_impl` functions to explicitly check for the `defined_only` mode using `cxx_use_shlib_intfs_mode`. This ensures that shared library interfaces are only generated for prebuilt libraries when the specific `defined_only` mode is active, preventing incorrect builds and enhancing the stability of the **build system**.

This commit **improves the C++ linking infrastructure** by **modifying the `cxx_link_into` function** within `prelude/cxx/link.bzl`. It now explicitly passes the `-o output` argument to the linker during **shared library interface generation**. This **enables the linker to infer the `install name`** for shared libraries, even when not explicitly provided, ensuring more consistent and robust build behavior. This **fix** aligns the interface generation process with existing practices for distributed thin-LTO, preventing potential issues where the `install name` might otherwise be undefined or incorrect.

This commit introduces a **new capability** by adding **pass plugin infrastructure** to **Darwin distributed thin-LTO** rules. It modifies the `cxx_toolchain` definition in `prelude/cxx/cxx_toolchain.bzl` to accept a `pass_plugin` attribute and extends the `CxxToolchainInfo` provider in `prelude/cxx/cxx_toolchain_types.bzl` to include this field. Crucially, the `prepare_opt_flags` function in `prelude/cxx/dist_lto/darwin/dist_lto.bzl` is updated to incorporate the specified pass plugin into the linker flags. This enables the use of custom compiler passes during distributed thin-LTO on Darwin platforms, allowing for more flexible and powerful compiler optimizations within the build system.

This commit **enables compiler optimizations** for the `distributed_thin_lto` planner host tool by adding the `-O2` flag to its `cxx_binary` build configuration. This change specifically affects the **build process** of this **native tool** within the `prelude/apple/tools` module. The primary goal is to **improve the runtime performance** of the planner host tool, which can lead to more efficient distributed builds. This is a **maintenance** task focused on optimizing the build configuration for a critical component.

This commit **removes the external `llvm-tbd-gen` tool** and its associated usage from the project. This is a **cleanup and maintenance** task, as the functionality for generating TBD files from object files has been integrated directly into the **linker**. The change streamlines the build process by eliminating a **redundant external dependency**, consolidating TBD generation within the core toolchain. This simplifies the overall system and reduces maintenance overhead by removing an unnecessary component.

This commit performs **maintenance** by **removing an unused attribute**, `cxx_toolchain`, from the `shared_library_interface_type` configuration. This attribute was not being read or having any functional effect within the build system. The change cleans up the codebase by eliminating dead code, as the correct and active attribute for this purpose is `shared_library_interface_mode`. There is no downstream impact on functionality or behavior, as the system already relies on the correctly spelled attribute.

This commit **enables content-based output path hashing** for `cxx_compile` actions within **Apple build rules** such as `apple_library`, `apple_binary`, and `apple_test`. This **new capability** is activated when the `uses_experimental_content_based_path_hashing` attribute is set on the **CXX toolchain**, modifying `_compile_single_cxx` to use these paths and extending `cxx_toolchain_impl` to support the new attribute. It also includes **fixes** to prevent `cxx_link_into` and `rust_compile` from using content-based paths for split debug information with **Darwin linkers**, as these platforms handle paths differently. This enhancement aims to improve build caching and determinism for C++ compilation in Apple projects.

This commit **enhances the distributed ThinLTO (dthin-lto) build system** on **Darwin** by **enabling content-based output paths** for most generated artifacts. It modifies `prelude/cxx/dist_lto/darwin/dist_lto.bzl` and `prelude/cxx/dist_lto/darwin/thin_link.bzl` to update functions like `create_output_first_codegen_round_native_object_file` and `thin_link` for index, metadata, and other LTO artifacts. An important exception is made for pre-merged bitcode files, which retain traditional paths to prevent issues with references in index summary shard files. This **feature enhancement** improves build system efficiency and correctness by leveraging content-based paths where possible. Additionally, a new target platform is introduced to expand `dthin-lto` test coverage.

This commit introduces a **new capability** by adding the `has_content_based_path` attribute to the **`remote_file`**, **`http_file`**, and **`http_archive`** rules. This attribute enables these rules to generate output paths that are derived from the content of the downloaded or unarchived files, rather than relying on fixed locations. The change involves updating the rule declarations in `prelude/decls/core_rules.bzl` and modifying the respective implementation functions, such as `http_archive_impl`, `http_file_impl`, and `unarchive`, to correctly process and utilize this new parameter. This enhancement provides users with greater control over output path generation, potentially improving caching efficiency and build reproducibility for external dependencies.

This commit **refactors** how the final native link's object file list is generated within the **ThinLTO build system**. Previously, the `thin-link` process relied on brittle path prediction for native object files, which was incompatible with content-based output hashing. Instead, **Starlark linker rules** now dynamically construct this list using `dynamic_output` from `thin-link` and a new `final_link_line_position` field in optimization plans. This **refactoring** impacts the `dist_lto_planner` C++ tool and Python script, along with `dist_lto.bzl` and `thin_link.bzl` Starlark rules, to enable **content-based output path hashing** for native object files.

This commit performs a **refactoring** to resolve **Starlark linting errors** within the **C++ distributed LTO and general linking prelude files** (`prelude/cxx/dist_lto/darwin/dist_lto.bzl` and `prelude/cxx/link.bzl`). It addresses warnings about unused local helper functions by **inlining the logic** of `_get_shared_library_interface_generation_linker_flags` directly into `generate_shared_library_interface` and `cxx_link_into`. This **maintenance** change improves code hygiene and ensures compliance with linter rules, specifically for the **Buck2 C++ build system**, without altering functional behavior.

This commit provides a **bug fix** for the **OSS build system** by correcting the application of the `oss-disable` comment directive. Previously, an incorrect usage of this directive led to build failures in **Open Source Software (OSS) builds**. The fix specifically targets the `_get_shared_library_interface_generation_linker_flags` function within the **C++ build prelude** files `prelude/cxx/dist_lto/darwin/dist_lto.bzl` and `prelude/cxx/link.bzl`. This ensures proper code inclusion management, thereby **restoring the functionality of the OSS build** for C++ projects, particularly those involving distributed LTO and shared library linking.

This commit introduces a new helper function, `create_local_linker_invocation`, within the **C++ linking infrastructure** defined in `prelude/cxx/link.bzl`. This is a **refactoring** effort that encapsulates the complex logic for generating arguments for local linker invocations, specifically within the `cxx_link_into` function. The helper is designed to accept a boolean parameter, allowing callers to control whether standard linker output artifacts are included in the generated command arguments. This change prepares the groundwork for future enhancements, enabling more flexible linker invocations, such as generating interface artifacts without conventional outputs, which will **optimize C++ build processes**.

This commit introduces a **new capability** to generate **shared library interfaces** directly from the linker, controlled by a new `produce_shared_library_interface` option within `LinkOptions`. This interface, now included in `CxxLinkResult`, allows reverse dependencies to link against a lightweight stub instead of the full shared library, significantly **improving build performance** and **reducing resource consumption**, especially for LTO builds. The implementation primarily affects the **Cxx linking rules** and **distributed thin-LTO processes** on **Darwin**, with modifications across `prelude/cxx/link.bzl`, `prelude/cxx/dist_lto/darwin/dist_lto.bzl`, and related files. This feature provides a substantial **optimization for C++ builds** by avoiding redundant full link unit generation, though it is currently limited to Darwin.

This commit **refactors** the **C++ shared library interface generation logic** by removing the unused and ambiguous `'enabled'` value from the `ShlibInterfacesMode` enum in `prelude/cxx/cxx_toolchain_types.bzl`. It introduces an `effective_shlib_interfaces_mode` calculation within `prelude/cxx/cxx_library.bzl` to accurately account for opt-outs required by `ShlibInterfacesMode("defined")`. This **cleanup and simplification** improves the clarity and robustness of how shared library interfaces are managed. The change **prepares the system for future enhancements** to `cxx_link_shared_library` by providing a clearer mechanism for determining the active shared library interface mode.

This commit **refactors** the logic for determining if a dylib is "extension safe" within the **C++ build rules**, specifically impacting the `_shared_library` function in `prelude/cxx/cxx_library.bzl`. It addresses an inaccuracy where `ResolvedStringWithMacros` objects caused the previous `is_extension_safe` check to be unreliable. The updated logic now iterates through linker flags to provide a more robust, albeit not yet perfect, determination of this flag. This **maintenance fix** is primarily intended to enable a **quick experiment for TBD generation**, allowing for evaluation of its impact before pursuing a more comprehensive solution.

This commit introduces a **new capability** to the **`cxx_library` rule** by enabling the generation of shared library interfaces (TBD files) directly from object files. This **performance enhancement** allows the interface to be produced faster than the full shared library can be linked, significantly improving **build parallelism** for dependent link units. The change involves extending the CXX toolchain types, adding utility functions in `prelude/cxx/shared_library_interface.bzl` and `prelude/linking/link_info.bzl` to handle this new generation mode, and integrating it into the `_shared_library` rule. This optimizes the build process by decoupling interface generation from full library linking, particularly impacting **CXX linking and build performance**.

This commit **removes the `tbd from headers` functionality** within the **C++ library definition and toolchain configuration**. It specifically **refactors** the `prelude/cxx` module by deleting the mechanism that attempted to generate shared library interfaces directly from header files, including related parameters in functions like `cxx_library_parameterized` and the `stub_from_headers` option from the `ShlibInterfacesMode` enum. This **cleanup** eliminates an unused and overly complex approach that proved difficult to implement effectively. The removal simplifies the codebase and prepares for a future, more viable solution for shared library interface generation based on object files.

This commit introduces a **new capability** to the **native planner** for **distributed thin-LTO thin-link**. A new command-line flag is added to `dist_lto_planner.cpp` that allows users to **dump the final linker invocation command** to stdout instead of executing it. This **debugging enhancement** addresses the complexity of understanding linker arguments when multiple wrapper layers modify them. By providing visibility into the exact command, this change will significantly ease the process of **debugging thin-link failures**.

This commit introduces a **new capability** to generate **modularization dependency graphs** for **Apple Swift modules**. It adds a `modularization-dependency-graph` subtarget to `apple_library` rules, allowing users to explicitly materialize the dependency structure of their Swift codebases. The change integrates a new compilation function, `_compile_modularization_dependency_graph`, into the existing `SwiftCompilationOutput` process and provides specific output file mapping via `get_modularization_dependency_graph_output_map`. This enhancement provides valuable insights into module interdependencies, aiding in build optimization and architectural analysis, alongside a minor **refactoring** of incremental Swift compilation constants.