Prune commentary and stale Rust port notes

app-rust/tests/catch_a_fling.rs

@@ -1,24 +1,8 @@
-//! Layer 1 of docs/RUST.md's "Three test layers", for catching a fling:
-//! the real transcript screen over the real bench fixture, at the phone's
-//! size and density, with no window, no compositor and no GPU.
-//!
-//! docs/IRIS_TODO.md's 2026-09-07 night report -- "sometimes when I try to
-//! catch it while it's still moving (particularly if I drag) then it fails
-//! to stop & snap to where finger is". The finger goes down on content
-//! that is still travelling and the content does not follow it until
-//! `DRAG_SLOP` has been crossed, which at a fling's speed is several
-//! frames of the content sliding *away* from a finger that is already
-//! down. Compose does not do that: a down while `isScrollInProgress`
-//! starts the drag immediately (`scrollable`'s `startDragImmediately`).
-
 use ai_app::ui::fixture::{PHONE_FRAME_MS, PHONE_SCALE, phone_size};
 use iris::harness::{Harness, TouchAction, TouchScript};
 use iris::prelude::*;
 use iris::sense::DRAG_SLOP;
 
-/// The screen open on the fixture, framed twice -- once to draw, once for
-/// `LazySpan::repair_anchor` to resolve the opening `snap_end` into a real
-/// anchor, which is what every assertion about scroll position reads.
 fn opened() -> (Harness, ai_app::ui::TranscriptScreen) {
     let mut h = Harness::new(phone_size(), PHONE_SCALE);
     let opened = ai_app::ui::fixture::open(&mut h.rsc, &mut h.state).expect("the fixture folds");
@@ -27,10 +11,6 @@ fn opened() -> (Harness, ai_app::ui::TranscriptScreen) {
     (h, opened.screen)
 }
 
-/// Where the content is, in window pixels: the top of whichever row is
-/// under the middle of the viewport. `LazySpan` has no travel accessor and
-/// this needs none -- a row's own extent moves exactly as far as the
-/// content does, and the row is picked once so the two readings compare.
 fn tracked_row(h: &mut Harness, screen: &ai_app::ui::TranscriptScreen) -> (RowKey, f32) {
     let middle = phone_size().y / 2.0;
     let list = (screen.list)(&mut h.rsc);
@@ -46,17 +26,10 @@ fn row_top(h: &mut Harness, screen: &ai_app::ui::TranscriptScreen, key: RowKey)
         .0
 }
 
-/// Three finger samples 8ms apart, each moving `STEP` further down the
-/// screen. `STEP * 3` is deliberately **under** `DRAG_SLOP`: a gesture
-/// this small moves nothing at all on a settled list (the control below),
-/// so anything it moves here is the catch and not the slop being crossed.
 const STEP: f32 = 2.0;
 const SAMPLES: usize = 3;
 const CATCH_X: f32 = 540.0;
 
-/// Feeds the down and its `SAMPLES` moves from `y0` at `t0`, asserting
-/// after each one that the content moved by exactly the finger's own
-/// delta. Returns the release time.
 fn drag_from(
     h: &mut Harness,
     screen: &ai_app::ui::TranscriptScreen,
@@ -101,10 +74,6 @@ fn drag_from(
     t
 }
 
-/// The report itself: flick, let the fling run for 150ms, then put a
-/// finger down and drag it a little. From the down onwards the content is
-/// pinned to the finger, sample for sample -- no slop, and no coasting
-/// past the place the finger stopped it.
 #[test]
 fn a_press_on_a_flinging_list_pins_the_content_to_the_finger() {
     let (mut h, screen) = opened();
@@ -113,10 +82,6 @@ fn a_press_on_a_flinging_list_pins_the_content_to_the_finger() {
         .unwrap_or_else(|e| panic!("flick-120hz.touch: {e}"));
     h.replay(&flick);
 
-    // Frames, not a file: the second half of this gesture has to arrive
-    // *while* the fling is ticking, and a `.touch` replay inserts no
-    // frames between its samples, so a fling recorded that way would be
-    // running on paper and stationary in fact.
     let catch_at = flick.end_ms() + 150;
     h.frames_until(
         flick.end_ms() + PHONE_FRAME_MS,
@@ -132,11 +97,6 @@ fn a_press_on_a_flinging_list_pins_the_content_to_the_finger() {
     drag_from(&mut h, &screen, key, 1200.0, catch_at, true);
 }
 
-/// The other half of the same rule: a catch that never moved at all is a
-/// `Released(None)`, not a tap. Compose's scrollable consumes that DOWN,
-/// so no click detector under it ever sees the gesture -- stopping a
-/// fling with a finger must not also follow the link it landed on, and
-/// must not hand the list a velocity to start again with.
 #[test]
 fn a_catch_that_never_moved_is_not_a_tap_and_does_not_fling() {
     let (mut h, screen) = opened();
@@ -177,10 +137,6 @@ fn a_catch_that_never_moved_is_not_a_tap_and_does_not_fling() {
     );
 }
 
-/// The half this change had no reason to touch: on a list that is *not*
-/// moving, the same tiny drag is still inside `DRAG_SLOP` and still moves
-/// nothing. Without this, making every press pin the content would pass
-/// the test above and take the slop away from every ordinary press.
 #[test]
 fn the_same_small_drag_on_a_settled_list_moves_nothing() {
     let (mut h, screen) = opened();
@@ -188,7 +144,6 @@ fn the_same_small_drag_on_a_settled_list_moves_nothing() {
     let flick = TouchScript::parse(include_str!("../touch/flick-120hz.touch"))
         .unwrap_or_else(|e| panic!("flick-120hz.touch: {e}"));
     h.replay(&flick);
-    // Long past the spline's own 2071ms for this recording.
     let settled = h.frames_until(
         flick.end_ms() + PHONE_FRAME_MS,
         flick.end_ms() + 4000,