ember-eslint-parser 0.11.3 → 0.12.0

package/package.json

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

package/src/parser/ember71-built-in-keywords.js

@@ -0,0 +1,105 @@
+import { createRequire } from 'node:module';
+
+/**
+ * Built-in template keywords shipped from `ember-source` 7.1.0
+ * (RFCs 389, 470, 560, 561, 562, 997, 998, 999, 1000). They can be referenced
+ * in strict-mode (`.gjs` / `.gts`) templates without an explicit import.
+ *
+ * `@glimmer/syntax`'s `isKeyword` does not (yet) include these, so the
+ * scope-registration pass would otherwise treat `{{eq}}`, `{{on}}`, etc. as
+ * free identifiers and ESLint's `no-undef` would flag them.
+ *
+ * Mirrors Glint's `KeywordsForEmber71` gate in
+ * `@glint/ember-tsc/types/-private/dsl/globals.d.ts`.
+ */
+export const EMBER_71_BUILT_IN_KEYWORDS = new Set([
+  'and',
+  'array',
+  'element',
+  'eq',
+  'fn',
+  'gt',
+  'gte',
+  'hash',
+  'lt',
+  'lte',
+  'neq',
+  'not',
+  'on',
+  'or',
+]);
+
+/**
+ * Returns `true` when `name` is one of the Ember 7.1 built-in template
+ * keywords AND the supplied `ember-source` version is >= 7.1.0.
+ *
+ * Pure — accepts the version string instead of reading the filesystem so it
+ * is trivially testable.
+ *
+ * @param {string} name
+ * @param {string | undefined | null} version
+ * @returns {boolean}
+ */
+export function isEmber71BuiltInKeywordForVersion(name, version) {
+  if (!EMBER_71_BUILT_IN_KEYWORDS.has(name)) return false;
+  if (typeof version !== 'string') return false;
+
+  const [major, minor] = version.split('.').map(Number);
+  return major > 7 || (major === 7 && minor >= 1);
+}
+
+const require = createRequire(import.meta.url);
+
+let cachedVersion;
+let cachedVersionResolved = false;
+
+function resolveEmberSourceVersion() {
+  if (cachedVersionResolved) return cachedVersion;
+  cachedVersionResolved = true;
+  try {
+    // ember-source is a peer of consumers, not of this parser.
+    // eslint-disable-next-line n/no-missing-require, import/no-unresolved
+    const pkg = require('ember-source/package.json');
+    cachedVersion = typeof pkg?.version === 'string' ? pkg.version : undefined;
+  } catch {
+    cachedVersion = undefined;
+  }
+  return cachedVersion;
+}
+
+/**
+ * Decide whether `name` should be treated as a built-in template keyword
+ * given the consumer's installed `ember-source`. Returns `false` when
+ * `ember-source` is not resolvable or its version is older than 7.1.0, so
+ * pre-7.1 projects keep their existing lint behavior and typos like
+ * `{{eq}}` continue to surface as `no-undef`.
+ *
+ * The probe is cached for the lifetime of the process so this is cheap
+ * to call from per-node scope registration.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isEmber71BuiltInKeyword(name) {
+  if (!EMBER_71_BUILT_IN_KEYWORDS.has(name)) return false;
+  return isEmber71BuiltInKeywordForVersion(name, resolveEmberSourceVersion());
+}
+
+/**
+ * Test-only: reset the cached `ember-source` version probe.
+ */
+export function _resetEmberSourceVersionCache() {
+  cachedVersion = undefined;
+  cachedVersionResolved = false;
+}
+
+/**
+ * Test-only: force the resolved `ember-source` version. Pass `undefined`
+ * to clear and fall back to real probing on the next call.
+ *
+ * @param {string | undefined} version
+ */
+export function _setEmberSourceVersionForTesting(version) {
+  cachedVersion = version;
+  cachedVersionResolved = true;
+}

package/src/parser/transforms.js

@@ -2,6 +2,7 @@ import { createRequire } from 'node:module';
 import { Preprocessor } from 'content-tag';
 import { isKeyword as glimmerIsKeyword } from '@glimmer/syntax';
 import { glimmerVisitorKeys } from 'ember-estree';
+import { isEmber71BuiltInKeyword } from './ember71-built-in-keywords.js';
 import { Reference, Scope, Variable, Definition } from 'eslint-scope';
 import htmlTags from 'html-tags';
 import svgTags from 'svg-tags';
@@ -118,6 +119,16 @@ function registerPathExpression(node, path, scopeManager) {
   const name = node.head.name;
   if (glimmerIsKeyword(name)) return;
   const { scope, variable } = findVarInParentScopes(scopeManager, path, name) || {};
+  // `@glimmer/syntax`'s `isKeyword` table predates the Ember 7.1 built-in
+  // keywords (RFCs 389/470/560/561/562/997-1000). When the consumer is on
+  // ember-source >= 7.1, treat them as built-ins too so `no-undef` doesn't
+  // flag bare references like `{{eq}}` or `{{on "click" handler}}`.
+  //
+  // Only when there is NO local binding — a user-authored
+  // `import { eq } from 'ember-truth-helpers'` (or a `const eq = …`) must
+  // shadow the built-in so the scope reference is registered and the
+  // import is marked as used by `no-unused-vars`.
+  if (!variable && isEmber71BuiltInKeyword(name)) return;
   if (scope) {
     node.head.parent = node;
     registerNodeInScope(node.head, scope, variable);