OverlayPortal.overlayChild contributes semantics to OverlayPortal instead of Overlay (flutter#134921)

Fixes flutter#134456

Author: LongCatIsLooong

packages/flutter/lib/src/material/tooltip.dart

@@ -901,17 +901,20 @@ class _TooltipOverlay extends StatelessWidget {
         constraints: BoxConstraints(minHeight: height),
         child: DefaultTextStyle(
           style: Theme.of(context).textTheme.bodyMedium!,
-          child: Container(
-            decoration: decoration,
-            padding: padding,
-            margin: margin,
-            child: Center(
-              widthFactor: 1.0,
-              heightFactor: 1.0,
-              child: Text.rich(
-                richMessage,
-                style: textStyle,
-                textAlign: textAlign,
+          child: Semantics(
+            container: true,
+            child: Container(
+              decoration: decoration,
+              padding: padding,
+              margin: margin,
+              child: Center(
+                widthFactor: 1.0,
+                heightFactor: 1.0,
+                child: Text.rich(
+                  richMessage,
+                  style: textStyle,
+                  textAlign: textAlign,
+                ),
               ),
             ),
           ),

packages/flutter/lib/src/rendering/object.dart

@@ -3531,7 +3531,7 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
     // node, thus marking this semantics boundary dirty is not enough, it needs
     // to find the first parent semantics boundary that does not have any
     // possible sibling node.
-    while (node.parent is RenderObject && (mayProduceSiblingNodes || !isEffectiveSemanticsBoundary)) {
+    while (node.parent != null && (mayProduceSiblingNodes || !isEffectiveSemanticsBoundary)) {
       if (node != this && node._needsSemanticsUpdate) {
         break;
       }
@@ -3565,7 +3565,7 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
     if (!node._needsSemanticsUpdate) {
       node._needsSemanticsUpdate = true;
       if (owner != null) {
-        assert(node._semanticsConfiguration.isSemanticBoundary || node.parent is! RenderObject);
+        assert(node._semanticsConfiguration.isSemanticBoundary || node.parent == null);
         owner!._nodesNeedingSemantics.add(node);
         owner!.requestVisualUpdate();
       }
@@ -3574,7 +3574,7 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
 
   /// Updates the semantic information of the render object.
   void _updateSemantics() {
-    assert(_semanticsConfiguration.isSemanticBoundary || parent is! RenderObject);
+    assert(_semanticsConfiguration.isSemanticBoundary || parent == null);
     if (_needsLayout) {
       // There's not enough information in this subtree to compute semantics.
       // The subtree is probably being kept alive by a viewport but not laid out.
@@ -3625,8 +3625,8 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
     final bool blockChildInteractions = blockUserActions || config.isBlockingUserActions;
     final bool childrenMergeIntoParent = mergeIntoParent || config.isMergingSemanticsOfDescendants;
     final List<SemanticsConfiguration> childConfigurations = <SemanticsConfiguration>[];
-    final bool explicitChildNode = config.explicitChildNodes || parent is! RenderObject;
-    final bool hasChildConfigurationsDelegate = config.childConfigurationsDelegate != null;
+    final bool explicitChildNode = config.explicitChildNodes || parent == null;
+    final ChildSemanticsConfigurationsDelegate? childConfigurationsDelegate = config.childConfigurationsDelegate;
     final Map<SemanticsConfiguration, _InterestingSemanticsFragment> configToFragment = <SemanticsConfiguration, _InterestingSemanticsFragment>{};
     final List<_InterestingSemanticsFragment> mergeUpFragments = <_InterestingSemanticsFragment>[];
     final List<List<_InterestingSemanticsFragment>> siblingMergeFragmentGroups = <List<_InterestingSemanticsFragment>>[];
@@ -3650,7 +3650,7 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
         if (hasTags) {
           fragment.addTags(config.tagsForChildren!);
         }
-        if (hasChildConfigurationsDelegate && fragment.config != null) {
+        if (childConfigurationsDelegate != null && fragment.config != null) {
           // This fragment need to go through delegate to determine whether it
           // merge up or not.
           childConfigurations.add(fragment.config!);
@@ -3674,14 +3674,14 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
       }
     });
 
-    assert(hasChildConfigurationsDelegate || configToFragment.isEmpty);
+    assert(childConfigurationsDelegate != null || configToFragment.isEmpty);
 
     if (explicitChildNode) {
       for (final _InterestingSemanticsFragment fragment in mergeUpFragments) {
         fragment.markAsExplicit();
       }
-    } else if (hasChildConfigurationsDelegate) {
-      final ChildSemanticsConfigurationsResult result = config.childConfigurationsDelegate!(childConfigurations);
+    } else if (childConfigurationsDelegate != null) {
+      final ChildSemanticsConfigurationsResult result = childConfigurationsDelegate(childConfigurations);
       mergeUpFragments.addAll(
         result.mergeUp.map<_InterestingSemanticsFragment>((SemanticsConfiguration config) {
           final _InterestingSemanticsFragment? fragment = configToFragment[config];
@@ -3706,7 +3706,7 @@ abstract class RenderObject with DiagnosticableTreeMixin implements HitTestTarge
     _needsSemanticsUpdate = false;
 
     final _SemanticsFragment result;
-    if (parent is! RenderObject) {
+    if (parent == null) {
       assert(!config.hasBeenAnnotated);
       assert(!mergeIntoParent);
       assert(siblingMergeFragmentGroups.isEmpty);
@@ -4781,26 +4781,14 @@ class _SwitchableSemanticsFragment extends _InterestingSemanticsFragment {
             parentPaintClipRect: parentPaintClipRect,
           )!;
           final Rect fragmentRect = MatrixUtils.transformRect(geometry.transform, geometry.rect);
-          if (rect == null) {
-            rect = fragmentRect;
-          } else {
-            rect = rect.expandToInclude(fragmentRect);
-          }
+          rect = rect?.expandToInclude(fragmentRect) ?? fragmentRect;
           if (geometry.semanticsClipRect != null) {
             final Rect rect = MatrixUtils.transformRect(geometry.transform, geometry.semanticsClipRect!);
-            if (semanticsClipRect == null) {
-              semanticsClipRect = rect;
-            } else {
-              semanticsClipRect = semanticsClipRect.intersect(rect);
-            }
+            semanticsClipRect = semanticsClipRect?.intersect(rect) ?? rect;
           }
           if (geometry.paintClipRect != null) {
             final Rect rect = MatrixUtils.transformRect(geometry.transform, geometry.paintClipRect!);
-            if (paintClipRect == null) {
-              paintClipRect = rect;
-            } else {
-              paintClipRect = paintClipRect.intersect(rect);
-            }
+            paintClipRect = paintClipRect?.intersect(rect) ?? rect;
           }
           if (switchableFragment._tagsForChildren != null) {
             tags.addAll(switchableFragment._tagsForChildren!);
@@ -4891,8 +4879,7 @@ class _SwitchableSemanticsFragment extends _InterestingSemanticsFragment {
       return; // Drop the node, it's not going to be visible.
     }
 
-    owner._semantics ??= SemanticsNode(showOnScreen: owner.showOnScreen);
-    final SemanticsNode node = owner._semantics!
+    final SemanticsNode node = (owner._semantics ??= SemanticsNode(showOnScreen: owner.showOnScreen))
       ..isMergedIntoParent = _mergeIntoParent
       ..tags = _tagsForChildren;
 
@@ -5070,24 +5057,45 @@ class _SemanticsGeometry {
     _transform = Matrix4.identity();
     _semanticsClipRect = parentSemanticsClipRect;
     _paintClipRect = parentPaintClipRect;
+
     for (int index = ancestors.length-1; index > 0; index -= 1) {
-      final RenderObject parent = ancestors[index];
-      final RenderObject child = ancestors[index-1];
-      final Rect? parentSemanticsClipRect = parent.describeSemanticsClip(child);
-      if (parentSemanticsClipRect != null) {
-        _semanticsClipRect = parentSemanticsClipRect;
-        _paintClipRect = _intersectRects(_paintClipRect, parent.describeApproximatePaintClip(child));
+      final RenderObject semanticsParent = ancestors[index];
+      final RenderObject semanticsChild = ancestors[index-1];
+      _applyIntermediatePaintTransforms(semanticsParent, semanticsChild, _transform);
+
+      if (identical(semanticsParent, semanticsChild.parent)) {
+        // The easier and more common case: semanticsParent is directly
+        // responsible for painting (and potentially clipping) the semanticsChild
+        // RenderObject.
+        _computeClipRect(semanticsParent, semanticsChild, _semanticsClipRect, _paintClipRect);
       } else {
-        _semanticsClipRect = _intersectRects(_semanticsClipRect, parent.describeApproximatePaintClip(child));
+        // Otherwise we have to find the closest ancestor RenderObject that
+        // has up-to-date semantics geometry and compute the clip rects from there.
+        //
+        // Currently it can only happen when the subtree contains an OverlayPortal.
+        final List<RenderObject> clipPath = <RenderObject>[semanticsChild];
+
+        RenderObject? ancestor = semanticsChild.parent;
+        while (ancestor != null && ancestor._semantics == null) {
+          clipPath.add(ancestor);
+          ancestor = ancestor.parent;
+        }
+        _paintClipRect = ancestor?._semantics?.parentPaintClipRect;
+        _semanticsClipRect = ancestor?._semantics?.parentSemanticsClipRect;
+        if (ancestor != null) {
+          assert(ancestor._semantics != null);
+          assert(!ancestor._needsSemanticsUpdate);
+          RenderObject parent = ancestor;
+          for (int i = clipPath.length - 1; i >= 0; i -= 1) {
+            _computeClipRect(parent, clipPath[i], _semanticsClipRect, _paintClipRect);
+            parent = clipPath[i];
+          }
+        }
       }
-      _temporaryTransformHolder.setIdentity(); // clears data from previous call(s)
-      _applyIntermediatePaintTransforms(parent, child, _transform, _temporaryTransformHolder);
-      _semanticsClipRect = _transformRect(_semanticsClipRect, _temporaryTransformHolder);
-      _paintClipRect = _transformRect(_paintClipRect, _temporaryTransformHolder);
     }
 
     final RenderObject owner = ancestors.first;
-    _rect = _semanticsClipRect == null ? owner.semanticBounds : _semanticsClipRect!.intersect(owner.semanticBounds);
+    _rect = _semanticsClipRect?.intersect(owner.semanticBounds) ?? owner.semanticBounds;
     if (_paintClipRect != null) {
       final Rect paintRect = _paintClipRect!.intersect(_rect);
       _markAsHidden = paintRect.isEmpty && !_rect.isEmpty;
@@ -5097,15 +5105,6 @@ class _SemanticsGeometry {
     }
   }
 
-  // A matrix used to store transient transform data.
-  //
-  // Reusing this matrix avoids allocating a new matrix every time a temporary
-  // matrix is needed.
-  //
-  // This instance should never be returned to the caller. Otherwise, the data
-  // stored in it will be overwritten unpredictably by subsequent reuses.
-  static final Matrix4 _temporaryTransformHolder = Matrix4.zero();
-
   /// From parent to child coordinate system.
   static Rect? _transformRect(Rect? rect, Matrix4 transform) {
     if (rect == null) {
@@ -5117,36 +5116,88 @@ class _SemanticsGeometry {
     return MatrixUtils.inverseTransformRect(transform, rect);
   }
 
-  // Calls applyPaintTransform on all of the render objects between [child] and
-  // [ancestor]. This method handles cases where the immediate semantic parent
-  // is not the immediate render object parent of the child.
+  // Computes the paint transform from `childFragmentOwner` to
+  // `parentFragmentOwner` and applies the paint transform to `transform` in
+  // place.
   //
-  // It will mutate both transform and clipRectTransform.
+  // The `parentFragmentOwner` and `childFragmentOwner` [RenderObject]s must be
+  // in the same render tree (so they have a common ancestor).
   static void _applyIntermediatePaintTransforms(
-    RenderObject ancestor,
-    RenderObject child,
+    RenderObject parentFragmentOwner,
+    RenderObject childFragmentOwner,
     Matrix4 transform,
-    Matrix4 clipRectTransform,
   ) {
-    assert(clipRectTransform.isIdentity());
-    RenderObject intermediateParent = child.parent!;
-    while (intermediateParent != ancestor) {
-      intermediateParent.applyPaintTransform(child, transform);
-      intermediateParent = intermediateParent.parent!;
-      child = child.parent!;
+    Matrix4? parentToCommonAncestorTransform;
+    RenderObject from = childFragmentOwner;
+    RenderObject to = parentFragmentOwner;
+
+    while (!identical(from, to)) {
+      final int fromDepth = from.depth;
+      final int toDepth = to.depth;
+
+      if (fromDepth >= toDepth) {
+        assert(from.parent != null, '$parentFragmentOwner and $childFragmentOwner are not in the same render tree.');
+        final RenderObject fromParent = from.parent!;
+        fromParent.applyPaintTransform(from, transform);
+        from = fromParent;
+      }
+      if (fromDepth <= toDepth) {
+        assert(to.parent != null, '$parentFragmentOwner and $childFragmentOwner are not in the same render tree.');
+        final RenderObject toParent = to.parent!;
+        toParent.applyPaintTransform(to, parentToCommonAncestorTransform ??= Matrix4.identity());
+        to = toParent;
+      }
+    }
+
+    if (parentToCommonAncestorTransform != null) {
+      if (parentToCommonAncestorTransform.invert() != 0) {
+        transform.multiply(parentToCommonAncestorTransform);
+      } else {
+        transform.setZero();
+      }
     }
-    ancestor.applyPaintTransform(child, transform);
-    ancestor.applyPaintTransform(child, clipRectTransform);
   }
 
-  static Rect? _intersectRects(Rect? a, Rect? b) {
-    if (a == null) {
-      return b;
+  // A matrix used to store transient transform data.
+  //
+  // Reusing this matrix avoids allocating a new matrix every time a temporary
+  // matrix is needed.
+  //
+  // This instance should never be returned to the caller. Otherwise, the data
+  // stored in it will be overwritten unpredictably by subsequent reuses.
+  static final Matrix4 _temporaryTransformHolder = Matrix4.zero();
+
+  // Computes the semantics and painting clip rects for the given child and
+  // assigns the rects to _semanticsClipRect and _paintClipRect respectively.
+  //
+  // The caller must guarantee that child.parent == parent. The resulting rects
+  // are in `child`'s coordinate system.
+  void _computeClipRect(RenderObject parent, RenderObject child, Rect? parentSemanticsClipRect, Rect? parentPaintClipRect) {
+    assert(identical(child.parent, parent));
+    // Computes the paint transform from child to parent. The _transformRect
+    // method will compute the inverse.
+    _temporaryTransformHolder.setIdentity(); // clears data from previous call(s)
+    parent.applyPaintTransform(child, _temporaryTransformHolder);
+
+    final Rect? additionalPaintClip = parent.describeApproximatePaintClip(child);
+    _paintClipRect = _transformRect(
+      _intersectRects(additionalPaintClip, parentPaintClipRect),
+      _temporaryTransformHolder,
+    );
+
+    if (_paintClipRect == null) {
+      _semanticsClipRect = null;
+    } else {
+      final Rect? semanticsClip = parent.describeSemanticsClip(child) ?? _intersectRects(parentSemanticsClipRect, additionalPaintClip);
+      _semanticsClipRect = _transformRect(semanticsClip, _temporaryTransformHolder);
     }
+  }
+
+  static Rect? _intersectRects(Rect? a, Rect? b) {
     if (b == null) {
       return a;
     }
-    return a.intersect(b);
+    return a?.intersect(b) ?? b;
   }
 
   /// Whether the [SemanticsNode] annotated with the geometric information tracked