@mrclrchtr/supi-code-intelligence 4.0.0 → 4.2.0

package/node_modules/@mrclrchtr/supi-tree-sitter/src/syntax-node.ts

@@ -10,4 +10,5 @@ export interface SyntaxNodeLike {
   startPosition: { row: number; column: number };
   endPosition: { row: number; column: number };
   childForFieldName(name: string): SyntaxNodeLike | null;
+  childrenForFieldName(name: string): SyntaxNodeLike[];
 }

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline-c-family.ts

@@ -0,0 +1,230 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract C and C++ declarations from their grammar-specific node shapes. */
+export function extractCFamilyOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  switch (node.type) {
+    case "class_specifier":
+      return one(typeContainer(node, "class", source));
+    case "struct_specifier":
+      return one(typeContainer(node, "struct", source));
+    case "union_specifier":
+      return one(typeContainer(node, "union", source));
+    case "enum_specifier":
+      return one(enumContainer(node, source));
+    case "type_definition":
+      return typeDefinitions(node, source);
+    case "alias_declaration":
+      return one(named(node, "type", source));
+    case "concept_definition":
+      return one(named(node, "concept", source));
+    case "namespace_definition": {
+      const item = namespaceItem(node, source);
+      return item ? [item] : collectDeclarations(node.childForFieldName("body"), source);
+    }
+    case "function_definition":
+      return one(declaratorItem(node, "function", source));
+    case "declaration":
+      return declarationItems(node, "variable", "function", source);
+    default:
+      return undefined;
+  }
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function named(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+function typeContainer(
+  node: SyntaxNodeLike,
+  kind: "class" | "struct" | "union",
+  source: string,
+): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: collectTypeMembers(node.childForFieldName("body"), source),
+  };
+}
+
+function enumContainer(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind: "enum",
+    range: nodeToRange(node, source),
+    children: enumMembers(node, source),
+  };
+}
+
+function enumMembers(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("body");
+  return (
+    body?.children.flatMap((child) =>
+      child.type === "enumerator" ? one(named(child, "enum-member", source)) : [],
+    ) ?? []
+  );
+}
+
+function typeDefinitions(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const type = node.childForFieldName("type");
+  const kind = cTypeKind(type?.type);
+  const aliases = declaratorNodes(node).flatMap((declarator) => declaratorNames(declarator));
+  if (aliases.length === 0) return [];
+  const range = nodeToRange(node, source);
+  const children =
+    kind === "enum" && type
+      ? enumMembers(type, source)
+      : type
+        ? collectTypeMembers(type.childForFieldName("body"), source)
+        : undefined;
+  return aliases.map((name) => ({ name, kind, range, ...(children ? { children } : {}) }));
+}
+
+function cTypeKind(type: string | undefined): string {
+  switch (type) {
+    case "class_specifier":
+      return "class";
+    case "struct_specifier":
+      return "struct";
+    case "union_specifier":
+      return "union";
+    case "enum_specifier":
+      return "enum";
+    default:
+      return "type";
+  }
+}
+
+function namespaceItem(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind: "namespace",
+    range: nodeToRange(node, source),
+    children: collectDeclarations(node.childForFieldName("body"), source),
+  };
+}
+
+function collectDeclarations(
+  parent: SyntaxNodeLike | null | undefined,
+  source: string,
+): OutlineItem[] {
+  if (!parent) return [];
+  return parent.children.flatMap((child) => {
+    const items = extractCFamilyOutlineItems(child, source);
+    return items ?? collectDeclarations(child, source);
+  });
+}
+
+function collectTypeMembers(
+  body: SyntaxNodeLike | null | undefined,
+  source: string,
+): OutlineItem[] {
+  if (!body) return [];
+  return body.children.flatMap((child) => typeMemberItems(child, source));
+}
+
+function typeMemberItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  switch (node.type) {
+    case "field_declaration":
+    case "declaration":
+      return declarationItems(node, "field", "method", source);
+    case "function_definition":
+      return one(declaratorItem(node, "method", source));
+    case "class_specifier":
+      return one(typeContainer(node, "class", source));
+    case "struct_specifier":
+      return one(typeContainer(node, "struct", source));
+    case "union_specifier":
+      return one(typeContainer(node, "union", source));
+    case "enum_specifier":
+      return one(enumContainer(node, source));
+    case "type_definition":
+      return typeDefinitions(node, source);
+    case "alias_declaration":
+      return one(named(node, "type", source));
+    case "friend_declaration":
+      return [];
+    default:
+      return node.children.flatMap((child) => typeMemberItems(child, source));
+  }
+}
+
+function declarationItems(
+  node: SyntaxNodeLike,
+  valueKind: string,
+  functionKind: string,
+  source: string,
+): OutlineItem[] {
+  const range = nodeToRange(node, source);
+  return declaratorNodes(node).flatMap((declarator) =>
+    declaratorNames(declarator).map((name) => ({
+      name,
+      kind: isFunctionDeclarator(declarator) ? functionKind : valueKind,
+      range,
+    })),
+  );
+}
+
+function declaratorItem(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const declarator = node.childForFieldName("declarator");
+  const name = declarator ? declaratorNames(declarator)[0] : undefined;
+  return name ? { name, kind, range: nodeToRange(node, source) } : null;
+}
+
+function declaratorNodes(node: SyntaxNodeLike): SyntaxNodeLike[] {
+  const declarators = node.childrenForFieldName("declarator");
+  if (declarators.length > 0) return declarators;
+  const declarator = node.childForFieldName("declarator");
+  return declarator ? [declarator] : [];
+}
+
+function declaratorNames(node: SyntaxNodeLike): string[] {
+  if (DECLARATOR_NAME_TYPES.has(node.type)) return [node.text];
+  if (node.type === "structured_binding_declarator") {
+    return node.children.filter((child) => child.type === "identifier").map((child) => child.text);
+  }
+  const nested = node.childrenForFieldName("declarator");
+  if (nested.length > 0) return nested.flatMap(declaratorNames);
+  const declarator = node.childForFieldName("declarator");
+  return declarator ? declaratorNames(declarator) : [];
+}
+
+function isFunctionDeclarator(node: SyntaxNodeLike): boolean {
+  if (node.type === "function_declarator") {
+    const subject = node.childForFieldName("declarator");
+    return subject?.type !== "parenthesized_declarator" || !containsPointer(subject);
+  }
+  const declarator = node.childForFieldName("declarator");
+  return declarator ? isFunctionDeclarator(declarator) : false;
+}
+
+function containsPointer(node: SyntaxNodeLike): boolean {
+  if (node.type === "pointer_declarator" || node.type === "reference_declarator") return true;
+  return node.children.some(containsPointer);
+}
+
+const DECLARATOR_NAME_TYPES = new Set([
+  "identifier",
+  "field_identifier",
+  "type_identifier",
+  "qualified_identifier",
+  "template_function",
+  "operator_name",
+  "destructor_name",
+]);

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline-html-sql.ts

