Jack Wrenn

This commit significantly **enhances the testing and documentation** surrounding the **`FromZeros` trait's code generation**. It introduces a comprehensive suite of **benchmarks** for various zeroing operations, such as `Vec` and `Box` creation, extension, and insertion, covering both static and dynamic sizing, to validate their performance characteristics. The **codegen test harness** is also improved by vendoring the `regex` crate to normalize assembly labels and enabling all `cargo-asm` features, ensuring more robust and accurate codegen comparisons. Furthermore, **documentation** is added to `src/lib.rs` for key `FromZeros` methods like `zero` and `new_zeroed`, detailing their codegen and benchmarking metadata. This work primarily focuses on **maintenance and quality assurance**, providing better insights into the generated code and performance of fundamental zeroing primitives.

This commit introduces a **new capability** for the **`zerocopy` library**, allowing users to control the inlining aggressiveness of its public conversion functions. It **refactors** `src/lib.rs` to conditionally apply `#[inline(always)]` to many core functions, such as `ref_from_bytes` and `write_to`, based on a new `--cfg zerocopy_inline_always` flag. This provides a targeted **performance optimization** lever, enabling better codegen for specific scenarios without incurring the broad build time penalties associated with globally reducing `codegen-units`. The `README.md` is updated to document this new build tuning option, offering users more granular control over compiler optimizations.

This commit performs a **performance optimization refactoring** by applying the `#[inline(always)]` attribute to numerous closures and the `try_with` function. This change primarily affects the **pointer and reference handling logic** across `src/pointer`, `src/ref`, `src/util`, and `src/wrappers` modules. The explicit inlining aims to **reduce function call overhead** for frequently executed, small code blocks, potentially improving overall execution speed. Accompanying updates to benchmark assembly and machine code analysis, along with UI test stderr outputs, reflect the compiler's response to these inlining directives.

This commit **fixes mis-run UI tests** within the `zerocopy-derive` crate by correcting the test runner's configuration. It updates the **UI testing infrastructure** in `testutil/src/lib.rs` to properly strip the `--cfg zerocopy_unstable_derive_on_error` flag from `RUSTFLAGS` and `RUSTDOCFLAGS`, which was preventing certain tests from executing correctly. Additionally, the `zerocopy-derive/tests/ui.rs` runner is adjusted to correctly identify and execute tests located in the `zerocopy-derive/tests/ui/cfgs` directory. This **test fix** and **maintenance** ensures the reliability of feature-gated UI tests, preventing future regressions related to unstable derive features and their interaction with the compiler.

This commit significantly **enhances the testing and documentation** for the **`SplitAt` and `Split` traits' code generation**. It introduces a comprehensive suite of **new benchmarks** in the `benches/` directory, specifically targeting `split_at`, `split_at_unchecked`, and various `split.via_*` methods with dynamic padding and sizing to validate their performance and correctness. Furthermore, the **`src/split_at.rs` documentation** is updated with `codegen_section` and `codegen_header` attributes, providing clearer insights into the generated code. This **maintenance and testing effort** improves the robustness and clarity of the `zerocopy` library's splitting mechanisms, making progress towards issue #3079.

This commit **documents** the `IntoBytes` trait by adding `codegen_section` attributes to its methods, including `as_bytes`, `as_mut_bytes`, `write_to`, `write_to_prefix`, and `write_to_suffix`. It also introduces a comprehensive suite of **new benchmarks** within the `benches/` directory to measure the performance of these byte conversion and writing operations for both static and dynamic sized packets. This work **enhances the testing and documentation** of the **codegen** system, providing critical performance insights and improving the clarity of the `IntoBytes` API. Additionally, it **refactors** packet definitions in the benchmarks using a macro to derive `IntoBytes`, ensuring consistency and simplifying future benchmark setup. The overall effort contributes to better understanding and optimization of **codegen performance analysis**.

