Revert "fix(gxt): tie classic-tag reactors to instance/owner destroy chains"

This reverts commit ef6ce28.

Author: lifeart

packages/@ember/-internals/glimmer/lib/renderer.ts

@@ -1746,90 +1746,6 @@ function intoTarget(into: IntoTarget): Cursor {
   }
 }
 
-/**
- * Set of cleanup functions for active GXT renderComponent calls, drained
- * by __gxtCleanupActiveComponents (called from QUnit testStart and from
- * test-case afterEach in internal-test-helpers). Without this, reactors
- * registered by _renderComponentGxt leak across tests because the
- * synthetic `{}` owner default is not in any destroy chain — nobody
- * ever calls destroy() on a freshly-allocated plain object.
- */
-const _gxtPendingRenderCleanups = new Set<() => void>();
-(globalThis as any).__gxtDrainPendingRenderCleanups = function () {
-  if (_gxtPendingRenderCleanups.size === 0) return;
-  for (const fn of Array.from(_gxtPendingRenderCleanups)) {
-    try {
-      fn();
-    } catch {
-      /* ignore */
-    }
-  }
-  _gxtPendingRenderCleanups.clear();
-};
-
-/**
- * Wire `owner` into the destroyable chain so the registered cleanup
- * actually fires on teardown.
- *
- * The renderComponent API documents `owner = {}` as the default. That
- * synthetic plain object isn't in any destroy chain by itself — calling
- * registerDestructor on it records the destructor but it never runs,
- * because nothing ever calls destroy() on the synthetic owner.
- *
- * Three layers of cleanup, all pointing at the same cleanupFn:
- *
- * 1. Ambient parent owner via associateDestroyableChild — when the
- *    parent owner is destroyed via the standard glimmer/destroyable
- *    chain, the synthetic descends with it.
- * 2. registerDestructor on owner — covers callers that do call
- *    destroy(owner) directly.
- * 3. _gxtPendingRenderCleanups Set — eagerly drained by
- *    __gxtCleanupActiveComponents at QUnit testStart and from
- *    test-case afterEach; this is the only layer that fires
- *    synchronously regardless of the runloop, which is what
- *    actually prevents the cross-test reactor leak.
- *
- * Idempotent — safe to call from both _renderComponentGxt return paths.
- */
-function _wireOwnerDestroyChain(owner: object, parentOwner: unknown, cleanupFn: () => void): void {
-  // Wrap so each layer fires the underlying cleanup exactly once and
-  // removing from the pending Set is automatic.
-  let fired = false;
-  const oneShot = () => {
-    if (fired) return;
-    fired = true;
-    _gxtPendingRenderCleanups.delete(oneShot);
-    try {
-      cleanupFn();
-    } catch {
-      /* ignore */
-    }
-  };
-  _gxtPendingRenderCleanups.add(oneShot);
-  if (
-    parentOwner &&
-    parentOwner !== owner &&
-    typeof owner === 'object' &&
-    owner !== null &&
-    Object.getPrototypeOf(owner) === Object.prototype &&
-    !isDestroyed(parentOwner) &&
-    !isDestroying(parentOwner) &&
-    !isDestroyed(owner) &&
-    !isDestroying(owner)
-  ) {
-    try {
-      associateDestroyableChild(parentOwner as any, owner as any);
-    } catch {
-      // parent may not accept association; fall through to register
-    }
-  }
-  try {
-    registerDestructor(owner, oneShot);
-  } catch {
-    // owner may not be destroyable; nothing else to do
-  }
-}
-
 /**
  * GXT-specific renderComponent implementation.
  * Bypasses Glimmer VM bytecode compilation entirely.
@@ -1863,18 +1779,11 @@ function _renderComponentGxt(
   ensureGxtContext();
 
   let destroyed = false;
-  let reactorCleanedUp = false;
   let classicReactorUnsub: (() => void) | null = null;
 
-  // Reactor-only cleanup. Fires when the owner is destroyed via the
-  // standard destroyable chain (registered below). Cleaning up the
-  // classic-tag reactor is critical to prevent cross-test leaks; the
-  // DOM is not touched here because owner destruction does not imply
-  // the caller wants the rendered nodes removed (that is what
-  // result.destroy() means, see doDestroy).
-  const cleanupReactor = () => {
-    if (reactorCleanedUp) return;
-    reactorCleanedUp = true;
+  const doDestroy = () => {
+    if (destroyed) return;
+    destroyed = true;
     if (classicReactorUnsub) {
       try {
         classicReactorUnsub();
@@ -1883,14 +1792,6 @@ function _renderComponentGxt(
       }
       classicReactorUnsub = null;
     }
-  };
-
-  // Full destroy. Returned to the caller as result.destroy(). Cleans
-  // the reactor and wipes the rendered content.
-  const doDestroy = () => {
-    if (destroyed) return;
-    destroyed = true;
-    cleanupReactor();
     if (targetElement instanceof Element) {
       targetElement.innerHTML = '';
     }
@@ -1965,7 +1866,12 @@ function _renderComponentGxt(
 
       const result: RenderResult = { destroy: doDestroy };
       RENDER_CACHE.set(into, { result, glimmerResult: undefined });
-      _wireOwnerDestroyChain(owner, prevOwner, cleanupReactor);
+      // Register destructor on owner so owner.destroy() cleans up DOM
+      try {
+        registerDestructor(owner, doDestroy);
+      } catch {
+        // owner may not be destroyable
+      }
       return result;
     }
 
@@ -2277,7 +2183,13 @@ function _renderComponentGxt(
 
   const result: RenderResult = { destroy: doDestroy };
   RENDER_CACHE.set(into, { result, glimmerResult: undefined });
-  _wireOwnerDestroyChain(owner, prevOwner, cleanupReactor);
+
+  // Register destructor on owner so that destroying the owner cleans up the DOM
+  try {
+    registerDestructor(owner, doDestroy);
+  } catch {
+    // owner may not be destroyable
+  }
 
   return result;
 }

packages/@ember/-internals/gxt-backend/compile.ts

@@ -5784,16 +5784,6 @@ setInterval(() => {
   if (typeof destroyTracked === 'function') {
     destroyTracked();
   }
-  // Eagerly drain any classic-tag reactor cleanups for renderComponent
-  // calls whose synthetic plain-object owner ({}) isn't otherwise in a
-  // destroy chain (the renderComponent API documents `owner = {}` as the
-  // default — see _wireOwnerDestroyChain in renderer.ts). Without this
-  // drain, those reactors leak across the QUnit testStart/testDone
-  // boundary and clobber shared GXT sync state on subsequent tests.
-  const drainPending = (globalThis as any).__gxtDrainPendingRenderCleanups;
-  if (typeof drainPending === 'function') {
-    drainPending();
-  }
   // Reset block params stack
   blockParamsStack.length = 0;
   // Reset current slot params

packages/@ember/-internals/gxt-backend/manager.ts

@@ -4134,26 +4134,6 @@ let _preRerenderSnapshot: Set<any> = new Set();
     }
   }
 
-  // Phase 0 (eager): drain any classic-tag reactor unsubs registered
-  // on instances. These unsubs (set by renderLinkToElement) need to
-  // fire SYNCHRONOUSLY here, before Ember's async runloop-based
-  // destroy chain runs — otherwise the reactor stays in
-  // _classicReactors across the testStart/testDone boundary and
-  // fires on the next test's tag dirties. The willDestroy monkey-
-  // patch in renderLinkToElement is a fallback for instances not
-  // reached by this phase.
-  for (const instance of instances) {
-    const unsub = instance && instance.__gxtClassicReactorUnsub;
-    if (typeof unsub === 'function') {
-      try {
-        unsub();
-      } catch {
-        /* ignore */
-      }
-      instance.__gxtClassicReactorUnsub = null;
-    }
-  }
-
   // Phase 1: willDestroyElement + willClearRender (top-down, element still present)
   for (const instance of instances) {
     try {
@@ -9537,36 +9517,6 @@ function renderLinkToElement(instance: any, args: any, fw: any): HTMLAnchorEleme
       }
     };
     unsub = (_gxtRegisterClassicReactor as any)(wrapped, 'renderLinkToElement');
