Nivaldo Bondança

This commit implements a **bug fix** and **maintenance** change for the **Nullsafe plugin integration**, resolving critical build failures in CI. It modifies the build configuration to pass **Nullsafe javac plugin** options via `javac -Xplugin` arguments instead of `-A` annotation processor flags. This change, primarily within `prelude/jvm/nullsafe.bzl` and the `get_nullsafe_info` function, prevents "unrecognized option" warnings from being promoted to fatal errors by `-Werror`. By correctly configuring the plugin's arguments like `nullsafe.reportToJava` and `nullsafe.signatures`, this significantly improves the overall **build stability** and reliability of Nullsafe checks.

This commit performs a comprehensive **code style update** across numerous Kotlin files within the **Fresco library**, including components like `animated-drawable`, `imagepipeline`, and various `vito` modules. It primarily involves **reformatting code for improved readability** and consistency, driven by an update to the `ktfmt` component. This is a **maintenance** and **refactoring** effort that ensures adherence to current coding standards. The changes are purely cosmetic, introducing no functional modifications to the library's behavior, but enhancing the overall maintainability and clarity of the codebase.

This commit applies a **code reformatting** across several **Kotlin-related modules** within the Buck build system, driven by an update to the `ktfmt` formatting tool. Specifically, it improves the code style and **readability** of files related to **Kotlin build tools** like `KotlinExtraParams.kt` and `BuildToolsKotlinc.kt`, as well as components of the **Kosabi (Kotlin Stubs ABI) compiler plugin**, such as `K2JvmAbiFirAnalysisHandlerExtension.kt`. This **maintenance** effort ensures consistent code style and has no functional impact on the system.

This commit **updates the `ktfmt` component** to its latest version within the project. As a result, it applies **code style formatting** across numerous Kotlin files in the **React Native Android codebase**, specifically reformatting lambdas, function definitions, and assignments within modules such as `devsupport`, `uimanager`, and `runtime`. This is a **maintenance** task focused on improving code readability and ensuring consistent style, with no functional changes to the application.

This commit **fixes a linting error** within the **`kotlin_library` BUCK file** by adding specific `# starlark-lint-disable unused-assign` comments. Previously, conditional target definitions introduced unused variables (`_uses_ksp_and_ap`, `_ksp_generates`, `_uses_ksp_and_kapt`) that triggered the Buck2 Starlark linter's `unused-assign` rule, as existing `buildifier` suppressions were insufficient. This **maintenance change** ensures the `kotlin_library` definition adheres to Starlark linting standards, resolving `test_lint_buck2` failures and improving the overall **build system hygiene**.

This commit **refactors** the **Compiler Daemon (`jvm/cd`)** and its **serialization utilities (`jvm/cd/serialization`)** to enhance **null safety**. It introduces `Nullsafe(Nullsafe.Mode.LOCAL)` annotations across numerous Java classes, migrates from `javax.annotation.Nullable` to `org.jetbrains.annotations.Nullable` for improved `TYPE_USE` support, and adds explicit null-checks using `Objects.requireNonNull()`. This comprehensive update, including necessary `NULLSAFE_FIXME` suppressions, significantly **reduces the risk of `NullPointerException`s** within these critical build system components, improving their overall stability and reliability.

This commit **refactors** key **Android build components** to enforce **null-safety**, applying `Nullsafe(Nullsafe.Mode.LOCAL)` to Java classes across the `apk`, `bundle`, `apkmodule`, and `manifest` targets. The work involved migrating from `javax.annotation.Nullable` to `org.jetbrains.annotations.Nullable` for `TYPE_USE` support, adding extensive `Nullable` annotations, and implementing null-checks via `Objects.requireNonNull()`. Furthermore, `NULLSAFE_FIXME` suppressions were introduced for external interactions, and `args4j Option` fields were explicitly initialized to `null` where appropriate. This substantial **code quality improvement** significantly reduces the potential for `NullPointerException`s, enhancing the robustness and reliability of the **Android build toolchain**.

