Examples with VOID org.apache.groovy.parser.antlr4.GroovyLexer.VOID used on opensource projects

Example 1 with VOID

use of org.apache.groovy.parser.antlr4.GroovyLexer.VOID in project groovy by apache.

the class AstBuilder method visitSwitchBlockStatementExpressionGroup.

@Override
@SuppressWarnings("unchecked")
public Tuple3<List<Statement>, Boolean, Boolean> visitSwitchBlockStatementExpressionGroup(SwitchBlockStatementExpressionGroupContext ctx) {
    int labelCnt = ctx.switchExpressionLabel().size();
    List<Token> firstLabelHolder = new ArrayList<>(1);
    final int[] arrowCntHolder = new int[1];
    boolean[] isArrowHolder = new boolean[1];
    boolean[] hasResultStmtHolder = new boolean[1];
    List<Statement> result = (List<Statement>) ctx.switchExpressionLabel().stream().map(e -> (Object) this.visitSwitchExpressionLabel(e)).reduce(new ArrayList<Statement>(4), (r, e) -> {
        List<Statement> statementList = (List<Statement>) r;
        Tuple3<Token, List<Expression>, Integer> tuple = (Tuple3<Token, List<Expression>, Integer>) e;
        boolean isArrow = ARROW == tuple.getV3();
        isArrowHolder[0] = isArrow;
        if (isArrow) {
            if (++arrowCntHolder[0] > 1 && !firstLabelHolder.isEmpty()) {
                throw createParsingFailedException("`case ... ->` does not support falling through cases", firstLabelHolder.get(0));
            }
        }
        boolean isLast = labelCnt - 1 == statementList.size();
        BlockStatement codeBlock = this.visitBlockStatements(ctx.blockStatements());
        List<Statement> statements = codeBlock.getStatements();
        int statementsCnt = statements.size();
        if (0 == statementsCnt) {
            throw createParsingFailedException("`yield` is expected", ctx.blockStatements());
        }
        if (isArrow && statementsCnt > 1) {
            throw createParsingFailedException("Expect only 1 statement, but " + statementsCnt + " statements found", ctx.blockStatements());
        }
        if (!isArrow) {
            boolean[] hasYieldHolder = new boolean[1];
            boolean[] hasThrowHolder = new boolean[1];
            codeBlock.visit(new CodeVisitorSupport() {

                @Override
                public void visitReturnStatement(ReturnStatement statement) {
                    if (isTrue(statement, IS_YIELD_STATEMENT)) {
                        hasYieldHolder[0] = true;
                        return;
                    }
                    super.visitReturnStatement(statement);
                }

                @Override
                public void visitThrowStatement(ThrowStatement statement) {
                    hasThrowHolder[0] = true;
                }
            });
            if (hasYieldHolder[0] || hasThrowHolder[0]) {
                hasResultStmtHolder[0] = true;
            }
        }
        Statement exprOrBlockStatement = statements.get(0);
        if (exprOrBlockStatement instanceof BlockStatement) {
            BlockStatement blockStatement = (BlockStatement) exprOrBlockStatement;
            List<Statement> branchStatementList = blockStatement.getStatements();
            if (1 == branchStatementList.size()) {
                exprOrBlockStatement = branchStatementList.get(0);
            }
        }
        if (!(exprOrBlockStatement instanceof ReturnStatement || exprOrBlockStatement instanceof ThrowStatement)) {
            if (isArrow) {
                MethodCallExpression callClosure = callX(configureAST(closureX(null, exprOrBlockStatement), exprOrBlockStatement), "call");
                callClosure.setImplicitThis(false);
                Expression resultExpr = exprOrBlockStatement instanceof ExpressionStatement ? ((ExpressionStatement) exprOrBlockStatement).getExpression() : callClosure;
                codeBlock = configureAST(createBlockStatement(configureAST(returnS(resultExpr), exprOrBlockStatement)), exprOrBlockStatement);
            }
        }
        switch(tuple.getV1().getType()) {
            case CASE:
                {
                    if (!asBoolean(statementList)) {
                        firstLabelHolder.add(tuple.getV1());
                    }
                    for (int i = 0, n = tuple.getV2().size(); i < n; i++) {
                        Expression expr = tuple.getV2().get(i);
                        statementList.add(configureAST(new CaseStatement(expr, // check whether processing the last label. if yes, block statement should be attached.
                        (isLast && i == n - 1) ? codeBlock : EmptyStatement.INSTANCE), firstLabelHolder.get(0)));
                    }
                    break;
                }
            case DEFAULT:
                {
                    codeBlock.putNodeMetaData(IS_SWITCH_DEFAULT, true);
                    statementList.add(// this.configureAST(codeBlock, tuple.getKey())
                    codeBlock);
                    break;
                }
        }
        return statementList;
    });
    return tuple(result, isArrowHolder[0], hasResultStmtHolder[0]);
}

