Scope the TextInput spannable cache to the React instance

Summary:
WARNING: Generated by Autopilot (alpha) — review carefully, verify the underlying claim before accepting.
Agent: React Native Agent (Bugs) | Trajectory: https://www.internalfb.com/intern/devai/devmate/inspector/4f3686f6-6eac-416a-8116-4fd4ee5a627f/ | SC job: https://www.internalfb.com/intern/sandcastle/instance/54043196239422512/

---

On Fabric, `ReactEditText` caches its spannable in `TextLayoutManager` keyed by react tag, and the shadow node's state keeps that tag as `cachedAttributedStringId` to re-measure against. The cache was a single process-global map keyed only by tag. React tags restart for every new React instance, so after a reload the old and new instances can use the same tags in the same map: the new instance can read the old instance's spannable, and when an old `ReactEditText` is finalized it removes the new view's entry. The next cached measure then fails `checkNotNull` in `getOrCreateSpannableForText` with "Required value was null".

This change gives each React instance its own spannable cache:
- `TextLayoutManager` keeps one map per `ReactApplicationContext`. `FabricUIManager` creates it in its constructor and removes it in `invalidate()`.
- `FabricUIManager.measureText` passes its own context, so a cached measure only looks in that instance's map.
- `ReactEditText` writes to and evicts from the map of the context it was created with (`ThemedReactContext.reactApplicationContext`). Create, destroy, read and write all resolve the key through one helper, so a view's `ThemedReactContext` and `FabricUIManager`'s `ReactApplicationContext` always hit the same map. After teardown, an old view's set or evict does nothing because its map is gone.
- A layout that started before `invalidate()` can still reach `measureText` after the map is removed. In that case the cached measure uses an empty spannable instead of throwing, because the cache-id `MapBuffer` carries only the id and there is nothing to rebuild from. The result belongs to an instance that is going away. A missing entry in a live map still fails `checkNotNull`.

This replaces the previous version of this diff, where `finalize()` only evicted the spannable the instance itself had cached. Per-tag eviction still happens in `finalize()`, but now only within the view's own instance, where tags are never reused. I did not move eviction to `onDropViewInstance`: a commit whose layout is still running on a background thread can measure a TextInput after the UI thread has already processed that view's delete, so evicting right away would add a new way to hit the same `checkNotNull`.

Changelog:
[Android][Fixed] - Fix TextInput measurement crash ("Required value was null") after a React instance reload, by scoping the cached TextInput spannables to the React instance

Reviewed By: zeyap

Differential Revision: D122870300

Author: Autopilot Bot

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -259,6 +259,7 @@ public FabricUIManager(
 
     mViewManagerRegistry = viewManagerRegistry;
     mReactApplicationContext.registerComponentCallbacks(viewManagerRegistry);
+    TextLayoutManager.createSpannableCache(mReactApplicationContext);
   }
 
   @Override
@@ -496,6 +497,7 @@ public void invalidate() {
     }
     mBinding = null;
 
+    TextLayoutManager.destroySpannableCache(mReactApplicationContext);
     ViewManagerPropertyUpdater.clear();
   }
 
@@ -658,7 +660,8 @@ public long measureText(
             ? (ReactTextViewManagerCallback) textViewManager
             : null,
         attachmentsPositions,
-        mTextEffectRegistry);
+        mTextEffectRegistry,
+        mReactApplicationContext);
   }
 
   @AnyThread

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/text/TextLayoutManager.kt

@@ -30,6 +30,7 @@ import com.facebook.common.logging.FLog
 import com.facebook.infer.annotation.Assertions
 import com.facebook.react.bridge.JavaOnlyArray
 import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.common.ReactConstants
@@ -42,6 +43,7 @@ import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PixelUtil.pxToDp
 import com.facebook.react.uimanager.ReactAccessibilityDelegate
+import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.util.AndroidVersion.VERSION_CODE_VANILLA_ICE_CREAM
 import com.facebook.react.views.text.internal.span.CustomLetterSpacingSpan
 import com.facebook.react.views.text.internal.span.CustomLineHeightSpan
