Function parseTypeFromSymbolGroup

compiler/companion/src/AST.ts:252–304

(
  type: ts.NodeWithTypeArguments,
  symbolGroup: SymbolGroup,
  leadingComments: NodeComments | undefined,
  references: AST.TypeReferences,
)

}

function parseTypeFromSymbolGroup(
  type: ts.NodeWithTypeArguments,
  symbolGroup: SymbolGroup,
  leadingComments: NodeComments | undefined,
  references: AST.TypeReferences,
): AST.Type {
  if (symbolGroup.symbol) {
    const resolvedSymbol = symbolGroup.symbol;
    if (resolvedSymbol.name === 'Array') {
      if (!type.typeArguments || type.typeArguments.length !== 1) {
        throw new Error(
          `Resolved a generic Array reference with invalid type arguments ${getNodeDebugDescription(type)}`,
        );
      }

      const elementTypeNode = type.typeArguments[0];
      const elementType = parseType(elementTypeNode, references);
      return { name: 'array', leadingComments, array: elementType };
    }

    const typeArguments = type.typeArguments?.map((typeArgTypeNode) => {
      const parsedType = parseType(typeArgTypeNode, references);
      return { type: parsedType };
    });

    const typeReferenceIndex = resolveTypeReference(type, resolvedSymbol, references);
    return {
      name: 'reference',
      leadingComments,
      typeReferenceIndex,
      typeArguments,
      isTypeParameter: resolvedSymbol.isTypeParameter,
    };
  }

  if (symbolGroup.intersections) {
    return {
      name: 'intersection',
      leadingComments,
      intersections: symbolGroup.intersections.map((u) => parseTypeFromSymbolGroup(type, u, undefined, references)),
    };
  }

  if (symbolGroup.unions) {
    return {
      name: 'union',
      leadingComments,
      unions: symbolGroup.unions.map((u) => parseTypeFromSymbolGroup(type, u, undefined, references)),
    };
  }

  throw new Error('Invalid symbolGroup');
}

function parseType(type: ts.TypeNode | undefined, references: AST.TypeReferences): AST.Type {
  if (!type) {