Example 2 with VOID

use of org.apache.groovy.parser.antlr4.GroovyLexer.VOID in project groovy by apache.

the class AstBuilder method transformRecordHeaderToProperties.

private void transformRecordHeaderToProperties(ClassDeclarationContext ctx, ClassNode classNode) {
    Parameter[] parameters = this.visitFormalParameters(ctx.formalParameters());
    classNode.putNodeMetaData(RECORD_HEADER, parameters);
    final int n = parameters.length;
    for (int i = 0; i < n; i += 1) {
        Parameter parameter = parameters[i];
        FormalParameterContext parameterCtx = parameter.getNodeMetaData(PARAMETER_CONTEXT);
        ModifierManager parameterModifierManager = parameter.getNodeMetaData(PARAMETER_MODIFIER_MANAGER);
        ClassNode originType = parameter.getOriginType();
        PropertyNode propertyNode = declareProperty(parameterCtx, parameterModifierManager, originType, classNode, i, parameter, parameter.getName(), parameter.getModifiers(), parameter.getInitialExpression());
        propertyNode.getField().putNodeMetaData(IS_RECORD_GENERATED, Boolean.TRUE);
    }
}

Example 3 with VOID

use of org.apache.groovy.parser.antlr4.GroovyLexer.VOID in project groovy by apache.

the class SmartDocumentFilter method parseDocument.

private void parseDocument() throws BadLocationException {
    GroovyLangLexer lexer;
    try {
        lexer = createLexer(styledDocument.getText(0, styledDocument.getLength()));
    } catch (IOException e) {
        e.printStackTrace();
        this.latest = false;
        return;
    }
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    try {
        tokenStream.fill();
    } catch (LexerNoViableAltException | GroovySyntaxError e) {
        // ignore
        this.latest = false;
        return;
    } catch (Exception e) {
        e.printStackTrace();
        this.latest = false;
        return;
    }
    List<Token> tokenList = tokenStream.getTokens();
    List<Token> tokenListToRender;
    try {
        tokenListToRender = findTokensToRender(tokenList);
    } finally {
        this.setRenderRange(null);
    }
    for (Token token : tokenListToRender) {
        int tokenType = token.getType();
        if (EOF == tokenType) {
            continue;
        }
        int tokenStartIndex = token.getStartIndex();
        int tokenStopIndex = token.getStopIndex();
        int tokenLength = tokenStopIndex - tokenStartIndex + 1;
        styledDocument.setCharacterAttributes(tokenStartIndex, tokenLength, findStyleByTokenType(tokenType), true);
        if (GStringBegin == tokenType || GStringPart == tokenType) {
            styledDocument.setCharacterAttributes(tokenStartIndex + tokenLength - 1, 1, defaultStyle, true);
        }
    }
    this.latestTokenList = tokenList;
    this.latest = true;
}

Example 4 with VOID

use of org.apache.groovy.parser.antlr4.GroovyLexer.VOID in project groovy by apache.

the class AstBuilder method visitPathElement.

