[perf] box RenderItem behavior

Move RenderItem's lifecycle closures and reuse/transition/animation
config into a single boxed reference (Storage); id/frame stay inline.
Copying an item up the container tree is now one retain instead of ~13,
with the public API preserved via computed forwards.

Flat-layer scroll profile: RenderItem copy/teardown self-time dropped
from ~839 to ~124 samples; scroll.flatSmall.5000 median ~0.113 -> ~0.097 ms.

Author: honghaoz

ComposeUI/Sources/ComposeUI/ComposeNode/RenderItem/RenderItem.swift

@@ -56,8 +56,16 @@ public struct RenderItem<T> {
   /// The frame of the renderable.
   public var frame: CGRect
 
+  /// The renderable's behavior: the lifecycle callbacks plus the reuse / transition / animation configuration.
+  ///
+  /// This is boxed in a reference type so that copying a `RenderItem` — which the render walk does at every container
+  /// level — is a single retain instead of copying ~10 escaping closures, and so the value type stays small (cheaper to
+  /// store in, and tear down, the per-pass render dictionaries). `id` and `frame` stay inline because they are mutated
+  /// per render pass.
+  private let storage: Storage
+
   /// The block to create a renderable.
-  public let make: (RenderableMakeContext) -> T
+  public var make: (RenderableMakeContext) -> T { storage.make }
 
   /// The block to be called when the renderable is just made and is about to be inserted into the renderable hierarchy.
   ///
@@ -66,7 +74,7 @@ public struct RenderItem<T> {
   /// after the insertion.
   ///
   /// This is guaranteed to be the first call for the renderable's lifecycle in the renderable hierarchy.
-  public let willInsert: ((T, RenderableInsertContext) -> Void)?
+  public var willInsert: ((T, RenderableInsertContext) -> Void)? { storage.willInsert }
 
   /// The block to be called when the renderable is just inserted into the renderable hierarchy.
   ///
@@ -76,14 +84,14 @@ public struct RenderItem<T> {
   /// same as the new frame, because during the transition animation, the renderable maybe updated for additional changes.
   ///
   /// This is not guaranteed to be called before the `update` block is called.
-  public let didInsert: ((T, RenderableInsertContext) -> Void)?
+  public var didInsert: ((T, RenderableInsertContext) -> Void)? { storage.didInsert }
 
   /// The block to be called when the renderable is about to be updated.
   ///
   /// At this point, the renderable might be not inserted into the renderable hierarchy yet. The renderable's properties, including its
   /// frame, are not updated yet. You can use this block to get the properties of the renderable before the update and use the
   /// information to help renderable content update. For example, to get the old properties for animating the renderable's changes.
-  public let willUpdate: ((T, RenderableUpdateContext) -> Void)?
+  public var willUpdate: ((T, RenderableUpdateContext) -> Void)? { storage.willUpdate }
 
   /// The block to be called when the renderable's frame is just updated and is ready to be updated for additional changes.
   ///
@@ -96,21 +104,21 @@ public struct RenderItem<T> {
   /// Note that it is possible that when a renderable is being inserted into the renderable hierarchy with a transition animation, a
   /// new update, which is triggered by a `refresh()`, is called on the renderable. In this case, an update call with
   /// `RenderableUpdateType.refresh` type will be called before the update call with `RenderableUpdateType.insert` type.
-  public let update: (T, RenderableUpdateContext) -> Void
+  public var update: (T, RenderableUpdateContext) -> Void { storage.update }
 
   /// The block to be called when the renderable is about to be removed from the renderable hierarchy.
   ///
   /// At this point, the renderable is still in the renderable hierarchy, but it is about to be removed, before the transition
   /// animation if has one.
-  public let willRemove: ((T, RenderableRemoveContext) -> Void)?
+  public var willRemove: ((T, RenderableRemoveContext) -> Void)? { storage.willRemove }
 
   /// The block to be called when the renderable is just removed from the renderable hierarchy.
   ///
   /// At this point, the renderable is already removed from the renderable hierarchy with its transition animation completed.
   ///
   /// Note that it is possible that a removing renderable, during its removal transition animation, is re-inserted into the
   /// renderable hierarchy. In this case, the `didRemove` block won't be called.
-  public let didRemove: ((T, RenderableRemoveContext) -> Void)?
+  public var didRemove: ((T, RenderableRemoveContext) -> Void)? { storage.didRemove }
 
   /// An optional reuse identifier that opts the renderable into the recycle pool.
   ///
@@ -120,20 +128,67 @@ public struct RenderItem<T> {
   ///
   /// To ensure a reused renderable is in the same state a freshly made one would have, use the `resetForReuse` block to
   /// reset the renderable's modified properties.
-  let reuseId: ReuseId?
+  var reuseId: ReuseId? { storage.reuseId }
 
   /// The concrete renderable type generated by `ObjectIdentifier(T.self)`.
-  let renderableType: ObjectIdentifier?
+  var renderableType: ObjectIdentifier? { storage.renderableType }
 
   /// The block to be called when the renderable is about to be added to the reuse pool, to reset any modified state so
   /// the reused renderable is clean (freshly-made-equivalent) for its next use.
-  public let resetForReuse: ((T) -> Void)?
+  public var resetForReuse: ((T) -> Void)? { storage.resetForReuse }
 
   /// The transition of the renderable. The transition is used to animate the renderable's insertion and removal.
-  public let transition: RenderableTransition?
+  public var transition: RenderableTransition? { storage.transition }
 
   /// The animation timing of the renderable. The animation timing is used to animate the renderable's changes.
-  public let animationTiming: AnimationTiming?
+  public var animationTiming: AnimationTiming? { storage.animationTiming }
+
+  /// The boxed behavior backing a `RenderItem`. See `storage`.
+  ///
+  /// Holds everything except `id` and `frame`. Because all fields are immutable, the box can be shared freely across
+  /// the copies a render pass makes (containers copy child items to re-position them), so each copy is one retain.
+  private final class Storage {
+
+    let make: (RenderableMakeContext) -> T
+    let willInsert: ((T, RenderableInsertContext) -> Void)?
+    let didInsert: ((T, RenderableInsertContext) -> Void)?
+    let willUpdate: ((T, RenderableUpdateContext) -> Void)?
+    let update: (T, RenderableUpdateContext) -> Void
+    let willRemove: ((T, RenderableRemoveContext) -> Void)?
+    let didRemove: ((T, RenderableRemoveContext) -> Void)?
+    let reuseId: ReuseId?
+    let renderableType: ObjectIdentifier?
+    let resetForReuse: ((T) -> Void)?
+    let transition: RenderableTransition?
+    let animationTiming: AnimationTiming?
+
+    init(make: @escaping (RenderableMakeContext) -> T,
+         willInsert: ((T, RenderableInsertContext) -> Void)?,
+         didInsert: ((T, RenderableInsertContext) -> Void)?,
+         willUpdate: ((T, RenderableUpdateContext) -> Void)?,
+         update: @escaping (T, RenderableUpdateContext) -> Void,
+         willRemove: ((T, RenderableRemoveContext) -> Void)?,
+         didRemove: ((T, RenderableRemoveContext) -> Void)?,
+         reuseId: ReuseId?,
+         renderableType: ObjectIdentifier?,
+         resetForReuse: ((T) -> Void)?,
+         transition: RenderableTransition?,
+         animationTiming: AnimationTiming?)
+    {
+      self.make = make
+      self.willInsert = willInsert
+      self.didInsert = didInsert
+      self.willUpdate = willUpdate
+      self.update = update
+      self.willRemove = willRemove
+      self.didRemove = didRemove
+      self.reuseId = reuseId
+      self.renderableType = renderableType
+      self.resetForReuse = resetForReuse
+      self.transition = transition
+      self.animationTiming = animationTiming
+    }
+  }
 
   public init(id: ComposeNodeId,
               frame: CGRect,
@@ -151,18 +206,20 @@ public struct RenderItem<T> {
   {
     self.id = id
     self.frame = frame
-    self.make = make
-    self.willInsert = willInsert
-    self.didInsert = didInsert
-    self.willUpdate = willUpdate
-    self.update = update
-    self.willRemove = willRemove
-    self.didRemove = didRemove
-    self.reuseId = reuseId.map { ReuseId(namespace: .user, id: $0) } // external callers can only set a user-provided identifier
-    self.renderableType = ObjectIdentifier(T.self)
-    self.resetForReuse = resetForReuse
-    self.transition = transition
-    self.animationTiming = animationTiming
+    self.storage = Storage(
+      make: make,
+      willInsert: willInsert,
+      didInsert: didInsert,
+      willUpdate: willUpdate,
+      update: update,
+      willRemove: willRemove,
+      didRemove: didRemove,
+      reuseId: reuseId.map { ReuseId(namespace: .user, id: $0) }, // external callers can only set a user-provided identifier
+      renderableType: ObjectIdentifier(T.self),
+      resetForReuse: resetForReuse,
+      transition: transition,
+      animationTiming: animationTiming
+    )
   }
 
   /// Internal initializer for creating a renderable item with a specified renderable type and reuse identifier.
@@ -184,18 +241,20 @@ public struct RenderItem<T> {
   {
     self.id = id
     self.frame = frame
-    self.make = make
-    self.willInsert = willInsert
-    self.didInsert = didInsert
-    self.willUpdate = willUpdate
-    self.update = update
-    self.willRemove = willRemove
-    self.didRemove = didRemove
-    self.reuseId = reuseId
-    self.renderableType = renderableType
-    self.resetForReuse = resetForReuse
-    self.transition = transition
-    self.animationTiming = animationTiming
+    self.storage = Storage(
+      make: make,
+      willInsert: willInsert,
+      didInsert: didInsert,
+      willUpdate: willUpdate,
+      update: update,
+      willRemove: willRemove,
+      didRemove: didRemove,
+      reuseId: reuseId,
+      renderableType: renderableType,
+      resetForReuse: resetForReuse,
+      transition: transition,
+      animationTiming: animationTiming
+    )
   }
 
   /// Add an additional will insert block to the renderable item.