ember-eslint-parser 0.14.8 → 0.14.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.14.8",
+  "version": "0.14.9",
   "description": "",
   "keywords": [],
   "repository": {

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
 }
@@ -92,11 +113,15 @@ function createBlockScope(node, path, scopeManager, isTypescript) {
     : 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.
+// 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) {
-  createBlockScope(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) {