-    // Tie the reactor's lifetime to the LinkTo instance's lifetime.
-    // The element-detachment heuristic above is unreliable in routing
-    // tests that reattach the same <a> across transitions (counter
-    // resets each time); without an additional escape hatch the
-    // reactor lives forever and fires across unrelated tests.
-    //
-    // Two hooks, both pointing at the same unsub:
-    //
-    // 1. instance.__gxtClassicReactorUnsub — picked up SYNCHRONOUSLY
-    //    by Phase 0 of __gxtDestroyTrackedInstances. Ember's async
-    //    runloop-based destroy chain doesn't fire willDestroy soon
-    //    enough to prevent the reactor from leaking across the
-    //    testStart/testDone boundary, so we drain it eagerly there.
-    // 2. willDestroy override — fallback for instances not reached
-    //    by __gxtDestroyTrackedInstances (e.g. component destroyed
-    //    via a route transition rather than test teardown).
-    if (instance && typeof instance === 'object' && !instance.__gxtLinkToReactorUnsubInstalled) {
-      instance.__gxtClassicReactorUnsub = unsub;
-      const prior = instance.willDestroy;
-      const priorBound = typeof prior === 'function' ? prior.bind(instance) : null;
-      instance.willDestroy = function () {
-        try {
-          unsub();
-        } catch {
-          /* ignore */
-        }
-        if (priorBound) return priorBound();
-      };
-      instance.__gxtLinkToReactorUnsubInstalled = true;
-    }
   };
 
   // id attribute (doesn't change over the element's lifetime, so no reactor)