Dustin Shahidehpour

This commit performs a **maintenance fix** within the `folly/BUCK` file by **removing a tuple used as a key** in the `compiler_flags` definition. This change addresses a **parsing issue** encountered by a new ruff-based **Starlark formatter**, which was unable to process tuples as keys. By modifying the `folly/BUCK` file to use a compatible key format, this commit unblocks the **rollout of the Starlark formatter** for the `folly` module, ensuring proper parsing and formatting.

This commit **refactors** the propagation of XPlugins debug artifacts and usage information, moving this responsibility from the `apple_binary` rule to the underlying **Cxx build rules**. This change centralizes XPlugins data handling within the Cxx layer, as Cxx targets are the primary consumers of XPlugins. Specifically, **Cxx modules** like `cxx_binary_impl`, `cxx_executable`, and `cxx_library_parameterized` are enhanced to propagate this information, while `apple_binary_impl` is simplified to consume it from its Cxx dependencies. This architectural improvement ensures more consistent and robust XPlugins data flow across all Cxx-based targets, including Apple binaries.

This commit **refactors** the `get_xplugins_usage_subtargets` function within the **`prelude/xplugins/utils.bzl` module** to **deduplicate logic**. It extracts common manifest processing into new helper functions, `_process_manifest` and `_make_manifest_providers`, and introduces a record type for better data encapsulation. This **refactoring** significantly improves code organization and maintainability within the **`xplugins` subsystem**. The change enhances the internal structure of the utility module without altering its external behavior or functionality.

This commit introduces a **refactoring** across the build system to **reduce unnecessary memory allocations** during attribute processing. Specifically, it optimizes **C++ build system utilities** within `cxx_library_utility.bzl` by simplifying direct attribute access for dependencies and linker flags, eliminating redundant list copies in functions such as `cxx_attr_deps` and `cxx_attr_linker_flags_all`. The **Apple prebuilt framework implementation** in `prelude/apple/prebuilt_apple_framework.bzl` is also updated to directly retrieve exported linker flags, further streamlining attribute handling. This **performance optimization** aims to improve overall build efficiency by minimizing object creation and memory footprint, particularly benefiting C++ and Apple framework builds.

This commit introduces a **new capability** to the **Buck2 superconsole** by adding a "Running validations." progress line, significantly **improving user experience** during builds with validation actions. Previously, the superconsole appeared to "hang" as rapid validation actions were not visibly tracked, but now a dedicated line provides clear visibility into this phase. This feature tracks `SingleValidationKey` DICE states, appearing after action execution and before build completion, and is only displayed when validations are active. The change primarily affects the `buck2_client_ctx` module for rendering and the `buck2_event_observer` module for progress tracking logic, enhancing the overall build progress reporting.

This commit introduces a **new capability** to collect and expose **XPlugins debug artifacts** within Apple binaries and bundles, significantly improving the **debugging experience for XPlugins**. It provides a standardized way to generate a debug artifacts directory and manifest, making this information available as subtargets and providers. The feature is integrated into the `apple_binary`, `apple_library`, and `apple_test` rules, and most notably exposed via the `apple_bundle` rule. This involves new type definitions in `prelude/xplugins/types.bzl` and core logic for artifact collection in `prelude/xplugins/debug_artifacts.bzl`.

This commit introduces a **performance optimization** and **refactoring** across the **Apple and C++ build rules** to reduce unnecessary memory allocations. It modifies `apple_binary_impl` and `apple_bundle_impl` in `prelude/apple/` to avoid redundant list concatenations of `deps` and `exported_deps`, instead reusing pre-calculated dependency lists. Concurrently, the `make_link_command_debug_output_json_info` function in `prelude/linking/link_info.bzl` and its callers in `cxx_executable` and `cxx_library` are refactored to explicitly pass `ctx.actions`. This work aims to **improve build system efficiency** by reducing memory footprint and potentially speeding up dependency processing within these core build components.

This commit **introduces** the `XPluginsManifestInfo` provider and an associated `xplugins_manifest` rule within the **`prelude/xplugins` module**. This **new capability** establishes a structured way to hold function mapping and manifest artifacts. The `XPluginsManifestInfo` is specifically designed to be propagated and aggregated within the prelude, enabling a centralized collection of these mappings. This foundational work is crucial for future plugin management and aggregation logic.

This commit **improves diagnostic capabilities** for **BXL test failures** by ensuring that `stderr` output is properly surfaced. Previously, `bxl_test` executions would hide `stderr`, obscuring critical Starlark backtraces needed for debugging. This **bug fix** modifies the error handling within `tests/e2e_util/test_bxl_template.py` to append the `stderr` content upon test failure. As a result, developers will now receive comprehensive failure messages, significantly **simplifying the debugging process** for BXL tests.

This commit **refactors** the **Apple framework linking logic** to optimize the construction of `-framework` and `-weak_framework` flags. Specifically, it modifies `get_framework_linker_args` and `_get_unchecked_framework_linker_args` in `prelude/apple/apple_framework_versions.bzl` to return `cmd_args` objects instead of `list[str]`. This **performance optimization** avoids intermediate list allocations and leverages `cmd_args`'s efficient composability for library linker flags. The change results in a significant **memory reduction**, notably a **1.81 GiB drop in resident memory (RSS)**, improving overall system resource utilization.

