[BUGFIX] Preserve barrel side effects when rewriting deep imports

The no-barrel-imports rule rewrites `import { x } from 'BARREL'` to
deep paths like `import { x } from 'BARREL/lib/foo'` for tree-shaking.
But when the barrel itself has top-level side effects (e.g.
`import './lib/bootstrap';` in @glimmer/runtime/index.ts, or the
`globalThis` registration check in @glimmer/validator/index.ts), those
side effects are skipped — the barrel is never loaded.

Concrete failure: @glimmer/runtime/index.ts pulls in bootstrap.ts as
a side-effect import. bootstrap.ts then imports
./compiled/opcodes/{component,content,dom,debugger,expressions,vm,lists},
each of which calls APPEND_OPCODES.add(...) at module-load to register
opcode handlers. Without bootstrap, AppendOpcodes.evaluateOpcode[type]
is null at render time → "Cannot read properties of null (reading
'syscall')" in the smoke tests.

The rule now:

1. Detects whether a barrel has top-level side effects (any
   non-export, non-pure-type, non-`declare` statement, or any
   side-effect-only import).
2. When rewriting away from such a barrel, prepends a side-effect-only
   `import 'BARREL';` to the rewritten output. Modules are cached, so
   this is idempotent; bundlers will tree-shake the named exports and
   leave only the side effects, which is exactly what we want.
3. Skips this for `import type` / `export type` (no runtime).

Side-effect detection caught and preserved three barrels we'd
otherwise have silently broken: @glimmer/runtime (opcode bootstrap),
@glimmer/validator (duplicate-package guard), and @ember/object
(EmberObject extends CoreObject.extend(Observable) at top level).

The Fix commit's manual one-off patches in @glimmer/debug and
@glimmer/opcode-compiler aren't needed anymore — the rule now handles
the IS_COMPILABLE_TEMPLATE type/value distinction correctly via its
existing isType tracking.

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

Author: NullVoxPopuli

eslint-rules/no-barrel-imports.js

@@ -9,6 +9,7 @@ const WORKSPACE_ROOT = path.resolve(__dirname, '..');
 const PACKAGES_ROOT = path.join(WORKSPACE_ROOT, 'packages');
 
 const moduleCache = new Map();
+const sideEffectsCache = new Map();
 const owningPackageCache = new Map();
 const wildcardExportsCache = new Map();
 
@@ -87,11 +88,13 @@ function getModuleExports(filepath, stack = new Set()) {
     ast = parse(fs.readFileSync(filepath, 'utf8'), { jsx: false, range: true, loc: true });
   } catch {
     moduleCache.set(filepath, null);
+    sideEffectsCache.set(filepath, false);
     stack.delete(filepath);
     return null;
   }
 
   const exports = new Map();
+  let hasSideEffects = false;
   for (const stmt of ast.body) {
     if (stmt.type === 'ExportNamedDeclaration') collectNamedExports(stmt, exports, filepath, stack);
     else if (stmt.type === 'ExportAllDeclaration')
@@ -103,14 +106,41 @@ function getModuleExports(filepath, stack = new Set()) {
         isType: false,
         kind: 'local',
       });
+    } else if (
+      stmt.type === 'ImportDeclaration' &&
+      (stmt.specifiers?.length ?? 0) === 0 &&
+      stmt.importKind !== 'type'
+    ) {
+      // Bare side-effect-only import: `import 'foo';`
+      hasSideEffects = true;
+    } else if (
+      stmt.type !== 'ImportDeclaration' &&
+      stmt.type !== 'TSImportEqualsDeclaration' &&
+      stmt.type !== 'TSModuleDeclaration' &&
+      stmt.type !== 'TSInterfaceDeclaration' &&
+      stmt.type !== 'TSTypeAliasDeclaration' &&
+      stmt.type !== 'TSDeclareFunction' &&
+      // `declare` statements (`declare const x: ...`, `declare function f()`)
+      // and ambient enums are TS-only — they emit nothing at runtime.
+      !stmt.declare
+    ) {
+      // Any other top-level statement that isn't an import or a pure type-level
+      // declaration is potentially side-effecting (e.g. `someFn()` or `let x = 1`).
+      hasSideEffects = true;
     }
   }
 
   moduleCache.set(filepath, exports);
