Examples with SwitchExpressionContext org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchExpressionContext used on opensource projects

Example 1 with SwitchExpressionContext

use of org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchExpressionContext in project groovy by apache.

the class AstBuilder method visitContinueStatement.

@Override
public ContinueStatement visitContinueStatement(final ContinueStatementContext ctx) {
    if (visitingLoopStatementCount == 0) {
        throw createParsingFailedException("continue statement is only allowed inside loops", ctx);
    }
    GroovyParserRuleContext gprc = switchExpressionRuleContextStack.peek();
    if (gprc instanceof SwitchExpressionContext) {
        throw createParsingFailedException("switch expression does not support `continue`", ctx);
    }
    String label = asBoolean(ctx.identifier()) ? this.visitIdentifier(ctx.identifier()) : null;
    return configureAST(new ContinueStatement(label), ctx);
}

Example 2 with SwitchExpressionContext

use of org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchExpressionContext in project groovy by apache.

the class AstBuilder method visitBreakStatement.

@Override
public BreakStatement visitBreakStatement(final BreakStatementContext ctx) {
    if (0 == visitingLoopStatementCount && 0 == visitingSwitchStatementCount) {
        throw createParsingFailedException("break statement is only allowed inside loops or switches", ctx);
    }
    GroovyParserRuleContext gprc = switchExpressionRuleContextStack.peek();
    if (gprc instanceof SwitchExpressionContext) {
        throw createParsingFailedException("switch expression does not support `break`", ctx);
    }
    String label = asBoolean(ctx.identifier()) ? this.visitIdentifier(ctx.identifier()) : null;
    return configureAST(new BreakStatement(label), ctx);
}

Example 3 with SwitchExpressionContext

use of org.apache.groovy.parser.antlr4.GroovyLangParser.SwitchExpressionContext in project groovy by apache.

the class AstBuilder method visitSwitchExpression.

/**
 * <pre>
 * switch(a) {
 *     case 0, 1  ->   'a';
 *     case 2     ->   'b';
 *     default    ->   'z';
 * }
 * </pre>
 * the above code will be transformed to:
 * <pre>
 * {->
 *     switch(a) {
 *         case 0:
 *         case 1:  return 'a';
 *         case 2:  return 'b';
 *         default: return 'z';
 *     }
 * }()
 * </pre>
 *
 * @param ctx the parse tree
 * @return {@link MethodCallExpression} instance
 */
@Override
public MethodCallExpression visitSwitchExpression(SwitchExpressionContext ctx) {
    switchExpressionRuleContextStack.push(ctx);
    try {
        validateSwitchExpressionLabels(ctx);
        List<Tuple3<List<Statement>, Boolean, Boolean>> statementInfoList = ctx.switchBlockStatementExpressionGroup().stream().map(e -> this.visitSwitchBlockStatementExpressionGroup(e)).collect(Collectors.toList());
        if (statementInfoList.isEmpty()) {
            throw createParsingFailedException("`case` or `default` branches are expected", ctx.LBRACE());
        }
        Boolean isArrow = statementInfoList.get(0).getV2();
        if (!isArrow && statementInfoList.stream().noneMatch(e -> {
            Boolean hasYieldOrThrowStatement = e.getV3();
            return hasYieldOrThrowStatement;
        })) {
            throw createParsingFailedException("`yield` or `throw` is expected", ctx);
        }
        List<Statement> statementList = statementInfoList.stream().map(e -> e.getV1()).reduce(new LinkedList<>(), (r, e) -> {
            r.addAll(e);
            return r;
        });
        List<CaseStatement> caseStatementList = new LinkedList<>();
        List<Statement> defaultStatementList = new LinkedList<>();
        statementList.forEach(e -> {
            if (e instanceof CaseStatement) {
                caseStatementList.add((CaseStatement) e);
            } else if (isTrue(e, IS_SWITCH_DEFAULT)) {
                defaultStatementList.add(e);
            }
        });
        int defaultStatementListSize = defaultStatementList.size();
        if (defaultStatementListSize > 1) {
            throw createParsingFailedException("switch expression should have only one default case, which should appear at last", defaultStatementList.get(0));
        }
        if (defaultStatementListSize > 0 && last(statementList) instanceof CaseStatement) {
            throw createParsingFailedException("default case should appear at last", defaultStatementList.get(0));
        }
        String variableName = "__$$sev" + switchExpressionVariableSeq++;
        Statement declarationStatement = declS(localVarX(variableName), this.visitExpressionInPar(ctx.expressionInPar()));
        SwitchStatement switchStatement = configureAST(new SwitchStatement(varX(variableName), caseStatementList, defaultStatementListSize == 0 ? EmptyStatement.INSTANCE : defaultStatementList.get(0)), ctx);
        MethodCallExpression callClosure = callX(configureAST(closureX(null, createBlockStatement(declarationStatement, switchStatement)), ctx), "call");
        callClosure.setImplicitThis(false);
        return configureAST(callClosure, ctx);
    } finally {
        switchExpressionRuleContextStack.pop();
    }
}