This commit **refactors** the **Apple framework linker argument generation** within `prelude/apple/apple_framework_versions.bzl` and `prelude/apple/apple_frameworks.bzl`. Functions like `get_framework_linker_args` and `_get_apple_frameworks_linker_flags` now return and construct arguments using `cmd_args` objects instead of `list[str]`. This **performance optimization** reduces intermediate list allocations and leverages `cmd_args` composability, streamlining the process of building linker flags. The change significantly improves memory efficiency, leading to a notable **reduction in resident memory (RSS)** by 1.6 GiB, without increasing allocation pressure.

This commit introduces a **new capability** by adding the `dump_failures` BXL entrypoint to the **validation auditing system**. This new entrypoint allows users to easily inspect and report validation failures by opening the `ValidationSpec` and collecting failure messages. Concurrently, it **refactors** the `prelude/validation/audit_results.bxl` module by centralizing validation result retrieval into a new helper function, `_get_results`, which simplifies the codebase and removes redundancy. This change significantly improves the **diagnosability** of validation issues and enhances the overall readability and maintainability of the validation logic.

This commit **refactors** the **`prelude/validation/audit_results.bxl` script** to leverage **lazy evaluation** using `ctx.lazy` for configured targets and analysis. This **enhances robustness** by allowing the script to proceed even when encountering configuration errors, preventing premature termination. Additionally, a **new `take` CLI argument** is introduced, enabling users to **filter specific validation specs** and gain more granular control over the audit process. This **new feature** significantly improves both the reliability and usability of the audit results generation.

This commit **refactors** the **`prelude`'s framework and library linking logic** to consistently use **sets** for `FrameworkLinkables` instead of lists. This change **improves deduplication and efficiency** by eliminating redundant deduplication passes across different layers, thereby **reducing memory usage**. Specifically, functions within **`prelude/apple/apple_frameworks.bzl`** are updated to process these new set-based structures, and the `FrameworksLinkable` definition and `_merge_framework_linkables` function in **`prelude/linking/link_info.bzl`** are adapted. This **performance optimization** streamlines the management of linkable dependencies, particularly benefiting **Apple build targets**.

This commit **fixes a bug** in the **Buck2 Swift compilation database** generation by refactoring the `cmd_args` passed to `other_outputs`. Previously, the `swift-compilation-database` subtarget did not include source files, leading to "file not found" errors when tools like codemods attempted to access them. The change ensures that **source files are properly materialized** by including them alongside the `argsfile.cmd_form` in the `other_outputs` of the `_create_compilation_database` function within `prelude/apple/swift/swift_compilation.bzl`. This resolves issues with downstream tools relying on the compilation database for accurate file paths.

This commit introduces a **new capability** to propagate `ValidationSpecs` to **`cxx_binary`** and **`cxx_test`** rules, enhancing the build system's ability to enforce validation constraints on C++ executables and tests. It extends the `cxx_binary` and `cxx_test` rule definitions in `prelude/decls/cxx_rules.bzl` and `prelude/cxx/cxx.bzl` to accept and process `attrs_validators`, ensuring that validation information is correctly associated and passed through these targets. The `CxxExecutableOutput` in `prelude/cxx/cxx_executable.bzl` is updated to store these specs, and the `apple_binary` rule in `prelude/apple/apple_binary.bzl` is refactored to consume these newly propagated validation specifications. This change allows for more robust and integrated validation checks across C++ and Apple build targets.

This commit **introduces attribute validation capabilities to the `java_test` rule**, mirroring functionality already present in `java_library`. It **adds `attrs_validators_arg`** to the `java_test` rule definition in `prelude/decls/java_rules.bzl` and modifies the `java_test_impl` function in `prelude/java/java_test.bzl` to conditionally append validation information. This **new capability** allows developers to define and enforce attribute constraints for `java_test` rules, thereby enhancing their robustness and maintainability.

This commit **refactors** the **Swift error handling** logic within `prelude/apple/apple_error_handler.bzl` to improve error categorization. It introduces and utilizes a new `subcategory` field, allowing for more precise classification of errors and effectively **shortening existing error categories**. This change enhances the diagnostic capabilities for Apple-related build issues by providing more granular and clearer error messages. The `swift_error_handler` symbol is specifically updated to leverage this new categorization scheme.

This commit **refactors** the **Swift error handler** within the `prelude/apple` module to incorporate a new `remediation` field. The `swift_error_handler` function will now utilize this field to enhance error messages and conditionally control `stderr` output. This **enhancement** aims to provide more informative and actionable error reporting for Swift builds, improving the developer experience by offering clearer guidance.

This commit **enhances C++ error handling** within the **Apple build system** by integrating remediation messages and subcategories into `ActionSubError` instances. Specifically, the `cxx_error_handler` in `prelude/apple/apple_error_handler.bzl` is updated to provide these additional details. This **enhancement** improves the diagnostic information for C++ build failures, offering clearer context and actionable steps for developers to resolve issues.