Nikita Patskov

This commit introduces a **new capability** by adding the `UploadFileToCas` gRPC RPC to the **TestOrchestrator service**. This enables external clients, such as `tpx`, to request that `buck2` upload a local file to Content Addressable Storage (CAS) and return its unique digest. The change spans the **`buck2_test_proto`**, **`buck2_test_api`**, and **`buck2_test`** modules, encompassing new protocol buffer definitions, updates to the `TestOrchestrator` trait, and the necessary gRPC client/server plumbing. A stub implementation for the `upload_to_cas` method is included, establishing the foundation for future CAS integration within the test orchestration system.

This commit **implements a new feature** in **`buck2_test`** to **upload local test artifacts to Content-Addressable Storage (CAS)**. It introduces the `upload_to_cas` RPC handler in `app/buck2_test/src/orchestrator.rs` and a new `upload_local_file` method in `ReClientWithCache` within `app/buck2_test/src/remote_storage.rs`. This functionality allows `buck2` to read local files, compute their digests, and upload them to CAS via the remote execution client. The primary impact is enabling `tpx` to store test artifacts in CAS, replacing the previous Everstore mechanism for artifact storage.

This commit introduces a **new capability** to explicitly manage the Time-To-Live (TTL) and use case for artifacts uploaded to the Content Addressable Storage (CAS) within the **Buck2 test orchestrator**. It modifies the `upload_to_cas` and `upload_local_file` functions across the `buck2_test` and `buck2_test_api` modules to accept `ttl_seconds` and `use_case` parameters. This change ensures that test artifacts, particularly those reported or re-reported, can have their retention period extended to prevent premature expiration. The **gRPC interface** and **protobuf definitions** for `UploadFileToCasRequest` were updated to support these new parameters, providing more granular control over remote artifact lifecycle management.

This commit performs a **maintenance cleanup** by **removing an unused field** from a data structure or class. This action improves code clarity and slightly reduces the memory footprint by eliminating dead code. The change primarily affects the **internal implementation** of a component, streamlining its definition without altering external behavior or functionality.

This commit performs a **refactoring** within the **C++ build system's linking logic** by making an internal helper function private. Specifically, the `cxx_link` function in `prelude/cxx/link.bzl` has been renamed to `_cxx_link` to clearly mark it as an internal implementation detail. This **cleanup** effort improves encapsulation and clarifies the intended usage of the function, ensuring it is only invoked internally within the `prelude/cxx` module. All existing internal calls to `cxx_link` have been updated to use `_cxx_link`, preventing any functional changes or regressions.

This commit performs a **refactoring** and **cleanup** within the **C++ linking rules** by extracting specific logic for building shared library options. The logic previously embedded in the `cxx_link_shared_library` function is now encapsulated into a new, private helper function named `_build_cxx_link_shared_library_options` within `prelude/cxx/link.bzl`. This improves the modularity and maintainability of the **shared library build process** by centralizing option generation. The change is purely an internal code organization improvement and has no functional impact on the generated shared libraries.

This commit implements a **bug fix** within the **`folly/debugging/symbolizer`** module by **increasing the `kSmallSigAltStackSize` constant** in `folly/debugging/symbolizer/SignalHandler.cpp` to 65536. This adjustment addresses observed stack overflows during symbolization, particularly when using ASAN and processing async stacks in C++ tests. The change ensures more robust and reliable symbolization by providing sufficient stack space for the alternate signal handler, preventing crashes and improving the stability of debugging tools.

This commit introduces a **new feature** to the **build graph pattern matching system**, adding a `root/...` pattern to simplify target selection. This pattern enables matching all build targets located within the root directory and its subfolders, addressing a common need for debugging and broad target inclusion. The `parse_build_graph_pattern` function in `prelude/utils/build_graph_pattern.bzl` is updated to support this new capability. This enhancement significantly **streamlines configuration at the macro level** by providing a clear and concise way to define widespread target sets, particularly useful for debugging entire project subtrees.

This commit introduces a new `supports_stripping` attribute to **C++ build rules** within the `prelude` build system, allowing granular control over whether C++ objects are stripped during compilation. This **feature addition** specifically addresses an issue where default stripping in `ti/edgeray` interfered with its bitcode compilation and graph analysis. By setting `supports_stripping` to `false` for `ti/edgeray`, the module can now correctly generate bitcode. This **maintenance fix** ensures `ti/edgeray`'s functionality while providing a general mechanism for future stripping control across C++ libraries and Python extensions.

This commit **reverts** the test changes introduced by a previous feature that materialized `native-executable dwp` when modifier constraints were present. It addresses an oversight where the original code revert (D83880616) did not include its corresponding tests. This **maintenance** action ensures the **testing infrastructure** accurately reflects the current state of the codebase. By removing these orphaned tests, it prevents potential failures or confusion related to the `native-executable dwp` materialization logic, ensuring a cleaner and more consistent test suite.

