Defer backtracking assertion to end-of-frame for same-frame mutations

Instead of immediately allowing or throwing for same-frame get/set,
defer the assertion to endTrackingTransaction. If the tag is
re-consumed (get/set/get pattern) before the frame ends, the pending
assertion is cleared. Otherwise it still fires.

This preserves the safety net for get/set without re-get (which can
cause infinite revalidation) while allowing the lazy initialization
pattern (get/set/get).

Also fixes lint: remove unused backtrackingMessageFor import.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: NullVoxPopuli

packages/@ember/-internals/glimmer/tests/integration/custom-modifier-manager-test.js

@@ -11,7 +11,6 @@ import { Component } from '@ember/-internals/glimmer';
 import { setModifierManager, modifierCapabilities } from '@glimmer/manager';
 import EmberObject, { set } from '@ember/object';
 import { tracked } from '@ember/-internals/metal';
-import { backtrackingMessageFor } from '../utils/debug-stack';
 
 class ModifierManagerTest extends RenderingTestCase {
   '@test throws a useful error when missing capabilities'(assert) {
@@ -272,6 +271,7 @@ class ModifierManagerTest extends RenderingTestCase {
           let val = person.name;
           if (val === undefined) {
             person.name = 'sam';
+            val = person.name;
           }
         }
       }

packages/@ember/-internals/metal/tests/tracked/validation_test.js

@@ -380,6 +380,24 @@ moduleFor(
       });
     }
 
