From 029c2c08461f6745562047bdadfb0033ad8c7739 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Sun, 12 Apr 2026 22:59:16 +0200
Subject: [PATCH 1/6] Fix template-no-obsolete-elements: track element-level
 block params

The rule suppressed obsolete-element reports when the tag name shadows a
block param from a GlimmerBlockStatement (e.g. {{#let (...) as |marquee|}}).
It did not track element-level block params (<Comp as |marquee|>), so
inside an angle-bracket component the shadowing was ignored and the tag
was falsely reported. Push element block params on enter and pop on exit,
mirroring the existing GlimmerBlockStatement handling.
---
 lib/rules/template-no-obsolete-elements.js     | 18 ++++++++++++++----
 .../lib/rules/template-no-obsolete-elements.js |  9 +++++++++
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index af82f4e007..c1f4948add 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -64,12 +64,22 @@ module.exports = {
         }
       },
       GlimmerElementNode(node) {
-        if (blockParamsInScope.includes(node.tag)) {
-          return;
-        }
-        if (obsolete.has(node.tag)) {
+        // 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 } });
         }
+        // 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();
+        }
       },
     };
   },
diff --git a/tests/lib/rules/template-no-obsolete-elements.js b/tests/lib/rules/template-no-obsolete-elements.js
index 5c995da69b..16221c7ee6 100644
--- a/tests/lib/rules/template-no-obsolete-elements.js
+++ b/tests/lib/rules/template-no-obsolete-elements.js
@@ -11,6 +11,9 @@ ruleTester.run('template-no-obsolete-elements', rule, {
     `<template>{{#let (component 'whatever-here') as |plaintext|}}
       <plaintext />
     {{/let}}</template>`,
+    // Element-level block params (<Comp as |...|>) are now tracked
+    '<template><Comp as |plaintext|><plaintext /></Comp></template>',
+    '<template><Outer as |marquee|><marquee /></Outer></template>',
   ],
   invalid: [
     {
@@ -18,6 +21,12 @@ ruleTester.run('template-no-obsolete-elements', rule, {
       output: null,
       errors: [{ messageId: 'obsolete' }],
     },
+    // Element's own block params must not shadow its own tag name.
+    {
+      code: '<template><marquee as |marquee|></marquee></template>',
+      output: null,
+      errors: [{ messageId: 'obsolete', data: { element: 'marquee' } }],
+    },
   ],
 });
 

From 5fddf2b5f2e0baafc318822bdbd34986b631e6e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Mon, 13 Apr 2026 20:50:01 +0200
Subject: [PATCH 2/6] Document why manual block-param tracking is used instead
 of scope manager

---
 lib/rules/template-no-obsolete-elements.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index c1f4948add..ddb50eb4db 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -50,6 +50,19 @@ module.exports = {
   },
   create(context) {
     const obsolete = new Set(OBSOLETE);
+
+    // Manual block-param tracking is intentional here. The ESLint scope manager
+    // cannot be used as a drop-in replacement because:
+    //
+    // 1. In GJS/GTS, an element's own `as |x|` block params are already
+    //    visible in the scope at the element node itself, so getScope(node) on
+    //    `<marquee as |marquee|>` would incorrectly skip flagging it.
+    //
+    // 2. In HBS mode the scope manager only creates a minimal top-level scope;
+    //    block params from `{{#let ... as |x|}}` are not registered, so
+    //    getScope would not see them at all.
+    //
+    // The push/pop approach handles both edge cases correctly.
     const blockParamsInScope = [];
 
     return {

From 44f81f764568f79c68f96d08e34c829eb66f0c56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Tue, 14 Apr 2026 00:40:57 +0200
Subject: [PATCH 3/6] Simplify comment: focus on HBS scope limitation, drop
 unverified GJS edge case

---
 lib/rules/template-no-obsolete-elements.js | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index ddb50eb4db..2987cdfaeb 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -51,18 +51,11 @@ module.exports = {
   create(context) {
     const obsolete = new Set(OBSOLETE);
 
-    // Manual block-param tracking is intentional here. The ESLint scope manager
-    // cannot be used as a drop-in replacement because:
-    //
-    // 1. In GJS/GTS, an element's own `as |x|` block params are already
-    //    visible in the scope at the element node itself, so getScope(node) on
-    //    `<marquee as |marquee|>` would incorrectly skip flagging it.
-    //
-    // 2. In HBS mode the scope manager only creates a minimal top-level scope;
-    //    block params from `{{#let ... as |x|}}` are not registered, so
-    //    getScope would not see them at all.
-    //
-    // The push/pop approach handles both edge cases correctly.
+    // 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 = [];
 
     return {

From 61898184f4f3883267151ccb9443377fd1107d83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 15 Apr 2026 21:52:36 +0200
Subject: [PATCH 4/6] refactor(template-no-obsolete-elements): use scope
 manager for block params
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

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>.
---
 lib/rules/template-no-obsolete-elements.js | 47 ++++++++--------------
 1 file changed, 17 insertions(+), 30 deletions(-)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index 2987cdfaeb..0984947350 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -29,6 +29,7 @@ const OBSOLETE = [
   'tt',
   'xmp',
 ];
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -50,42 +51,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 } });
       },
     };
   },

From 85e6988ba462e79293fcb1e78ef69a205a85a7fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 15 Apr 2026 21:55:43 +0200
Subject: [PATCH 5/6] chore: remove stray blank line after OBSOLETE array

---
 lib/rules/template-no-obsolete-elements.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index 0984947350..adaef20c85 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -29,7 +29,6 @@ const OBSOLETE = [
   'tt',
   'xmp',
 ];
-
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {

From a2ec4be0e204504cda58ec04994b56a0af344911 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johan=20R=C3=B8ed?= <johanroed@gmail.com>
Date: Wed, 15 Apr 2026 21:58:51 +0200
Subject: [PATCH 6/6] lint: hoist hasBindingInScopeChain to module scope, add
 curly braces

---
 lib/rules/template-no-obsolete-elements.js | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/lib/rules/template-no-obsolete-elements.js b/lib/rules/template-no-obsolete-elements.js
index adaef20c85..31f97a07e3 100644
--- a/lib/rules/template-no-obsolete-elements.js
+++ b/lib/rules/template-no-obsolete-elements.js
@@ -29,6 +29,16 @@ const OBSOLETE = [
   'tt',
   'xmp',
 ];
+
+function hasBindingInScopeChain(scope, name) {
+  for (let s = scope; s; s = s.upper) {
+    if (s.set && s.set.has(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -52,13 +62,6 @@ module.exports = {
     const obsolete = new Set(OBSOLETE);
     const sourceCode = context.sourceCode;
 
-    function hasBindingInScopeChain(scope, name) {
-      for (let s = scope; s; s = s.upper) {
-        if (s.set && s.set.has(name)) return true;
-      }
-      return false;
-    }
-
     return {
       GlimmerElementNode(node) {
         if (!obsolete.has(node.tag)) {