@ohos-ports/ember-estree 0.6.11-beta.0

package/src/tokens.js

@@ -0,0 +1,177 @@
+/**
+ * Token stream generation for Glimmer templates.
+ *
+ * Only needed by ESLint consumers — codemods, type-checkers, and formatters
+ * do not use the flat token stream and skip this entirely by omitting
+ * `{ tokens: true }` from processTemplate options.
+ *
+ * ESLint-specific note: comment tokens are placed at range[0]+1 rather than
+ * range[0] because ESLint's createIndexMap infinite-loops when a token and an
+ * ast.comments entry share range[0] — both inner loops fail the strict-less-than
+ * guard and the outer loop never advances. Tracked upstream as eslint/eslint#20492.
+ */
+
+function isAlphaNumeric(code) {
+  return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+
+/**
+ * Lex a Glimmer template into a flat token array.
+ * Tracks line/column incrementally from a single seed call to
+ * doc.offsetToPosition — O(n + log L) instead of O(n log L).
+ */
+export function tokenize(template, doc, startOffset) {
+  const tokens = [];
+  let wordStart = -1;
+
+  // Seed position from the start offset — one binary search total.
+  // Then track line/column incrementally (DocumentLines counts only \n
+  // as line separators, so this matches offsetToPosition exactly).
+  let { line: curLine, column: curCol } = doc.offsetToPosition(startOffset);
+  let wordLine = 0,
+    wordCol = 0;
+
+  for (let i = 0; i < template.length; i++) {
+    const code = template.charCodeAt(i);
+    if (isAlphaNumeric(code)) {
+      if (wordStart < 0) {
+        wordStart = i;
+        wordLine = curLine;
+        wordCol = curCol;
+      }
+      curCol++;
+    } else {
+      if (wordStart >= 0) {
+        const absStart = startOffset + wordStart;
+        const absEnd = startOffset + i;
+        tokens.push({
+          type: "word",
+          value: template.slice(wordStart, i),
+          range: [absStart, absEnd],
+          start: absStart,
+          end: absEnd,
+          loc: {
+            start: { line: wordLine, column: wordCol, index: absStart },
+            end: { line: curLine, column: curCol, index: absEnd },
+          },
+        });
+        wordStart = -1;
+      }
+      if (code === 10 /* \n */) {
+        curLine++;
+        curCol = 0;
+      } else {
+        if (code !== 32 && code !== 9 && code !== 13 && code !== 11 /* non-whitespace */) {
+          const absPos = startOffset + i;
+          tokens.push({
+            type: "Punctuator",
+            value: template[i],
+            range: [absPos, absPos + 1],
+            start: absPos,
+            end: absPos + 1,
+            loc: {
+              start: { line: curLine, column: curCol, index: absPos },
+              end: { line: curLine, column: curCol + 1, index: absPos + 1 },
+            },
+          });
+        }
+        curCol++;
+      }
+    }
+  }
+
+  if (wordStart >= 0) {
+    const absStart = startOffset + wordStart;
+    const absEnd = startOffset + template.length;
+    tokens.push({
+      type: "word",
+      value: template.slice(wordStart),
+      range: [absStart, absEnd],
+      start: absStart,
+      end: absEnd,
+      loc: {
+        start: { line: wordLine, column: wordCol, index: absStart },
+        end: { line: curLine, column: curCol, index: absEnd },
+      },
+    });
+  }
+
+  return tokens;
+}
+
+/**
+ * Merge the raw Glimmer token stream with text nodes and comment tokens,
+ * dropping raw tokens that fall inside comment or text-node intervals.
+ *
+ * All inputs are sorted by range[0] (sequential document scan), so the
+ * entire operation is a single O(n+m+k) pass with advancing pointers
+ * rather than O(n log m) per-token binary searches.
+ */
+export function buildTokenStream(rawTokens, comments, textNodes, templateContent, offset) {
+  // Comment tokens shifted by 1 to avoid the ESLint createIndexMap conflict
+  const commentTokens = comments.map((c) => {
+    const start = c.range[0] + 1;
+    const end = c.range[1];
+    return {
+      type: "Block",
+      value: templateContent.slice(start - offset, end - offset),
+      range: [start, end],
+      start,
+      end,
+      loc: c.loc,
+    };
+  });
+
+  const spliceables = linearMerge(textNodes, commentTokens);
+
+  const result = [];
+  let ri = 0; // rawTokens
+  let si = 0; // spliceables
+  let ci = 0; // comment intervals (for skip detection)
+  let ni = 0; // text-node intervals (for skip detection)
+
+  while (ri < rawTokens.length || si < spliceables.length) {
+    if (ri >= rawTokens.length) {
+      result.push(spliceables[si++]);
+      continue;
+    }
+
+    const tok = rawTokens[ri];
+
+    // Advance interval pointers past intervals that end before this token
+    while (ci < comments.length && comments[ci].range[1] <= tok.range[0]) ci++;
+    while (ni < textNodes.length && textNodes[ni].range[1] <= tok.range[0]) ni++;
+
+    // Skip raw token if it falls inside a comment or text-node interval
+    if (
+      (ci < comments.length && comments[ci].range[0] <= tok.range[0]) ||
+      (ni < textNodes.length && textNodes[ni].range[0] <= tok.range[0])
+    ) {
+      ri++;
+      continue;
+    }
+
+    // Emit the earlier of the next spliceable or this raw token
+    if (si < spliceables.length && spliceables[si].range[0] < tok.range[0]) {
+      result.push(spliceables[si++]);
+    } else {
+      result.push(tok);
+      ri++;
+    }
+  }
+
+  return result;
+}
+
+function linearMerge(a, b) {
+  const result = Array.from({ length: a.length + b.length });
+  let ai = 0,
+    bi = 0,
+    ri = 0;
+  while (ai < a.length && bi < b.length) {
+    result[ri++] = a[ai].range[0] <= b[bi].range[0] ? a[ai++] : b[bi++];
+  }
+  while (ai < a.length) result[ri++] = a[ai++];
+  while (bi < b.length) result[ri++] = b[bi++];
+  return result;
+}

package/src/transforms.js

@@ -0,0 +1,279 @@
+/**
+ * Glimmer AST → ESTree transform utilities.
+ */
+
+import {
+  visitorKeys as rawGlimmerVisitorKeys,
+  preprocess as glimmerPreprocess,
+} from "@glimmer/syntax";
+
+import { tokenize, buildTokenStream } from "./tokens.js";
+
+/**
+ * Converts between character offsets and line/column positions.
+ * Lines are 1-based, columns are 0-based (matching ESTree & Glimmer conventions).
+ */
+export class DocumentLines {
+  constructor(source) {
+    this.lineStarts = [0];
+    for (let i = 0; i < source.length; i++) {
+      if (source[i] === "\n") {
+        this.lineStarts.push(i + 1);
+      }
+    }
+  }
+
+  positionToOffset(pos) {
+    return this.lineStarts[pos.line - 1] + pos.column;
+  }
+
+  offsetToPosition(offset) {
+    let lo = 0;
+    let hi = this.lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi + 1) >> 1;
+      if (this.lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return { line: lo + 1, column: offset - this.lineStarts[lo] };
+  }
+}
+
+/**
+ * Glimmer visitor keys map with "Glimmer" prefix.
+ * Computed once at module load.
+ */
+export const glimmerVisitorKeys = (() => {
+  const keys = {};
+  for (const [k, v] of Object.entries(rawGlimmerVisitorKeys)) {
+    keys[`Glimmer${k}`] = v;
+  }
+  keys.GlimmerElementNode = [...keys.GlimmerElementNode, "blockParamNodes", "parts"];
+  keys.GlimmerProgram = ["body", "blockParamNodes"];
+  keys.GlimmerTemplate = ["body"];
+  return keys;
+})();
+
+// ── Internal helpers ──────────────────────────────────────────────────
+
+// @glimmer/syntax nodes use prototype getters that form circular chains,
+// crashing traversers like esrecurse. We snapshot configurable getters:
+//   ElementNode: tag, blockParams, selfClosing
+//   PathExpression: original
+//   VarHead: name, original
+//   Block: blockParams
+const _desc = { value: undefined, configurable: true, enumerable: true, writable: true };
+const _parentDesc = { value: null, configurable: true, enumerable: false, writable: true };
+export function setParent(node, parent) {
+  _parentDesc.value = parent;
+  Object.defineProperty(node, "parent", _parentDesc);
+}
+function defOwn(obj, key) {
+  _desc.value = obj[key];
+  Object.defineProperty(obj, key, _desc);
+}
+
+function removeFromParent(nodes) {
+  for (const node of nodes) {
+    const children =
+      (node.parent && (node.parent.children || node.parent.body || node.parent.parts)) || [];
+    const idx = children.indexOf(node);
+    if (idx >= 0) {
+      children.splice(idx, 1);
+    }
+  }
+}
+
+/**
+ * Parse and transform a Glimmer template into an ESTree-compatible AST.
+ * Internal — consumed by toTree.
+ *
+ * Single recursive pass: collect, categorize, snapshot getters, fix
+ * positions, create parts/blockParamNodes, nullify empty hashes, and
+ * prefix types. No separate collect-then-transform loop.
+ */
+export function processTemplate(templateContent, codeLines, options = {}) {
+  const { templateRange, tokens: generateTokens = false } = options;
+  const offset = templateRange[0];
+  const docLines = offset === 0 ? codeLines : new DocumentLines(templateContent);
+
+  const toFileRange = (loc) => [
+    offset + docLines.positionToOffset(loc.start),
+    offset + docLines.positionToOffset(loc.end),
+  ];
+  const toFileLoc = (range) => ({
+    start: codeLines.offsetToPosition(range[0]),
+    end: codeLines.offsetToPosition(range[1]),
+  });
+
+  const ast = glimmerPreprocess(templateContent, { mode: "codemod" });
+  const comments = [];
+  const textNodes = [];
+  const emptyTextNodes = [];
+
+  // Single recursive pass over the glimmer AST. Processes each node
+  // fully (getters, positions, parts, blockParams) then recurses into
+  // children using raw visitor keys. Type prefixing happens inline
+  // AFTER recursing (so children see the original type during lookup).
+  function visit(n, parent) {
+    setParent(n, parent);
+
+    // Categorize
+    if (n.type === "CommentStatement" || n.type === "MustacheCommentStatement") {
+      comments.push(n);
+    }
+    if (n.type === "TextNode") {
+      n.value = n.chars;
+      if (n.value.trim().length !== 0 || (parent && parent.type === "AttrNode")) {
+        textNodes.push(n);
+      } else {
+        emptyTextNodes.push(n);
+      }
+    }
+
+    // Snapshot configurable prototype getters
+    switch (n.type) {
+      case "ElementNode":
+        defOwn(n, "tag");
+        defOwn(n, "blockParams");
+        defOwn(n, "selfClosing");
+        if (n.path?.head) {
+          defOwn(n.path.head, "name");
+          defOwn(n.path.head, "original");
+        }
+        break;
+      case "PathExpression":
+        defOwn(n, "original");
+        if (n.head) {
+          defOwn(n.head, "name");
+          defOwn(n.head, "original");
+        }
+        break;
+      case "Block":
+        defOwn(n, "blockParams");
+        break;
+    }
+
+    // Fix positions
+    if (n.type === "PathExpression") {
+      n.head.range = toFileRange(n.head.loc);
+      n.head.start = n.head.range[0];
+      n.head.end = n.head.range[1];
+      n.head.loc = toFileLoc(n.head.range);
+    }
+    n.range = n.type === "Template" ? [...templateRange] : toFileRange(n.loc);
+    n.start = n.range[0];
+    n.end = n.range[1];
+    n.loc = toFileLoc(n.range);
+
+    if (n.type === "MustacheCommentStatement") {
+      n.longForm = templateContent.slice(n.start - offset, n.start - offset + 4) === "{{!-";
+    }
+
+    // Create parts for ElementNode
+    if (n.type === "ElementNode") {
+      n.name = n.tag;
+      const p = n.path.head;
+      const partRange = toFileRange(p.loc);
+      const part = {
+        type: "GlimmerElementNodePart",
+        original: p.original,
+        name: p.original,
+        range: partRange,
+        start: partRange[0],
+        end: partRange[1],
+        loc: toFileLoc(partRange),
+      };
+      setParent(part, n);
+      n.parts = [part];
+    }
+
+    // Create blockParamNodes
+    if ("blockParams" in n && Array.isArray(n.blockParams)) {
+      if (n.params && n.params.length === n.blockParams.length) {
+        n.blockParamNodes = n.params.map((p) => {
+          const range = toFileRange(p.loc);
+          const bp = {
+            type: "GlimmerBlockParam",
+            name: p.original || p.name,
+            original: p.original,
+            range,
+            start: range[0],
+            end: range[1],
+            loc: toFileLoc(range),
+          };
+          setParent(bp, n);
+          return bp;
+        });
+      } else {
+        n.blockParamNodes = n.blockParams.map((bpName) => {
+          const bp = {
+            type: "GlimmerBlockParam",
+            name: bpName,
+            range: [n.range[0], n.range[1]],
+            start: n.range[0],
+            end: n.range[1],
+            loc: toFileLoc(n.range),
+          };
+          setParent(bp, n);
+          return bp;
+        });
+      }
+    }
+
+    // Nullify empty hashes
+    if (
+      (n.type === "MustacheStatement" ||
+        n.type === "BlockStatement" ||
+        n.type === "SubExpression") &&
+      n.hash?.pairs?.length === 0
+    ) {
+      n.hash = null;
+    }
+
+    // Recurse into children BEFORE prefixing type (visitor keys use original type)
+    const keys = rawGlimmerVisitorKeys[n.type];
+    if (keys) {
+      for (const key of keys) {
+        const child = n[key];
+        if (!child) continue;
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && item.type) visit(item, n);
+          }
+        } else if (typeof child === "object" && child.type) {
+          visit(child, n);
+        }
+      }
+    }
+
+    // Prefix type after children are visited
+    n.type = `Glimmer${n.type}`;
+  }
+
+  visit(ast, null);
+
+  removeFromParent(emptyTextNodes);
+
+  if (generateTokens) {
+    // buildTokenStream walks comments and textNodes as sorted intervals via
+    // pointer advancement. AST-traversal order doesn't match source order
+    // when an element has both attribute-position and body-position
+    // MustacheCommentStatements (e.g. `<li {{! a }}>{{! b }}</li>`), so
+    // sort here. Without the sort, raw tokens that fall inside an earlier-
+    // source-position comment fail the skip check, the same span ends up
+    // tokenized twice (raw punctuators *and* a Block), and downstream
+    // ESLint token walks can infinite-loop on the non-monotonic stream.
+    comments.sort((a, b) => a.range[0] - b.range[0]);
+    ast.tokens = buildTokenStream(
+      tokenize(templateContent, codeLines, offset),
+      comments,
+      textNodes,
+      templateContent,
+      offset,
+    );
+  }
+  ast.contents = templateContent;
+
+  return { ast, comments };
+}