@Override
public Expression visitPathElement(final PathElementContext ctx) {
    Expression baseExpr = ctx.getNodeMetaData(PATH_EXPRESSION_BASE_EXPR);
    Objects.requireNonNull(baseExpr, "baseExpr is required!");
    if (asBoolean(ctx.namePart())) {
        Expression namePartExpr = this.visitNamePart(ctx.namePart());
        GenericsType[] genericsTypes = this.visitNonWildcardTypeArguments(ctx.nonWildcardTypeArguments());
        if (asBoolean(ctx.DOT())) {
            boolean isSafeChain = this.isTrue(baseExpr, PATH_EXPRESSION_BASE_EXPR_SAFE_CHAIN);
            return this.createDotExpression(ctx, baseExpr, namePartExpr, genericsTypes, isSafeChain);
        } else if (asBoolean(ctx.SAFE_DOT())) {
            return this.createDotExpression(ctx, baseExpr, namePartExpr, genericsTypes, true);
        } else if (asBoolean(ctx.SAFE_CHAIN_DOT())) {
            // e.g. obj??.a  OR obj??.@a
            Expression expression = createDotExpression(ctx, baseExpr, namePartExpr, genericsTypes, true);
            expression.putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_SAFE_CHAIN, true);
            return expression;
        } else if (asBoolean(ctx.METHOD_POINTER())) {
            // e.g. obj.&m
            return configureAST(new MethodPointerExpression(baseExpr, namePartExpr), ctx);
        } else if (asBoolean(ctx.METHOD_REFERENCE())) {
            // e.g. obj::m
            return configureAST(new MethodReferenceExpression(baseExpr, namePartExpr), ctx);
        } else if (asBoolean(ctx.SPREAD_DOT())) {
            if (asBoolean(ctx.AT())) {
                // e.g. obj*.@a
                AttributeExpression attributeExpression = new AttributeExpression(baseExpr, namePartExpr, true);
                attributeExpression.setSpreadSafe(true);
                return configureAST(attributeExpression, ctx);
            } else {
                // e.g. obj*.p
                PropertyExpression propertyExpression = new PropertyExpression(baseExpr, namePartExpr, true);
                propertyExpression.putNodeMetaData(PATH_EXPRESSION_BASE_EXPR_GENERICS_TYPES, genericsTypes);
                propertyExpression.setSpreadSafe(true);
                return configureAST(propertyExpression, ctx);
            }
        }
    } else if (asBoolean(ctx.creator())) {
        CreatorContext creatorContext = ctx.creator();
        creatorContext.putNodeMetaData(ENCLOSING_INSTANCE_EXPRESSION, baseExpr);
        return configureAST(this.visitCreator(creatorContext), ctx);
    } else if (asBoolean(ctx.indexPropertyArgs())) {
        // e.g. list[1, 3, 5]
        Tuple2<Token, Expression> tuple = this.visitIndexPropertyArgs(ctx.indexPropertyArgs());
        boolean isSafeChain = this.isTrue(baseExpr, PATH_EXPRESSION_BASE_EXPR_SAFE_CHAIN);
        return configureAST(new BinaryExpression(baseExpr, createGroovyToken(tuple.getV1()), tuple.getV2(), isSafeChain || asBoolean(ctx.indexPropertyArgs().SAFE_INDEX())), ctx);
    } else if (asBoolean(ctx.namedPropertyArgs())) {
        // this is a special way to signify a cast, e.g. Person[name: 'Daniel.Sun', location: 'Shanghai']
        List<MapEntryExpression> mapEntryExpressionList = this.visitNamedPropertyArgs(ctx.namedPropertyArgs());
        Expression right;
        Expression firstKeyExpression;
        int mapEntryExpressionListSize = mapEntryExpressionList.size();
        if (mapEntryExpressionListSize == 0) {
            // expecting list of MapEntryExpressions later so use SpreadMap to smuggle empty MapExpression to later stages
            right = configureAST(new SpreadMapExpression(configureAST(new MapExpression(), ctx.namedPropertyArgs())), ctx.namedPropertyArgs());
        } else if (mapEntryExpressionListSize == 1 && (firstKeyExpression = mapEntryExpressionList.get(0).getKeyExpression()) instanceof SpreadMapExpression) {
            right = firstKeyExpression;
        } else {
            ListExpression listExpression = configureAST(new ListExpression(mapEntryExpressionList.stream().map(e -> {
                if (e.getKeyExpression() instanceof SpreadMapExpression) {
                    return e.getKeyExpression();
                }
                return e;
            }).collect(Collectors.toList())), ctx.namedPropertyArgs());
            listExpression.setWrapped(true);
            right = listExpression;
        }
        NamedPropertyArgsContext namedPropertyArgsContext = ctx.namedPropertyArgs();
        Token token = (namedPropertyArgsContext.LBRACK() == null ? namedPropertyArgsContext.SAFE_INDEX() : namedPropertyArgsContext.LBRACK()).getSymbol();
        return configureAST(new BinaryExpression(baseExpr, createGroovyToken(token), right), ctx);
    } else if (asBoolean(ctx.arguments())) {
        Expression argumentsExpr = this.visitArguments(ctx.arguments());
        configureAST(argumentsExpr, ctx);
        if (isInsideParentheses(baseExpr)) {
            // e.g. (obj.x)(), (obj.@x)()
            return configureAST(createCallMethodCallExpression(baseExpr, argumentsExpr), ctx);
        }
        if (baseExpr instanceof AttributeExpression) {
            // e.g. obj.@a(1, 2)
            AttributeExpression attributeExpression = (AttributeExpression) baseExpr;
            // whether attributeExpression is spread safe or not, we must reset it as false
            attributeExpression.setSpreadSafe(false);
            return configureAST(createCallMethodCallExpression(attributeExpression, argumentsExpr, true), ctx);
        }
        if (baseExpr instanceof PropertyExpression) {
            // e.g. obj.a(1, 2)
            MethodCallExpression methodCallExpression = this.createMethodCallExpression((PropertyExpression) baseExpr, argumentsExpr);
            return configureAST(methodCallExpression, ctx);
        }
        if (baseExpr instanceof VariableExpression) {
            // void and primitive type AST node must be an instance of VariableExpression
            String baseExprText = baseExpr.getText();
            if (VOID_STR.equals(baseExprText)) {
                // e.g. void()
                return configureAST(this.createCallMethodCallExpression(this.createConstantExpression(baseExpr), argumentsExpr), ctx);
            } else if (isPrimitiveType(baseExprText)) {
                // e.g. int(), long(), float(), etc.
                throw this.createParsingFailedException("Primitive type literal: " + baseExprText + " cannot be used as a method name", ctx);
            }
        }
        if (// e.g. m()
        baseExpr instanceof VariableExpression || // e.g. "$m"()
        baseExpr instanceof GStringExpression || (baseExpr instanceof ConstantExpression && this.isTrue(baseExpr, IS_STRING))) {
            // e.g. "m"()
            String baseExprText = baseExpr.getText();
            if (THIS_STR.equals(baseExprText) || SUPER_STR.equals(baseExprText)) {
                // @MapConstructor(pre={ super(args?.first, args?.last); args = args ?: [:] }, post = { first = first?.toUpperCase() })
                if (visitingClosureCount > 0) {
                    return configureAST(new MethodCallExpression(baseExpr, baseExprText, argumentsExpr), ctx);
                }
                return configureAST(new ConstructorCallExpression(SUPER_STR.equals(baseExprText) ? ClassNode.SUPER : ClassNode.THIS, argumentsExpr), ctx);
            }
            MethodCallExpression methodCallExpression = this.createMethodCallExpression(baseExpr, argumentsExpr);
            return configureAST(methodCallExpression, ctx);
        }
        // e.g. 1(), 1.1(), ((int) 1 / 2)(1, 2), {a, b -> a + b }(1, 2), m()()
        return configureAST(this.createCallMethodCallExpression(baseExpr, argumentsExpr), ctx);
    } else if (asBoolean(ctx.closureOrLambdaExpression())) {
        ClosureExpression closureExpression = this.visitClosureOrLambdaExpression(ctx.closureOrLambdaExpression());
        if (baseExpr instanceof MethodCallExpression) {
            MethodCallExpression methodCallExpression = (MethodCallExpression) baseExpr;
            Expression argumentsExpression = methodCallExpression.getArguments();
            if (argumentsExpression instanceof ArgumentListExpression) {
                // normal arguments, e.g. 1, 2
                ArgumentListExpression argumentListExpression = (ArgumentListExpression) argumentsExpression;
                argumentListExpression.getExpressions().add(closureExpression);
                return configureAST(methodCallExpression, ctx);
            }
            if (argumentsExpression instanceof TupleExpression) {
                // named arguments, e.g. x: 1, y: 2
                TupleExpression tupleExpression = (TupleExpression) argumentsExpression;
                NamedArgumentListExpression namedArgumentListExpression = (NamedArgumentListExpression) tupleExpression.getExpression(0);
                if (asBoolean(tupleExpression.getExpressions())) {
                    methodCallExpression.setArguments(configureAST(new ArgumentListExpression(configureAST(new MapExpression(namedArgumentListExpression.getMapEntryExpressions()), namedArgumentListExpression), closureExpression), tupleExpression));
                } else {
                    // the branch should never reach, because named arguments must not be empty
                    methodCallExpression.setArguments(configureAST(new ArgumentListExpression(closureExpression), tupleExpression));
                }
                return configureAST(methodCallExpression, ctx);
            }
        }
        if (baseExpr instanceof PropertyExpression) {
            // e.g. obj.m { }
            MethodCallExpression methodCallExpression = this.createMethodCallExpression((PropertyExpression) baseExpr, configureAST(new ArgumentListExpression(closureExpression), closureExpression));
            return configureAST(methodCallExpression, ctx);
        }
        if (// e.g. m { }
        baseExpr instanceof VariableExpression || // e.g. "$m" { }
        baseExpr instanceof GStringExpression || (baseExpr instanceof ConstantExpression && this.isTrue(baseExpr, IS_STRING))) {
            // e.g. "m" { }
            MethodCallExpression methodCallExpression = this.createMethodCallExpression(baseExpr, configureAST(new ArgumentListExpression(closureExpression), closureExpression));
            return configureAST(methodCallExpression, ctx);
        }
        // e.g. 1 { }, 1.1 { }, (1 / 2) { }, m() { }, { -> ... } { }
        MethodCallExpression methodCallExpression = this.createCallMethodCallExpression(baseExpr, configureAST(new ArgumentListExpression(closureExpression), closureExpression));
        return configureAST(methodCallExpression, ctx);
    }
    throw createParsingFailedException("Unsupported path element: " + ctx.getText(), ctx);
}

