Fix: exempt JS-scope locals from restriction checks in gjs/gts

When in gjs/gts mode, names that resolve to JS-scope variables (imports,
const, let, function params) are now treated the same as block params and
exempted from restriction checks. Previously, block params were exempt but
JS-scope bindings were not, which was inconsistent -- both are local
bindings that the developer explicitly controls.

Uses sourceCode.getScope(node) to check whether a reference resolves to
an actual variable definition (ref.resolved != null), ensuring that
ambient/global names are still flagged.

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

Author: NullVoxPopuli

lib/rules/template-no-restricted-invocations.js

@@ -92,6 +92,8 @@ module.exports = {
       return {};
     }
 
+    const sourceCode = context.sourceCode;
+
     // Track block params in a scope stack so yielded names are not flagged.
     const blockParamScopes = [];
 
@@ -112,6 +114,37 @@ module.exports = {
       return false;
     }
 
+    /**
+     * In gjs/gts, check whether a name resolves to a JS-scope variable
+     * (import, const, let, function param, etc.). If it does, it's a local
+     * binding and should be exempt from restriction checks — same as block params.
+     */
+    function isJsScopeVariable(node) {
+      if (!sourceCode) return false;
+
+      try {
+        if (node.type === 'GlimmerElementNode') {
+          // Element nodes use parts[0] for scope lookup, and need parent scope
+          if (!node.parts || !node.parts[0]) return false;
+          const scope = sourceCode.getScope(node.parent);
+          const ref = scope.references.find((r) => r.identifier === node.parts[0]);
+          // Only exempt if the reference actually resolves to a JS variable definition
+          return ref != null && ref.resolved != null;
+        }
+
+        // For mustache/block/sub/modifier statements, check the path's head
+        if (node.path && node.path.head) {
+          const scope = sourceCode.getScope(node);
+          const ref = scope.references.find((r) => r.identifier === node.path.head);
+          return ref != null && ref.resolved != null;
+        }
+      } catch {
+        // sourceCode.getScope may not be available in .hbs-only mode; ignore.
+      }
+
+      return false;
+    }
+
     function isRestricted(name) {
       for (const item of config) {
         if (typeof item === 'string') {
@@ -209,6 +242,14 @@ module.exports = {
           return;
         }
 
+        // In gjs/gts, skip if the tag resolves to a JS-scope variable (import, const, etc.)
+        if (isJsScopeVariable(node)) {
+          if (node.blockParams && node.blockParams.length > 0) {
+            pushBlockParams(node.blockParams);
+          }
+          return;
+        }
+
         const name = getComponentOrHelperName(node);
         if (name && !isBlockParam(name)) {
           const result = isRestricted(name);
@@ -236,6 +277,7 @@ module.exports = {
               modifier.path.original;
             if (!modName) continue;
             if (isBlockParam(modName)) continue;
+            if (isJsScopeVariable(modifier)) continue;
 
             const modResult = isRestricted(modName);
             if (modResult.restricted) {
@@ -264,6 +306,9 @@ module.exports = {
         if (isBlockParam(name)) {
           return;
         }
+        if (isJsScopeVariable(node)) {
+          return;
+        }
 
         const result = isRestricted(name);
         if (result.restricted) {
@@ -278,7 +323,7 @@ module.exports = {
 
       GlimmerBlockStatement(node) {
         const name = getComponentOrHelperName(node);
-        if (name && !isBlockParam(name)) {
+        if (name && !isBlockParam(name) && !isJsScopeVariable(node)) {
           const result = isRestricted(name);
           if (result.restricted) {
             context.report({
@@ -310,6 +355,9 @@ module.exports = {
         if (isBlockParam(name)) {
           return;
         }
+        if (isJsScopeVariable(node)) {
+          return;
+        }
 
         const result = isRestricted(name);
         if (result.restricted) {
@@ -329,6 +377,9 @@ module.exports = {
         if (isBlockParam(name)) {
           return;
         }
+        if (isJsScopeVariable(node)) {
+          return;
+        }
 
         const result = isRestricted(name);
         if (result.restricted) {

tests/lib/rules/template-no-restricted-invocations.js

@@ -66,6 +66,51 @@ ruleTester.run('template-no-restricted-invocations', rule, {
     '<template><Random/></template>',
     '<template><HelloWorld/></template>',
     '<template><NestedScope::Random/></template>',
+
+    // JS-scope variables (imports, const, let) should be exempt — same as block params.
+    {
+      code: `
+        import foo from './foo';
+        <template>{{foo}}</template>
+      `,
+      options: [['foo', 'bar']],
+    },
+    {
+      code: `
+        import Foo from './foo';
+        <template><Foo /></template>
+      `,
+      options: [['foo', 'bar']],
+    },
+    {
+      code: `
+        const foo = () => {};
+        <template>{{foo}}</template>
+      `,
+      options: [['foo', 'bar']],
+    },
+    {
+      code: `
+        import foo from './foo';
+        <template>{{foo "hello"}}</template>
+      `,
+      options: [['foo', 'bar']],
+    },
+    {
+      code: `
+        import bar from './bar';
+        <template>{{bar}}</template>
+      `,
+      options: [['foo', 'bar']],
+    },
+    {
+      code: `
+        import foo from './foo';
+        import bar from './bar';
+        <template>{{foo}}{{bar}}</template>
+      `,
+      options: [['foo', 'bar']],
+    },
   ],
   invalid: [
     {