function readUnaryExpression()

in src/powerquery-parser/parser/parsers/combinatorialParser.ts [278:350]
54 lines of code
24 McCabe index (conditional complexity)

function readUnaryExpression(state: ParseState, parser: Parser): Ast.TUnaryExpression {
    state.maybeCancellationToken?.throwIfCancelled();

    let maybePrimaryExpression: Ast.TPrimaryExpression | undefined;

    // LL(1)
    switch (state.maybeCurrentTokenKind) {
        // PrimaryExpression
        case Token.TokenKind.AtSign:
        case Token.TokenKind.Identifier:
            maybePrimaryExpression = NaiveParseSteps.readIdentifierExpression(state, parser);
            break;

        case Token.TokenKind.LeftParenthesis:
            maybePrimaryExpression = NaiveParseSteps.readParenthesizedExpression(state, parser);
            break;

        case Token.TokenKind.LeftBracket:
            maybePrimaryExpression = DisambiguationUtils.readAmbiguousBracket(state, parser, [
                Disambiguation.BracketDisambiguation.RecordExpression,
                Disambiguation.BracketDisambiguation.FieldSelection,
                Disambiguation.BracketDisambiguation.FieldProjection,
            ]);

            break;

        case Token.TokenKind.LeftBrace:
            maybePrimaryExpression = NaiveParseSteps.readListExpression(state, parser);
            break;

        case Token.TokenKind.Ellipsis:
            maybePrimaryExpression = NaiveParseSteps.readNotImplementedExpression(state, parser);
            break;

        // LiteralExpression
        case Token.TokenKind.HexLiteral:
        case Token.TokenKind.KeywordFalse:
        case Token.TokenKind.KeywordTrue:
        case Token.TokenKind.NumericLiteral:
        case Token.TokenKind.NullLiteral:
        case Token.TokenKind.TextLiteral:
            return NaiveParseSteps.readLiteralExpression(state, parser);

        // TypeExpression
        case Token.TokenKind.KeywordType:
            return NaiveParseSteps.readTypeExpression(state, parser);

        case Token.TokenKind.KeywordHashSections:
        case Token.TokenKind.KeywordHashShared:
        case Token.TokenKind.KeywordHashBinary:
        case Token.TokenKind.KeywordHashDate:
        case Token.TokenKind.KeywordHashDateTime:
        case Token.TokenKind.KeywordHashDateTimeZone:
        case Token.TokenKind.KeywordHashDuration:
        case Token.TokenKind.KeywordHashTable:
        case Token.TokenKind.KeywordHashTime:
            maybePrimaryExpression = parser.readKeyword(state, parser);
            break;

        // Let Naive throw an error.
        default:
            return NaiveParseSteps.readUnaryExpression(state, parser);
    }

    // We should only reach this code block if a primary expression was read.
    const primaryExpression: Ast.TPrimaryExpression = maybePrimaryExpression;

    if (ParseStateUtils.isRecursivePrimaryExpressionNext(state, state.tokenIndex)) {
        return parser.readRecursivePrimaryExpression(state, parser, primaryExpression);
    } else {
        return primaryExpression;
    }
}