+    ['@test gives helpful assertion when a tracked property is mutated after access without re-read']() {
+      class MyObject {
+        @tracked value;
+        toString() {
+          return 'MyObject';
+        }
+      }
+
+      let obj = new MyObject();
+
+      expectAssertion(() => {
+        track(() => {
+          obj.value;
+          obj.value = 123;
+        });
+      }, /You attempted to update `value` on `MyObject`, but it had already been used previously in the same computation/);
+    }
+
     ['@test get() does not entangle in the autotracking stack until after retrieving the value'](
       assert
     ) {

packages/@glimmer-workspace/integration-tests/test/managers/modifier-manager-test.ts

@@ -228,6 +228,7 @@ abstract class ModifierManagerTest extends RenderTest {
         let val = this.foo;
         if (val === undefined) {
           this.foo = 456;
+          val = this.foo;
         }
       }
 

packages/@glimmer/validator/lib/debug.ts

@@ -34,6 +34,14 @@ interface Transaction {
 if (DEBUG) {
   let CONSUMED_TAGS: WeakMap<Tag, Transaction> | null = null;
 
+  // Tracks tags that were dirtied after being consumed within the same tracking frame.
+  // If a tag is re-consumed before the frame ends, it's removed (get/set/get is OK).
+  // Any remaining entries at end-of-frame trigger the backtracking assertion.
+  let PENDING_SAME_FRAME_ASSERTIONS: Map<
+    Tag,
+    { obj?: unknown; keyName?: string | symbol; transaction: Transaction }
+  > | null = null;
+
   const TRANSACTION_STACK: Transaction[] = [];
 
   /////////
@@ -81,10 +89,26 @@ if (DEBUG) {
       throw new Error('attempted to close a tracking transaction, but one was not open');
     }
 
-    TRANSACTION_STACK.pop();
+    let closingTransaction = TRANSACTION_STACK.pop();
+
+    // Check for any same-frame get/set that was never followed by a re-get.
+    // This catches patterns like `get → set` (without a second get) which can
+    // cause infinite revalidation loops.
+    if (PENDING_SAME_FRAME_ASSERTIONS !== null && closingTransaction !== undefined) {
+      for (let [, pending] of PENDING_SAME_FRAME_ASSERTIONS) {
+        if (pending.transaction === closingTransaction) {
+          // This tag was dirtied after being consumed but never re-consumed
+          // before the frame ended — this is likely a bug, not lazy init.
+          let message = TRANSACTION_ENV.debugMessage(pending.obj, pending.keyName && String(pending.keyName));
+          PENDING_SAME_FRAME_ASSERTIONS = null;
+          assert(false, message);
+        }
+      }
+    }
 
     if (TRANSACTION_STACK.length === 0) {
       CONSUMED_TAGS = null;
+      PENDING_SAME_FRAME_ASSERTIONS = null;
     }
   };
 
@@ -97,6 +121,7 @@ if (DEBUG) {
 
     TRANSACTION_STACK.splice(0, TRANSACTION_STACK.length);
     CONSUMED_TAGS = null;
+    PENDING_SAME_FRAME_ASSERTIONS = null;
 
     return stack;
   };
@@ -178,7 +203,15 @@ if (DEBUG) {
   };
 
   debug.markTagAsConsumed = (_tag: Tag) => {
-    if (!CONSUMED_TAGS || CONSUMED_TAGS.has(_tag)) return;
+    if (!CONSUMED_TAGS) return;
+
+    // If this tag has a pending same-frame assertion, the re-consume (second get)
+    // resolves it — this is the valid get/set/get (lazy initialization) pattern.
+    if (PENDING_SAME_FRAME_ASSERTIONS !== null && PENDING_SAME_FRAME_ASSERTIONS.has(_tag)) {
+      PENDING_SAME_FRAME_ASSERTIONS.delete(_tag);
+    }
+
+    if (CONSUMED_TAGS.has(_tag)) return;
 
     CONSUMED_TAGS.set(_tag, getLast(asPresentArray(TRANSACTION_STACK)));
 
@@ -204,10 +237,15 @@ if (DEBUG) {
     if (!transaction) return;
 
     // Allow get/set/get (lazy initialization) within the same tracking frame.
-    // If the tag was consumed in the current transaction, un-consume it so that
-    // a subsequent read can re-consume it with the updated value.
+    // Instead of throwing immediately, defer the assertion to end-of-frame.
+    // If the tag is re-consumed (second get) before the frame ends, the pending
+    // assertion is cleared. Otherwise it fires at endTrackingTransaction.
     let currentTransaction = TRANSACTION_STACK[TRANSACTION_STACK.length - 1];
     if (transaction === currentTransaction) {
+      if (PENDING_SAME_FRAME_ASSERTIONS === null) {
+        PENDING_SAME_FRAME_ASSERTIONS = new Map();
+      }
+      PENDING_SAME_FRAME_ASSERTIONS.set(tag, { obj, keyName, transaction });
       CONSUMED_TAGS.delete(tag);
       return;
     }

packages/@glimmer/validator/test/tracking-test.ts

@@ -513,6 +513,29 @@ module('@glimmer/validator: tracking', () => {
         assert.strictEqual(result, 789, 'get after set returns the updated value');
       });
 
+      test('it errors when get/set is not followed by a re-get in the same frame', (assert) => {
+        class Foo {
+          foo = 123;
+          bar = 456;
+        }
+
+        let { getter, setter } = trackedData<Foo, keyof Foo>('foo', function (this: Foo) {
+          return this.bar;
+        });
+
+        let foo = new Foo();
+
+        assert.throws(() => {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+          debug.runInTrackingTransaction!(() => {
+            track(() => {
+              getter(foo);
+              setter(foo, 789);
+            });
+          });
+        }, /You attempted to update `foo` on `Foo`/);
+      });
+
       test('it still errors when updating a value consumed in a previous tracking frame', (assert) => {
         class Foo {
           foo = 123;
@@ -547,7 +570,7 @@ module('@glimmer/validator: tracking', () => {
         assert.expect(0);
         let tag = createTag();
 
-        // consume/dirty within the same frame should not throw (supports get/set/get pattern)
+        // consume/dirty/consume within the same frame should not throw (get/set/get pattern)
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
         debug.runInTrackingTransaction!(() => {
           track(() => {
@@ -558,6 +581,20 @@ module('@glimmer/validator: tracking', () => {
         });
       });
 
+      test('it errors when consume/dirty is not followed by a re-consume in the same frame', (assert) => {
+        let tag = createTag();
+
+        assert.throws(() => {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+          debug.runInTrackingTransaction!(() => {
+            track(() => {
+              consumeTag(tag);
+              dirtyTag(tag);
+            });
+          });
+        }, /Error: Assertion Failed: You attempted to update/u);
+      });
+
       test('it throws errors across track frames within the same debug transaction', (assert) => {
         let tag = createTag();