export function isCompatible()

in src/powerquery-parser/language/type/typeUtils/isCompatible.ts [14:78]
52 lines of code
30 McCabe index (conditional complexity)

export function isCompatible(left: Type.TPowerQueryType, right: Type.TPowerQueryType): boolean | undefined {
    if (
        left.kind === Type.TypeKind.NotApplicable ||
        left.kind === Type.TypeKind.Unknown ||
        right.kind === Type.TypeKind.NotApplicable ||
        right.kind === Type.TypeKind.Unknown
    ) {
        return undefined;
    } else if (
        left.kind === Type.TypeKind.None ||
        right.kind === Type.TypeKind.None ||
        (left.isNullable && !right.isNullable)
    ) {
        return false;
    } else if (left.kind === Type.TypeKind.Null && right.isNullable) {
        return true;
    }

    switch (right.kind) {
        case Type.TypeKind.Action:
        case Type.TypeKind.Binary:
        case Type.TypeKind.Date:
        case Type.TypeKind.DateTime:
        case Type.TypeKind.DateTimeZone:
        case Type.TypeKind.Duration:
        case Type.TypeKind.Time:
            return isEqualType(left, right);

        case Type.TypeKind.Any:
            return isCompatibleWithAny(left, right);

        case Type.TypeKind.AnyNonNull:
            return left.kind !== Type.TypeKind.Null && !left.isNullable;

        case Type.TypeKind.Function:
            return isCompatibleWithFunction(left, right);

        case Type.TypeKind.List:
            return isCompatibleWithList(left, right);

        case Type.TypeKind.Logical:
            return isCompatibleWithPrimitiveOrLiteral(left, right);

        case Type.TypeKind.Number:
            return isCompatibleWithPrimitiveOrLiteral(left, right);

        case Type.TypeKind.Null:
            return left.kind === Type.TypeKind.Null;

        case Type.TypeKind.Record:
            return isCompatibleWithRecord(left, right);

        case Type.TypeKind.Table:
            return isCompatibleWithTable(left, right);

        case Type.TypeKind.Text:
            return isCompatibleWithPrimitiveOrLiteral(left, right);

        case Type.TypeKind.Type:
            return isCompatibleWithType(left, right);

        default:
            throw Assert.isNever(right);
    }
}