Example 5 with VOID

use of org.apache.groovy.parser.antlr4.GroovyLexer.VOID in project groovy by apache.

the class LexerFrame method scanScript.

private void scanScript(final StringReader reader) throws Exception {
    scriptPane.read(reader, null);
    reader.reset();
    // create lexer
    final GroovyLangLexer lexer = new GroovyLangLexer(reader);
    tokenPane.setEditable(true);
    tokenPane.setText("");
    int line = 1;
    final ButtonGroup bg = new ButtonGroup();
    Token token;
    int tokenCnt = 0;
    while (true) {
        token = lexer.nextToken();
        JToggleButton tokenButton = new JToggleButton(tokens.get(token.getType()));
        tokenButton.setFont(MONOSPACED_FONT);
        bg.add(tokenButton);
        tokenButton.addActionListener(this);
        tokenButton.setToolTipText(token.getText());
        tokenButton.putClientProperty("token", token);
        tokenButton.setMargin(new Insets(0, 1, 0, 1));
        tokenButton.setFocusPainted(false);
        if (token.getLine() > line) {
            tokenPane.getDocument().insertString(tokenPane.getDocument().getLength(), "\n", null);
            line = token.getLine();
        }
        insertComponent(tokenButton);
        tokenCnt++;
        if (eof().equals(token.getType())) {
            break;
        }
    }
    tokenStreamLabel.setText(" Token Stream(" + tokenCnt + "):");
    tokenPane.setEditable(false);
    tokenPane.setCaretPosition(0);
    reader.close();
}