Simon Krueger

This commit **enhances the definition and documentation** for the `clang_trace` field within the **C++ toolchain configuration** (`CxxToolchainInfo`). It **updates the type annotation** in `prelude/cxx/cxx_toolchain_types.bzl` from a generic `Any` to a more precise `bool`, improving static analysis and code clarity. Furthermore, **explanatory documentation is added** to clarify the purpose and expected usage of the `clang_trace` attribute. This **maintenance** effort provides better type information and developer guidance for users interacting with the `CxxToolchainInfo` structure.

This commit **enhances critical path analysis data** within Buck2 by introducing and populating the `target_rule_type_name` field. It modifies the **Buck2 data schema** (`buck2_data`) to include an optional `target_rule_type_name` in the `CriticalPathEntry2.Analysis` protocol buffer message. Concurrently, the **Buck2 build signals implementation** (`buck2_build_signals_impl`) is updated to populate this `target_rule_type_name` for `AnalysisKey` nodes during critical path generation. This **new capability** provides **more granular insights** into the types of rules contributing to build critical paths, aiding in performance optimization and debugging.

This commit introduces a **new capability** to store the `target_rule_type_name` (e.g., `cxx_library`) for **analysis nodes** within the `NodeData` structure, specifically for the critical path logger. This **enhancement** to the **`buck2_analysis`** and **`buck2_build_signals_impl`** modules enables future measurement of analysis overhead broken down by rule type, which was previously only available for actions. The implementation refactors internal data representation by introducing a `NodeExtraData` enum to uniformly handle both action and analysis-specific metadata, ensuring that even forward targets are correctly labeled by their `configured_node.rule_type()`. This is a foundational change for improved **telemetry** of the build graph, though the actual logging to the critical path is deferred to a subsequent change.

This commit significantly **reduces memory allocations** within the **Rust build system** by **refactoring** how transitive dependency symlinks are managed. It moves the `simple_symlinked_dirs` logic into the `transitive_dependency_symlinks.py` tool, enhancing it to support relative output paths for `-Ldependency=` and to generate `cmd_args` for argsfiles, which is crucial for `rustc` shim calls in `cargo_buildscript`. This **performance optimization** primarily affects `prelude/rust/build.bzl`, `cargo_buildscript.bzl`, and `link_info.bzl`, resulting in a substantial 5.56% reduction in allocated bytes and an 83% decrease in "symlinked_dir" memory samples. The change improves the efficiency of **Rust compilation**, particularly for projects utilizing `cargo_buildscript`.

This commit introduces a significant **performance optimization** to the **Rust build system** by refactoring how `rustdoc_test` targets generate their shared library symlink trees. It leverages `TransitiveSet` projections and a new `shared_libraries_symlink_tree.py` tool to efficiently create these trees, eliminating redundant `TransitiveSet#traverse` calls previously made in each `rust_library`. This **refactoring** of the `generate_rustdoc_test` function and related `prelude/linking` and `prelude/rust/link_info` modules results in substantial reductions in build time, heap allocations, and overall resource consumption for Rust projects. The change specifically impacts the **Buck2 build system's handling of Rust shared libraries**, leading to faster and more efficient builds.

This commit **refactors** the `executable_shared_lib_arguments` function within the **`prelude/cxx/cxx_link_utility.bzl`** module. It introduces a new templated version, `executable_shared_lib_arguments_template`, and extracts logic for creating debug information and shared library symlink trees into dedicated helper functions like `create_external_debug_info` and `create_shared_libs_symlink_trees`. This **preparatory refactoring** is the first part of a two-part series designed to improve memory usage in `fbcode/buck2/prelude/rust/build.bzl#generate_rustdoc_test` by enabling the use of Transitive Sets for symlink trees. Although this specific change slightly increases memory allocations, it is a necessary foundation for the subsequent, more impactful memory optimizations.

This commit introduces a **performance optimization** to the **C++ build system's header processing** by refactoring the `cxx_attr_headers_list` function in `prelude/cxx/headers.bzl`. It semantically reduces heap allocations by ensuring that memory is no longer allocated for platform headers that do not exist. This change leads to a more efficient build process, significantly decreasing the number of calls, allocations, and total allocated bytes. The primary impact is a **reduction in heap allocations** during the build process, improving overall resource utilization for C++ builds.

This commit performs a **refactoring** of the **Buck2 C++ rules** to **optimize memory allocation**. It replaces manual filtering and mapping of provider information, such as shared library details, Clang traces, and preprocessor infos, with the more efficient `filter_and_map_idx` utility function across several `prelude/cxx/*.bzl` files. This change significantly **reduces heap allocations** by over 100MB and 1.3 million individual allocations, improving overall build performance for C++ targets. The adoption of `filter_and_map_idx` also serves as a **code cleanup**, standardizing the approach for collecting providers from dependencies.

This commit introduces a **performance optimization** and **refactoring** to **reduce allocations and calls** within the C++ build system's linker flag generation. Specifically, the `cxx_attr_linker_flags` function in `prelude/cxx/cxx_library_utility.bzl` was refactored to replace the `flatten` utility with an explicit loop and `extend` for handling platform-specific linker flags. This change measurably decreases heap allocations (0.17%) and calls (0.47%), particularly for `list` and `array` objects. The **optimization** improves the efficiency and reduces the memory footprint of C++ target builds.

This commit introduces a **memory optimization** within the **build system's linking prelude**. It **refactors** the `merge_swiftmodule_linkables` function in `prelude/linking/link_info.bzl` to return an empty `SwiftmoduleLinkable` object when no linkables are provided. This change avoids unnecessary object allocations, resulting in a notable **reduction in retained and allocated heap memory** during build execution. Specifically, it decreases the number of `record` and `dict` objects, contributing to more efficient resource utilization for builds involving Swift modules.

