fix: route JS path through @babel/eslint-parser so decorators parse

The JS-fallback path (taken when @typescript-eslint/parser isn't
installed) parsed with oxc-parser, then briefly with espree. Both
broke real ember apps:

  * oxc emits only start/end byte offsets — no loc, no range array,
    no token stream — so ESLint's SourceCode.validate() rejected the
    Program node and rules walking tokens (no-dupe-args et al)
    crashed.
  * espree carries loc/tokens but is acorn-based, and acorn rejects
    `@decorator` syntax outright. Every JS-only ember app failed
    with `SyntaxError: Unexpected character '@'` the first time it
    tried to lint a `.gjs` file with `@tracked` or `@service`.

Switch the JS path to `@babel/eslint-parser/experimental-worker`,
which is the same parser ember-cli already wires up for plain `.js`
files in JS-only apps. It picks up the project's babel config and
applies its plugins — decorators included — so syntax accepted in
the rest of the project parses here too.

`@babel/eslint-parser` is declared as an optional peer alongside
`@typescript-eslint/parser`. If neither is installed the JS path
throws a clear "install one of these" error rather than the cryptic
acorn one. The TS path is unchanged.

The repo's own tests now exercise babel config discovery against a
minimal `babel.config.cjs` that enables the legacy decorators
plugin, and `tests/js-path.test.js` pins a regression case for a
class field decorator on a `.gjs` file.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

Author: NullVoxPopuli

babel.config.cjs

@@ -0,0 +1,7 @@
+// Used by tests that exercise the JS-path of ember-eslint-parser, which
+// delegates to @babel/eslint-parser. The decorators plugin lets fixtures
+// pin behaviour for `@tracked` / `@service`-style class-field decorators
+// — the syntax that broke when the JS fallback was raw espree.
+module.exports = {
+  plugins: [['@babel/plugin-proposal-decorators', { version: 'legacy' }]],
+};

package.json

@@ -36,13 +36,14 @@
     "content-tag": "^4.1.1",
     "ember-estree": "^0.6.2",
     "eslint-scope": "^9.1.2",
-    "espree": "^10.4.0",
     "html-tags": "^5.1.0",
     "mathml-tag-names": "^4.0.0",
     "svg-tags": "^1.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.23.6",
+    "@babel/eslint-parser": "^7.28.6",
+    "@babel/plugin-proposal-decorators": "^7.25.9",
     "@typescript-eslint/parser": "^7.1.0",
     "@typescript-eslint/scope-manager": "^7.1.0",
     "@typescript-eslint/visitor-keys": "^7.1.0",
