Cache delegate recipes per recipe instance to avoid repeated construction

[knutwannheden]

Motivation

The Gradle/Maven dependency wrapper recipes — AddDependency, ChangeDependency, UpgradeDependencyVersion, and UpgradeTransitiveDependencyVersion — each delegate to a Gradle and a Maven ScanningRecipe. Until now they constructed a fresh delegate instance on every getInitialValue, getScanner, getVisitor, and validate call, and AddDependency.getScanner even constructed its delegates once per source file from inside the scanner's visit. Every ScanningRecipe constructor computes "org.openrewrite.recipe.acc." + UUID.randomUUID() for its accumulator-message key, and UUID.randomUUID() draws from SecureRandom. In profiles of recipe-heavy runs this SecureRandom draw dominated, with these wrapper recipes accounting for nearly all of the cost.

The fix is to build each delegate at most once and reuse it. The delegate recipe is derived from the wrapper's options, so it logically belongs to the wrapper recipe instance, not to the run-scoped accumulator. Each wrapper memoizes its two delegates lazily in a final transient AtomicReference — final and initialized so it is excluded from the Lombok-generated constructor, transient so it stays out of equals/hashCode, and AtomicReference for safe publication under concurrent getScanner/getVisitor calls. The Accumulator types are deliberately left unchanged so their public constructors keep working for downstream callers that build them directly (for example rewrite-spring, which constructs UpgradeDependencyVersion.Accumulator itself).

Caching on the instance rather than the accumulator also avoids a subtle correctness trap: rewrite-spring reuses a single accumulator across two different UpgradeDependencyVersion instances — an empty-option one for scanning and a real-option one for editing — so a delegate cached on the accumulator would apply the wrong options during the edit phase. Instance memoization gives each wrapper its own correctly-configured delegate.

Summary

• Each wrapper memoizes its Gradle and Maven delegate ScanningRecipe lazily on the recipe instance via a final transient AtomicReference, reused across the scanning and editing phases.
• Delegate construction per wrapper per run drops from "once per phase (and, for AddDependency, per source file)" to at most one Gradle and one Maven delegate per wrapper instance.
• Hoisted AddDependency.getScanner's delegate-scanner creation out of the per-source-file visit.
• Accumulator types are unchanged, preserving their public constructors.

Test plan

• Re-ran AddDependencyTest, ChangeDependencyTest, and UpgradeDependencyVersionTest — green before and after.
• Ran the full test suite — green.
• Published to Maven Local and rebuilt rewrite-spring, which constructs UpgradeDependencyVersion.Accumulator directly — compiles successfully, confirming the public accumulator API is preserved.