@@ -0,0 +1,186 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract HTML id declarations and SQL schema declarations. */
+export function extractHtmlSqlOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  if (HTML_ELEMENT_TYPES.has(node.type)) return htmlElementItems(node, source);
+
+  switch (node.type) {
+    case "create_schema":
+      return one(sqlItem(node, "schema", source, sqlSchemaChildren(node, source)));
+    case "create_type":
+      return one(sqlType(node, source));
+    case "create_table":
+      return one(sqlItem(node, "table", source, sqlColumns(node, source)));
+    case "create_view":
+    case "create_materialized_view":
+      return one(sqlItem(node, "view", source));
+    case "create_index":
+      return one(sqlItem(node, "index", source));
+    case "create_sequence":
+      return one(sqlItem(node, "sequence", source));
+    case "create_function":
+      return one(sqlItem(node, "function", source));
+    case "create_trigger":
+      return one(sqlItem(node, "trigger", source));
+    case "create_database":
+      return one(sqlItem(node, "database", source));
+    case "create_role":
+      return one(sqlItem(node, "role", source));
+    case "create_extension":
+      return one(sqlItem(node, "extension", source));
+    default:
+      return undefined;
+  }
+}
+
+function htmlElementItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const children = node.children.flatMap((child) =>
+    HTML_ELEMENT_TYPES.has(child.type) ? htmlElementItems(child, source) : [],
+  );
+  const tag = node.type === "self_closing_tag" ? node : directChild(node, "start_tag");
+  const id = tag && htmlId(tag);
+  if (!id) return children;
+  return [
+    {
+      name: id,
+      kind: "element",
+      range: nodeToRange(node, source),
+      children,
+    },
+  ];
+}
+
+function htmlId(tag: SyntaxNodeLike): string | null {
+  for (const attribute of tag.children) {
+    if (attribute.type !== "attribute") continue;
+    const name = directChild(attribute, "attribute_name");
+    if (name?.text.toLowerCase() !== "id") continue;
+    return firstDescendant(attribute, "attribute_value")?.text || null;
+  }
+  return null;
+}
+
+function firstDescendant(node: SyntaxNodeLike, type: string): SyntaxNodeLike | null {
+  for (const child of node.children) {
+    if (child.type === type) return child;
+    const nested = firstDescendant(child, type);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+function sqlType(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const enumElements = directChild(node, "enum_elements");
+  const children = enumElements
+    ? enumElements.children
+        .filter((child) => child.type === "literal")
+        .map((child) => ({
+          name: stripSqlQuotes(child.text),
+          kind: "enum-member",
+          range: nodeToRange(child, source),
+        }))
+    : sqlColumns(node, source);
+  return sqlItem(node, enumElements ? "enum" : "type", source, children);
+}
+
+function sqlColumns(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const definitions = node.children.flatMap((child) => {
+    if (child.type === "column_definitions") return [child];
+    if (child.type !== "table_partition") return [];
+    return child.children.filter((nested) => nested.type === "column_definitions");
+  });
+  return definitions.flatMap((group) =>
+    group.children.flatMap((child) => {
+      if (child.type === "column_definition") {
+        return [...one(sqlMember(child, "field", source)), ...sqlInlineConstraints(child, source)];
+      }
+      if (child.type === "constraints") {
+        return child.children.flatMap((constraint) =>
+          constraint.type === "constraint" ? one(sqlMember(constraint, "constraint", source)) : [],
+        );
+      }
+      return [];
+    }),
+  );
+}
+
+function sqlInlineConstraints(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const marker = node.children.findIndex((child) => child.type === "keyword_constraint");
+  if (marker < 0) return [];
+  const name = node.children.slice(marker + 1).find((child) => child.type === "literal");
+  return name
+    ? [{ name: stripSqlQuotes(name.text), kind: "constraint", range: nodeToRange(name, source) }]
+    : [];
+}
+
+function sqlSchemaChildren(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  return node.children.flatMap((child) => extractHtmlSqlOutlineItems(child, source) ?? []);
+}
+
+function sqlItem(
+  node: SyntaxNodeLike,
+  kind: string,
+  source: string,
+  children?: OutlineItem[],
+): OutlineItem | null {
+  const name = sqlDeclarationName(node);
+  if (!name) return null;
+  return {
+    name,
+    kind,
+    range: nodeToRange(node, source),
+    ...(children ? { children } : {}),
+  };
+}
+
+function sqlMember(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name") ?? directChild(node, "identifier");
+  return name ? { name: stripSqlQuotes(name.text), kind, range: nodeToRange(node, source) } : null;
+}
+
+function sqlDeclarationName(node: SyntaxNodeLike): string | null {
+  if (node.type === "create_index") {
+    const indexName = node.childForFieldName("column");
+    return indexName ? stripSqlQuotes(indexName.text) : null;
+  }
+  const reference = directChild(node, "object_reference");
+  if (reference) {
+    const name = reference.childForFieldName("name") ?? lastDirectChild(reference, "identifier");
+    if (name) return name.text;
+  }
+  return directChild(node, "identifier")?.text ?? null;
+}
+
+function directChild(node: SyntaxNodeLike, type: string): SyntaxNodeLike | null {
+  return node.children.find((child) => child.type === type) ?? null;
+}
+
+function lastDirectChild(node: SyntaxNodeLike, type: string): SyntaxNodeLike | null {
+  for (let index = node.children.length - 1; index >= 0; index -= 1) {
+    const child = node.children[index];
+    if (child?.type === type) return child;
+  }
+  return null;
+}
+
+function stripSqlQuotes(value: string): string {
+  return value.startsWith("'") && value.endsWith("'")
+    ? value.slice(1, -1).replaceAll("''", "'")
+    : value;
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+const HTML_ELEMENT_TYPES = new Set([
+  "element",
+  "script_element",
+  "self_closing_tag",
+  "style_element",
+]);