ember-eslint-parser 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "",
   "keywords": [],
   "repository": {
@@ -68,6 +68,8 @@
     "lint:js": "eslint . --max-warnings=0",
     "lint:js:fix": "eslint . --fix --max-warnings=0",
     "lint:package": "pnpm publint",
+    "bench": "vitest bench",
+    "bench:compare": "node scripts/bench-compare.mjs",
     "test": "vitest run"
   }
 }

package/src/parser/hbs-parser.js

@@ -2,6 +2,9 @@ const eslintScope = require('eslint-scope');
 const DocumentLines = require('../utils/document');
 const { processGlimmerTemplate, buildGlimmerVisitorKeys } = require('./transforms');
 
+// Constant: Program + all Glimmer node types. Computed once at module load.
+const hbsVisitorKeys = { Program: ['body'], ...buildGlimmerVisitorKeys() };
+
 /**
  * implements https://eslint.org/docs/latest/extend/custom-parsers
  * for Handlebars (.hbs) template files.
@@ -64,7 +67,7 @@ module.exports = {
     };
 
     // Build visitor keys: Program + all Glimmer node types
-    const visitorKeys = { Program: ['body'], ...buildGlimmerVisitorKeys() };
+    const visitorKeys = hbsVisitorKeys;
 
     // Create an empty scope manager.
     // For HBS, all locals are assumed to be defined at runtime,

package/src/parser/transforms.js

@@ -3,9 +3,9 @@ const glimmer = require('@glimmer/syntax');
 const { visitorKeys: glimmerVisitorKeys } = glimmer;
 const DocumentLines = require('../utils/document');
 const { Reference, Scope, Variable, Definition } = require('eslint-scope');
-const htmlTags = require('html-tags').default;
-const svgTags = require('svg-tags');
-const mathMLTags = require('mathml-tag-names').mathmlTagNames;
+const htmlTagsSet = new Set(require('html-tags').default);
+const svgTagsSet = new Set(require('svg-tags'));
+const mathMLTagsSet = new Set(require('mathml-tag-names').mathmlTagNames);
 
 let TypescriptScope = null;
 try {
@@ -19,31 +19,6 @@ try {
   // not available
 }
 
-const BufferMap = new Map();
-
-function getBuffer(str) {
-  let buf = BufferMap.get(str);
-  if (!buf) {
-    buf = Buffer.from(str);
-    BufferMap.set(str, buf);
-  }
-  return buf;
-}
-
-function sliceByteRange(str, a, b) {
-  const buf = getBuffer(str);
-  return buf.slice(a, b).toString();
-}
-
-function byteToCharIndex(str, byteOffset) {
-  const buf = getBuffer(str);
-  return buf.slice(0, byteOffset).toString().length;
-}
-
-function byteLength(str) {
-  return getBuffer(str).length;
-}
-
 /**
  * finds the nearest node scope
  * @param scopeManager
@@ -67,27 +42,33 @@ function findParentScope(scopeManager, nodePath) {
  * tries to find the variable names {name} in any parent scope
  * if the variable is not found it just returns the nearest scope,
  * so that it's usage can be registered.
+ *
+ * Also returns the nearest scope (equivalent to findParentScope) in one pass,
+ * avoiding the redundant second traversal that findParentScope would perform.
  * @param scopeManager
  * @param nodePath
  * @param name
  * @return {{scope: null, variable: *}|{scope: (*|null)}}
  */
 function findVarInParentScopes(scopeManager, nodePath, name) {
-  let scope = null;
+  let defScope = null;
+  let currentScope = null;
   let path = nodePath;
   while (path) {
-    scope = scopeManager.acquire(path.node, true);
-    if (scope && scope.set.has(name)) {
-      break;
+    const s = scopeManager.acquire(path.node, true);
+    if (s) {
+      if (!currentScope) currentScope = s;
+      if (s.set.has(name)) {
+        defScope = s;
+        break;
+      }
     }
     path = path.parentPath;
   }
-  const currentScope = findParentScope(scopeManager, nodePath);
-  if (!scope) {
+  if (!defScope) {
     return { scope: currentScope };
   }
-
-  return { scope: currentScope, variable: scope.set.get(name) };
+  return { scope: currentScope, variable: defScope.set.get(name) };
 }
 
 /**
@@ -115,9 +96,12 @@ function registerNodeInScope(node, scope, variable) {
 /**
  * Builds the complete Glimmer visitor keys map with "Glimmer" prefix and
  * additional keys needed for traversal (blockParamNodes, parts, etc).
+ * Result is cached since glimmerVisitorKeys is a constant.
  * @return {object}
  */
+let _cachedGlimmerVisitorKeys = null;
 function buildGlimmerVisitorKeys() {
+  if (_cachedGlimmerVisitorKeys) return _cachedGlimmerVisitorKeys;
   const keys = {};
   for (const [k, v] of Object.entries(glimmerVisitorKeys)) {
     keys[`Glimmer${k}`] = [...v];
@@ -127,6 +111,7 @@ function buildGlimmerVisitorKeys() {
   }
   keys.GlimmerProgram = ['body', 'blockParamNodes'];
   keys.GlimmerTemplate = ['body'];
+  _cachedGlimmerVisitorKeys = keys;
   return keys;
 }
 
@@ -170,7 +155,7 @@ function traverse(visitorKeys, node, visitor) {
           queue.push({
             node: item,
             parent: currentPath.node,
-            context: Object.assign({}, currentPath.context),
+            context: currentPath.context,
             parentKey: visitorKey,
             parentPath: currentPath,
           });
@@ -179,7 +164,7 @@ function traverse(visitorKeys, node, visitor) {
         queue.push({
           node: child,
           parent: currentPath.node,
-          context: Object.assign({}, currentPath.context),
+          context: currentPath.context,
           parentKey: visitorKey,
           parentPath: currentPath,
         });
@@ -200,8 +185,14 @@ function isAlphaNumeric(code) {
   );
 }
 
-function isWhiteSpace(code) {
-  return code === ' ' || code === '\t' || code === '\r' || code === '\n' || code === '\v';
+function isWhiteSpaceCode(code) {
+  return (
+    code === 32 /* space */ ||
+    code === 9 /* tab */ ||
+    code === 13 /* carriageReturn */ ||
+    code === 10 /* lineFeed */ ||
+    code === 11 /* verticalTab */
+  );
 }
 
 /**
@@ -213,8 +204,7 @@ function isWhiteSpace(code) {
  */
 function tokenize(template, doc, startOffset) {
   const tokens = [];
-  let current = '';
-  let start = 0;
+  let wordStart = -1;
   function pushToken(value, type, range) {
     const t = {
       type,
@@ -229,24 +219,28 @@ function tokenize(template, doc, startOffset) {
     };
     tokens.push(t);
   }
-  for (const [i, c] of [...template].entries()) {
-    if (isAlphaNumeric(c.codePointAt(0))) {
-      if (current.length === 0) {
-        start = i;
+  for (let i = 0; i < template.length; i++) {
+    const code = template.charCodeAt(i);
+    if (isAlphaNumeric(code)) {
+      if (wordStart < 0) {
+        wordStart = i;
       }
-      current += c;
     } else {
-      let range = [startOffset + start, startOffset + i];
-      if (current.length > 0) {
-        pushToken(current, 'word', range);
-        current = '';
+      if (wordStart >= 0) {
+        pushToken(template.slice(wordStart, i), 'word', [startOffset + wordStart, startOffset + i]);
+        wordStart = -1;
       }
-      range = [startOffset + i, startOffset + i + 1];
-      if (!isWhiteSpace(c)) {
-        pushToken(c, 'Punctuator', range);
+      if (!isWhiteSpaceCode(code)) {
+        pushToken(template[i], 'Punctuator', [startOffset + i, startOffset + i + 1]);
       }
     }
   }
+  if (wordStart >= 0) {
+    pushToken(template.slice(wordStart), 'word', [
+      startOffset + wordStart,
+      startOffset + template.length,
+    ]);
+  }
   return tokens;
 }
 
@@ -306,27 +300,55 @@ function removeFromParent(nodes) {
  * @return {object[]}
  */
 function buildTokenStream(rawTokens, comments, textNodes) {
-  let tokens = rawTokens.filter(
-    (t) => !comments.some((c) => c.range[0] <= t.range[0] && c.range[1] >= t.range[1])
-  );
-  tokens = tokens.filter(
-    (t) => !textNodes.some((c) => c.range[0] <= t.range[0] && c.range[1] >= t.range[1])
+  // Build sorted interval arrays for O(log n) exclusion checks
+  const commentIntervals = comments.map((c) => c.range).sort((a, b) => a[0] - b[0]);
+  const textNodeIntervals = textNodes.map((t) => t.range).sort((a, b) => a[0] - b[0]);
+
+  /**
+   * Binary-search: is the token's range fully covered by any interval in `intervals`?
+   * Intervals must be sorted by start offset.
+   * @param {number[]} tokenRange
+   * @param {number[][]} intervals
+   */
+  function isCovered(tokenRange, intervals) {
+    let lo = 0;
+    let hi = intervals.length - 1;
+    while (lo <= hi) {
+      const mid = (lo + hi) >> 1;
+      const iv = intervals[mid];
+      if (iv[0] <= tokenRange[0] && iv[1] >= tokenRange[1]) {
+        return true;
+      }
+      if (iv[0] > tokenRange[0]) {
+        hi = mid - 1;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return false;
+  }
+
+  // Single-pass filter: drop tokens covered by a comment or text node
+  const filteredTokens = rawTokens.filter(
+    (t) => !isCovered(t.range, commentIntervals) && !isCovered(t.range, textNodeIntervals)
   );
 
-  const sortedTextNodes = [...textNodes];
-  let currentTextNode = sortedTextNodes.pop();
-  for (let i = tokens.length - 1; i >= 0; i--) {
-    const t = tokens[i];
-    while (currentTextNode && t.range[0] < currentTextNode.range[0]) {
-      tokens.splice(i + 1, 0, currentTextNode);
-      currentTextNode = sortedTextNodes.pop();
+  // Merge text nodes (already sorted by position from the AST) into filteredTokens
+  // using a single linear merge pass instead of repeated splice calls.
+  const sortedTextNodes = [...textNodes].sort((a, b) => a.range[0] - b.range[0]);
+  const result = [];
+  let ti = 0;
+  for (const token of filteredTokens) {
+    while (ti < sortedTextNodes.length && sortedTextNodes[ti].range[0] < token.range[0]) {
+      result.push(sortedTextNodes[ti++]);
     }
+    result.push(token);
   }
-  if (currentTextNode) {
-    tokens.unshift(currentTextNode);
+  while (ti < sortedTextNodes.length) {
+    result.push(sortedTextNodes[ti++]);
   }
 
-  return tokens;
+  return result;
 }
 
 /**
@@ -399,6 +421,18 @@ function processGlimmerTemplate({ templateContent, codeLines, templateRange, tok
       });
     }
 
+    // Nullify empty hashes before the type is renamed
+    if (
+      (n.type === 'MustacheStatement' ||
+        n.type === 'BlockStatement' ||
+        n.type === 'SubExpression') &&
+      n.hash &&
+      n.hash.pairs &&
+      n.hash.pairs.length === 0
+    ) {
+      n.hash = null;
+    }
+
     n.type = `Glimmer${n.type}`;
   }
 
@@ -409,17 +443,6 @@ function processGlimmerTemplate({ templateContent, codeLines, templateRange, tok
     comment.type = 'Block';
   }
 
-  // Nullify empty hashes
-  for (const n of allNodes) {
-    if (
-      ['GlimmerMustacheStatement', 'GlimmerBlockStatement', 'GlimmerSubExpression'].includes(n.type)
-    ) {
-      if (n.hash && n.hash.pairs && n.hash.pairs.length === 0) {
-        n.hash = null;
-      }
-    }
-  }
-
   // Build final token stream
   ast.tokens = buildTokenStream(
     tokenize(tokenSource || templateContent, codeLines, offset),
@@ -442,23 +465,18 @@ function processGlimmerTemplate({ templateContent, codeLines, templateRange, tok
  */
 module.exports.preprocessGlimmerTemplates = function preprocessGlimmerTemplates(info, code) {
   const templateInfos = info.templateInfos.map((r) => ({
-    range: [r.contentRange.startByte, r.contentRange.endByte],
-    templateRange: [r.range.startByte, r.range.endByte],
-    utf16Range: [byteToCharIndex(code, r.range.startByte), byteToCharIndex(code, r.range.endByte)],
+    utf16Range: [r.range.startUtf16Codepoint, r.range.endUtf16Codepoint],
   }));
   const codeLines = new DocumentLines(code);
   const allComments = [];
-  const templateVisitorKeys = {};
 
   for (const tpl of templateInfos) {
-    const range = tpl.utf16Range;
-    const template = code.slice(...range);
+    const template = code.slice(...tpl.utf16Range);
 
     const { ast, comments } = processGlimmerTemplate({
       templateContent: template,
       codeLines,
       templateRange: [...tpl.utf16Range],
-      tokenSource: sliceByteRange(code, ...tpl.templateRange),
     });
 
     ast.content = template;
@@ -466,12 +484,8 @@ module.exports.preprocessGlimmerTemplates = function preprocessGlimmerTemplates(
     tpl.ast = ast;
   }
 
-  for (const [k, v] of Object.entries(glimmerVisitorKeys)) {
-    templateVisitorKeys[`Glimmer${k}`] = [...v];
-  }
-
   return {
-    templateVisitorKeys,
+    templateVisitorKeys: buildGlimmerVisitorKeys(),
     templateInfos,
     comments: allComments,
   };
@@ -499,6 +513,9 @@ module.exports.convertAst = function convertAst(result, preprocessedResult, visi
     result.ast.tokens.splice(firstIdx, lastIdx - firstIdx + 1, ...ti.ast.tokens);
   }
 
+  // Build a Map keyed by range start for O(1) lookup during traversal
+  const templateInfoByStart = new Map(templateInfos.map((t) => [t.utf16Range[0], t]));
+
   // eslint-disable-next-line complexity
   traverse(visitorKeys, result.ast, (path) => {
     const node = path.node;
@@ -515,12 +532,11 @@ module.exports.convertAst = function convertAst(result, preprocessedResult, visi
         range = [node.declaration.range[0], node.declaration.range[1]];
       }
 
-      const template = templateInfos.find(
-        (t) =>
-          t.utf16Range[0] === range[0] &&
-          (t.utf16Range[1] === range[1] || t.utf16Range[1] === range[1] + 1)
-      );
-      if (!template) {
+      const template = templateInfoByStart.get(range[0]);
+      if (
+        !template ||
+        (template.utf16Range[1] !== range[1] && template.utf16Range[1] !== range[1] + 1)
+      ) {
         return null;
       }
       counter++;
@@ -570,9 +586,9 @@ module.exports.convertAst = function convertAst(result, preprocessedResult, visi
       const registerUndef =
         isUpperCase(n.name[0]) ||
         node.name.includes('.') ||
-        (!htmlTags.includes(node.name) &&
-          !svgTags.includes(node.name) &&
-          !mathMLTags.includes(node.name));
+        (!htmlTagsSet.has(node.name) &&
+          !svgTagsSet.has(node.name) &&
+          !mathMLTagsSet.has(node.name));
 
       if (!ignore && (variable || registerUndef)) {
         registerNodeInScope(n, scope, variable);
@@ -622,7 +638,7 @@ module.exports.convertAst = function convertAst(result, preprocessedResult, visi
 };
 
 const replaceRange = function replaceRange(s, start, end, substitute) {
-  return sliceByteRange(s, 0, start) + substitute + sliceByteRange(s, end);
+  return s.slice(0, start) + substitute + s.slice(end);
 };
 module.exports.replaceRange = replaceRange;
 
@@ -725,25 +741,25 @@ module.exports.transformForLint = function transformForLint(code, fileName) {
   for (const tplInfo of result.reverse()) {
     const content = tplInfo.contents.replace(/`/g, '\\`').replace(/\$/g, '\\$');
     if (tplInfo.type === 'class-member') {
-      const tplLength = tplInfo.range.endByte - tplInfo.range.startByte;
-      const spaces = tplLength - byteLength(content) - 'static{`'.length - '`}'.length;
+      const tplLength = tplInfo.range.endUtf16Codepoint - tplInfo.range.startUtf16Codepoint;
+      const spaces = tplLength - content.length - 'static{`'.length - '`}'.length;
       const total = content + ' '.repeat(spaces);
       const replacementCode = `static{\`${total}\`}`;
       jsCode = replaceRange(
         jsCode,
-        tplInfo.range.startByte,
-        tplInfo.range.endByte,
+        tplInfo.range.startUtf16Codepoint,
+        tplInfo.range.endUtf16Codepoint,
         replacementCode
       );
     } else {
-      const tplLength = tplInfo.range.endByte - tplInfo.range.startByte;
-      const spaces = tplLength - byteLength(content) - '`'.length - '`'.length;
+      const tplLength = tplInfo.range.endUtf16Codepoint - tplInfo.range.startUtf16Codepoint;
+      const spaces = tplLength - content.length - '`'.length - '`'.length;
       const total = content + ' '.repeat(spaces);
       const replacementCode = `\`${total}\``;
       jsCode = replaceRange(
         jsCode,
-        tplInfo.range.startByte,
-        tplInfo.range.endByte,
+        tplInfo.range.startUtf16Codepoint,
+        tplInfo.range.endUtf16Codepoint,
         replacementCode
       );
     }

package/src/parser/ts-patch.js

@@ -80,12 +80,32 @@ try {
     let jsCode = code;
     const sourceFile = ts.createSourceFile('__x__.ts', code, ts.ScriptTarget.Latest);
     const length = jsCode.length;
-    for (const b of sourceFile.statements) {
-      if (b.kind === ts.SyntaxKind.ImportDeclaration && b.moduleSpecifier.text.endsWith('.gts')) {
-        const value = b.moduleSpecifier.text.replace(/\.gts$/, '.mts');
-        jsCode = replaceRange(jsCode, b.moduleSpecifier.pos + 2, b.moduleSpecifier.end - 1, value);
+    function visit(node) {
+      if (
+        node.kind === ts.SyntaxKind.ImportDeclaration &&
+        node.moduleSpecifier.text.endsWith('.gts')
+      ) {
+        const value = node.moduleSpecifier.text.replace(/\.gts$/, '.mts');
+        jsCode = replaceRange(
+          jsCode,
+          node.moduleSpecifier.pos + 2,
+          node.moduleSpecifier.end - 1,
+          value
+        );
+      }
+      if (
+        node.kind === ts.SyntaxKind.CallExpression &&
+        node.expression.kind === ts.SyntaxKind.ImportKeyword
+      ) {
+        const arg = node.arguments[0];
+        if (arg && arg.kind === ts.SyntaxKind.StringLiteral && arg.text.endsWith('.gts')) {
+          const value = arg.text.replace(/\.gts$/, '.mts');
+          jsCode = replaceRange(jsCode, arg.getStart(sourceFile) + 1, arg.end - 1, value); // +1/-1 to skip surrounding quotes
+        }
       }
+      ts.forEachChild(node, visit);
     }
+    visit(sourceFile);
     if (length !== jsCode.length) {
       throw new Error('bad replacement');
     }

package/src/utils/document.js

@@ -28,12 +28,20 @@ class DocumentLines {
    */
   offsetToPosition(position) {
     const lineStarts = this.lineStarts;
-    let line = 0;
-    while (line + 1 < lineStarts.length && lineStarts[line + 1] <= position) {
-      line++;
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    // Upper-biased midpoint is required here: we want the *rightmost* line whose
+    // start is ≤ position. With a lower-biased mid, when lo + 1 === hi and the
+    // condition is true, mid === lo and lo never advances, causing an infinite loop.
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (lineStarts[mid] <= position) {
+        lo = mid;
+      } else {
+        hi = mid - 1;
+      }
     }
-    const column = position - lineStarts[line];
-    return { line: line + 1, column };
+    return { line: lo + 1, column: position - lineStarts[lo] };
   }
 }
 
@@ -46,27 +54,20 @@ function computeLineStarts(text) {
   let pos = 0;
   let lineStart = 0;
   while (pos < text.length) {
-    const ch = text.codePointAt(pos);
-    pos++;
-    switch (ch) {
-      case 13 /* carriageReturn */: {
-        if (text.codePointAt(pos) === 10 /* lineFeed */) {
-          pos++;
-        }
-      }
-      // falls through
-      case 10 /* lineFeed */: {
-        result.push(lineStart);
-        lineStart = pos;
-        break;
-      }
-      default: {
-        if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
-          result.push(lineStart);
-          lineStart = pos;
-        }
-        break;
+    const ch = text.charCodeAt(pos++);
+    if (ch === 13 /* carriageReturn */) {
+      if (text.charCodeAt(pos) === 10 /* lineFeed */) {
+        pos++;
       }
+      result.push(lineStart);
+      lineStart = pos;
+    } else if (
+      ch === 10 /* lineFeed */ ||
+      ch === 8232 /* lineSeparator */ ||
+      ch === 8233 /* paragraphSeparator */
+    ) {
+      result.push(lineStart);
+      lineStart = pos;
     }
   }
   result.push(lineStart);