@mrclrchtr/supi-tree-sitter 10.0.0 → 11.0.0

package/src/tool/outline-jvm.ts

@@ -20,6 +20,15 @@ export function extractJvmOutlineItems(
       return one(javaContainerItem(node, "interface", source));
     case "module_declaration":
       return one(javaNamed(node, "module", source));
+    case "method_declaration":
+      return one(javaNamed(node, "method", source));
+    case "constructor_declaration":
+      return one(javaNamed(node, "method", source, "constructor"));
+    case "field_declaration":
+    case "constant_declaration":
+      return javaVariables(node, "field", source);
+    case "enum_constant":
+      return one(javaNamed(node, "enum-member", source));
     case "object_declaration":
       return one(kotlinObject(node, source));
     case "function_declaration":
@@ -113,9 +122,16 @@ function javaMemberItems(node: SyntaxNodeLike, ownerName: string, source: string
     case "constant_declaration":
       return javaVariables(node, "field", source);
     case "constructor_declaration":
-      return one(javaNamed(node, "method", source));
+      return one(javaNamed(node, "method", source, "constructor"));
     case "compact_constructor_declaration":
-      return [{ name: ownerName, kind: "method", range: nodeToRange(node, source) }];
+      return [
+        {
+          name: ownerName,
+          kind: "method",
+          nativeKind: "constructor",
+          range: nodeToRange(node, source),
+        },
+      ];
     case "method_declaration":
     case "annotation_type_element_declaration":
       return one(javaNamed(node, "method", source));
@@ -150,9 +166,14 @@ function javaVariables(node: SyntaxNodeLike, kind: string, source: string): Outl
   });
 }
 