This commit performs a significant **refactoring** to enhance **null safety** across the **Android helper, utility API, and manifest utility modules** within the Buck build system. It introduces `@Nullsafe(Nullsafe.Mode.LOCAL)` annotations to numerous classes and interfaces, explicitly marking nullable types and ensuring proper null checks to prevent `NullPointerException`s. The work involves updating method signatures, adding `Objects.requireNonNull` calls, and incorporating third-party nullability signatures for methods like `ThreadFactoryBuilder#build()` and `Joiner#join(Iterator)`. This comprehensive effort improves the overall robustness and reliability of these core Android-related components, with `NULLSAFE_FIXME` comments added for static fields that cannot be vetted via signature files.

This commit **refactors** several Java classes within the **`jvm/cd` subsystem** to enforce null safety. Specifically, it applies `@Nullsafe(Nullsafe.Mode.LOCAL)` annotations to classes in `jvm/cd/serialization/kotlin`, `jvm/cd/workertool`, and `jvm/cd/workertool/grpc`, including serializers like `ActionMetadataSerializer` and gRPC components like `WorkerGrpcServer` and `WorkerGrpcService`. This **maintenance** work adds necessary `Nullable` annotations, `Objects.requireNonNull()` checks, and `NULLSAFE_FIXME` suppressions to prevent `NullPointerException`s. Build files for these modules were also updated to include `infer-annotations` and `kotlin-annotations`. The change significantly **improves the robustness and reliability** of the build system's Kotlin serialization and worker tool communication by ensuring stricter null handling.

This commit **enables local null safety** for key **Android resource processing modules**, including `resources:resources`, `resources:merge_android_resources`, `resources:merge_assets`, `resources:exo_resources_rewriter`, `resources/filter:filter`, and `resources/strings:strings`. It involves a **refactoring** effort to migrate from `javax.annotation.Nullable` to `org.jetbrains.annotations.Nullable` for `TYPE_USE` support, adding `Nullsafe(Nullsafe.Mode.LOCAL)` to relevant Java classes. This change introduces comprehensive null checks via `Objects.requireNonNull()`, adds missing `Nullable` annotations, and correctly initializes non-required `args4j` `Option` fields, significantly **improving the robustness and type safety** of Android resource compilation and manipulation by preventing potential `NullPointerException`s.

This commit **refactors** the `ProguardTranslatorFactory` within the **Buck Android Proguard toolchain** to be **null-safe**. It achieves this by adding a `Nullsafe` annotation and splitting existing function creation methods, such as `createFunction()`, into explicit `createNonNullableFunction()` and `createNullableFunction()` variants. Additionally, a `buildMap()` helper method was extracted to reduce code duplication, and a `kotlin-annotations` dependency was introduced to support `Nullable` in type parameters. This **enhances the robustness and reliability** of Proguard translation functions by preventing potential `NullPointerException`s during **Android build processes**.

This commit continues the **null safety enforcement** initiative by applying `Nullsafe(Nullsafe.Mode.LOCAL)` annotations to Java classes across several **Android build components**, specifically within the `build_config`, `dex`, and `proguard` modules. The **refactoring** involves switching from `javax.annotation.Nullable` to `org.jetbrains.annotations.Nullable` for enhanced `TYPE_USE` support, alongside adding explicit `Nullable` annotations, `Objects.requireNonNull()` checks, and `NULLSAFE_FIXME` suppressions. This **code quality improvement** enhances the robustness and reliability of critical Android build tools like `D8ExecutableMain` and `MultiDexExecutableMain`, preventing potential `NullPointerException`s and ensuring more stable execution of the build process.

