sticky_header: Fix hit-testing when header overflows sliver

When the sticky header overflows the sliver that provides it -- that
is, when the sliver boundary is scrolled to within the area the
header covers -- the existing code already got the right visual
result, painting the header at its full size.

But it didn't work properly for hit-testing: trying to tap the
header in the portion where it's overflowing wouldn't work, and
would instead go through to whatever's underneath (like the top of
the next sliver).  That's because the geometry it was reporting from
this `performLayout` method didn't reflect the geometry it would
actually paint in the `paint` method.  When hit-testing, that
reported geometry gets interpreted by the framework code before
calling this render object's other methods.

Fix that by reporting an accurate `paintOrigin` and `paintExtent`.

After this fix, sticky headers overflowing into the next sliver
seem to work completely correctly... as long as the viewport paints
the slivers in the necessary order.  We'll take care of that next.

Author: gnprice

lib/widgets/sticky_header.dart

@@ -617,10 +617,18 @@ class _RenderSliverStickyHeaderList extends RenderSliver with RenderSliverHelper
         // even if the (visible part of the) item is smaller than the header,
         // and even if the whole child sliver is smaller than the header.
 
+        final headerGrowthPlacement =
+          _widget.headerPlacement._byGrowth(constraints.growthDirection);
+
         geometry = SliverGeometry( // TODO review interaction with other slivers
           scrollExtent: geometry.scrollExtent,
           layoutExtent: childExtent,
-          paintExtent: childExtent,
+          paintExtent: math.max(childExtent, headerExtent),
+          paintOrigin: switch (headerGrowthPlacement) {
+            _HeaderGrowthPlacement.growthStart => 0,
+            _HeaderGrowthPlacement.growthEnd =>
+              math.min(0.0, childExtent - headerExtent),
+          },
           maxPaintExtent: math.max(geometry.maxPaintExtent, headerExtent),
           hasVisualOverflow: geometry.hasVisualOverflow
             || headerExtent > constraints.remainingPaintExtent,

test/widgets/sticky_header_test.dart

@@ -220,6 +220,48 @@ void main() {
     await tester.pump();
     checkState(103, item:   0, header:   0);
   });
+
+  testWidgets('hit-testing for header overflowing sliver', (tester) async {
+    final controller = ScrollController();
+    await tester.pumpWidget(Directionality(textDirection: TextDirection.ltr,
+      child: CustomScrollView(
+        controller: controller,
+        slivers: [
+          SliverStickyHeaderList(
+            headerPlacement: HeaderPlacement.scrollingStart,
+            delegate: SliverChildListDelegate(
+              List.generate(100, (i) => StickyHeaderItem(
+                allowOverflow: true,
+                header: _Header(i, height: 20),
+                child: _Item(i, height: 100))))),
+          SliverStickyHeaderList(
+            headerPlacement: HeaderPlacement.scrollingStart,
+            delegate: SliverChildListDelegate(
+              List.generate(100, (i) => StickyHeaderItem(
+                allowOverflow: true,
+                header: _Header(100 + i, height: 20),
+                child: _Item(100 + i, height: 100))))),
+        ])));
+
+    const topExtent = 100 * 100;
+    for (double topHeight in [5, 10, 15, 20]) {
+      controller.jumpTo(topExtent - topHeight);
+      await tester.pump();
+      // The top sliver occupies height [topHeight].
+      // Its header overhangs by `20 - topHeight`.
+
+      final expected = <Condition<Object?>>[];
+      for (int y = 1; y < 20; y++) {
+        await tester.tapAt(Offset(400, y.toDouble()));
+        expected.add((it) => it.isA<_Header>().index.equals(99));
+      }
+      for (int y = 21; y < 40; y += 2) {
+        await tester.tapAt(Offset(400, y.toDouble()));
+        expected.add((it) => it.isA<_Item>().index.equals(100));
+      }
+      check(_TapLogged.takeTapLog()).deepEquals(expected);
+    }
+  });
 }
 
 Future<void> _checkSequence(
@@ -389,6 +431,10 @@ class _Header extends StatelessWidget implements _TapLogged {
   }
 }
 
+extension _HeaderChecks on Subject<_Header> {
+  Subject<int> get index => has((x) => x.index, 'index');
+}
+
 class _Item extends StatelessWidget implements _TapLogged {
   const _Item(this.index, {required this.height});
 
@@ -412,6 +458,10 @@ class _Item extends StatelessWidget implements _TapLogged {
   }
 }
 
+extension _ItemChecks on Subject<_Item> {
+  Subject<int> get index => has((x) => x.index, 'index');
+}
+
 /// Sets [DeviceGestureSettings.touchSlop] for the child subtree
 /// to the given value, by inserting a [MediaQuery].
 ///