ember-eslint-parser 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.10.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",

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

@@ -27,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);
@@ -55,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,

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;
@@ -151,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) ──────────────────