This commit **fixes a logic error** in the **linking process** by ensuring that **transformation specifications** (`transformation_spec`) correctly take precedence over the `prefer_stripped` argument when determining how binaries are stripped. Previously, the stripping logic could be misapplied, leading to incorrect build outputs. The change refactors the `prelude/linking/link_info.bzl` module, introducing `_get_non_transformed_info` and modifying `get_link_info_for_transformation` to implement this priority. This **logic correction** guarantees that build transformations consistently apply the intended stripping behavior, improving the reliability of generated artifacts.

This commit **enables content-based hashing** for **private headers** within the **Buck build system's C++ preprocessor rules**. This **bug fix** addresses a previously observed lack of deduplication for private headers, where identical files were not being recognized as such. By deriving the header's hash from its content, the build system can now correctly identify and deduplicate these headers, improving **build efficiency** and reducing redundant file generation. The change is implemented in `prelude/cxx/preprocessor.bzl` by passing a new argument to the `prepare_headers` function.

This commit **fixes an oversight** in the **linking subsystem** by ensuring that link argument generation now properly **respects the configured link ordering** for different linkers. Previously, this configuration was missed, potentially leading to incorrect link order. The `get_link_args_for_strategy` function in `prelude/linking/link_info.bzl` has been modified to honor these settings, defaulting to 'preorder' if no specific ordering is defined. This **maintenance update** improves the robustness and correctness of the build process by aligning with linker-specific requirements.

This commit introduces **support for `transformation_spec` within the Rust build system**, specifically for **link group handling**. It **enables the propagation of `transformation_spec_context`** by modifying `_rust_binary_common` in `rust_binary.bzl` to create and pass this context, and updating `inherited_rust_cxx_link_group_info` in `link_info.bzl` to accept and utilize it. This **new capability** is essential for **migrating Rust targets off older, link group-based APIs**, ensuring a more unified and modern approach to dependency management across the project. The change allows Rust binaries to leverage the existing `transformation_spec` infrastructure, streamlining future development and maintenance.

This commit introduces a **new capability** by allowing **transformation specifications** to be passed to **Rust binaries and tests**. It modifies the `rust_binary` and `rust_test` build rules in `prelude/decls/rust_rules.bzl` to accept a `transformation_spec_arg`. This change is essential for migrating Rust projects away from older link group-based APIs, enabling them to leverage the more modern transformation specification system. The implementation is designed for ease of use, as existing internal handling logic will automatically process the propagated specification values without further modification.

This commit **enables transformation specifications** for **Rust binaries** when configured with **shared linking**. This **enhancement** is a significant **infrastructure improvement** aimed at migrating the Rust build system away from outdated link group-based APIs. It achieves this by integrating new build graph and transformation spec context functions within the `_rust_binary_common` function in `prelude/rust/rust_binary.bzl`. The change simplifies configuration by propagating necessary values, ensuring consistent and robust handling of shared linkage within the **Rust build system**.

This commit introduces a **new capability** by **enabling transformation specifications for Rust compilation**, particularly for static linking scenarios. It modifies the **Rust build system**, specifically updating the `rust_compile` function in `prelude/rust/build.bzl` and `_rust_binary_common` in `prelude/rust/rust_binary.bzl` to accept and propagate a `transformation_spec_context` parameter. This change allows the Rust build process to leverage these specifications, facilitating a migration away from older link group-based APIs and **modernizing the Rust build infrastructure** by ensuring proper context propagation for static linkage.

This commit **enables the configuration of `transformation_spec`** for both **`cxx_binary`** and **`cxx_test`** build rules, standardizing its usage across these critical C++ targets. It introduces a new helper function, `_transformation_spec_arg` in `prelude/decls/native_common.bzl`, to centralize the attribute definition for this feature. The `transformation_spec` argument is then added to `cxx_binary` and `cxx_test` in `prelude/decls/cxx_rules.bzl`, while `cxx_test`'s existing definition is refactored to utilize the new common helper. This **new capability** and **refactoring** streamlines the rollout and management of transformation specifications for C++ applications and tests.

This commit introduces **pattern matching capabilities** to the **`transformation_spec`** system, allowing users to define transformations for entire folders or groups of targets using patterns like `//some/folder/...`. This **new feature** enhances the flexibility of applying transformations, moving beyond exact target matches to support broader, directory-level specifications. It modifies `prelude/cxx/transformation_spec.bzl` by adding helper functions like `_build_pattern_matcher` and updating `transformation_spec_impl` to process these patterns. This change enables more efficient and scalable application of optimizations across cohorts of targets, reusing existing `BuildTargetPattern` logic.

This commit introduces a **new capability** to the build system, allowing **transformation specifications** to be applied specifically to the **first-order dependencies** of a target. This is achieved by enhancing the **build graph pattern matching system** in `prelude/utils/build_graph_pattern.bzl` to recognize and match `first_order_deps`, and updating the `cxx_executable` rule to pass necessary CXX dependency information. This **feature** enables more **focused debugging** by allowing specific transformations, such as "debug" transformations, to be precisely applied to a root target and its immediate dependencies. The change provides finer-grained control over build transformations, improving the efficiency and scope of debugging efforts.