@@ -115,7 +117,11 @@ internal object TextLayoutManager {
 
   private const val TEXT_WIDTH_MODE_LONGEST_LINE = "longest-line"
 
-  private val tagToSpannableCache = ConcurrentHashMap<Int, Spannable>()
+  // TextInput spannables keyed by react tag, one map per React instance. Tags restart from the same
+  // value in every instance, so entries must not be shared across instances. FabricUIManager
+  // creates and destroys the map for its ReactApplicationContext.
+  private val tagToSpannableCaches =
+      ConcurrentHashMap<ReactContext, ConcurrentHashMap<Int, Spannable>>()
 
   // These wrappers mirror Android 15 APIs but use reflection because some internal targets still
   // compile against Android 14. They return null when the API is unavailable or cannot be invoked.
@@ -180,12 +186,30 @@ internal object TextLayoutManager {
         null
       }
 
-  fun setCachedSpannableForTag(reactTag: Int, sp: Spannable) {
-    tagToSpannableCache[reactTag] = sp
+  // Views hold a ThemedReactContext while FabricUIManager holds the ReactApplicationContext it
+  // wraps. Every cache access goes through this so both resolve to the same key.
+  private fun spannableCacheKey(reactContext: ReactContext): ReactContext =
+      if (reactContext is ThemedReactContext) reactContext.reactApplicationContext else reactContext
+
+  @JvmStatic
+  fun createSpannableCache(reactContext: ReactContext) {
+    tagToSpannableCaches[spannableCacheKey(reactContext)] = ConcurrentHashMap()
+  }
+
+  @JvmStatic
+  fun destroySpannableCache(reactContext: ReactContext) {
+    tagToSpannableCaches.remove(spannableCacheKey(reactContext))
+  }
+
+  private fun getSpannableCache(reactContext: ReactContext): ConcurrentHashMap<Int, Spannable>? =
+      tagToSpannableCaches[spannableCacheKey(reactContext)]
+
+  fun setCachedSpannableForTag(reactContext: ReactContext, reactTag: Int, sp: Spannable) {
+    getSpannableCache(reactContext)?.put(reactTag, sp)
   }
 
-  fun deleteCachedSpannableForTag(reactTag: Int) {
-    tagToSpannableCache.remove(reactTag)
+  fun deleteCachedSpannableForTag(reactContext: ReactContext, reactTag: Int) {
+    getSpannableCache(reactContext)?.remove(reactTag)
   }
 
   fun isRTL(attributedString: MapBuffer): Boolean {
@@ -765,11 +789,15 @@ internal object TextLayoutManager {
       attributedString: MapBuffer,
       reactTextViewManagerCallback: ReactTextViewManagerCallback?,
       textEffectRegistry: TextEffectRegistry?,
+      spannableCacheOwner: ReactContext? = null,
   ): Spannable {
     val text: Spannable?
     if (attributedString.contains(AS_KEY_CACHE_ID)) {
       val cacheId = attributedString.getInt(AS_KEY_CACHE_ID)
-      text = checkNotNull(tagToSpannableCache[cacheId])
+      val cache = getSpannableCache(checkNotNull(spannableCacheOwner))
+      // FabricUIManager.invalidate() can remove the cache while a layout that started before it is
+      // still measuring on another thread. That layout's result is discarded with the instance.
+      text = if (cache == null) SpannableString("") else checkNotNull(cache[cacheId])
     } else {
       text =
           createSpannableFromAttributedString(
@@ -1091,6 +1119,7 @@ internal object TextLayoutManager {
       heightYogaMeasureMode: YogaMeasureMode,
       reactTextViewManagerCallback: ReactTextViewManagerCallback?,
       textEffectRegistry: TextEffectRegistry? = null,
+      spannableCacheOwner: ReactContext? = null,
   ): Layout {
     val text =
         getOrCreateSpannableForText(
@@ -1099,6 +1128,7 @@ internal object TextLayoutManager {
             attributedString,
             reactTextViewManagerCallback,
             textEffectRegistry,
+            spannableCacheOwner,
         )
 
     val paint: TextPaint
@@ -1463,6 +1493,7 @@ internal object TextLayoutManager {
       reactTextViewManagerCallback: ReactTextViewManagerCallback?,
       attachmentsPositions: FloatArray?,
       textEffectRegistry: TextEffectRegistry? = null,
+      spannableCacheOwner: ReactContext? = null,
   ): Long =
       measureText(
           assets,
@@ -1476,6 +1507,7 @@ internal object TextLayoutManager {
           reactTextViewManagerCallback,
           attachmentsPositions,
           textEffectRegistry,
+          spannableCacheOwner,
       )
 
   @JvmStatic
@@ -1492,6 +1524,7 @@ internal object TextLayoutManager {
       reactTextViewManagerCallback: ReactTextViewManagerCallback?,
       attachmentsPositions: FloatArray?,
       textEffectRegistry: TextEffectRegistry? = null,
+      spannableCacheOwner: ReactContext? = null,
   ): Long {
     // TODO(5578671): Handle text direction (see View#getTextDirectionHeuristic)
     val layout =
@@ -1506,6 +1539,7 @@ internal object TextLayoutManager {
             heightYogaMeasureMode,
             reactTextViewManagerCallback,
             textEffectRegistry,
+            spannableCacheOwner,
         )
 
     val maximumNumberOfLines =

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactEditText.kt

@@ -292,7 +292,7 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
     if (DEBUG_MODE) {
       FLog.e(TAG, "finalize[$id] delete cached spannable")
     }
-    TextLayoutManager.deleteCachedSpannableForTag(id)
+    TextLayoutManager.deleteCachedSpannableForTag(UIManagerHelper.getReactContext(this), id)
   }
 
   // After the text changes inside an EditText, TextView checks if a layout() has been requested.
@@ -1220,7 +1220,7 @@ public open class ReactEditText public constructor(context: Context) : AppCompat
         sb.length,
         Spannable.SPAN_INCLUSIVE_INCLUSIVE,
     )
-    TextLayoutManager.setCachedSpannableForTag(id, sb)
+    TextLayoutManager.setCachedSpannableForTag(UIManagerHelper.getReactContext(this), id, sb)
   }
 
   public fun setEventDispatcher(eventDispatcher: EventDispatcher?) {

packages/react-native/ReactAndroid/src/test/java/com/facebook/react/views/textinput/ReactEditTextSpannableCacheTest.kt

@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.views.textinput
+
+import android.text.SpannableString
+import android.util.DisplayMetrics
+import android.view.Gravity
+import androidx.core.content.res.ResourcesCompat.ID_NULL
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.common.mapbuffer.WritableMapBuffer
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlagsForTests
+import com.facebook.react.uimanager.DisplayMetricsHolder
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.views.text.ReactTextUpdate
+import com.facebook.react.views.text.TextLayoutManager
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.mock
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class ReactEditTextSpannableCacheTest {
+
+  private lateinit var manager: ReactTextInputManager
+  private val oldRuntime = mock<ReactApplicationContext>()
+  private val newRuntime = mock<ReactApplicationContext>()
+
+  @Before
+  fun setup() {
+    ReactNativeFeatureFlagsForTests.setUp()
+    manager = ReactTextInputManager()
+    DisplayMetricsHolder.setScreenDisplayMetrics(DisplayMetrics())
+  }
+
+  @After
+  fun tearDown() {
+    TextLayoutManager.destroySpannableCache(oldRuntime)
+    TextLayoutManager.destroySpannableCache(newRuntime)
+  }
+
+  @Test
+  fun `a view from a destroyed runtime does not evict a new runtime's spannable for the same tag`() {
+    // Mirrors FabricUIManager's constructor and invalidate() across a React instance reload.
+    TextLayoutManager.createSpannableCache(oldRuntime)
+    val staleView = createViewWithCachedText(oldRuntime, "stale")
+    TextLayoutManager.destroySpannableCache(oldRuntime)
+    TextLayoutManager.createSpannableCache(newRuntime)
+
+    assertThatThrownBy { cachedSpannable(newRuntime) }
+        .isInstanceOf(IllegalStateException::class.java)
+
+    val liveView = createViewWithCachedText(newRuntime, "live")
+    runFinalizer(staleView)
+
+    assertThat(cachedSpannable(newRuntime).toString()).isEqualTo("live")
+
+    runFinalizer(liveView)
+
+    assertThatThrownBy { cachedSpannable(newRuntime) }
+        .isInstanceOf(IllegalStateException::class.java)
+  }
+
+  @Test
+  fun `a view's spannable lands in the cache registered for its ReactApplicationContext`() {
+    TextLayoutManager.createSpannableCache(newRuntime)
+    val view = createViewWithCachedText(newRuntime, "live")
+
+    assertThat(view.context).isInstanceOf(ThemedReactContext::class.java)
+    assertThat(cachedSpannable(newRuntime).toString()).isEqualTo("live")
+  }
+
+  @Test
+  fun `measuring after the runtime's cache is destroyed returns an empty spannable`() {
+    TextLayoutManager.createSpannableCache(oldRuntime)
+    createViewWithCachedText(oldRuntime, "stale")
+    TextLayoutManager.destroySpannableCache(oldRuntime)
+
+    assertThat(cachedSpannable(oldRuntime).toString()).isEmpty()
+  }
+
+  private fun createViewWithCachedText(
+      runtime: ReactApplicationContext,
+      text: String,
+  ): ReactEditText {
+    val themedContext =
+        ThemedReactContext(runtime, RuntimeEnvironment.getApplication(), null, ID_NULL)
+    val view = manager.createViewInstance(themedContext)
+    view.id = TAG
+    view.stateWrapper = mock<StateWrapper>()
+    view.maybeSetTextFromState(
+        ReactTextUpdate(
+            SpannableString(text),
+            0,
+            view.gravity and Gravity.HORIZONTAL_GRAVITY_MASK,
+            0,
+            0,
+        ),
+    )
+    return view
+  }
+
+  private fun runFinalizer(view: ReactEditText) {
+    ReactEditText::class.java.getDeclaredMethod("finalize").apply { isAccessible = true }(view)
+  }
+
+  @OptIn(UnstableReactNativeAPI::class)
+  private fun cachedSpannable(runtime: ReactApplicationContext) =
+      TextLayoutManager.getOrCreateSpannableForText(
+          RuntimeEnvironment.getApplication().assets,
+          0,
+          WritableMapBuffer().put(TextLayoutManager.AS_KEY_CACHE_ID, TAG),
+          null,
+          null,
+          runtime,
+      )
+
+  private companion object {
+    const val TAG = 42
+  }
+}