+  sideEffectsCache.set(filepath, hasSideEffects);
   stack.delete(filepath);
   return exports;
 }
 
+function moduleHasSideEffects(filepath) {
+  if (!sideEffectsCache.has(filepath)) getModuleExports(filepath);
+  return sideEffectsCache.get(filepath) === true;
+}
+
 function collectNamedExports(stmt, exports, filepath, stack) {
   const stmtIsType = stmt.exportKind === 'type';
 
@@ -402,6 +432,23 @@ module.exports = {
       return missing;
     }
 
+    // If `barrelPath` has top-level side effects (e.g. a side-effect-only
+    // `import './lib/bootstrap';`), bypassing the barrel skips those side
+    // effects. Returns a side-effect-only import statement that re-establishes
+    // them when prepended to the rewritten output, or `null` if the barrel has
+    // no side effects.
+    function sideEffectImportFor(barrelPath, barrelSpec) {
+      if (!moduleHasSideEffects(barrelPath)) return null;
+      const currentInfo = getPackageInfo(filename);
+      const targetInfo = getPackageInfo(barrelPath);
+      if (currentInfo && targetInfo && currentInfo.bareSpec === targetInfo.bareSpec) {
+        let rel = toPosix(path.relative(path.dirname(filename), barrelPath));
+        if (!rel.startsWith('.')) rel = './' + rel;
+        return `import '${stripExt(rel)}';`;
+      }
+      return `import '${barrelSpec}';`;
+    }
+
     function check(node) {
       const spec = node.source?.value;
       if (typeof spec !== 'string') return;
@@ -492,10 +539,21 @@ module.exports = {
       // be sourced from a sub-file because they don't live in one.
       for (const item of kept) pushGroup(groups, spec, item);
 
-      const statements = namespaceImports.map((ns) => {
+      const statements = [];
+      // Type-only imports (`import type { ... } from 'foo';`) don't trigger
+      // module evaluation at runtime, so there are no side effects to preserve.
+      // For everything else, if the barrel has top-level side effects,
+      // bypassing it would skip them — emit a bare side-effect import.
+      if (!isWholeTypeImport) {
+        const sideEffectImport = sideEffectImportFor(barrelPath, spec);
+        if (sideEffectImport) statements.push(sideEffectImport);
+      }
+      for (const ns of namespaceImports) {
         const useType = isWholeTypeImport || ns.isType;
-        return `import ${useType ? 'type ' : ''}* as ${ns.localName} from '${ns.newSpec}';`;
-      });
+        statements.push(
+          `import ${useType ? 'type ' : ''}* as ${ns.localName} from '${ns.newSpec}';`
+        );
+      }
       if (groups.size > 0) statements.push(buildImportStatements(groups, isWholeTypeImport));
 
       const allSpecs = [...namespaceImports.map((n) => n.newSpec), ...groups.keys()];
@@ -564,10 +622,17 @@ module.exports = {
 
       for (const item of kept) pushGroup(groups, spec, item);
 
-      const statements = namespaceExports.map((ns) => {
+      const statements = [];
+      if (!isWholeTypeExport) {
+        const sideEffectImport = sideEffectImportFor(barrelPath, spec);
+        if (sideEffectImport) statements.push(sideEffectImport);
+      }
+      for (const ns of namespaceExports) {
         const useType = isWholeTypeExport || ns.isType;
-        return `export ${useType ? 'type ' : ''}* as ${ns.exportedName} from '${ns.newSpec}';`;
-      });
+        statements.push(
+          `export ${useType ? 'type ' : ''}* as ${ns.exportedName} from '${ns.newSpec}';`
+        );
+      }
       if (groups.size > 0) statements.push(buildExportStatements(groups, isWholeTypeExport));
 
       const allSpecs = [...namespaceExports.map((n) => n.newSpec), ...groups.keys()];

packages/@ember/-internals/glimmer/lib/component-managers/curly.ts

@@ -36,9 +36,11 @@ import {
   createPrimitiveRef,
   valueForRef,
 } from '@glimmer/reference/lib/reference';
+import '@glimmer/runtime';
 import { reifyPositional } from '@glimmer/runtime/lib/vm/arguments';
 import { EMPTY_ARRAY } from '@glimmer/util/lib/array-utils';
 import { unwrapTemplate } from './unwrap-template';
+import '@glimmer/validator';
 import {
   beginTrackFrame,
   beginUntrackFrame,

packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts

@@ -18,6 +18,7 @@ import type {
 import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
 import type { Reference } from '@glimmer/reference/lib/reference';
 import { UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference/lib/reference';
+import '@glimmer/runtime';
 import { EMPTY_ARGS } from '@glimmer/runtime/lib/vm/arguments';
 import { unwrapTemplate } from './unwrap-template';
 

packages/@ember/-internals/glimmer/lib/component-managers/root.ts

@@ -11,6 +11,7 @@ import type {
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
 import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
+import '@glimmer/validator';
 import { CONSTANT_TAG } from '@glimmer/validator/lib/validators';
 import { consumeTag } from '@glimmer/validator/lib/tracking';
 import type Component from '../component';

packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts

@@ -18,6 +18,7 @@ import { DEBUG } from '@glimmer/env';
 import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
 import type { Reference } from '@glimmer/reference/lib/reference';
 import { createDebugAliasRef, valueForRef } from '@glimmer/reference/lib/reference';
+import '@glimmer/runtime';
 import { curry, type CurriedValue } from '@glimmer/runtime/lib/curried-value';
 import { unwrapTemplate } from './unwrap-template';
 

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

@@ -20,8 +20,10 @@ import { DEBUG } from '@glimmer/env';
 import type { Environment, Template, TemplateFactory } from '@glimmer/interfaces';
 import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import { isUpdatableRef, updateRef } from '@glimmer/reference/lib/reference';
+import '@glimmer/runtime';
 import { normalizeProperty } from '@glimmer/runtime/lib/dom/props';
 import type { DirtyableTag } from '@glimmer/interfaces';
+import '@glimmer/validator';
 import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 import type { SimpleElement } from '@simple-dom/interface';
 import {

packages/@ember/-internals/glimmer/lib/components/input.ts

@@ -6,6 +6,7 @@ import { type Opaque } from '@ember/-internals/utility-types';
 import { assert, warn } from '@ember/debug';
 import { action } from '@ember/object';
 import { valueForRef } from '@glimmer/reference/lib/reference';
+import '@glimmer/validator';
 import { untrack } from '@glimmer/validator/lib/tracking';
 import InputTemplate from '../templates/input';
 import AbstractInput, { valueFrom } from './abstract-input';

packages/@ember/-internals/glimmer/lib/components/internal.ts

@@ -17,6 +17,7 @@ import { setComponentTemplate } from '@glimmer/manager/lib/public/template';
 import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import type { Reference } from '@glimmer/reference/lib/reference';
 import { createConstRef, isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
+import '@glimmer/validator';
 import { untrack } from '@glimmer/validator/lib/tracking';
 
 function NOOP(): void {}

packages/@ember/-internals/glimmer/lib/components/link-to.ts

@@ -1,6 +1,7 @@
 import type Route from '@ember/routing/route';
 import type { RouterState, RoutingService } from '@ember/routing/-internals';
 import { isSimpleClick } from '@ember/-internals/views/lib/system/utils';
+import '@ember/debug';
 import inspect from '@ember/debug/lib/inspect';
 import { assert, debugFreeze, warn } from '@ember/debug';
 import { getEngineParent } from '@ember/engine/parent';
@@ -11,6 +12,7 @@ import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
 import type { Maybe } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
+import '@glimmer/validator';
 import { consumeTag, createCache, getValue, untrack } from '@glimmer/validator/lib/tracking';
 import { tagFor } from '@glimmer/validator/lib/meta';
 import type { Transition } from 'router_js';

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

@@ -1,3 +1,4 @@
+import '@glimmer/runtime';
 export { DOMChanges } from '@glimmer/runtime/lib/dom/helper';
 export { DOMTreeConstruction } from '@glimmer/runtime/lib/dom/api';
 export { clientBuilder } from '@glimmer/runtime/lib/vm/element-builder';