@mrclrchtr/supi-code-intelligence 4.1.0 → 4.2.0

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",
+]);

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

@@ -0,0 +1,311 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract Java and Kotlin declarations from their grammar-specific node shapes. */
+export function extractJvmOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  switch (node.type) {
+    case "class_declaration":
+      return classDeclaration(node, source);
+    case "interface_declaration":
+      return javaContainer(node, "interface", source);
+    case "enum_declaration":
+      return javaContainer(node, "enum", source);
+    case "record_declaration":
+      return one(javaRecord(node, source));
+    case "annotation_type_declaration":
+      return one(javaContainerItem(node, "interface", source));
+    case "module_declaration":
+      return one(javaNamed(node, "module", source));
+    case "object_declaration":
+      return one(kotlinObject(node, source));
+    case "function_declaration":
+      return kotlinFunction(node, "function", source);
+    case "property_declaration":
+      return kotlinProperties(node, undefined, source);
+    default:
+      return undefined;
+  }
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function classDeclaration(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  if (!node.childForFieldName("name") && directChild(node, "type_identifier")) {
+    return one(kotlinClass(node, source));
+  }
+  const body = node.childForFieldName("body");
+  if (!body?.children.some((child) => JAVA_CLASS_MEMBER_TYPES.has(child.type))) {
+    return undefined;
+  }
+  return one(javaContainerItem(node, "class", source));
+}
+
+function javaContainer(
+  node: SyntaxNodeLike,
+  kind: "interface" | "enum",
+  source: string,
+): OutlineItem[] | undefined {
+  const body = node.childForFieldName("body");
+  if (!body?.children.some((child) => JAVA_CONTAINER_MEMBER_TYPES.has(child.type))) {
+    return undefined;
+  }
+  return one(javaContainerItem(node, kind, source));
+}
+
+function javaContainerItem(
+  node: SyntaxNodeLike,
+  kind: "class" | "interface" | "enum",
+  source: string,
+): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: javaMembers(node.childForFieldName("body"), name.text, source),
+  };
+}
+
+function javaRecord(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind: "record",
+    range: nodeToRange(node, source),
+    children: [
+      ...javaRecordFields(node.childForFieldName("parameters"), source),
+      ...javaMembers(node.childForFieldName("body"), name.text, source),
+    ],
+  };
+}
+
+function javaRecordFields(
+  parameters: SyntaxNodeLike | null | undefined,
+  source: string,
+): OutlineItem[] {
+  if (!parameters) return [];
+  return parameters.children.flatMap((child) => {
+    if (child.type !== "formal_parameter" && child.type !== "spread_parameter") return [];
+    return one(javaNamed(child, "field", source));
+  });
+}
+
+function javaMembers(
+  parent: SyntaxNodeLike | null | undefined,
+  ownerName: string,
+  source: string,
+): OutlineItem[] {
+  if (!parent) return [];
+  return parent.children.flatMap((child) => javaMemberItems(child, ownerName, source));
+}
+
+function javaMemberItems(node: SyntaxNodeLike, ownerName: string, source: string): OutlineItem[] {
+  switch (node.type) {
+    case "field_declaration":
+    case "constant_declaration":
+      return javaVariables(node, "field", source);
+    case "constructor_declaration":
+      return one(javaNamed(node, "method", source));
+    case "compact_constructor_declaration":
+      return [{ name: ownerName, kind: "method", range: nodeToRange(node, source) }];
+    case "method_declaration":
+    case "annotation_type_element_declaration":
+      return one(javaNamed(node, "method", source));
+    case "enum_constant":
+      return one(javaNamed(node, "enum-member", source));
+    case "enum_body_declarations":
+      return javaMembers(node, ownerName, source);
+    case "class_declaration":
+      return one(javaContainerItem(node, "class", source) ?? javaNamed(node, "class", source));
+    case "interface_declaration":
+      return one(
+        javaContainerItem(node, "interface", source) ?? javaNamed(node, "interface", source),
+      );
+    case "enum_declaration":
+      return one(javaContainerItem(node, "enum", source) ?? javaNamed(node, "enum", source));
+    case "record_declaration":
+      return one(javaRecord(node, source));
+    case "annotation_type_declaration":
+      return one(
+        javaContainerItem(node, "interface", source) ?? javaNamed(node, "interface", source),
+      );
+    default:
+      return [];
+  }
+}
+
+function javaVariables(node: SyntaxNodeLike, kind: string, source: string): OutlineItem[] {
+  const range = nodeToRange(node, source);
+  return node.childrenForFieldName("declarator").flatMap((declarator) => {
+    const name = declarator.childForFieldName("name");
+    return name ? [{ name: name.text, kind, range }] : [];
+  });
+}
+
+function javaNamed(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 kotlinClass(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = directChild(node, "type_identifier");
+  if (!name) return null;
+  const kind = hasDirectToken(node, "interface")
+    ? "interface"
+    : hasDirectToken(node, "enum")
+      ? "enum"
+      : "class";
+  const body = node.children.find(
+    (child) => child.type === "class_body" || child.type === "enum_class_body",
+  );
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: [...kotlinConstructorFields(node, source), ...kotlinMembers(body, name.text, source)],
+  };
+}
+
+function kotlinObject(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = directChild(node, "type_identifier");
+  if (!name) return null;
+  const body = directChild(node, "class_body");
+  return {
+    name: name.text,
+    kind: "object",
+    range: nodeToRange(node, source),
+    children: kotlinMembers(body, name.text, source),
+  };
+}
+
+function kotlinCompanion(node: SyntaxNodeLike, source: string): OutlineItem {
+  const name = directChild(node, "type_identifier")?.text ?? "Companion";
+  return {
+    name,
+    kind: "object",
+    range: nodeToRange(node, source),
+    children: kotlinMembers(directChild(node, "class_body"), name, source),
+  };
+}
+
+function kotlinMembers(
+  parent: SyntaxNodeLike | null | undefined,
+  ownerName: string,
+  source: string,
+): OutlineItem[] {
+  if (!parent) return [];
+  return parent.children.flatMap((child) => {
+    switch (child.type) {
+      case "property_declaration":
+        return kotlinProperties(child, "field", source);
+      case "function_declaration":
+        return kotlinFunction(child, "method", source) ?? [];
+      case "secondary_constructor":
+        return [{ name: ownerName, kind: "method", range: nodeToRange(child, source) }];
+      case "class_declaration":
+        return one(kotlinClass(child, source));
+      case "object_declaration":
+        return one(kotlinObject(child, source));
+      case "companion_object":
+        return [kotlinCompanion(child, source)];
+      case "type_alias":
+        return one(kotlinTypeAlias(child, source));
+      case "enum_entry":
+        return one(kotlinSimpleNamed(child, "enum-member", source));
+      default:
+        return [];
+    }
+  });
+}
+
+function kotlinConstructorFields(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const primaryConstructor = directChild(node, "primary_constructor");
+  if (!primaryConstructor) return [];
+  return primaryConstructor.children.flatMap((child) => {
+    if (child.type !== "class_parameter" || !directChild(child, "binding_pattern_kind")) return [];
+    return one(kotlinSimpleNamed(child, "field", source));
+  });
+}
+
+function kotlinFunction(
+  node: SyntaxNodeLike,
+  kind: "function" | "method",
+  source: string,
+): OutlineItem[] | undefined {
+  if (node.childForFieldName("name")) return undefined;
+  return one(kotlinSimpleNamed(node, kind, source));
+}
+
+function kotlinProperties(
+  node: SyntaxNodeLike,
+  memberKind: "field" | undefined,
+  source: string,
+): OutlineItem[] {
+  const kind = memberKind ?? (containsToken(node, "const") ? "constant" : "variable");
+  const declarations = node.children.filter(
+    (child) => child.type === "variable_declaration" || child.type === "multi_variable_declaration",
+  );
+  const range = nodeToRange(node, source);
+  return declarations.flatMap((declaration) =>
+    simpleIdentifiers(declaration).map((name) => ({ name, kind, range })),
+  );
+}
+
+function kotlinTypeAlias(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const name = directChild(node, "type_identifier");
+  return name ? { name: name.text, kind: "type", range: nodeToRange(node, source) } : null;
+}
+
+function kotlinSimpleNamed(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = directChild(node, "simple_identifier");
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+function simpleIdentifiers(node: SyntaxNodeLike): string[] {
+  if (node.type === "simple_identifier") return [node.text];
+  return node.children.flatMap(simpleIdentifiers);
+}
+
+function directChild(node: SyntaxNodeLike, type: string): SyntaxNodeLike | null {
+  return node.children.find((child) => child.type === type) ?? null;
+}
+
+function hasDirectToken(node: SyntaxNodeLike, type: string): boolean {
+  return node.children.some((child) => child.type === type);
+}
+
+function containsToken(node: SyntaxNodeLike, type: string): boolean {
+  return (
+    node.type === type ||
+    (node.children.length === 0 && node.text === type) ||
+    node.children.some((child) => containsToken(child, type))
+  );
+}
+
+const JAVA_CLASS_MEMBER_TYPES = new Set([
+  "annotation_type_declaration",
+  "class_declaration",
+  "compact_constructor_declaration",
+  "constructor_declaration",
+  "enum_declaration",
+  "field_declaration",
+  "interface_declaration",
+  "method_declaration",
+  "record_declaration",
+]);
+
+const JAVA_CONTAINER_MEMBER_TYPES = new Set([
+  ...JAVA_CLASS_MEMBER_TYPES,
+  "constant_declaration",
+  "enum_body_declarations",
+  "enum_constant",
+  "annotation_type_element_declaration",
+]);