ember-eslint-parser 0.14.6 → 0.14.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "description": "",
   "keywords": [],
   "repository": {
@@ -33,6 +33,7 @@
     "@babel/core": "^7.23.6",
     "@babel/eslint-parser": "^7.28.6",
     "@babel/plugin-proposal-decorators": "^7.25.9",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
     "@typescript-eslint/parser": "^8.0.0",
     "@typescript-eslint/scope-manager": "^8.0.0",
     "@typescript-eslint/visitor-keys": "^8.0.0",

package/src/parser/transforms.js

@@ -61,6 +61,13 @@ function findVarInParentScopes(scopeManager, nodePath, name) {
 
 function registerNodeInScope(node, scope, variable) {
   const ref = new Reference(node, scope, Reference.READ);
+  // A template reference always reads a value. typescript-eslint's scope
+  // manager flags every reference as a value or type reference, and its rules
+  // rely on that (no-unused-vars treats a reference without
+  // isValueReference as type-only since 8.71.1), but eslint-scope's
+  // Reference has neither flag.
+  ref.isValueReference = true;
+  ref.isTypeReference = false;
   if (variable) {
     variable.references.push(ref);
     ref.resolved = variable;
@@ -78,13 +85,24 @@ function isUpperCase(char) {
   return char.toUpperCase() === char;
 }
 
-function registerBlockParams(node, path, scopeManager, isTypescript) {
-  const blockParamNodes = node.blockParamNodes || [];
-  if (blockParamNodes.length === 0) return;
+function createBlockScope(node, path, scopeManager, isTypescript) {
   const upperScope = findParentScope(scopeManager, path);
-  const scope = isTypescript
+  return isTypescript
     ? new TypescriptScope.BlockScope(scopeManager, upperScope, node)
     : new Scope(scopeManager, 'block', upperScope, node);
+}
+
+// Give each template a scope of its own. Otherwise typescript-eslint's
+// no-use-before-define treats a reference in `const Foo = <template>` as
+// running in Foo's initializer, though a template reads its scope lazily.
+function registerTemplateScope(node, path, scopeManager, isTypescript) {
+  createBlockScope(node, path, scopeManager, isTypescript);
+}
+
+function registerBlockParams(node, path, scopeManager, isTypescript) {
+  const blockParamNodes = node.blockParamNodes || [];
+  if (blockParamNodes.length === 0) return;
+  const scope = createBlockScope(node, path, scopeManager, isTypescript);
   const declaredVariables = scopeManager.declaredVariables || scopeManager.__declaredVariables;
   const vars = [];
   declaredVariables.set(node, vars);
@@ -97,7 +115,10 @@ function registerBlockParams(node, path, scopeManager, isTypescript) {
   };
   for (const [i, b] of blockParamNodes.entries()) {
     const v = new Variable(b.name, scope);
-    v.identifiers.push(b);
+    // The block param, parented to the virtual function, so rules that walk
+    // up from a declaration (no-use-before-define's initializer check) stop
+    // there, as they do for a function parameter.
+    v.identifiers.push({ ...b, parent: virtualJSParentNode });
     scope.variables.push(v);
     scope.set.set(b.name, v);
     vars.push(v);
@@ -170,6 +191,9 @@ function registerElementNode(node, path, scopeManager) {
 export function buildGlimmerVisitors(scopeManager, isTypescript, collectComments) {
   if (!scopeManager) return null;
   const visitors = {
+    GlimmerTemplate(node, path) {
+      registerTemplateScope(node, path, scopeManager, isTypescript);
+    },
     GlimmerPathExpression(node, path) {
       registerPathExpression(node, path, scopeManager);
     },
@@ -244,6 +268,9 @@ export function registerGlimmerScopes(result) {
   traverse(result.visitorKeys, result.ast, (path) => {
     const node = path.node;
     if (!node) return;
+    if (node.type === 'GlimmerTemplate') {
+      registerTemplateScope(node, path, result.scopeManager, result.isTypescript);
+    }
     if (node.type === 'GlimmerPathExpression') {
       registerPathExpression(node, path, result.scopeManager);
     }