@@ -65,9 +66,13 @@
     "vitest": "^1.2.2"
   },
   "peerDependencies": {
+    "@babel/eslint-parser": "^7.28.6",
     "@typescript-eslint/parser": "*"
   },
   "peerDependenciesMeta": {
+    "@babel/eslint-parser": {
+      "optional": true
+    },
     "@typescript-eslint/parser": {
       "optional": true
     }

pnpm-lock.yaml

@@ -4,11 +4,25 @@ 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';
-import * as espree from 'espree';
 
 const require = createRequire(import.meta.url);
 
+// Lazily resolved at first use so the absence of @babel/eslint-parser is only
+// surfaced for projects that actually take the JS path. The experimental-worker
+// entry point runs babel in a worker and matches the parser ember-cli wires up
+// for plain `.js` files in JS-only apps, so config discovery (decorators &
+// friends) lines up with how the rest of the project is being parsed.
+let babelParser;
+function loadBabelParser() {
+  if (babelParser !== undefined) return babelParser;
+  try {
+    babelParser = require('@babel/eslint-parser/experimental-worker');
+  } catch {
+    babelParser = null;
+  }
+  return babelParser;
+}
+
 /**
  * implements https://eslint.org/docs/latest/extend/custom-parsers
  *
@@ -186,30 +200,26 @@ export function parseForESLint(code, options) {
             return tsResult;
           }
         : (placeholderJS) => {
-            // JS path: parse with espree so the AST already carries loc/range,
-            // tokens, and comments — what ESLint validates and rules consume.
-            //
-            // We'd prefer oxc-parser here (faster, already used elsewhere in
-            // the pipeline), but its JS API exposes only `start`/`end` byte
-            // offsets and an opt-in `range` array — no `loc`, no token
-            // stream — so its output fails ESLint's SourceCode validation
-            // on the Program node and breaks any rule that walks tokens.
-            // Switch back once oxc lands native loc support:
-            //   https://github.com/oxc-project/oxc/issues/10307
-            const program = espree.parse(placeholderJS, {
-              ecmaVersion: 'latest',
-              sourceType: 'module',
-              loc: true,
-              range: true,
-              tokens: true,
-              comment: true,
-            });
-            scopeManager = eslintScope.analyze(program, {
-              ecmaVersion: 2022,
-              sourceType: 'module',
-              range: true,
+            // JS path: defer to @babel/eslint-parser, which discovers the
+            // consuming app's babel config and applies its plugins (notably
+            // decorators) when parsing. That keeps gjs aligned with how the
+            // app's plain `.js` files are parsed, so syntax accepted there
+            // is accepted here without a second parser config.
+            const parser = loadBabelParser();
+            if (!parser) {
+              throw new Error(
+                'ember-eslint-parser: linting `.gjs`/`.gts` files in a JS-only ' +
+                  'project requires `@babel/eslint-parser`. Install it as a ' +
+                  'dev dependency, or install `@typescript-eslint/parser` to ' +
+                  'opt into the TypeScript-based path.'
+              );
+            }
+            const babelResult = parser.parseForESLint(placeholderJS, {
+              ...options,
+              filePath,
             });
-            return { ast: program, scopeManager };
+            scopeManager = babelResult.scopeManager;
+            return babelResult;
           },
       // Factory form: scopeManager is set by the parser callback before this
       // runs. Returns null when unavailable so ember-estree skips the walk.

src/parser/gjs-gts-parser.js

@@ -2,19 +2,23 @@
  * Regression tests for the JS-fallback parse path.
  *
  * The JS path runs when @typescript-eslint/parser isn't available (or when
- * `useBabel: true` is set). Historically this path produced an AST that
- * ESLint refused — `oxc-parser` only emits `start`/`end` byte offsets, so
- * `Program.loc` and `Program.range` were missing and `Program.tokens` was
- * empty. Lint of any .gjs file blew up with `TypeError: AST is missing
- * location information.`, and rules that walk tokens (e.g. no-dupe-args)
- * crashed even after that.
+ * `useBabel: true` is set). It now defers to @babel/eslint-parser, which
+ * picks up the consuming app's babel config — so any plugin enabled there
+ * (decorators, etc.) is honoured when linting `.gjs` files.
  *
- * These tests force the JS path via `useBabel: true` and pin the contract
- * at two layers: the AST shape the parser returns, and a real Linter pass
- * driving an ESLint rule that walks tokens. Both fail under oxc.
+ * Two earlier shapes of this path each broke ESLint differently:
+ *   - oxc-parser emitted only `start`/`end` byte offsets, so `Program.loc`
+ *     and `Program.range` were missing and `Program.tokens` was empty.
+ *     Lint of any .gjs file blew up with `TypeError: AST is missing
+ *     location information.`, and rules that walk tokens (e.g.
+ *     no-dupe-args) crashed even after that.
+ *   - raw espree carries loc/tokens but rejects modern syntax outright —
+ *     `@tracked count = 0;` produced `SyntaxError: Unexpected character '@'`
+ *     for every JS-only ember app.
  *
- * Switch back to oxc once https://github.com/oxc-project/oxc/issues/10307
- * lands native loc support.
+ * These tests force the JS path via `useBabel: true` and pin three
+ * contracts: the AST shape ESLint requires, decorator syntax parses
+ * cleanly, and a real Linter pass walks tokens without throwing.
  */
 
 import { describe, expect, it } from 'vitest';
@@ -62,6 +66,50 @@ describe('JS path (useBabel) — AST shape ESLint requires', () => {
   });
 });
 
+describe('JS path (useBabel) — class decorators', () => {
+  // Regression: when @typescript-eslint/parser isn't installed, the JS path
+  // historically fell back to raw espree, which rejects `@decorator` syntax
+  // outright (`SyntaxError: Unexpected character '@'`). Routing the JS path
+  // through @babel/eslint-parser picks up the consuming app's babel config —
+  // the decorators plugin lives there for ember apps — so a `.gjs` file with
+  // a `@tracked` field parses cleanly without any TypeScript tooling.
+  const code = [
+    "import Component from '@glimmer/component';",
+    "import { tracked } from '@glimmer/tracking';",
+    '',
+    'export default class Counter extends Component {',
+    '  @tracked count = 0;',
+    '  <template>{{this.count}}</template>',
+    '}',
+  ].join('\n');
+
+  it('parses a class field decorator without throwing', () => {
+    const result = parseForESLint(code, {
+      filePath: 'fixture.gjs',
+      useBabel: true,
+    });
+    expect(result.ast.type).toBe('Program');
+
+    // Walk the AST to confirm the decorator landed on the class member.
+    let decoratorName = null;
+    function walk(node) {
+      if (!node || typeof node !== 'object') return;
+      if (Array.isArray(node.decorators) && node.decorators.length > 0) {
+        const expr = node.decorators[0].expression;
+        decoratorName = expr?.name ?? expr?.callee?.name ?? null;
+      }
+      for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'parent') continue;
+        const child = node[key];
+        if (Array.isArray(child)) child.forEach(walk);
+        else if (child && typeof child === 'object') walk(child);
+      }
+    }
+    walk(result.ast);
+    expect(decoratorName).toBe('tracked');
+  });
+});
+
 describe('JS path (useBabel) — end-to-end Linter pass', () => {
   function makeLinter() {
     const linter = new Linter();
@@ -83,10 +131,10 @@ describe('JS path (useBabel) — end-to-end Linter pass', () => {
 
     // `no-dupe-args` is a core rule that calls
     // `astUtils.getOpeningParenOfParams(...).loc.start`, which reaches
-    // through the token stream. Under the oxc path this throws because
-    // `program.tokens` is empty. Enabling the rule keeps that surface
-    // covered even if a future change quietly restores `loc` but still
-    // ships an empty token array.
+    // through the token stream. Enabling it pins the contract that the
+    // JS path emits a populated `program.tokens` — earlier oxc-based
+    // implementations shipped an empty array and crashed every rule
+    // that walked tokens.
     const messages = linter.verify(
       code,
       {