Fix template-no-unbound false positive in GJS/GTS

`unbound` is an ambient strict-mode keyword in Glimmer/Ember
(registered in STRICT_MODE_KEYWORDS, backed by
BUILTIN_KEYWORD_HELPERS.unbound), so `{{unbound foo}}` works in .gjs/.gts
templates without an import. The rule should still flag those uses —
its purpose is to discourage `unbound` everywhere — but skip cases
where the user has shadowed `unbound` with a JS import or a template
block param.

Replace the previous .hbs-only gate with a JS-scope-binding check
(mirroring template-no-log): walk sourceCode.getScope().variables
to detect imports/consts/params, plus track template block params,
and skip reporting only when the identifier resolves to a local.
This restores correct behavior for:

- bare `{{unbound foo}}` in .gjs (now flagged again — was a false
  negative under the .hbs-only gate)
- `import unbound from '...'; {{unbound foo}}` (correctly skipped)
- `{{#let (...) as |unbound|}}{{unbound}}{{/let}}` (correctly skipped)

Update templateMode metadata from 'loose' to 'both' to reflect that
the rule now runs in strict mode.

Author: johanrd

lib/rules/template-no-unbound.js

@@ -6,7 +6,7 @@ module.exports = {
       description: 'disallow {{unbound}} helper',
       category: 'Deprecations',
       url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-no-unbound.md',
-      templateMode: 'loose',
+      templateMode: 'both',
     },
     schema: [],
     messages: { unexpected: 'Unexpected {{unboundHelper}} usage.' },
@@ -18,18 +18,90 @@ module.exports = {
     },
   },
   create(context) {
+    // `unbound` is an ambient strict-mode keyword in Glimmer/Ember (registered
+    // in STRICT_MODE_KEYWORDS), so `{{unbound foo}}` in a .gjs/.gts file
+    // resolves to the built-in helper without an import. Flag it everywhere
+    // unless the user has shadowed `unbound` with a JS binding or a template
+    // block param.
+    const sourceCode = context.sourceCode;
+    const localScopes = [];
+
+    function isJsScopeVariable(node) {
+      if (!sourceCode || !node.path?.original) {
+        return false;
+      }
+      const name = node.path.original;
+      try {
+        let scope = sourceCode.getScope(node);
+        while (scope) {
+          if (scope.variables.some((v) => v.name === name)) {
+            return true;
+          }
+          scope = scope.upper;
+        }
+      } catch {
+        // sourceCode.getScope may not be available in .hbs-only mode; ignore.
+      }
+      return false;
+    }
+
+    function pushLocals(params) {
+      localScopes.push(new Set(params || []));
+    }
+
+    function popLocals() {
+      localScopes.pop();
+    }
+
+    function isLocal(name) {
+      for (const scope of localScopes) {
+        if (scope.has(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
     function check(node) {
-      if (node.path?.type === 'GlimmerPathExpression' && node.path.original === 'unbound') {
+      if (
+        node.path?.type === 'GlimmerPathExpression' &&
+        node.path.original === 'unbound' &&
+        !isLocal('unbound') &&
+        !isJsScopeVariable(node)
+      ) {
         context.report({
           node,
           messageId: 'unexpected',
           data: { unboundHelper: '{{unbound}}' },
         });
       }
     }
+
     return {
+      GlimmerBlockStatement(node) {
+        if (node.program?.blockParams) {
+          pushLocals(node.program.blockParams);
+        }
+        check(node);
+      },
+      'GlimmerBlockStatement:exit'(node) {
+        if (node.program?.blockParams) {
+          popLocals();
+        }
+      },
+
+      GlimmerElementNode(node) {
+        if (node.blockParams?.length > 0) {
+          pushLocals(node.blockParams);
+        }
+      },
+      'GlimmerElementNode:exit'(node) {
+        if (node.blockParams?.length > 0) {
+          popLocals();
+        }
+      },
+
       GlimmerMustacheStatement: check,
-      GlimmerBlockStatement: check,
       GlimmerSubExpression: check,
     };
   },

tests/lib/rules/template-no-unbound.js

@@ -35,8 +35,40 @@ const gjsRuleTester = new RuleTester({
 });
 
 gjsRuleTester.run('template-no-unbound', rule, {
-  valid: validHbs.map(wrapTemplate),
-  invalid: invalidHbs.map(wrapTemplate),
+  valid: [
+    ...validHbs.map(wrapTemplate),
+    // JS-scope shadowing: a user-imported `unbound` is not the Glimmer keyword.
+    {
+      filename: 'test.gjs',
+      code: "import unbound from './my-unbound-helper';\n<template>{{unbound foo}}</template>",
+    },
+    {
+      filename: 'test.gts',
+      code: "import unbound from '@some/addon';\n<template>{{my-thing foo=(unbound foo)}}</template>",
+    },
+    // Local block-param shadowing.
+    {
+      filename: 'test.gjs',
+      code: '<template>{{#let (component "foo") as |unbound|}}{{unbound}}{{/let}}</template>',
+    },
+  ],
+  invalid: [
+    ...invalidHbs.map(wrapTemplate),
+    // `unbound` is an ambient Glimmer keyword in strict mode — flag bare uses
+    // without a shadowing import or block param.
+    {
+      filename: 'test.gjs',
+      code: '<template>{{unbound foo}}</template>',
+      output: null,
+      errors: [{ messageId: 'unexpected' }],
+    },
+    {
+      filename: 'test.gts',
+      code: '<template>{{my-thing foo=(unbound foo)}}</template>',
+      output: null,
+      errors: [{ messageId: 'unexpected' }],
+    },
+  ],
 });
 
 const hbsRuleTester = new RuleTester({