Jakub Piasecki

This commit **integrates automated snapshot comparison into the CI pipeline** for the **C++ API parser**. It introduces a new `--validate-output` argument to `scripts/cxx-api/parser/__main__.py` to enable this validation, alongside improvements to error reporting and configurable Node.js paths for `build_codegen`. The `scripts/cxx-api/parser/snapshot_diff.py` module is also updated to allow redirecting comparison output and refactor core validation logic. This **new capability** significantly enhances the **maintenance** and reliability of the C++ API codegen by automatically catching regressions in generated code during CI runs.

This commit **fixes a bug** in the **C++ API documentation generation** process where Doxygen incorrectly emitted duplicate `basecompoundref` entries for base classes inheriting constructors via `using Base::Base;`. The change **deduplicates base classes by name** within the `get_base_classes` function in `scripts/cxx-api/parser/builders.py`. This **ensures base classes are listed only once** in the API snapshot output, correcting an issue that caused classes like `ConverterBase` to appear twice. The **maintenance** work improves the accuracy and consistency of the generated API documentation, with new snapshot tests verifying the deduplication logic.

This commit **fixes an issue** in the **C++ API parser** where conversion operator type names, such as `operator jsi::Array`, were not being fully qualified in the generated API snapshots. A new method, `_qualify_conversion_operator_type`, has been integrated into the `FunctionMember.close()` process within `scripts/cxx-api/parser/member/function_member.py` to detect these operators and apply proper type qualification. This **maintenance** change ensures that the API definition snapshots accurately represent fully qualified type names, improving the correctness and reliability of the API generation process. New and updated snapshot tests confirm the correct qualification of these types.

This commit **fixes a bug** in the **C++ API snapshot generator** that caused array brackets `[]` to be incorrectly appended to the type name instead of the parameter name when processing array types. The `get_doxygen_params` function within `scripts/cxx-api/parser/builders.py` was modified to correctly parse and represent array parameters. This **bug fix** ensures that the generated API snapshots accurately reflect the syntax of functions with array parameters, improving the correctness of the API definitions. New test cases and snapshots were added to validate this correction.

This commit delivers a **bug fix** to the **C++ API Doxygen parsing logic** that was incorrectly qualifying function pointer parameter names to outer class members. The `get_doxygen_params` function in `scripts/cxx-api/parser/builders.py` now re-parses function pointer type strings through `parse_type_with_argstrings` to correctly strip class qualification from parameter names. Concurrently, `parse_type_with_argstrings` in `scripts/cxx-api/parser/utils/argument_parsing.py` is enhanced to properly recognize complex declarator groups, preventing erroneous name extraction from nested function pointer types. This ensures **accurate Doxygen documentation generation** for C++ APIs, particularly for complex function pointer signatures, by preventing misleading cross-references.

This commit provides a **bug fix** to the **C++ API snapshot generation** process, specifically addressing the incorrect handling of **array types in member definitions**. It modifies the `variable_member.py` parser script to accurately append argument strings for variable members, ensuring that array types are properly represented in the generated API snapshots. This **maintenance** update improves the fidelity of the API definitions, which is crucial for tools and processes that rely on these snapshots for accurate C++ API analysis. New snapshot tests were introduced to validate this corrected behavior.

This commit delivers a **bug fix** for the **C++ API documentation generation pipeline**, specifically addressing an issue with parsing Doxygen output for **pointer-to-member-function parameters with ref-qualifiers**. Previously, Doxygen incorrectly embedded the parameter name into the type string, leading to malformed API snapshots. The `get_doxygen_params` function in `scripts/cxx-api/parser/builders.py` now correctly detects this misplaced name and reconstructs the proper pointer-to-member declarator. This ensures accurate representation of complex C++ types within the **API documentation**, improving the reliability of the `cxx-api` toolchain. New snapshot tests have been added to validate this parsing correction.

This commit implements a **bug fix** and **refactoring** within the **C++ API parser** to address an issue where inherited constructors were duplicated in generated snapshots. Specifically, when a class had multiple base classes defining constructors with the same signature, the parser was redundantly including these constructors for each base class. The change introduces **deduplication logic** in `base_scope_kind.py` and `namespace_scope_kind.py` to ensure that such constructors are represented only once, improving the accuracy and efficiency of the **API snapshot generation**. New snapshot tests have been added to validate the correct handling of multiple inherited constructors.

This commit **refactors** the **C++ API snapshot generation script** (`scripts/cxx-api/parser/__main__.py`) to execute Doxygen and codegen steps in parallel using a thread pool executor. This significant **performance improvement** drastically reduces the generation time for internal C++ API snapshots, streamlining the development workflow. Additionally, Doxygen utility functions in `scripts/cxx-api/parser/doxygen.py` are enhanced to support custom output directories and improve error handling, while Doxygen config templates are updated for flexibility.

This commit introduces an **optimization** to the **Doxygen documentation generation process** by making input filters opt-in via configuration. Specifically, it modifies the `scripts/cxx-api` module to add an `input_filter` option to the `config.yml` for `ReactCommon`, `ReactAndroid`, and `ReactApple` sections. This **maintenance** change ensures that Doxygen input filters are now **conditionally applied** only when needed for Objective-C files, preventing unnecessary processing for other codebases. The downstream impact is an **improved efficiency** in documentation builds by skipping redundant filter execution.

