ember-eslint-parser 0.9.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -23,7 +23,7 @@
     "@glimmer/syntax": "^0.95.0",
     "@typescript-eslint/tsconfig-utils": "^8.57.1",
     "content-tag": "^4.1.1",
-    "ember-estree": "^0.4.2",
+    "ember-estree": "^0.6.2",
     "eslint-scope": "^9.1.2",
     "html-tags": "^5.1.0",
     "mathml-tag-names": "^4.0.0",
@@ -47,7 +47,7 @@
     "mitata": "1.0.34",
     "prettier": "^3.2.5",
     "publint": "^0.2.6",
-    "release-plan": "^0.17.4",
+    "release-plan": "^0.18.0",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
     "vitest": "^1.2.2"
@@ -64,14 +64,14 @@
     "node": ">=16.0.0"
   },
   "scripts": {
+    "bench": "./scripts/run-bench.sh tests/parser.bench.mjs",
+    "bench:compare": "node scripts/bench-compare.mjs",
+    "bench:summary": "./scripts/local-bench-summary.sh",
     "lint": "concurrently \"npm:lint:*(!fix)\" --names \"lint:\"",
     "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
     "lint:js": "eslint . --max-warnings=0",
     "lint:js:fix": "eslint . --fix --max-warnings=0",
     "lint:package": "publint",
-    "bench": "node --expose-gc tests/parser.bench.mjs",
-    "bench:compare": "node scripts/bench-compare.mjs",
-    "bench:summary": "./scripts/local-bench-summary.sh",
     "test": "vitest run"
   }
 }

package/src/parser/gjs-gts-parser.js

