ember-eslint-parser 0.14.7 → 0.14.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.14.7",
+  "version": "0.14.9",
   "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/gjs-gts-parser.js

@@ -130,6 +130,20 @@ export function parseForESLint(code, options) {
       }
     }
 
+    // Scope analysis ran on the placeholder JS, so a write of a template
+    // (`const Foo = <template>`, an assignment, a default parameter) still
+    // has the placeholder as its writeExpr. The placeholder is out of the
+    // AST and never gets a `parent`, which rules read (#257).
+    if (result.scopeManager && result.templateInfos?.length) {
+      const templates = new Map(result.templateInfos.map((ti) => [ti.placeholder, ti.ast]));
+      for (const scope of result.scopeManager.scopes) {
+        for (const ref of scope.references) {
+          const template = ref.writeExpr && templates.get(ref.writeExpr);
+          if (template) ref.writeExpr = template;
+        }
+      }
+    }
+
     // Surface Glimmer template comments in program.comments as type:'Block'
     // so ESLint's inline-config scanner and plugin rules recognise them.
     if (glimmerComments.length > 0) {

package/src/parser/transforms.js

@@ -15,6 +15,7 @@ const mathMLTagsSet = new Set(mathmlTagNames);
 const require = createRequire(import.meta.url);
 
 let TypescriptScope = null;
+let TypescriptTemplateScope = null;
 try {
   const parserPath = require.resolve('@typescript-eslint/parser');
   // eslint-disable-next-line n/no-unpublished-require
@@ -22,6 +23,26 @@ try {
     paths: [parserPath],
   });
   TypescriptScope = require(scopeManagerPath);
+  TypescriptTemplateScope = class TemplateScope extends TypescriptScope.FunctionScope {
+    constructor(scopeManager, upperScope, block) {
+      // `isMethodDefinition` makes it strict without scanning the body for a
+      // "use strict" directive, which throws on a template's body.
+      super(scopeManager, upperScope, block, true);
+      // A template has no `arguments`, unlike the function FunctionScope models.
+      const args = this.set.get('arguments');
+      if (args) {
+        this.set.delete('arguments');
+        this.variables.splice(this.variables.indexOf(args), 1);
+      }
+    }
+
+    // Never called for a template scope: only closing a scope during analysis
+    // calls it, and templates get their scopes after that. The base would
+    // throw on a template's `body`, so guard it anyway.
+    isValidResolution() {
+      return true;
+    }
+  };
 } catch {
   // not available
 }
@@ -85,13 +106,28 @@ 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);
+}
+
+// A template compiles to a closure (`scope: () => ({ Foo })`), so give it a
+// function scope: its references run in an execution context of their own,
+// and no-use-before-define accepts `<Foo />` in `const Foo = <template>`.
+function registerTemplateScope(node, path, scopeManager, isTypescript) {
+  const upperScope = findParentScope(scopeManager, path);
+  if (isTypescript) return new TypescriptTemplateScope(scopeManager, upperScope, node);
+  // `isMethodDefinition` as in TemplateScope. eslint-scope's base Scope
+  // declares no `arguments`.
+  return new Scope(scopeManager, 'function', upperScope, node, true);
+}
+
+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);
@@ -104,7 +140,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);
@@ -177,6 +216,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);
     },
@@ -251,6 +293,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);
     }