This commit performs **maintenance cleanup** by **removing obsolete CI/CD workflows** that were specifically designed to test Hermes V1 integration. These workflows are no longer necessary because **Hermes V1 has become the default JavaScript engine** for the project. The change primarily affects the **project's build and test infrastructure**, streamlining the continuous integration process by eliminating redundant checks and improving overall CI efficiency. This update ensures that the automated testing suite accurately reflects the current development environment and priorities.

This commit **refactors** the `scripts/cxx-api` tooling by **relocating the `input_filters` module** to be a subpackage **within the `parser` package**. This **code reorganization** addresses import errors that previously occurred when running the **snapshot generator in OSS**, which failed due to incorrect external imports of `input_filters`. The change involved updating import paths across various **parser-related scripts** like `__main__.py` and `builders.py`, as well as associated **test files**. This ensures the **C++ API tooling** operates reliably across different environments.

This commit **fixes incorrect reference qualification** within the **C++ API parser**, specifically addressing a **bug** where Doxygen misresolved references for friend declarations or inherited constructors. The `qualify_name` logic in `scripts/cxx-api/parser/scope.py` has been refactored to correctly re-qualify these cases. This **maintenance** work significantly improves the accuracy of the generated **C++ API documentation**, ensuring developers receive reliable information. New tests were added to prevent regressions for incorrect scoping of base class typedefs and friend classes.

This commit **enhances** the **C++ API snapshot generator** by introducing logic to **skip private compound objects** during snapshot creation. The `build_snapshot` function in `scripts/cxx-api/parser/main.py` was updated to prevent C++ enums and structs with `private` visibility from being included. This **maintenance update** ensures that the generated API snapshots accurately reflect only the public interface, preventing internal implementation details from being exposed. New test snapshots and C++ header files were added to verify that private enums and structs are correctly ignored, improving the precision of the **API documentation and tooling**.

This commit introduces a **bug fix** to the **C++ API generation script** (`scripts/cxx-api/parser/builders.py`) to address an issue where Doxygen incorrectly substituted default template argument values in specialized base classes. A new reverse mapping mechanism is implemented within `create_class_scope` to restore the original template parameter names (e.g., mapping `"int"` back to `"T"` in `Base<int>`), ensuring accurate representation of template specializations. This **maintenance** work prevents misrepresentation of C++ class inheritance in the generated API, specifically impacting how **React Native's C++ components** are documented and processed.

This commit delivers a **bug fix** to the **C++ API parser** by correcting the ordering of `const` and `mutable` keywords within the string representation of variable members. Previously, the `scripts/cxx-api/parser/member.py` script incorrectly swapped their positions, leading to an inaccurate internal representation of C++ constructs. This change ensures the **correct generation of C++ API definitions** and is validated by new snapshot tests that specifically handle mutable and const pointer ordering. This is an **internal tooling improvement** that prevents potential misinterpretations in the generated API.

This commit **refines the C++ API parser's type qualification logic** by **stripping redundant leading `::`** from globally qualified identifiers in the generated output. Specifically, the `_qualify_type_str_impl` function in `scripts/cxx-api/parser/utils/type_qualification.py` is updated to remove these leading scope specifiers, as all types in the output are already fully qualified. This **maintenance improvement** ensures a cleaner and more consistent representation of C++ types in the API snapshots. The change primarily affects the **C++ API generation pipeline**, enhancing the **readability and accuracy of generated API definitions**. A corresponding test snapshot was updated to reflect this new behavior.

This commit **enhances the C++ API snapshot parser** to correctly **inline private type aliases** that are referenced within the public API. Previously, the parser would ignore private sections, leading to incomplete type definitions in the generated snapshot. This **tooling improvement** modifies the `cxx-api` parser's scope management and type resolution logic in `scripts/cxx-api/parser/builders.py`, `member.py`, and `scope.py` to track and resolve these private typedefs. The change ensures the **API snapshot accurately reflects all type information**, even when private aliases are used in public interfaces, improving the reliability of the generated API documentation.

This commit introduces a **new capability** to the **C++ API snapshot generator**, enabling it to automatically invoke codegen for each API view separately, generating platform-specific artifacts. It **refactors** the codegen configuration within `scripts/cxx-api` to support a nested `codegen` object with a `platform` field, updating `config.yml` and the `ApiViewSnapshotConfig` in `scripts/cxx-api/parser/config.py`. The core logic is implemented by integrating a new `build_codegen` function into `scripts/cxx-api/parser/__main__.py`, which now runs during the snapshot generation process. This enhancement improves the granularity and platform-awareness of **React Native's C++ API generation workflow**, ensuring correct artifact production for each specific platform.

This commit introduces a **new capability** to the **React Native codegen artifact generation process**, allowing users to explicitly force all generated core artifacts into a specified output directory. A new `--forceOutputPath` option is added to the `generate-codegen-artifacts.js` script, which is then propagated through the `executor.execute` and `generateNativeCode` functions. This enhancement provides greater control over the build output, particularly benefiting downstream consumers like the **C++ API snapshot generator** by enabling it to collect all platform-specific codegen output from a single, predictable location.