-function javaNamed(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+function javaNamed(
+  node: SyntaxNodeLike,
+  kind: string,
+  source: string,
+  nativeKind = kind,
+): OutlineItem | null {
   const name = node.childForFieldName("name");
-  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+  return name ? { name: name.text, kind, nativeKind, range: nodeToRange(node, source) } : null;
 }
 
 function kotlinClass(node: SyntaxNodeLike, source: string): OutlineItem | null {

package/src/tool/outline-nested.ts

@@ -0,0 +1,390 @@
+// Nested declaration expansion and native-kind metadata for selected grammars.
+
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { GrammarId, OutlineItem } from "../types.ts";
+
+type NestedOutlineOptions = {
+  readonly items: OutlineItem[];
+  readonly node: SyntaxNodeLike;
+  readonly source: string;
+  readonly lineStarts: readonly number[];
+  readonly grammarId?: GrammarId;
+  readonly extractItemsForNode: (node: SyntaxNodeLike) => OutlineItem[] | null;
+};
+
+/** Add named nested declarations while preserving the current shallow outline contract. */
+export function expandNestedItems(options: NestedOutlineOptions): OutlineItem[] {
+  const { items, node, source, lineStarts, grammarId } = options;
+  if (!grammarId || !EXPANDED_OUTLINE_GRAMMARS.has(grammarId)) return items;
+  return items.map((item) => {
+    const nativeKind = item.nativeKind ?? nativeDeclarationKind(item, node, grammarId);
+    const nested = NESTED_SCOPE_OWNER_TYPES[grammarId]?.has(node.type)
+      ? collectNestedDeclarations({
+          owner: node,
+          source,
+          lineStarts,
+          grammarId,
+          extractItemsForNode: options.extractItemsForNode,
+        })
+      : [];
+    const children = mergeOutlineChildren(item.children ?? [], nested).map(addDefaultNativeKind);
+    return {
+      ...item,
+      nativeKind,
+      ...(children.length > 0 ? { children } : {}),
+    };
+  });
+}
+
+function collectNestedDeclarations(options: {
+  readonly owner: SyntaxNodeLike;
+  readonly source: string;
+  readonly lineStarts: readonly number[];
+  readonly grammarId: GrammarId;
+  readonly extractItemsForNode: (node: SyntaxNodeLike) => OutlineItem[] | null;
+}): OutlineItem[] {
+  const { owner, source, lineStarts, grammarId, extractItemsForNode } = options;
+  const result: OutlineItem[] = [];
+  const visit = (node: SyntaxNodeLike): void => {
+    for (const child of node.children) {
+      if (isNestedDeclaration(child, owner, grammarId)) {
+        const items = extractItemsForNode(child);
+        const namedItems = (items ?? []).filter(
+          (item) => item.name.length > 0 && item.name !== "<anonymous>",
+        );
+        if (namedItems.length > 0) {
+          result.push(
+            ...expandNestedItems({
+              items: namedItems,
+              node: child,
+              source,
+              lineStarts,
+              grammarId,
+              extractItemsForNode,
+            }),
+          );
+          continue;
+        }
+      }
+      visit(child);
+    }
+  };
+  visit(owner);
+  return result;
+}
+
+function isNestedDeclaration(
+  node: SyntaxNodeLike,
+  owner: SyntaxNodeLike,
+  grammarId: GrammarId,
+): boolean {
+  const allowed = NESTED_DECLARATION_TYPES[grammarId];
+  if (!allowed?.has(node.type)) return false;
+  if (grammarId === "java" && node.type === "field_declaration") {
+    return isJavaAnonymousClassField(node, owner);
+  }
+  if (node.type === "declaration" && (grammarId === "c" || grammarId === "cpp")) {
+    let parent = node.parent;
+    while (parent && parent !== owner) {
+      if (
+        [
+          "field_declaration_list",
+          "field_declaration_list_item",
+          "class_specifier",
+          "struct_specifier",
+          "union_specifier",
+        ].includes(parent.type)
+      ) {
+        return true;
+      }
+      parent = parent.parent;
+    }
+    return false;
+  }
+  return true;
+}
+
+/** Named class fields are already in the shallow outline; add only anonymous-class fields here. */
+function isJavaAnonymousClassField(node: SyntaxNodeLike, owner: SyntaxNodeLike): boolean {
+  let parent = node.parent;
+  while (parent && parent !== owner) {
+    if (parent.type === "class_body") {
+      const container = parent.parent?.type;
+      return container === "object_creation_expression" || container === "enum_constant";
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+
+function mergeOutlineChildren(
+  existing: readonly OutlineItem[],
+  nested: readonly OutlineItem[],
+): OutlineItem[] {
+  const merged = [...existing];
+  for (const item of nested) {
+    const index = merged.findIndex((entry) => sameOutlineSource(entry, item));
+    if (index < 0) merged.push(item);
+    else {
+      const previous = merged[index];
+      merged[index] = {
+        ...previous,
+        nativeKind: item.nativeKind ?? previous.nativeKind,
+        ...(item.children?.length
+          ? { children: mergeOutlineChildren(previous.children ?? [], item.children) }
+          : {}),
+      };
+    }
+  }
+  return merged.sort(
+    (left, right) =>
+      left.range.startLine - right.range.startLine ||
+      left.range.startCharacter - right.range.startCharacter,
+  );
+}
+
+function addDefaultNativeKind(item: OutlineItem): OutlineItem {
+  return {
+    ...item,
+    nativeKind: item.nativeKind ?? item.kind,
+    ...(item.children ? { children: item.children.map(addDefaultNativeKind) } : {}),
+  };
+}
+
+function sameOutlineSource(left: OutlineItem, right: OutlineItem): boolean {
+  return (
+    left.name === right.name &&
+    left.range.startLine === right.range.startLine &&
+    left.range.startCharacter === right.range.startCharacter &&
+    left.range.endLine === right.range.endLine &&
+    left.range.endCharacter === right.range.endCharacter
+  );
+}
+
+function nativeDeclarationKind(
+  item: OutlineItem,
+  node: SyntaxNodeLike,
+  grammarId: GrammarId,
+): string {
+  if (grammarId === "rust" && node.type === "trait_item") return "trait";
+  if (grammarId === "java" && node.type === "record_declaration") return "record";
+  if (grammarId === "go" && node.type === "type_spec") {
+    const definition = node.childForFieldName("type");
+    if (definition?.type === "struct_type") return "struct";
+    if (definition?.type === "interface_type") return "interface";
+  }
+  const nativeKinds: Readonly<Record<string, string>> = {
+    function_definition: "function",
+    function_declaration: "function",
+    function_item: "function",
+    class_declaration: "class",
+    class_definition: "class",
+    class_specifier: "class",
+    struct_item: "struct",
+    struct_specifier: "struct",
+    union_item: "union",
+    union_specifier: "union",
+    enum_item: "enum",
+    enum_specifier: "enum",
+    interface_declaration: "interface",
+    method_declaration: "method",
+    method_definition: "method",
+    constructor_declaration: "constructor",
+    type_alias: "type alias",
+    type_item: "type alias",
+    type_alias_declaration: "type alias",
+    alias_declaration: "type alias",
+    type_definition: "typedef",
+  };
+  return nativeKinds[node.type] ?? item.kind;
+}
+
+const EXPANDED_OUTLINE_GRAMMARS: ReadonlySet<GrammarId> = new Set([
+  "javascript",
+  "typescript",
+  "tsx",
+  "python",
+  "java",
+  "go",
+  "rust",
+  "c",
+  "cpp",
+]);
+
+const NESTED_SCOPE_OWNER_TYPES: Partial<Record<GrammarId, ReadonlySet<string>>> = {
+  javascript: new Set([
+    "field_definition",
+    "function_declaration",
+    "generator_function_declaration",
+    "function_expression",
+    "generator_function",
+    "arrow_function",
+    "class_declaration",
+    "abstract_class_declaration",
+    "class_expression",
+    "method_definition",
+    "interface_declaration",
+    "enum_declaration",
+    "internal_module",
+    "module",
+    "variable_declarator",
+  ]),
+  typescript: new Set([
+    "public_field_definition",
+    "function_declaration",
+    "generator_function_declaration",
+    "function_expression",
+    "generator_function",
+    "arrow_function",
+    "class_declaration",
+    "abstract_class_declaration",
+    "class_expression",
+    "method_definition",
+    "interface_declaration",
+    "enum_declaration",
+    "internal_module",
+    "module",
+    "variable_declarator",
+  ]),
+  tsx: new Set([
+    "public_field_definition",
+    "function_declaration",
+    "generator_function_declaration",
+    "function_expression",
+    "generator_function",
+    "arrow_function",
+    "class_declaration",
+    "abstract_class_declaration",
+    "class_expression",
+    "method_definition",
+    "interface_declaration",
+    "enum_declaration",
+    "internal_module",
+    "module",
+    "variable_declarator",
+  ]),
+  python: new Set(["function_definition", "class_definition"]),
+  java: new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration",
+    "annotation_type_declaration",
+    "method_declaration",
+    "constructor_declaration",
+  ]),
+  go: new Set(["function_declaration", "method_declaration", "type_spec"]),
+  rust: new Set([
+    "function_item",
+    "struct_item",
+    "union_item",
+    "enum_item",
+    "trait_item",
+    "impl_item",
+    "mod_item",
+  ]),
+  c: new Set([
+    "function_definition",
+    "class_specifier",
+    "struct_specifier",
+    "union_specifier",
+    "enum_specifier",
+  ]),
+  cpp: new Set([
+    "function_definition",
+    "class_specifier",
+    "struct_specifier",
+    "union_specifier",
+    "enum_specifier",
+    "namespace_definition",
+  ]),
+};
+
+const NESTED_DECLARATION_TYPES: Partial<Record<GrammarId, ReadonlySet<string>>> = {
+  javascript: new Set([
+    "field_definition",
+    "function_declaration",
+    "generator_function_declaration",
+    "class_declaration",
+    "abstract_class_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+    "enum_declaration",
+    "method_definition",
+    "public_field_definition",
+    "function_signature",
+    "internal_module",
+    "module",
+  ]),
+  typescript: new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "class_declaration",
+    "abstract_class_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+    "enum_declaration",
+    "method_definition",
+    "public_field_definition",
+    "function_signature",
+    "internal_module",
+    "module",
+  ]),
+  tsx: new Set([
+    "function_declaration",
+    "generator_function_declaration",
+    "class_declaration",
+    "abstract_class_declaration",
+    "interface_declaration",
+    "type_alias_declaration",
+    "enum_declaration",
+    "method_definition",
+    "public_field_definition",
+    "function_signature",
+    "internal_module",
+    "module",
+  ]),
+  python: new Set(["function_definition", "class_definition"]),
+  java: new Set([
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration",
+    "annotation_type_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "field_declaration",
+  ]),
+  go: new Set(["function_declaration", "method_declaration", "type_spec", "type_alias"]),
+  rust: new Set([
+    "function_item",
+    "struct_item",
+    "union_item",
+    "enum_item",
+    "trait_item",
+    "impl_item",
+    "const_item",
+    "static_item",
+    "type_item",
+    "mod_item",
+  ]),
+  c: new Set([
+    "function_definition",
+    "class_specifier",
+    "struct_specifier",
+    "union_specifier",
+    "enum_specifier",
+    "type_definition",
+  ]),
+  cpp: new Set([
+    "function_definition",
+    "class_specifier",
+    "struct_specifier",
+    "union_specifier",
+    "enum_specifier",
+    "type_definition",
+    "alias_declaration",
+    "concept_definition",
+    "namespace_definition",
+  ]),
+};

package/src/tool/outline.ts

@@ -2,30 +2,11 @@
 
 import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
-import type { OutlineItem } from "../types.ts";
+import type { GrammarId, OutlineItem } from "../types.ts";
 import { extractBindingIdentifiers } from "./js-binding-pattern.ts";
+import { expandExtractedItems, OUTLINE_DECLARATION_NODE_TYPES } from "./outline-expansion.ts";
 import { extractPolyglotOutlineItems } from "./outline-polyglot.ts";
 
-/** Node types that can be extracted directly as outline items. */
-const OUTLINE_DECLARATION_NODE_TYPES = new Set([
-  "function_declaration",
-  "generator_function_declaration",
-  "class_declaration",
-  "abstract_class_declaration",
-  "class",
-  "interface_declaration",
-  "type_alias_declaration",
-  "enum_declaration",
-  "method_definition",
-  "public_field_definition",
-  "variable_declarator",
-  "lexical_declaration",
-  "ambient_declaration",
-  "internal_module",
-  "module",
-  "function_signature",
-]);
-
 function sourceLineStarts(source: string): number[] {
   const starts = [0];
   for (let index = 0; index < source.length; index += 1) {
@@ -37,27 +18,55 @@ function sourceLineStarts(source: string): number[] {
 }
 
 /** Extract a structural outline from a parsed tree. */
-export function collectOutline(rootNode: SyntaxNodeLike, source: string): OutlineItem[] {
-  return collectItems(rootNode, source, sourceLineStarts(source));
+export function collectOutline(
+  rootNode: SyntaxNodeLike,
+  source: string,
+  grammarId?: GrammarId,
+): OutlineItem[] {
+  return collectItems(rootNode, source, sourceLineStarts(source), grammarId);
 }
 
 function collectItems(
   node: SyntaxNodeLike,
   source: string,
   lineStarts: readonly number[],
+  grammarId?: GrammarId,
 ): OutlineItem[] {
   const items: OutlineItem[] = [];
 
   for (const child of node.children) {
     const polyglotItems = extractPolyglotOutlineItems(child, source, lineStarts);
     if (polyglotItems) {
-      items.push(...polyglotItems);
+      items.push(
+        ...expandExtractedItems({
+          items: polyglotItems,
+          node: child,
+          source,
+          lineStarts,
+          grammarId,
+          extractItemsForNode: (nested) =>
+            extractPolyglotOutlineItems(nested, source, lineStarts) ?? extractItems(nested, source),
+        }),
+      );
       continue;
     }
 
     const extractedItems = extractItems(child, source);
-    if (extractedItems) items.push(...extractedItems);
-    else items.push(...collectItems(child, source, lineStarts));
+    if (extractedItems) {
+      items.push(
+        ...expandExtractedItems({
+          items: extractedItems,
+          node: child,
+          source,
+          lineStarts,
+          grammarId,
+          extractItemsForNode: (nested) =>
+            extractPolyglotOutlineItems(nested, source, lineStarts) ?? extractItems(nested, source),
+        }),
+      );
+    } else {
+      items.push(...collectItems(child, source, lineStarts, grammarId));
+    }
   }
 
   return items;
@@ -93,6 +102,7 @@ function extractItem(node: SyntaxNodeLike, source: string): OutlineItem | null {
     case "method_definition":
       return extractNamedDeclaration(node, "method", source);
     case "public_field_definition":
+    case "field_definition":
       return extractFieldDefinition(node, source);
     case "variable_declarator":
       return extractVariableDeclaratorItems(node, source)[0] ?? null;
@@ -113,7 +123,14 @@ function extractExportStatement(node: SyntaxNodeLike, source: string): OutlineIt
     if (decl.type === "lexical_declaration") return extractLexicalDeclarationItems(decl, source);
     if (decl.type === "ambient_declaration") return extractAmbientDeclarationItems(decl, source);
     const item = extractItem(decl, source);
-    if (item) return [item];
+    if (item) {
+      return [
+        {
+          ...item,
+          nativeKind: decl.type === "type_alias_declaration" ? "type alias" : item.kind,
+        },
+      ];
+    }
   }
 
   if (hasDefaultKeyword(node)) {
@@ -232,7 +249,11 @@ function collectClassMembers(node: SyntaxNodeLike, source: string): OutlineItem[
 
   const items: OutlineItem[] = [];
   for (const child of body.children) {
-    if (child.type !== "method_definition" && child.type !== "public_field_definition") continue;
+    if (
+      !["method_definition", "public_field_definition", "field_definition"].includes(child.type)
+    ) {
+      continue;
+    }
     const item = extractItem(child, source);
     if (item) items.push(item);
   }

package/src/types.ts

@@ -13,6 +13,16 @@ export interface SourceRange {
 /** Discriminated result union for all service operations. */
 export type TreeSitterResult<T> =
   | { kind: "success"; data: T }
+  | {
+      kind: "partial";
+      data: T;
+      /** Affected source file. */
+      file: string;
+      /** Why recovered syntax may hide structural evidence. */
+      reason: string;
+      /** Available syntax error and missing-node ranges, in 1-based UTF-16 coordinates. */
+      errorRanges: SourceRange[];
+    }
   | { kind: "unsupported-language"; file: string; message: string }
   | { kind: "file-access-error"; file: string; message: string }
   | { kind: "validation-error"; message: string }
@@ -21,7 +31,10 @@ export type TreeSitterResult<T> =
 /** Structural outline item. */
 export interface OutlineItem {
   name: string;
+  /** Common structural search category. */
   kind: string;
+  /** Source-language declaration kind, separate from common search category. */
+  nativeKind?: string;
   range: SourceRange;
   /** Exact 1-based start of the declaration name, when available. */
   nameAnchor?: { line: number; character: number };
@@ -79,6 +92,9 @@ export interface QueryCapture {
 export interface CallSiteMatch {
   name: string;
   startLine: number;
+  startCharacter: number;
+  endLine: number;
+  endCharacter: number;
 }
 
 /**