refactor(template-no-obsolete-elements): use scope manager for block params

Replaces the manual block-param stack with sourceCode.getScope(node.parent)
+ a walk up the scope chain. GTS templates work today (36/37 tests pass).

BLOCKED BY UPSTREAM: ember-tooling/ember-eslint-parser#189. The HBS parser
currently builds an empty scope manager, so Glimmer block params aren't
registered for .hbs files. The failing test
`{{#let ... as |plaintext|}}<plaintext />` documents this gap and will
start passing once PR 189 is merged and consumed here.

Uses getScope(node.parent) rather than getScope(node) so an element's
own `as |x|` params (attached to that element's block scope) don't
shadow its own tag — e.g. `<marquee as |marquee|>` must still flag the
outer <marquee>.

Author: johanrd

lib/rules/template-no-obsolete-elements.js

@@ -29,6 +29,15 @@ const OBSOLETE = [
   'tt',
   'xmp',
 ];
+
+// BLOCKED BY UPSTREAM: ember-tooling/ember-eslint-parser#189
+// The HBS parser currently creates an empty scope manager, so Glimmer block
+// params (`{{#let ... as |x|}}` / `<Comp as |x|>`) are not registered in scope
+// for `.hbs` files. Until PR 189 lands and a release is consumed here, the
+// HBS test for `{{#let ... as |plaintext|}}<plaintext />` will fail. GTS
+// templates work today because the gjs/gts parser already registers block
+// params.
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -50,42 +59,28 @@ module.exports = {
   },
   create(context) {
     const obsolete = new Set(OBSOLETE);
+    const sourceCode = context.sourceCode;
 
-    // Manual block-param tracking is intentional here. In HBS mode the ESLint
-    // scope manager does not register Glimmer block params (from
-    // {{#let ... as |x|}} or <Comp as |x|>), so getScope() would not see them.
-    // The push/pop stack handles both GlimmerBlockStatement and
-    // GlimmerElementNode uniformly.
-    const blockParamsInScope = [];
+    function hasBindingInScopeChain(scope, name) {
+      for (let s = scope; s; s = s.upper) {
+        if (s.set && s.set.has(name)) return true;
+      }
+      return false;
+    }
 
     return {
-      GlimmerBlockStatement(node) {
-        const params = node.program?.blockParams || [];
-        blockParamsInScope.push(...params);
-      },
-      'GlimmerBlockStatement:exit'(node) {
-        const params = node.program?.blockParams || [];
-        for (let i = 0; i < params.length; i++) {
-          blockParamsInScope.pop();
-        }
-      },
       GlimmerElementNode(node) {
-        // Check the element's own tag before pushing its block params, so an
-        // element's own params don't shadow its own tag name (e.g.
-        // `<marquee as |marquee|>` should still flag the outer <marquee>).
-        if (!blockParamsInScope.includes(node.tag) && obsolete.has(node.tag)) {
-          context.report({ node, messageId: 'obsolete', data: { element: node.tag } });
+        if (!obsolete.has(node.tag)) {
+          return;
         }
-        // Element-level block params (e.g. `<Comp as |param|>`) are scoped to
-        // the children, so push them after the obsolete check. Pop on exit.
-        const elementParams = node.blockParams || [];
-        blockParamsInScope.push(...elementParams);
-      },
-      'GlimmerElementNode:exit'(node) {
-        const elementParams = node.blockParams || [];
-        for (let i = 0; i < elementParams.length; i++) {
-          blockParamsInScope.pop();
+        // Use the parent's scope so that the element's own `as |x|` params
+        // (which attach a block scope to this node) don't shadow its own tag
+        // name. e.g. `<marquee as |marquee|>` must still flag the outer tag.
+        const scope = sourceCode.getScope(node.parent);
+        if (hasBindingInScopeChain(scope, node.tag)) {
+          return;
         }
+        context.report({ node, messageId: 'obsolete', data: { element: node.tag } });
       },
     };
   },