This commit introduces a null object for `FrameworksLinkable` within the **linking prelude** (`prelude/linking/link_info.bzl`). It **refactors** the `merge_framework_linkables` function to return this null object when no linkables are provided, rather than allocating a new empty object. This **memory optimization** significantly **reduces retained and allocated heap memory**, as evidenced by millions fewer allocations and tens of megabytes less memory usage. The change improves overall performance and resource efficiency by avoiding unnecessary object creation in scenarios where no framework linkables are present.

This commit introduces a **performance optimization** by **refactoring** the `cxx_library_parameterized` function within the **build system's C++ library definition** (`prelude/cxx/cxx_library.bzl`). It modifies dictionary iteration to use `dict#values()` instead of `dict#items()` when only the values are needed, thereby **reducing heap allocations**. This change specifically targets and decreases the creation of unnecessary `tuple` objects, leading to a more memory-efficient build process for C++ libraries.

This commit introduces a **performance optimization** by **refactoring** the `cxx_library_parameterized` function within the **prelude/cxx/cxx_library.bzl** module. Specifically, it replaces an `expect` call with an `if` statement and `fail` to prevent unnecessary string allocations. This change significantly **reduces heap allocations** for strings, saving approximately 10MB of memory and over 150,000 string allocations, thereby improving the memory efficiency of `buck2` builds.

This commit introduces a **performance optimization** and **refactoring** within the **`cxx_library_parameterized`** rule in `prelude/cxx/cxx_library.bzl`. It **reduces heap memory allocations** by reusing pre-computed dependency lists (`all_deps`) instead of repeatedly allocating and freeing them for each call-site. This change, a re-implementation of a previous reverted attempt, significantly **decreases memory consumption** during builds, specifically reducing allocated bytes by 147MB and `list` object allocations by nearly 1 million. The `cxx_library_parameterized` rule now creates two distinct dependency lists to maintain ordering, improving build efficiency for projects utilizing this C++ library definition.

This commit introduces a **performance optimization** to the **`make_artifact_tset`** function within the **`prelude/artifact_tset.bzl`** module. It refactors the function to **reduce retained and allocated memory** by directly returning a single child artifact when no other artifacts or infos are present, avoiding the creation of an unnecessary new `TransitiveSet`. This **memory reduction** effort significantly decreases the memory footprint associated with `TransitiveSet` objects, showing a ~13% reduction in both retained and allocated memory for `TransitiveSet` instances. The change improves overall memory efficiency for builds that frequently invoke `make_artifact_tset` in such scenarios.

This commit introduces a **performance optimization** by **refactoring** the `cxx_attr_resources` function within the **C++ build rules** defined in `prelude/cxx/cxx_library_utility.bzl`. The change ensures that resource processing logic is only executed if a 'resources' attribute is explicitly present, thereby avoiding unnecessary operations. This targeted modification significantly **reduces memory allocations**, particularly for `dict` and `list` types, leading to a measurable decrease in overall allocated bytes during build graph analysis. The optimization improves the **efficiency and memory footprint of Buck2 builds** that involve C++ libraries.

This commit introduces a **performance optimization** by **refactoring** the `project_artifacts` function in `prelude/artifact_tset.bzl`. Previously, `project_artifacts` exclusively accepted a list of `ArtifactTSet`s, forcing callers with a single `ArtifactTSet` to create a superfluous one-element list. Now, the function accepts either a single `ArtifactTSet` or a list, allowing direct passing of individual sets and eliminating unnecessary list allocations. This change significantly reduces memory footprint and improves heap performance across various **Apple**, **C++**, **Python**, and **Rust build rules** that utilize artifact projection. The optimization is confirmed by reduced heap allocation metrics, particularly for lists and `TransitiveSet`s.

This commit introduces a **performance optimization** and **refactoring** within the **`cxx_python_extension`** rule implementation. Specifically, it removes an unnecessary list comprehension that was creating a redundant copy of `cxx_deps` inside the `cxx_python_extension_impl` function in `prelude/python/cxx_python_extension.bzl`. This change directly impacts the **build system's efficiency**, leading to a measurable reduction in build time and memory allocations for targets that depend on a large number of `cxx_python_extension` rules, as demonstrated by the improved metrics for `fbcode//zippydb/tools/zu_rs:zu`. The **optimization** streamlines dependency handling, contributing to faster and more resource-efficient builds.

This commit introduces a **performance optimization** by **refactoring** the `cxx_python_extension_impl` function within the **Buck2 build system's Python prelude**. Specifically, it replaces an `expect` call with a `get` and `fail` check in `prelude/python/cxx_python_extension.bzl` to **reduce memory allocations**. This change provides a minor but cumulative improvement, significantly benefiting projects with a large number of `cxx_python_extension` dependencies, such as `fbcode//zippydb/tools/zu_rs:zu`, which relies on thousands of them.

This commit **optimizes memory usage** within the **C++ build prelude** by **refactoring** the `cxx_attr_exported_post_linker_flags` function in `prelude/cxx/cxx_library_utility.bzl`. It reduces list allocations by switching from repeated list concatenation to more efficient list initialization and `extend` operations. This **performance optimization** leads to a measurable decrease in allocated memory (e.g., 0.77% fewer list allocations) and a slight improvement in overall build times. The change primarily impacts **Buck2 C++ builds**, making them more memory-efficient.