This commit updates the **codegen test suite** by modifying `tests/codegen.rs` to explicitly invoke `cargo.sh +nightly` when running `cargo asm`. This **test infrastructure update** ensures that the `cargo asm` command within the **codegen tests** is executed using the required **nightly Rust toolchain**, preventing potential build or execution failures due to toolchain mismatches. The change improves the reliability and correctness of the **codegen test environment**, making progress towards resolving issue #3079.

This commit **improves the project documentation** by removing a superfluous heading that was redundant or unnecessary. It specifically targets a section within the **user-facing documentation**, enhancing its readability and clarity for users. This is a **documentation maintenance task** that streamlines the information presented, making it easier to consume.

This commit significantly **enhances the codegen testing and documentation infrastructure** by introducing a comprehensive suite of **new benchmarks** for various data layout scenarios. These benchmarks, located under `benches/`, analyze the generated assembly and machine code for operations like `read_from_bytes`, `ref_from_bytes`, and `transmute` under static/dynamic sizing and padding. Concurrently, the **documentation system** is improved with new macros and CSS to visually present these codegen examples, illustrating the relationship between type complexity and codegen efficiency. This **new capability** and **documentation enhancement** improves the robustness of the codegen suite and provides valuable insights for future optimizations.

This commit **enhances the robustness of the codegen testing infrastructure** by introducing more stressful scenarios for `TryFromBytes` and `FromBytes` traits. It **refactors benchmarks** to use increased alignment, larger minimum sizes, and dynamic trailing padding in test data structures, particularly within the `coco` format. A **metadata fixup** is also applied to the `transmute_ref!` and `try_transmute_ref!` macros to ensure correct behavior under these new conditions. These **maintenance updates** lead to regenerated assembly and machine code analysis outputs for various benchmarks, validating the codegen's ability to handle complex data layouts. Furthermore, **documentation for these traits and macros is updated** to reflect the clarified requirements and behaviors.

This commit **refactors** the **codegen benchmark suite** by renaming generic `codegen_test` functions to more descriptive names, such as `bench_ref_from_bytes` and `bench_transmute_ref`. This **maintenance** change significantly improves **readability and clarity** for individual benchmarks across various `ref_from_*` and `transmute_ref` scenarios. Both the Rust source files (`.rs`) and their corresponding assembly output files (`.x86-64`) in the `benches/` directory are updated to reflect these new names, ensuring consistency between the source and generated assembly. Additionally, the `tests/codegen.rs` utility is adjusted to correctly invoke these descriptively named benchmarks, enhancing the maintainability of the test infrastructure.

This commit introduces a **new capability** to track and display raw, unanalyzed assembly output for various benchmarks directly within the project's documentation. It **enhances the codegen analysis and documentation system** by modifying the `codegen_tabs!` macro to include a dedicated tab for this assembly, supported by a `rustdoc` stylesheet update. The **codegen test runner** (`tests/codegen.rs`) is also refactored to generate and compare both the new raw assembly and existing `llvm-mca` outputs. This provides a more approachable and direct view of the generated code, complementing the detailed `llvm-mca` analysis for developers.

This commit introduces comprehensive **code generation documentation** directly into the `rustdoc` for various `bytemuck` traits and macros. It adds new `codegen_header!` and `codegen_tabs!` utility macros to embed benchmarks from #3042, enhancing the **documentation system** with detailed performance insights. The **`TryFromBytes` and `FromBytes` trait methods**, along with **`transmute_ref!` and `try_transmute_ref!` macros**, now feature these benchmarks, providing users with critical information about their runtime characteristics. This **documentation enhancement** also includes updates to the documentation build workflow and a new CSS file for styling, significantly improving the discoverability and presentation of code generation performance data.

