ember-eslint-parser 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -9,6 +9,7 @@
   },
   "license": "ISC",
   "author": "",
+  "type": "module",
   "exports": {
     ".": "./src/parser/gjs-gts-parser.js",
     "./hbs": "./src/parser/hbs-parser.js",
@@ -19,11 +20,11 @@
     "src"
   ],
   "dependencies": {
-    "@babel/eslint-parser": "^7.28.6",
-    "@glimmer/syntax": ">= 0.92.0",
-    "@typescript-eslint/tsconfig-utils": "^8.38.0",
-    "content-tag": "^4.1.0",
-    "eslint-scope": "^9.1.1",
+    "@glimmer/syntax": "^0.95.0",
+    "@typescript-eslint/tsconfig-utils": "^8.57.1",
+    "content-tag": "^4.1.1",
+    "ember-estree": "^0.4.2",
+    "eslint-scope": "^9.1.2",
     "html-tags": "^5.1.0",
     "mathml-tag-names": "^4.0.0",
     "svg-tags": "^1.0.0"
@@ -43,6 +44,7 @@
     "eslint-plugin-promise": "^6.0.0",
     "execa": "^8.0.1",
     "fs-extra": "^11.2.0",
+    "mitata": "1.0.34",
     "prettier": "^3.2.5",
     "publint": "^0.2.6",
     "release-plan": "^0.17.4",
@@ -51,7 +53,6 @@
     "vitest": "^1.2.2"
   },
   "peerDependencies": {
-    "@babel/core": "^7.23.6",
     "@typescript-eslint/parser": "*"
   },
   "peerDependenciesMeta": {
@@ -67,7 +68,10 @@
     "lint:fix": "concurrently \"npm:lint:*:fix\" --names \"fix:\"",
     "lint:js": "eslint . --max-warnings=0",
     "lint:js:fix": "eslint . --fix --max-warnings=0",
-    "lint:package": "pnpm publint",
+    "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

@@ -1,20 +1,22 @@
-const tsconfigUtils = require('@typescript-eslint/tsconfig-utils');
-const babelParser = require('@babel/eslint-parser/experimental-worker');
-const { registerParsedFile } = require('../preprocessor/noop');
-const {
-  patchTs,
-  replaceExtensions,
-  syncMtsGtsSourceFiles,
-  typescriptParser,
-} = require('./ts-patch');
-const { transformForLint, preprocessGlimmerTemplates, convertAst } = require('./transforms');
+import { createRequire } from 'node:module';
+import tsconfigUtils from '@typescript-eslint/tsconfig-utils';
+import { registerParsedFile } from '../preprocessor/noop.js';
+import { patchTs, replaceExtensions, syncMtsGtsSourceFiles, typescriptParser } from './ts-patch.js';
+import { buildGlimmerVisitors } from './transforms.js';
+import { toTree } from 'ember-estree';
+import * as eslintScope from 'eslint-scope';
+
+const require = createRequire(import.meta.url);
 
 /**
  * implements https://eslint.org/docs/latest/extend/custom-parsers
- * 1. transforms gts/gjs files into parseable ts/js without changing the offsets and locations around it
- * 2. parses the transformed code and generates the AST for TS ot JS
- * 3. preprocesses the templates info and prepares the Glimmer AST
- * 4. converts the js/ts AST so that it includes the Glimmer AST at the right locations, replacing the original
+ *
+ * Uses ember-estree's toTree with a custom parser option to handle
+ * the full pipeline: template extraction, placeholder replacement,
+ * JS/TS parsing, Glimmer AST processing, and AST splicing.
+ *
+ * Scope registration happens via toTree's visitors API, eliminating
+ * a second AST traversal.
  */
 
 /**
@@ -79,12 +81,10 @@ function getAllowJsFromPrograms(programs) {
 function getProjectServiceTsconfigPath(projectService) {
   if (!projectService) return null;
 
-  // If projectService is true, use default behavior (nearest tsconfig.json, allowJs from config)
   if (projectService === true) {
     return 'tsconfig.json';
   }
 
-  // If projectService is an object, handle ProjectServiceOptions
   if (typeof projectService === 'object') {
     if (typeof projectService.allowDefaultProject !== 'undefined') {
       // eslint-disable-next-line no-console
@@ -131,86 +131,115 @@ function getAllowJs(options) {
 /**
  * @type {import('eslint').ParserModule}
  */
-module.exports = {
-  meta: {
-    name: 'ember-eslint-parser',
-    version: '*',
-  },
-
-  parseForESLint(code, options) {
-    const allowGjsWasSet = options.allowGjs !== undefined;
-    const allowGjs = allowGjsWasSet ? options.allowGjs : getAllowJs(options);
-    let actualAllowGjs;
-    // Only patch TypeScript if we actually need it.
-    if (options.programs || options.projectService || options.project) {
-      ({ allowGjs: actualAllowGjs } = patchTs({ allowGjs }));
-    }
-    registerParsedFile(options.filePath);
-    let jsCode = code;
-    const info = transformForLint(code, options.filePath);
-    jsCode = info.output;
+export const meta = {
+  name: 'ember-eslint-parser',
+  version: '*',
+};
 
-    const isTypescript = options.filePath.endsWith('.gts') || options.filePath.endsWith('.ts');
-    let useTypescript = true;
+export function parseForESLint(code, options) {
+  const allowGjsWasSet = options.allowGjs !== undefined;
+  const allowGjs = allowGjsWasSet ? options.allowGjs : getAllowJs(options);
+  let actualAllowGjs;
+  // Only patch TypeScript if we actually need it.
+  if (options.programs || options.projectService || options.project) {
+    ({ allowGjs: actualAllowGjs } = patchTs({ allowGjs }));
+  }
+  registerParsedFile(options.filePath);
 
-    if (options.useBabel || !typescriptParser) {
-      useTypescript = false;
-    }
+  const isTypescript = options.filePath.endsWith('.gts') || options.filePath.endsWith('.ts');
+  let useTypescript = true;
 
-    let result = null;
-    const filePath = options.filePath;
-    if (options.project || options.projectService) {
-      jsCode = replaceExtensions(jsCode);
-    }
+  if (options.useBabel || !typescriptParser) {
+    useTypescript = false;
+  }
 
-    if (isTypescript && !typescriptParser) {
-      throw new Error('Please install typescript to process gts');
-    }
+  if (isTypescript && !typescriptParser) {
+    throw new Error('Please install typescript to process gts');
+  }
+
+  const filePath = options.filePath;
+  const useTS = isTypescript || useTypescript;
 
-    try {
-      result =
-        isTypescript || useTypescript
-          ? typescriptParser.parseForESLint(jsCode, {
+  // Both paths create scopeManager inside the parser callback so it's
+  // available when toTree invokes visitors during splice — no second pass.
+  let scopeManager = null;
+
+  try {
+    const result = toTree(code, {
+      filePath,
+      parser: useTS
+        ? (placeholderJS) => {
+            let parseCode = placeholderJS;
+            if (options.project || options.projectService) {
+              parseCode = replaceExtensions(parseCode);
+            }
+            const tsResult = typescriptParser.parseForESLint(parseCode, {
               ...options,
               ranges: true,
               extraFileExtensions: ['.gts', '.gjs'],
               filePath,
-            })
-          : babelParser.parseForESLint(jsCode, {
-              ...options,
-              requireConfigFile: false,
-              ranges: true,
             });
-      if (!info.templateInfos?.length) {
-        return result;
-      }
-      const preprocessedResult = preprocessGlimmerTemplates(info, code);
-      preprocessedResult.code = code;
-      const { templateVisitorKeys } = preprocessedResult;
-      const visitorKeys = { ...result.visitorKeys, ...templateVisitorKeys };
-      result.isTypescript = isTypescript || useTypescript;
-      convertAst(result, preprocessedResult, visitorKeys);
-      if (result.services?.program) {
-        // Compare allowJs with the actual program's compiler options
-        const programAllowJs = result.services.program.getCompilerOptions?.()?.allowJs;
-        if (
-          !allowGjsWasSet &&
-          programAllowJs !== undefined &&
-          actualAllowGjs !== undefined &&
-          actualAllowGjs !== programAllowJs
-        ) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[ember-eslint-parser] allowJs does not match the actual program. Consider setting allowGjs explicitly.\n' +
-              `    Current: ${allowGjs}, Program: ${programAllowJs}`
-          );
-        }
-        syncMtsGtsSourceFiles(result.services.program);
+            scopeManager = tsResult.scopeManager;
+            return tsResult;
+          }
+        : (placeholderJS) => {
+            // JS path: parse with oxc, create scope manager from placeholder AST
+            const { parseSync } = require('oxc-parser');
+            const oxcResult = parseSync(filePath || 'input.js', placeholderJS);
+            const program = oxcResult.program;
+            program.tokens = oxcResult.tokens || [];
+            program.comments = oxcResult.comments || [];
+            scopeManager = eslintScope.analyze(program, {
+              ecmaVersion: 2022,
+              sourceType: 'module',
+              range: true,
+            });
+            return { ast: program, scopeManager };
+          },
+      visitors: buildGlimmerVisitors(() => scopeManager, useTS),
+    });
+
+    if (!result.scopeManager) result.scopeManager = scopeManager;
+
+    if (result.services?.program) {
+      const programAllowJs = result.services.program.getCompilerOptions?.()?.allowJs;
+      if (
+        !allowGjsWasSet &&
+        programAllowJs !== undefined &&
+        actualAllowGjs !== undefined &&
+        actualAllowGjs !== programAllowJs
+      ) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          '[ember-eslint-parser] allowJs does not match the actual program. Consider setting allowGjs explicitly.\n' +
+            `    Current: ${allowGjs}, Program: ${programAllowJs}`
+        );
       }
-      return { ...result, visitorKeys };
-    } catch (e) {
-      console.error(e);
-      throw e;
+      syncMtsGtsSourceFiles(result.services.program);
     }
-  },
-};
+
+    delete result.templateInfos;
+    delete result.isTypescript;
+
+    return result;
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    // Convert content-tag parse errors to ESLint-compatible format
+    if (e.message?.includes('Parse Error at')) {
+      const [line, column] = e.message
+        .split(':')
+        .slice(-2)
+        .map((x) => parseInt(x));
+      const err = new Error(e.source_code || e.message);
+      err.lineNumber = line;
+      err.column = column;
+      err.fileName = filePath;
+      err.index = undefined;
+      throw err;
+    }
+    throw e;
+  }
+}
+
+export default { meta, parseForESLint };

package/src/parser/hbs-parser.js

@@ -1,6 +1,8 @@
-const eslintScope = require('eslint-scope');
-const DocumentLines = require('../utils/document');
-const { processGlimmerTemplate, buildGlimmerVisitorKeys } = require('./transforms');
+import * as eslintScope from 'eslint-scope';
+import { toTree, glimmerVisitorKeys, DocumentLines } from 'ember-estree';
+
+// Constant: Program + all Glimmer node types. Computed once at module load.
+const hbsVisitorKeys = { Program: ['body'], ...glimmerVisitorKeys };
 
 /**
  * implements https://eslint.org/docs/latest/extend/custom-parsers
@@ -14,76 +16,76 @@ const { processGlimmerTemplate, buildGlimmerVisitorKeys } = require('./transform
 /**
  * @type {import('eslint').ParserModule}
  */
-module.exports = {
-  meta: {
-    name: 'ember-eslint-parser/hbs',
-    version: '*',
-  },
+export const meta = {
+  name: 'ember-eslint-parser/hbs',
+  version: '*',
+};
 
-  parseForESLint(code, options) {
-    const filePath = (options && options.filePath) || '<hbs>';
-    const codeLines = new DocumentLines(code);
+export function parseForESLint(code, options) {
+  const filePath = (options && options.filePath) || '<hbs>';
 
-    let result;
-    try {
-      result = processGlimmerTemplate({
-        templateContent: code,
-        codeLines,
-        templateRange: [0, code.length],
+  let result;
+  try {
+    result = toTree(code, { templateOnly: true });
+  } catch (e) {
+    // Transform glimmer parse error to ESLint-compatible error
+    const loc = e.location || (e.hash && e.hash.loc);
+    if (loc && loc.start) {
+      const codeLines = new DocumentLines(code);
+      const err = Object.assign(new SyntaxError(e.message), {
+        lineNumber: loc.start.line,
+        column: loc.start.column,
+        index: codeLines.positionToOffset(loc.start),
+        fileName: filePath,
       });
-    } catch (e) {
-      // Transform glimmer parse error to ESLint-compatible error
-      const loc = e.location || (e.hash && e.hash.loc);
-      if (loc && loc.start) {
-        const err = Object.assign(new SyntaxError(e.message), {
-          lineNumber: loc.start.line,
-          column: loc.start.column,
-          index: codeLines.positionToOffset(loc.start),
-          fileName: filePath,
-        });
-        throw err;
-      }
-      throw e;
+      throw err;
     }
+    throw e;
+  }
+
+  const { ast: templateNode, comments } = result;
+
+  // Use the Template node's loc.end for the Program's end position
+  // (avoids creating a duplicate DocumentLines just for this)
+  const endLoc = templateNode.loc?.end || { line: 1, column: code.length };
 
-    const { ast: templateNode, comments } = result;
+  // Wrap in a synthetic Program node (required by ESLint)
+  const program = {
+    type: 'Program',
+    body: [templateNode],
+    tokens: templateNode.tokens,
+    comments,
+    range: [0, code.length],
+    start: 0,
+    end: code.length,
+    loc: {
+      start: { line: 1, column: 0 },
+      end: endLoc,
+    },
+  };
 
-    // Wrap in a synthetic Program node (required by ESLint)
-    const program = {
+  // Build visitor keys: Program + all Glimmer node types
+  const visitorKeys = hbsVisitorKeys;
+
+  // 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: [templateNode],
-      tokens: templateNode.tokens,
-      comments,
+      body: [],
       range: [0, code.length],
-      start: 0,
-      end: code.length,
-      loc: {
-        start: { line: 1, column: 0 },
-        end: codeLines.offsetToPosition(code.length),
-      },
-    };
-
-    // Build visitor keys: Program + all Glimmer node types
-    const visitorKeys = { Program: ['body'], ...buildGlimmerVisitorKeys() };
+      loc: program.loc,
+    },
+    { range: true }
+  );
 
-    // 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 }
-    );
+  return {
+    ast: program,
+    scopeManager,
+    visitorKeys,
+    services: {},
+  };
+}
 
-    return {
-      ast: program,
-      scopeManager,
-      visitorKeys,
-      services: {},
-    };
-  },
-};
+export default { meta, parseForESLint };