Function extractWithTreeSitter

src/codegraph/extractor.ts:77–159

(
  parserResult: { parser: any; language: any },
  lang: string,
  source: string,
)

}

function extractWithTreeSitter(
  parserResult: { parser: any; language: any },
  lang: string,
  source: string,
): ExtractedSymbol[] {
  const tree = parserResult.parser.parse(source);
  const root = tree.rootNode;
  const nodeMap = SYMBOL_NODE_TYPES[lang];
  if (!nodeMap) return [];

  const symbols: ExtractedSymbol[] = [];
  // Build a flat reverse lookup: node type → kind name
  const typeToKind = new Map<string, string>();
  for (const [kind, types] of Object.entries(nodeMap)) {
    for (const t of types) typeToKind.set(t, kind);
  }

  function getName(node: any): string | null {
    const nameNode = node.childForFieldName('name');
    if (nameNode) return nameNode.text;
    for (let i = 0; i < node.childCount; i++) {
      const c = node.child(i);
      if (c && (c.type === 'identifier' || c.type === 'property_identifier' || c.type === 'type_identifier')) {
        return c.text;
      }
    }
    return null;
  }

  function getEnclosingNamedSymbol(node: any): string | null {
    let cur = node.parent;
    while (cur) {
      const kind = typeToKind.get(cur.type);
      if (kind) {
        const name = getName(cur);
        if (name) return name;
      }
      cur = cur.parent;
    }
    return null;
  }

  function visit(node: any) {
    let kind = typeToKind.get(node.type);
    // Rust maps `function_item` to BOTH `function` and `method`, so the flat
    // type→kind map can't tell them apart (last write wins). Disambiguate by
    // context: a `fn` enclosed in an impl/trait block is a method, otherwise a
    // free function.
    if (lang === 'rust' && node.type === 'function_item') {
      let cur = node.parent;
      let insideImplOrTrait = false;
      while (cur) {
        if (cur.type === 'impl_item' || cur.type === 'trait_item') { insideImplOrTrait = true; break; }
        cur = cur.parent;
      }
      kind = insideImplOrTrait ? 'method' : 'function';
    }
    if (kind) {