gui: a wait for quiet called off on its way does nothing when it arrives

The window's clock hands what it fires to the toolkit's queue
(desktop.Later, time.AfterFunc then fyne.Do), and calling it off stops the
timer, not a call already queued. If somebody typed in that gap, the quiet
they broke still ran: it gave memory back twelve seconds later, in the
middle of their work, and took the place of the new quiet's handle, so
closing the window could no longer call that one off. tidy now counts the
waits called off and each call checks it is still its own - the same as
busy.epoch.

The concurrency guard reported a declared file that runs nothing, but only
among the files the walk reaches. A declared file that is gone kept its
declaration and its place on the race job's list, green. The check is a
function asked of a folder made in the test.

The changelog said memory goes back after the last thing done in the
window. It is the last setting changed or press of Preview or Generate -
scrolling does not count - and it waits while work runs.

Guards: TestAWaitCalledOffOnItsWayDoesNothingWhenItArrives (red on the old
tidy.go, 2 waits and 2 releases), TestADeclarationWhoseFileIsGoneIsReported.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: donislawdev

CHANGELOG.md

@@ -496,10 +496,12 @@ because it turns other people's test suites red.
 
 - **The window gives memory back once it has been left alone.** After a
   spell of work it used to keep about 200 MB for as long as it stood idle.
-  About a minute and a half after the last thing done in it, the window now
-  gives back what it no longer uses - 215 MB down to 129 MB in one
-  measurement. Nothing on the screen moves when it does. A minimised window
-  gives back less, because the toolkit only lets go while it draws.
+  About a minute and a half after the last setting changed or the last press
+  of Preview or Generate, the window now gives back what it no longer uses -
+  215 MB down to 129 MB in one measurement. Scrolling does not count, and
+  while Preview or Generate is running it waits. Nothing on the screen moves
+  when it does. A minimised window gives back less, because the toolkit only
+  lets go while it draws.
 
 - **Changing a setting of a preset is about four times faster.** With
   `upload-validation`, changing one of its settings held the window for

internal/guard/concurrency_test.go

@@ -140,7 +140,11 @@ func TestConcurrencyStaysWhereItWasPutOnPurpose(t *testing.T) {
 	// how a decision gets undone quietly: the window gives memory back on a
 	// goroutine BECAUSE a call on its own thread took 2491 ms once, and taking
 	// the go statement away would leave the file declared and every guard
-	// green. A file the build leaves out on this machine is not asked.
+	// green. A file the build leaves out on this machine is not asked. A file
+	// that is gone is, because the walk above never reaches it and a deleted
+	// file would otherwise keep its declaration and its place on the race
+	// detector's list - an outside review of the pull request named it.
+	idle = append(idle, declaredWithoutAFile(repoRoot(t), mayBeConcurrent)...)
 	if len(idle) > 0 {
 		sort.Strings(idle)
 		t.Errorf("declared as concurrent and running nothing beside anything:\n  %s\n\n"+
@@ -158,6 +162,35 @@ func TestConcurrencyStaysWhereItWasPutOnPurpose(t *testing.T) {
 	}
 }
 
+// declaredWithoutAFile is every declared path with no file under root, each
+// with what the system said about it.
+func declaredWithoutAFile(root string, declared map[string]string) []string {
+	var gone []string
+	for rel := range declared {
+		if _, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel))); err != nil {
+			gone = append(gone, rel+" ("+err.Error()+")")
+		}
+	}
+	return gone
+}
+
+// A declaration whose file is gone is reported, and one whose file is there
+// is not - asked of a folder made here, because every file the tree declares
+// exists and a check that stopped looking would stay green on it.
+func TestADeclarationWhoseFileIsGoneIsReported(t *testing.T) {
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "a"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "a", "here.go"), []byte("package a\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	got := declaredWithoutAFile(root, map[string]string{"a/here.go": "", "a/gone.go": ""})
+	if len(got) != 1 || !strings.HasPrefix(got[0], "a/gone.go ") {
+		t.Errorf("declared a/here.go, which exists, and a/gone.go, which does not - reported %q, expected a/gone.go alone", got)
+	}
+}
+
 // concurrencyIn is every place in one file that runs something beside the
 // code around it, as "line what".
 //

internal/guard/tidy_test.go

@@ -88,6 +88,49 @@ func TestSomethingDoneDuringTheWaitStartsTheQuietOver(t *testing.T) {
 	}
 }
 
