async_hooks: drop leftover legacy ALS paths

Remove the AsyncContextFrame.enabled checks and the
async_local_storage_context_symbol that only served the async_hooks
based implementation, and stop spawning test-timers-async-store-leak
with --no-async-context-frame.

Author: mcollina

lib/internal/async_hooks.js

@@ -105,7 +105,6 @@ const before_symbol = Symbol('before');
 const after_symbol = Symbol('after');
 const destroy_symbol = Symbol('destroy');
 const promise_resolve_symbol = Symbol('promiseResolve');
-const async_local_storage_context_symbol = Symbol('kAsyncLocalStorageContext');
 const emitBeforeNative = emitHookFactory(before_symbol, 'emitBeforeNative');
 const emitAfterNative = emitHookFactory(after_symbol, 'emitAfterNative');
 const emitDestroyNative = emitHookFactory(destroy_symbol, 'emitDestroyNative');
@@ -585,7 +584,7 @@ module.exports = {
   symbols: {
     async_id_symbol, trigger_async_id_symbol,
     init_symbol, before_symbol, after_symbol, destroy_symbol,
-    promise_resolve_symbol, async_local_storage_context_symbol,
+    promise_resolve_symbol,
     owner_symbol,
   },
   constants: {

lib/internal/timers.js

@@ -100,9 +100,6 @@ const {
   emitBefore,
   emitAfter,
   emitDestroy,
-  symbols: {
-    async_local_storage_context_symbol,
-  },
 } = require('internal/async_hooks');
 
 // Symbols for storing async id state.
@@ -132,12 +129,8 @@ const AsyncContextFrame = require('internal/async_context_frame');
 const async_context_frame = Symbol('kAsyncContextFrame');
 
 function removeStoresFromResource(resource) {
-  if (AsyncContextFrame.enabled) {
-    if (resource[async_context_frame] !== undefined) {
-      resource[async_context_frame] = undefined;
-    }
-  } else if (resource[async_local_storage_context_symbol] !== undefined) {
-    resource[async_local_storage_context_symbol] = undefined;
+  if (resource[async_context_frame] !== undefined) {
+    resource[async_context_frame] = undefined;
   }
 }
 

test/parallel/test-stream-finished-async-local-storage.js

@@ -1,12 +1,9 @@
-// Flags: --expose-internals
 'use strict';
 
 const common = require('../common');
 const { Readable, finished } = require('stream');
 const { AsyncLocalStorage } = require('async_hooks');
 const assert = require('assert');
-const AsyncContextFrame = require('internal/async_context_frame');
-const { enabledHooksExist } = require('internal/async_hooks');
 
 // This test verifies that ALS context is preserved when using stream.finished()
 
@@ -15,7 +12,6 @@ const readable = new Readable();
 
 als.run('test-context-1', common.mustCall(() => {
   finished(readable, common.mustCall(() => {
-    assert.strictEqual(!!AsyncContextFrame.current() || enabledHooksExist(), true);
     assert.strictEqual(als.getStore(), 'test-context-1');
   }));
 }));

test/parallel/test-timers-async-store-leak.js

@@ -2,61 +2,20 @@
 'use strict';
 
 const common = require('../common');
-const { spawnSyncAndAssert } = require('../common/child_process');
 const { AsyncLocalStorage } = require('async_hooks');
 const assert = require('assert');
-
-if (process.argv[2] !== 'child') {
-  // Test with async-context-frame disabled (legacy ALS mode)
-  spawnSyncAndAssert(process.execPath, [
-    '--expose-internals',
-    '--expose-gc',
-    '--no-async-context-frame',
-    __filename,
-    'child',
-  ], {});
-
-  // Test with async-context-frame enabled (default)
-  spawnSyncAndAssert(process.execPath, [
-    '--expose-internals',
-    '--expose-gc',
-    __filename,
-    'child',
-  ], {});
-}
-
-const AsyncContextFrame = require('internal/async_context_frame');
 const {
   async_context_frame,
 } = require('internal/timers');
-const {
-  symbols: {
-    async_local_storage_context_symbol,
-  },
-} = require('internal/async_hooks');
-
-// When async-context-frame is enabled, stores are stored in the async context
-// frame, not directly on the resource. The resource holds a reference to the
-// frame via async_context_frame.
-const isACFEnabled = AsyncContextFrame.enabled;
-
-function getStore(resource, als) {
-  if (isACFEnabled) {
-    return resource[async_context_frame]?.get(als);
-  }
-  return resource[async_local_storage_context_symbol]?.[als.kResourceStore];
-}
 
+// Stores live in the async context frame, not directly on the resource. The
+// resource holds a reference to the frame via async_context_frame.
 function assertStore(resource, als, store) {
-  assert.strictEqual(getStore(resource, als), store);
+  assert.strictEqual(resource[async_context_frame]?.get(als), store);
 }
 
 function assertNoStore(resource) {
-  if (isACFEnabled) {
-    assert.strictEqual(resource[async_context_frame], undefined);
-  } else {
-    assert.strictEqual(resource[async_local_storage_context_symbol], undefined);
-  }
+  assert.strictEqual(resource[async_context_frame], undefined);
 }
 
 // Test that setTimeout does not retain a reference to the async store after