Function parseType

compiler/companion/src/AST.ts:306–404

(type: ts.TypeNode | undefined, references: AST.TypeReferences)

}

function parseType(type: ts.TypeNode | undefined, references: AST.TypeReferences): AST.Type {
  if (!type) {
    return {
      name: 'void',
    };
  }

  const leadingComments = getNodeComments(type);

  if (ts.isFunctionTypeNode(type)) {
    return {
      name: 'function',
      leadingComments,
      function: parseFunctionType(type, references),
    };
  }

  if (ts.isUnionTypeNode(type)) {
    const unions: AST.Type[] = [];
    for (const unionType of type.types) {
      unions.push(parseType(unionType, references));
    }

    return {
      name: 'union',
      leadingComments,
      unions,
    };
  }

  if (ts.isIntersectionTypeNode(type)) {
    const intersections: AST.Type[] = [];
    for (const unionType of type.types) {
      intersections.push(parseType(unionType, references));
    }

    return {
      name: 'intersection',
      leadingComments,
      intersections,
    };
  }

  if (ts.isArrayTypeNode(type)) {
    return {
      name: 'array',
      leadingComments,
      array: parseType(type.elementType, references),
    };
  }

  if (ts.isTypeReferenceNode(type) || ts.isExpressionWithTypeArguments(type)) {
    const resolvedSymbol = resolveSymbol(type, references.typeChecker);
    if (!resolvedSymbol) {
      throw new Error(`Could not resolve symbol ${getNodeDebugDescription(type)}`);
    }

    return parseTypeFromSymbolGroup(type, resolvedSymbol, leadingComments, references);