Method extractAggregate

src/extraction/tree-sitter.ts:1892–1932

Extract a struct-like declaration without conflating its semantic kind.

(node: SyntaxNode, kind: 'struct' | 'union')

  /** Extract a struct-like declaration without conflating its semantic kind. */
  private extractAggregate(node: SyntaxNode, kind: 'struct' | 'union'): void {
    if (!this.extractor) return;

    // Skip forward declarations and type references (no body = not a definition)
    // — EXCEPT C# positional records (`record struct M(decimal Amount);`),
    // complete definitions with no body block. (#831)
    const body = getChildByField(node, this.extractor.bodyField);
    if (!body && node.type !== 'record_declaration') return;

    const name = extractName(node, this.source, this.extractor);
    const docstring = getPrecedingDocstring(node, this.source);
    const visibility = this.extractor.getVisibility?.(node);
    const isExported = this.extractor.isExported?.(node, this.source);

    const aggregateNode = this.createNode(kind, name, node, {
      docstring,
      visibility,
      isExported,
    });
    if (!aggregateNode) return;

    // Extract inheritance (e.g. Swift: struct HTTPMethod: RawRepresentable)
    this.extractInheritance(node, aggregateNode.id);

    // C# primary-constructor parameter dependencies (`struct P(int x)`, and
    // `record struct M(decimal Amount)` which the grammar nests here).
    this.extractCsharpPrimaryCtorParamRefs(node, aggregateNode.id);

    // Push to stack for field extraction (bodiless positional records have
    // no members to visit)
    if (body) {
      this.nodeStack.push(aggregateNode.id);
      for (let i = 0; i < body.namedChildCount; i++) {
        const child = body.namedChild(i);
        if (child) {
          this.visitNode(child);
        }
      }
      this.nodeStack.pop();
    }
  }

  /**
   * Extract an enum