+// A wait called off on its way does nothing when it arrives.
+//
+// Calling the clock off is not enough, and an outside review of the pull
+// request named why: the real window's clock hands what it fires to the
+// toolkit's queue (desktop.Later, time.AfterFunc then fyne.Do), and a call
+// already queued still runs. If somebody types in that gap, the quiet they
+// broke arrived anyway - it gave memory back twelve seconds later, in the
+// middle of their work, and took the place of the new quiet's handle, so
+// closing the window could no longer call that one off. The same gap as the
+// busy face's (TestAFaceAskedForByEarlierWorkNeverDressesLaterWork).
+//
+// Played out with the held clock: the first quiet is kept aside, a second key
+// calls it off, and then it is fired as if the queue had just got round to it.
+func TestAWaitCalledOffOnItsWayDoesNothingWhenItArrives(t *testing.T) {
+	host := newFakeHost(t)
+	window.Open(host)
+	host.quiet = &quietClock{}
+	content := tabNamed(t, host.content, text.TabOneTarget())
+
+	fill(t, content, text.FieldSeed(), "5")
+	first := host.quiet.waiting()
+	if len(first) != 1 {
+		t.Fatalf("typing into a box left %d wait(s) for quiet, expected one to keep aside", len(first))
+	}
+	fill(t, content, text.FieldSeed(), "6")
+	if !first[0].calledOff {
+		t.Fatal("a second key did not call the first quiet off, so there is no call on its way to ask about")
+	}
+
+	first[0].then() // the first quiet arriving from the queue after all
+	if got := len(host.quiet.waiting()); got != 1 {
+		t.Errorf("a quiet called off on its way arrived and %d wait(s) are left, expected the one quiet of the second key", got)
+	}
+	host.quiet.fireAll() // the second key's quiet
+	if host.releases != 0 {
+		t.Error("memory was given back after a quiet somebody had broken, in the middle of their work")
+	}
+	host.quiet.fireAll()
+	if host.releases != 1 {
+		t.Errorf("after the second key's quiet and its frame memory was given back %d time(s), expected once", host.releases)
+	}
+}
+
 // No memory goes back while work owns the window - the run is what is using it.
 func TestNoMemoryIsGivenBackWhileWorkIsGoing(t *testing.T) {
 	host, content, hold := heldScreen(t)

internal/gui/window/tidy.go

@@ -78,6 +78,12 @@ type tidy struct {
 	// newTidy.
 	later   later
 	callOff func()
+	// wait counts the waits called off, so that one called off on its way
+	// does nothing when it arrives. Calling the clock off is not enough: the
+	// real window's clock hands what it fires to the toolkit's queue, and a
+	// call already queued when somebody types still runs. The same as
+	// busy.epoch, and an outside review of the pull request named it.
+	wait int
 }
 
 // newTidy builds the wait for one window.
@@ -100,32 +106,44 @@ func newTidy(h Host, busy func() bool) *tidy {
 // touch is told that something happened, and starts the quiet over.
 func (t *tidy) touch() {
 	t.Stop()
-	t.callOff = t.later(tidyAfterQuiet, t.frame)
+	t.after(tidyAfterQuiet, t.frame)
 }
 
-// Stop calls off whatever is being waited for. Closing the window stops it,
-// along with every screen.
+// Stop calls off whatever is being waited for, a call already on its way
+// included. Closing the window stops it, along with every screen.
 func (t *tidy) Stop() {
+	t.wait++
 	if t.callOff != nil {
 		t.callOff()
 		t.callOff = nil
 	}
 }
 
+// after asks the clock for then, which arrives only if nothing called the
+// wait off in the meantime.
+func (t *tidy) after(d time.Duration, then func()) {
+	mine := t.wait
+	t.callOff = t.later(d, func() {
+		if t.wait != mine {
+			return
+		}
+		t.callOff = nil
+		then()
+	})
+}
+
 // frame asks the toolkit to draw, so that it lets go of what has expired. Even
 // under a run, which costs one frame and nothing else - whether to give memory
 // back is asked once, in release.
 func (t *tidy) frame() {
-	t.callOff = nil
 	if c := t.host.Canvas(); c != nil && c.Content() != nil {
 		c.Refresh(c.Content())
 	}
-	t.callOff = t.later(tidyAfterFrame, t.release)
+	t.after(tidyAfterFrame, t.release)
 }
 
 // release gives the memory back, beside the window.
 func (t *tidy) release() {
-	t.callOff = nil
 	if t.busy() {
 		t.touch()
 		return