@mrclrchtr/supi-tree-sitter 8.0.0 → 9.0.0

package/src/tool/outline-latex.ts

@@ -0,0 +1,288 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+const UNSUPPORTED_TITLE_CHARACTERS = /[\\{}%$#&^~_[\]()=]/u;
+
+const LATEX_SECTION_KINDS: Readonly<Record<string, string>> = {
+  part: "part",
+  chapter: "chapter",
+  section: "section",
+  subsection: "subsection",
+  subsubsection: "subsubsection",
+  paragraph: "paragraph",
+  subparagraph: "subparagraph",
+};
+
+const LATEX_DEFINITION_FIELDS: Readonly<Record<string, { field: string; kind: string }>> = {
+  new_command_definition: { field: "declaration", kind: "command" },
+  old_command_definition: { field: "declaration", kind: "command" },
+  let_command_definition: { field: "declaration", kind: "command" },
+  paired_delimiter_definition: { field: "declaration", kind: "command" },
+  environment_definition: { field: "name", kind: "environment" },
+  label_definition: { field: "name", kind: "label" },
+  acronym_definition: { field: "name", kind: "acronym" },
+  glossary_entry_definition: { field: "name", kind: "glossary-entry" },
+  color_definition: { field: "name", kind: "color" },
+};
+
+/** Extract LaTeX section headings and explicit definitions from grammar nodes. */
+export function extractLatexOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+): OutlineItem[] | undefined {
+  const sectionKind = LATEX_SECTION_KINDS[node.type];
+  if (sectionKind) return extractLatexSectionItem(node, source, lineStarts, sectionKind);
+
+  const definition = LATEX_DEFINITION_FIELDS[node.type];
+  if (!definition) return undefined;
+  const declaration = node.childForFieldName(definition.field);
+  const label = definition.kind === "label" ? extractLatexLabel(node, source, lineStarts) : null;
+  const name =
+    definition.kind === "label"
+      ? (label?.name ?? "")
+      : declaration
+        ? groupContent(declaration.text)
+        : "";
+  if (!name) return [];
+  return [
+    {
+      name,
+      kind: definition.kind,
+      range: nodeToRange(node, source),
+      ...(label ? { nameAnchor: label.nameAnchor } : {}),
+    },
+  ];
+}
+
+function extractLatexSectionItem(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+  sectionKind: string,
+): OutlineItem[] {
+  const title = node.childForFieldName("text");
+  const name = title ? groupContent(title.text) : "";
+  if (!name) return [];
+  const titleSpan = title ? findPlainTitleSpan(title, source, lineStarts, name) : null;
+  return [
+    {
+      name,
+      kind: sectionKind,
+      range: nodeToRange(node, source),
+      ...(titleSpan ? { nameAnchor: titleSpan.start, nameEndAnchor: titleSpan.end } : {}),
+      children: collectLatexMembers(node, source, lineStarts),
+    },
+  ];
+}
+
+/** Read only label keys with one source-contiguous name span. */
+function extractLatexLabel(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+): { name: string; nameAnchor: { line: number; character: number } } | null {
+  const commandStart = sourceOffsetAt(
+    source,
+    node.startPosition.row,
+    node.startPosition.column,
+    lineStarts,
+  );
+  const group = findLatexLabelGroup(source, commandStart);
+  if (!group) return null;
+  const key = findContiguousLabelKey(source, group.openBrace, group.closeBrace);
+  if (!key) return null;
+  const prefixLines = source.slice(commandStart, key.start).split(/\r\n|\r|\n/u);
+  const lastPrefix = prefixLines[prefixLines.length - 1] ?? "";
+  return {
+    name: source.slice(key.start, key.end),
+    nameAnchor: {
+      line: node.startPosition.row + prefixLines.length,
+      character:
+        prefixLines.length === 1
+          ? node.startPosition.column + lastPrefix.length + 1
+          : lastPrefix.length + 1,
+    },
+  };
+}
+
+function findLatexLabelGroup(
+  source: string,
+  commandStart: number,
+): { openBrace: number; closeBrace: number } | null {
+  if (!source.startsWith("\\label", commandStart)) return null;
+  const openBrace = skipLabelTrivia(source, commandStart + "\\label".length, source.length);
+  if (source[openBrace] !== "{") return null;
+  const closeBrace = findLabelGroupEnd(source, openBrace);
+  return closeBrace < 0 ? null : { openBrace, closeBrace };
+}
+
+function findContiguousLabelKey(
+  source: string,
+  openBrace: number,
+  closeBrace: number,
+): { start: number; end: number } | null {
+  const start = skipLabelTrivia(source, openBrace + 1, closeBrace);
+  if (start >= closeBrace || isLabelGroupBrace(source, start)) return null;
+  let end = start;
+  while (end < closeBrace && !isLabelKeyBoundary(source, end)) end += 1;
+  return skipLabelTrivia(source, end, closeBrace) === closeBrace ? { start, end } : null;
+}
+
+function skipLabelTrivia(source: string, start: number, end: number): number {
+  let cursor = start;
+  while (cursor < end) {
+    if (isTexCommentStart(source, cursor)) {
+      cursor = skipTexComment(source, cursor, end);
+      continue;
+    }
+    const character = source[cursor];
+    if (character !== undefined && /\s/u.test(character)) {
+      cursor += 1;
+      continue;
+    }
+    break;
+  }
+  return cursor;
+}
+
+function isLabelKeyBoundary(source: string, index: number): boolean {
+  const character = source[index];
+  return (
+    character === undefined ||
+    isTexCommentStart(source, index) ||
+    (character !== undefined && /\s/u.test(character)) ||
+    (isLabelGroupBrace(source, index) && !isEscaped(source, index))
+  );
+}
+
+function isLabelGroupBrace(source: string, index: number): boolean {
+  return source[index] === "{" || source[index] === "}";
+}
+
+function findLabelGroupEnd(text: string, openBrace: number): number {
+  let depth = 1;
+  for (let index = openBrace + 1; index < text.length; index += 1) {
+    if (isTexCommentStart(text, index)) {
+      index = skipTexComment(text, index, text.length) - 1;
+      continue;
+    }
+    if (isEscaped(text, index)) continue;
+    if (text[index] === "{") depth += 1;
+    if (text[index] === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function sourceOffsetAt(
+  source: string,
+  row: number,
+  column: number,
+  lineStarts: readonly number[],
+): number {
+  return Math.min(source.length, (lineStarts[row] ?? source.length) + column);
+}
+
+function isTexCommentStart(text: string, index: number): boolean {
+  return text[index] === "%" && !isEscaped(text, index);
+}
+
+function isEscaped(text: string, index: number): boolean {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+    slashCount += 1;
+  }
+  return slashCount % 2 === 1;
+}
+
+function skipTexComment(text: string, start: number, end: number): number {
+  const newline = text.indexOf("\n", start);
+  const carriageReturn = text.indexOf("\r", start);
+  const lineEnd =
+    newline < 0 ? carriageReturn : carriageReturn < 0 ? newline : Math.min(newline, carriageReturn);
+  if (lineEnd < 0 || lineEnd >= end) return end;
+  return lineEnd + (text[lineEnd] === "\r" && text[lineEnd + 1] === "\n" ? 2 : 1);
+}
+
+function collectLatexMembers(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+): OutlineItem[] {
+  const items: OutlineItem[] = [];
+  for (const child of node.children) {
+    const sectionKind = LATEX_SECTION_KINDS[child.type];
+    if (sectionKind) {
+      items.push(...(extractLatexOutlineItems(child, source, lineStarts) ?? []));
+      continue;
+    }
+
+    const definition = LATEX_DEFINITION_FIELDS[child.type];
+    if (definition) {
+      items.push(...(extractLatexOutlineItems(child, source, lineStarts) ?? []));
+      continue;
+    }
+    items.push(...collectLatexMembers(child, source, lineStarts));
+  }
+  return items;
+}
+
+function findPlainTitleSpan(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+  name: string,
+): { start: { line: number; character: number }; end: { line: number; character: number } } | null {
+  const groupStart = sourceOffsetAt(
+    source,
+    node.startPosition.row,
+    node.startPosition.column,
+    lineStarts,
+  );
+  const groupEnd = sourceOffsetAt(
+    source,
+    node.endPosition.row,
+    node.endPosition.column,
+    lineStarts,
+  );
+  if (source[groupStart] !== "{" || source[groupEnd - 1] !== "}") return null;
+
+  const rawText = source.slice(groupStart + 1, groupEnd - 1);
+  const text = rawText.trim();
+  if (!text || normalizeTitleWhitespace(text) !== name || UNSUPPORTED_TITLE_CHARACTERS.test(text)) {
+    return null;
+  }
+  const startOffset = groupStart + 1 + (rawText.length - rawText.trimStart().length);
+  const endOffset = startOffset + text.length;
+  if (source.slice(startOffset, endOffset) !== text) return null;
+  return {
+    start: sourcePointAtOffset(startOffset, lineStarts),
+    end: sourcePointAtOffset(endOffset, lineStarts),
+  };
+}
+
+function sourcePointAtOffset(
+  offset: number,
+  lineStarts: readonly number[],
+): { line: number; character: number } {
+  let lineIndex = 0;
+  while (lineIndex + 1 < lineStarts.length && (lineStarts[lineIndex + 1] ?? Infinity) <= offset) {
+    lineIndex += 1;
+  }
+  return { line: lineIndex + 1, character: offset - (lineStarts[lineIndex] ?? 0) + 1 };
+}
+
+function normalizeTitleWhitespace(value: string): string {
+  return value.replace(/\s+/gu, " ").trim();
+}
+
+function groupContent(value: string): string {
+  const trimmed = value.trim();
+  const contents =
+    trimmed.startsWith("{") && trimmed.endsWith("}") ? trimmed.slice(1, -1) : trimmed;
+  return contents.replace(/\s+/g, " ").trim();
+}

package/src/tool/outline-polyglot.ts

@@ -4,13 +4,18 @@ import type { OutlineItem } from "../types.ts";
 import { extractCFamilyOutlineItems } from "./outline-c-family.ts";
 import { extractHtmlSqlOutlineItems } from "./outline-html-sql.ts";
 import { extractJvmOutlineItems } from "./outline-jvm.ts";
+import { extractLatexOutlineItems } from "./outline-latex.ts";
 import { extractScriptingOutlineItems } from "./outline-scripting.ts";
 
 /** Extract declarations whose Tree-sitter node shapes are specific to non-JS/TS grammars. */
 export function extractPolyglotOutlineItems(
   node: SyntaxNodeLike,
   source: string,
+  lineStarts: readonly number[],
 ): OutlineItem[] | undefined {
+  const latexItems = extractLatexOutlineItems(node, source, lineStarts);
+  if (latexItems) return latexItems;
+
   const scriptingItems = extractScriptingOutlineItems(node, source);
   if (scriptingItems) return scriptingItems;
 
@@ -35,7 +40,9 @@ export function extractPolyglotOutlineItems(
     case "union_item":
       return one(container(node, "union", source, rustFields));
     case "enum_item":
-      return one(container(node, "enum", source, rustEnumVariants));
+      return node.childForFieldName("name")
+        ? one(container(node, "enum", source, rustEnumVariants))
+        : undefined;
     case "trait_item":
       return one(container(node, "interface", source, rustMethods));
     case "impl_item":

package/src/tool/outline.ts

@@ -26,16 +26,30 @@ const OUTLINE_DECLARATION_NODE_TYPES = new Set([
   "function_signature",
 ]);
 
+function sourceLineStarts(source: string): number[] {
+  const starts = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === "\r" && source[index + 1] === "\n") index += 1;
+    else if (source[index] !== "\r" && source[index] !== "\n") continue;
+    starts.push(index + 1);
+  }
+  return starts;
+}
+
 /** Extract a structural outline from a parsed tree. */
 export function collectOutline(rootNode: SyntaxNodeLike, source: string): OutlineItem[] {
-  return collectItems(rootNode, source);
+  return collectItems(rootNode, source, sourceLineStarts(source));
 }
 
-function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
+function collectItems(
+  node: SyntaxNodeLike,
+  source: string,
+  lineStarts: readonly number[],
+): OutlineItem[] {
   const items: OutlineItem[] = [];
 
   for (const child of node.children) {
-    const polyglotItems = extractPolyglotOutlineItems(child, source);
+    const polyglotItems = extractPolyglotOutlineItems(child, source, lineStarts);
     if (polyglotItems) {
       items.push(...polyglotItems);
       continue;
@@ -43,7 +57,7 @@ function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
 
     const extractedItems = extractItems(child, source);
     if (extractedItems) items.push(...extractedItems);
-    else items.push(...collectItems(child, source));
+    else items.push(...collectItems(child, source, lineStarts));
   }
 
   return items;

package/src/types.ts

@@ -23,6 +23,10 @@ export interface OutlineItem {
   name: string;
   kind: string;
   range: SourceRange;
+  /** Exact 1-based start of the declaration name, when available. */
+  nameAnchor?: { line: number; character: number };
+  /** Exclusive 1-based end of a verified literal name span, when available. */
+  nameEndAnchor?: { line: number; character: number };
   children?: OutlineItem[];
 }
 
@@ -99,7 +103,7 @@ export interface TreeSitterService {
    * HTML ids, and SQL schema members.
    */
   outline(file: string, control?: CodeRequestControl): Promise<TreeSitterResult<OutlineItem[]>>;
-  /** Extract static ES import declarations. */
+  /** Extract import records from JavaScript, TypeScript, TSX, and LaTeX files. */
   imports(file: string, control?: CodeRequestControl): Promise<TreeSitterResult<ImportRecord[]>>;
   /** Extract exported declarations, named exports, re-exports, and TS export assignments. */
   exports(file: string, control?: CodeRequestControl): Promise<TreeSitterResult<ExportRecord[]>>;
@@ -146,7 +150,8 @@ export type GrammarId =
   | "bash"
   | "html"
   | "r"
-  | "sql";
+  | "sql"
+  | "latex";
 
 /** Supported file extension. */
 export type SupportedExtension =
@@ -184,4 +189,7 @@ export type SupportedExtension =
   | ".htm"
   | ".xhtml"
   | ".r"
-  | ".sql";
+  | ".sql"
+  | ".tex"
+  | ".sty"
+  | ".cls";

package/src/worker/process-host.mjs

@@ -0,0 +1,92 @@
+import { Worker } from "node:worker_threads";
+
+const [cwd, generationValue] = process.argv.slice(2);
+const generation = Number(generationValue);
+if (!cwd || !Number.isSafeInteger(generation) || generation < 1) {
+  throw new Error("Structural Worker process received invalid startup data");
+}
+
+const worker = new Worker(new URL("./bootstrap.mjs", import.meta.url), {
+  execArgv: [],
+  workerData: { cwd, generation },
+});
+const cancellationFlags = new Map();
+let closing = false;
+let workerExited = false;
+
+worker.on("message", (message) => {
+  if (message.kind === "terminal") cancellationFlags.delete(message.requestId);
+  send({ channel: "supi-tree-sitter-worker", message });
+});
+worker.on("error", (error) => {
+  send(
+    {
+      channel: "supi-tree-sitter-worker",
+      message: { kind: "worker-error", message: error.message },
+    },
+    () => stopWorker(1),
+  );
+});
+worker.on("exit", (code) => {
+  workerExited = true;
+  cancellationFlags.clear();
+  process.exitCode = code === 0 ? 1 : code;
+  disconnect();
+});
+
+process.on("message", (value) => {
+  if (!isParentChannel(value)) {
+    stopWorker(1);
+    return;
+  }
+  forwardToWorker(value.message);
+});
+process.on("disconnect", () => stopWorker());
+if (!process.connected) stopWorker();
+
+function forwardToWorker(message) {
+  if (!message || typeof message !== "object") {
+    throw new Error("Structural Worker process received an invalid message");
+  }
+  if (message.kind === "request") {
+    if (cancellationFlags.size !== 0) {
+      throw new Error("Structural Worker process received overlapping requests");
+    }
+    // The process host creates the flag that it can share with its Worker thread.
+    const buffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT);
+    cancellationFlags.set(message.requestId, new Int32Array(buffer));
+    worker.postMessage({ ...message, cancellationFlag: buffer });
+    return;
+  }
+  if (message.kind === "cancel") {
+    const cancellationFlag = cancellationFlags.get(message.requestId);
+    if (cancellationFlag) Atomics.store(cancellationFlag, 0, 1);
+  }
+  worker.postMessage(message);
+}
+
+function isParentChannel(value) {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    value.channel === "supi-tree-sitter-parent" &&
+    value.message !== null &&
+    typeof value.message === "object"
+  );
+}
+
+function send(message, callback) {
+  if (process.connected && process.send) process.send(message, callback);
+}
+
+function disconnect() {
+  if (process.connected) process.disconnect();
+}
+
+function stopWorker(exitCode) {
+  if (closing || workerExited) return;
+  closing = true;
+  if (exitCode !== undefined) process.exitCode = exitCode;
+  cancellationFlags.clear();
+  void worker.terminate().finally(disconnect);
+}