@@ -161,12 +161,14 @@ export function parseForESLint(code, options) {
   const useTS = isTypescript || useTypescript;
 
   // Both paths create scopeManager inside the parser callback so it's
-  // available when toTree invokes visitors during splice — no second pass.
+  // available when toTree invokes the visitor factory — no second pass.
   let scopeManager = null;
+  const glimmerComments = [];
 
   try {
     const result = toTree(code, {
       filePath,
+      tokens: true,
       parser: useTS
         ? (placeholderJS) => {
             let parseCode = placeholderJS;
@@ -196,11 +198,44 @@ export function parseForESLint(code, options) {
             });
             return { ast: program, scopeManager };
           },
-      visitors: buildGlimmerVisitors(() => scopeManager, useTS),
+      // Factory form: scopeManager is set by the parser callback before this
+      // runs. Returns null when unavailable so ember-estree skips the walk.
+      // The comments array is passed through so comment handlers share a
+      // single closure over it.
+      visitors: () => buildGlimmerVisitors(scopeManager, useTS, glimmerComments),
     });
 
     if (!result.scopeManager) result.scopeManager = scopeManager;
 
+    // Forward each placeholder's tsNode onto its GlimmerTemplate replacement,
+    // so typed rules calling `getTypeAtLocation(glimmerTemplate)` see the
+    // placeholder's type (string for expression templates, void for class-
+    // member static blocks) instead of the TS error intrinsic.
+    const esMap = result.services?.esTreeNodeToTSNodeMap;
+    if (esMap && result.templateInfos) {
+      for (const ti of result.templateInfos) {
+        const ts = esMap.get(ti.placeholder);
+        if (ts && !esMap.has(ti.ast)) esMap.set(ti.ast, ts);
+      }
+    }
+
+    // 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) {
+      const programNode = result.ast?.program ?? result.ast;
+      if (programNode) {
+        programNode.comments = [
+          ...(programNode.comments || []),
+          ...glimmerComments.map((c) => ({
+            type: 'Block',
+            value: c.value,
+            range: c.range,
+            loc: c.loc,
+          })),
+        ].sort((a, b) => a.range[0] - b.range[0]);
+      }
+    }
+
     if (result.services?.program) {
       const programAllowJs = result.services.program.getCompilerOptions?.()?.allowJs;
       if (
@@ -231,7 +266,14 @@ export function parseForESLint(code, options) {
         .split(':')
         .slice(-2)
         .map((x) => parseInt(x));
-      const err = new Error(e.source_code || e.message);
+      // e.source_code is the full diagnostic block. Strip ANSI escape codes
+      // (content-tag colours output in TTY environments, which breaks
+      // grep-based test:check assertions) and trim leading/trailing blank
+      // lines so consumers see a clean message.
+      // eslint-disable-next-line no-control-regex
+      const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+      const errorText = e.source_code ? stripAnsi(e.source_code).trim() : e.message;
+      const err = new Error(errorText);
       err.lineNumber = line;
       err.column = column;
       err.fileName = filePath;

package/src/parser/hbs-parser.js

@@ -1,5 +1,6 @@
 import * as eslintScope from 'eslint-scope';
 import { toTree, glimmerVisitorKeys, DocumentLines } from 'ember-estree';
+import { registerHBSScopes } from './transforms.js';
 
 // Constant: Program + all Glimmer node types. Computed once at module load.
 const hbsVisitorKeys = { Program: ['body'], ...glimmerVisitorKeys };
@@ -26,7 +27,7 @@ export function parseForESLint(code, options) {
 
   let result;
   try {
-    result = toTree(code, { templateOnly: true });
+    result = toTree(code, { templateOnly: true, tokens: true });
   } catch (e) {
     // Transform glimmer parse error to ESLint-compatible error
     const loc = e.location || (e.hash && e.hash.loc);
@@ -54,7 +55,14 @@ export function parseForESLint(code, options) {
     type: 'Program',
     body: [templateNode],
     tokens: templateNode.tokens,
-    comments,
+    // Normalize Glimmer comment nodes to type:'Block' so ESLint's inline-config
+    // scanner and plugin rules that filter on type recognise them as comments.
+    comments: (comments || []).map((c) => ({
+      type: 'Block',
+      value: c.value,
+      range: c.range,
+      loc: c.loc,
+    })),
     range: [0, code.length],
     start: 0,
     end: code.length,
@@ -64,26 +72,27 @@ export function parseForESLint(code, options) {
     },
   };
 
-  // Build visitor keys: Program + all Glimmer node types
-  const visitorKeys = hbsVisitorKeys;
+  // Analyze a stub Program then rebind the resulting global scope to the real
+  // Program. Analyzing the real Program directly causes infinite recursion in
+  // esrecurse because Glimmer subtree nodes carry parent back-links.
+  const stubProgram = {
+    type: 'Program',
+    body: [],
+    range: [0, code.length],
+    loc: program.loc,
+  };
+  const scopeManager = eslintScope.analyze(stubProgram, { range: true });
+  const globalScope = scopeManager.acquire(stubProgram);
+  globalScope.block = program;
+  scopeManager.__nodeToScope.delete(stubProgram);
+  scopeManager.__nodeToScope.set(program, [globalScope]);
 
-  // Create an empty scope manager.
-  // For HBS, all locals are assumed to be defined at runtime,
-  // so we don't track variable references (no no-undef errors).
-  const scopeManager = eslintScope.analyze(
-    {
-      type: 'Program',
-      body: [],
-      range: [0, code.length],
-      loc: program.loc,
-    },
-    { range: true }
-  );
+  registerHBSScopes({ ast: program, scopeManager, visitorKeys: hbsVisitorKeys });
 
   return {
     ast: program,
     scopeManager,
-    visitorKeys,
+    visitorKeys: hbsVisitorKeys,
     services: {},
   };
 }

package/src/parser/transforms.js

@@ -28,13 +28,10 @@ try {
 // ── Scope helpers ─────────────────────────────────────────────────────
 
 function findParentScope(scopeManager, nodePath) {
-  let scope = null;
   let path = nodePath;
   while (path) {
-    scope = scopeManager.acquire(path.node, true);
-    if (scope) {
-      return scope;
-    }
+    const scope = scopeManager.acquire(path.node, true);
+    if (scope) return scope;
     path = path.parentPath;
   }
   return null;
@@ -82,6 +79,7 @@ function isUpperCase(char) {
 
 function registerBlockParams(node, path, scopeManager, isTypescript) {
   const blockParamNodes = node.blockParamNodes || [];
+  if (blockParamNodes.length === 0) return;
   const upperScope = findParentScope(scopeManager, path);
   const scope = isTypescript
     ? new TypescriptScope.BlockScope(scopeManager, upperScope, node)
@@ -150,26 +148,33 @@ function registerElementNode(node, path, scopeManager) {
 
 /**
  * Build Glimmer visitors for toTree that register scopes during traversal.
- * Uses a getter for scopeManager so it's available after the parser callback runs.
- * @param {function} getScopeManager - returns the scopeManager (may be null initially)
+ * Returns null when scopeManager is unavailable so the caller can skip the walk.
+ * When `collectComments` is provided, appends Glimmer comment nodes to it so
+ * callers can forward them into program.comments after the walk.
+ * @param {object|null} scopeManager
  * @param {boolean} isTypescript
- * @returns {object} visitors for toTree
+ * @param {Array|null} [collectComments] - optional array to collect Glimmer comment nodes into
+ * @returns {object|null} visitors for toTree, or null to skip
  */
-export function buildGlimmerVisitors(getScopeManager, isTypescript) {
-  return {
+export function buildGlimmerVisitors(scopeManager, isTypescript, collectComments) {
+  if (!scopeManager) return null;
+  const visitors = {
     GlimmerPathExpression(node, path) {
-      const sm = getScopeManager();
-      if (sm) registerPathExpression(node, path, sm);
+      registerPathExpression(node, path, scopeManager);
     },
     GlimmerElementNode(node, path) {
-      const sm = getScopeManager();
-      if (sm) registerElementNode(node, path, sm);
+      registerElementNode(node, path, scopeManager);
     },
     GlimmerBlockParams(node, path) {
-      const sm = getScopeManager();
-      if (sm) registerBlockParams(node, path, sm, isTypescript);
+      registerBlockParams(node, path, scopeManager, isTypescript);
     },
   };
+  if (collectComments) {
+    const push = (node) => collectComments.push(node);
+    visitors.GlimmerMustacheCommentStatement = push;
+    visitors.GlimmerCommentStatement = push;
+  }
+  return visitors;
 }
 
 // ── registerGlimmerScopes (fallback for JS/oxc path) ──────────────────
@@ -240,6 +245,22 @@ export function registerGlimmerScopes(result) {
   });
 }
 
+/**
+ * Scope registration for the HBS parser. Unlike the gjs/gts path, we do not
+ * register references for free identifiers (`{{path}}`, `<Tag>`) — all
+ * template locals are treated as runtime-defined, so no-undef stays quiet.
+ * Only block params from `as |x|` constructs are declared.
+ */
+export function registerHBSScopes(result) {
+  traverse(result.visitorKeys, result.ast, (path) => {
+    const node = path.node;
+    if (!node) return;
+    if ('blockParams' in node && node.type.startsWith('Glimmer')) {
+      registerBlockParams(node, path, result.scopeManager, false);
+    }
+  });
+}
+
 // ── transformForLint (used by ts-patch.js) ────────────────────────────
 
 export const replaceRange = function replaceRange(s, start, end, substitute) {