This commit introduces a **new capability** for **code generation testing** by adding a comprehensive suite of `llvm-mca` benchmarks to the `benches/` directory. A new `codegen` job is integrated into the **CI/CD pipeline** (`.github/workflows/ci.yml`) to automatically validate the generated machine code for critical functions, including various `FromBytes` and `TryFromBytes` methods and `transmute_ref`. This **enhances the reliability and performance stability** of the project by ensuring that changes do not introduce regressions in the generated assembly, with CI failures occurring for any unblessed mismatches. The new tests provide crucial feedback on the efficiency of the compiled output.

This commit **fixes bugs** in the `derive(IntoBytes)` macro by ensuring that **alignment directives** (`repr(align)` and `repr(packed)`) are correctly processed. It modifies the internal padding check macros in `src/macros.rs` and `src/util/macro_util.rs` to accept these directives, and updates the derive macro builder in `zerocopy-derive/src/util.rs` to extract and pass them. Additionally, it guarantees that padding checks are always emitted, even for types without fields, which is crucial for applying alignment requirements. This **enhances the correctness** of `IntoBytes` implementations, particularly for types with specific memory layout requirements, preventing incorrect byte representations due to misaligned data.

This commit introduces **alignment-aware data loading** into the `zerocopy` library's validation process by parameterizing `TryFromBytes::is_bit_valid` and `Ptr::read` with alignment information. This is a significant **performance optimization** that ensures well-aligned loads are used during validation, which is faster than unaligned loads on many platforms. The change **refactors** the internal `Ptr` API to leverage a new `Alignment::read` method and updates the `TryFromBytes` derive macro to generate alignment-aware code. This improves the performance of `try_transmute!` and `TryFromBytes::try_read_from_*` operations for destination types with alignments greater than 1, while also laying groundwork for future in-place validation optimizations.

This commit **introduces the `ProjectField` trait**, a **new capability** that enables **invariant-respecting field projection** over `Ptr` types. The core **`Ptr::project` method** is **refactored** to utilize this trait, enhancing the robustness and correctness of pointer operations. To support this, the **invariant tracking system** in `src/pointer/invariant.rs` is enhanced, and the **`zerocopy-derive` crate** is updated to automatically generate `ProjectField` implementations for enum fields. This change significantly improves the reliability of `Ptr` projections by ensuring memory invariants are upheld, impacting both manual and derived implementations.

This commit introduces a **new capability** by adding the `project_inner` method to the core **`HasField` trait**. This method enables more flexible field projection, specifically allowing projection from a `slf` reference to an inner field using the `PtrInner` mechanism. This enhancement to the **`HasField` trait** provides a new utility for accessing nested data structures, potentially simplifying code that relies on field-level introspection and manipulation. The change primarily affects the **`src/lib.rs`** module, expanding the trait's interface for broader use cases.

This commit performs a **refactoring** by **renaming** the `project` method within the **`HasField` trait** to `project_raw`. This change impacts the core **`zerocopy` library** and its **`zerocopy-derive` procedural macro**, where the method's definition and all `impl` blocks have been updated. The `src/pointer/mod.rs` module was also adjusted to call the newly named `project_raw` method, and all relevant tests were updated to reflect this change. This is a **breaking API change** for direct consumers of `HasField::project`, requiring them to update their code to use `HasField::project_raw`. The rename likely clarifies the "raw" or low-level nature of this field projection operation.

This commit introduces a **new capability** to the `zerocopy` library by automatically generating implementations for the `HasField`, `Immutable`, `TryFromBytes`, `FromZeros`, and `FromBytes` traits for **tuple types** up to a length of 26. This **enhances the usability** of the library, allowing tuples to seamlessly participate in zero-copy operations without requiring manual trait implementations. The change primarily affects the `src/impls.rs` module, where a new macro handles the generation, and necessitates extensive **maintenance updates** across numerous UI test files to reflect the expanded compatibility and correct diagnostic outputs. This broadens the range of types that can leverage `zerocopy`'s benefits, simplifying code for users working with tuple-based data structures.