This commit initiates the **null-safety migration** for several core **Android build toolchain** components within Buck, marking the first part of a broader effort. It **refactors** code across `device`, `zipalign`, `aapt:r_dot_txt`, `aapt:mini_aapt`, `aapt:merge_android_resource_sources`, `aar:aar_builder`, and `apk/sdk:apk_builder` targets by applying `@Nullsafe(Nullsafe.Mode.LOCAL)` annotations to Java classes. Key changes include migrating `@Nullable` annotations from `javax.annotation.Nullable` to `org.jetbrains.annotations.Nullable` for `TYPE_USE` support, adding explicit null checks via `Objects.requireNonNull()`, and introducing `NULLSAFE_FIXME` suppressions. This work significantly **improves code quality** and **prevents potential NullPointerExceptions**, enhancing the robustness and reliability of these critical Android build processes.

This commit **enables Nullsafe static analysis** for targets within the **`prelude//`** build system by resolving several infrastructure blockers. It **modifies the `prelude` Java compilation process** to correctly pass necessary JVM arguments for javac plugins, specifically by adjusting the `java_library.bzl` rule to remove a gate for the nullsafe subtarget. Additionally, the `compile_and_package.py` script is updated to support passing `--add-exports` JVM flags directly to `javac`. This **feature enablement** allows Nullsafe to perform static analysis on foundational `prelude` Java code, significantly enhancing code quality and null-safety guarantees for these core components.

This commit applies **code formatting** to **Buck build files** by running the `buckformat_fbsource` tool. It performs several stylistic cleanups, including removing unnecessary empty parentheses from function calls, merging multiple `load` statements from the same file into a single statement, and eliminating unused `load` calls. This **maintenance** effort serves as a **preparatory step** to reduce churn and simplify a larger upcoming change related to the sorting order of `load` calls. For example, the `prelude/toolchains/ocaml.bzl` file is updated to remove empty parentheses from the `DefaultInfo` function call within `_system_ocaml_toolchain_impl`.

This commit performs **code formatting and cleanup** on **BUCK files** by running the `tools/arcanist/lint/codemods/buckformat_fbsource` codemod. It specifically addresses empty parentheses in function calls, merges redundant `load` statements, and removes unused `load` declarations to improve code readability and consistency. This **maintenance** task primarily affects the **FBOSS agent platform utilities** (`fboss/agent/platforms/wedge/utils/BUCK`) and aims to prevent future churn from larger formatting updates. The changes are purely stylistic, with no functional impact on the build process.

Simplify further the Android and AOSP 3P contents that we have/use

This commit **enables the Kotlin K2 compiler by default** for all Kotlin builds, a significant **performance improvement** and **maintenance update**. By changing the default value of the `k2` attribute in `prelude/decls/jvm_common.bzl`, this ensures that all future Kotlin compilations leverage the stable K2 compiler. This adoption aligns with recommended best practices and is expected to provide **better build performance** across the entire project's Kotlin ecosystem.

This commit performs a **maintenance update** to the **kosabi k2-jvm-abi-gen plugin** within the Buck build system's Kotlin JVM toolchain. It **migrates the diagnostic reporter creation** from the deprecated `FirKotlinToJvmBytecodeCompiler.createPendingReporter` API to the new `DiagnosticReporterFactory.createPendingReporter` API. This change, primarily affecting the `runAnalysis` function in `K2JvmAbiFirAnalysisHandlerExtension.kt`, ensures **compatibility with Kotlin 2.2** and prevents build failures due to API removal. The update is crucial for maintaining the plugin's functionality as the project upgrades to newer Kotlin compiler versions.

This commit **refactors** the **Kotlin toolchain configuration** by removing the `allow_k2_usage` field, which previously gated K2 compiler usage at the toolchain level. This **simplifies** the logic for determining K2 compiler activation, as it is now solely controlled by the `k2` attribute on individual targets and the language version configuration. Specifically, the conditional check `if ctx.attrs.k2 != False and kotlin_toolchain.allow_k2_usage` was removed from the `get_language_version` function within `kotlin_library.bzl`. This change streamlines the **Kotlin build system** by eliminating an unnecessary layer of configuration for K2.