Java Statement类代码示例

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Nullable
public static MethodCallExpression extractBareMethodCall(Statement statement) {
    if (!(statement instanceof ExpressionStatement)) {
        return null;
    }

    ExpressionStatement expressionStatement = (ExpressionStatement) statement;
    if (!(expressionStatement.getExpression() instanceof MethodCallExpression)) {
        return null;
    }

    MethodCallExpression methodCall = (MethodCallExpression) expressionStatement.getExpression();
    if (!targetIsThis(methodCall)) {
        return null;
    }

    return methodCall;
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
/**
 * Returns true if the the given statement may have some effect as part of a script body.
 * Returns false when the given statement may be ignored, provided all other statements in the script body may also be ignored.
 */
public static boolean mayHaveAnEffect(Statement statement) {
    if (statement instanceof ReturnStatement) {
        ReturnStatement returnStatement = (ReturnStatement) statement;
        if (returnStatement.getExpression() instanceof ConstantExpression) {
            return false;
        }
    } else if (statement instanceof ExpressionStatement) {
        ExpressionStatement expressionStatement = (ExpressionStatement) statement;
        if (expressionStatement.getExpression() instanceof ConstantExpression) {
            return false;
        }
        if (expressionStatement.getExpression() instanceof DeclarationExpression) {
            DeclarationExpression declarationExpression = (DeclarationExpression) expressionStatement.getExpression();
            if (declarationExpression.getRightExpression() instanceof EmptyExpression || declarationExpression.getRightExpression() instanceof ConstantExpression) {
                return false;
            }
        }
    }
    return true;
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public void call(SourceUnit source) throws CompilationFailedException {
    BlockStatement statementBlock = source.getAST().getStatementBlock();
    List<Statement> statements = statementBlock.getStatements();
    for (Statement statement : statements) {
        if (!AstUtils.mayHaveAnEffect(statement)) {
            continue;
        }
        ScriptBlock scriptBlock = AstUtils.detectScriptBlock(statement);
        if (scriptBlock != null && scriptBlock.getName().equals(ModelBlockTransformer.MODEL)) {
            continue;
        }
        imperativeStatementDetected = true;
        break;
    }
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
protected Expression transformClosureExpression(ClosureExpression ce) {
    boolean oldInClosure = inClosure;
    inClosure = true;
    Parameter[] paras = ce.getParameters();
    if (paras != null) {
        for (Parameter para : paras) {
            ClassNode t = para.getType();
            resolveOrFail(t, ce);
            visitAnnotations(para);
            if (para.hasInitialExpression()) {
                Object initialVal = para.getInitialExpression();
                if (initialVal instanceof Expression) {
                    para.setInitialExpression(transform((Expression) initialVal));
                }
            }
            visitAnnotations(para);
        }
    }
    Statement code = ce.getCode();
    if (code != null) {
        code.visit(this);
    }
    inClosure = oldInClosure;
    return ce;
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public void call(final SourceUnit source) throws CompilationFailedException {
    // currently we only look in script code; could extend this to build script classes
    AstUtils.visitScriptCode(source, new ClassCodeVisitorSupport() {
        @Override
        protected SourceUnit getSourceUnit() {
            return source;
        }

        @Override
        protected void visitStatement(Statement statement) {
            if (statement.getStatementLabel() != null) {
                String message = String.format("Statement labels may not be used in build scripts.%nIn case you tried to configure a property named '%s', replace ':' with '=' or ' ', otherwise it will not have the desired effect.",
                        statement.getStatementLabel());
                addError(message, statement);
            }
        }
    });
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Test
public void transformationOfAnnotationOnLocalVariable() {
	ClassNode classNode = new ClassNode("Test", 0, new ClassNode(Object.class));
	this.moduleNode.addClass(classNode);

	DeclarationExpression declarationExpression = new DeclarationExpression(
			new VariableExpression("test"), null, new ConstantExpression("test"));
	declarationExpression.addAnnotation(this.grabAnnotation);

	BlockStatement code = new BlockStatement(
			Arrays.asList((Statement) new ExpressionStatement(declarationExpression)),
			new VariableScope());

	MethodNode methodNode = new MethodNode("test", 0, new ClassNode(Void.class),
			new Parameter[0], new ClassNode[0], code);

	classNode.addMethod(methodNode);

	assertGrabAnnotationHasBeenTransformed();
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public void visitClosureExpression(final ClosureExpression expression) {
    super.visitClosureExpression(expression);
    if (inBuilderMethod) {
        Statement oldCode = expression.getCode();
        BlockStatement block = oldCode instanceof BlockStatement?
                ((BlockStatement)oldCode):
                new BlockStatement(Arrays.asList(oldCode), new VariableScope());
        List<Statement> statements = block.getStatements();
        if (!statements.isEmpty()) {
            Statement first = statements.get(0);
            Statement last = statements.get(statements.size()-1);
            if (expression.getLineNumber()<first.getLineNumber()) {
                // there's a new line between { -> ... and the first statement
                statements.add(0,createNewLine(expression));
            }
            if (expression.getLastLineNumber()>last.getLastLineNumber()) {
                // there's a new line between { -> ... and the first statement
                statements.add(createNewLine(expression));
            }
        }
        expression.setCode(block);
    }
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
protected void addInitialization(final ClassNode node) {
    boolean addSwapInit = moveOptimizedConstantsInitialization(node);

    for (ConstructorNode cn : node.getDeclaredConstructors()) {
        addInitialization(node, cn);
    }

    if (addSwapInit) {
        BytecodeSequence seq = new BytecodeSequence(
                new BytecodeInstruction() {
                    @Override
                    public void visit(MethodVisitor mv) {
                        mv.visitMethodInsn(INVOKESTATIC, BytecodeHelper.getClassInternalName(node), SWAP_INIT, "()V", false);
                    }
                });

        List<Statement> swapCall = new ArrayList<Statement>(1);
        swapCall.add(seq);
        node.addStaticInitializerStatements(swapCall, true);
    }
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public IfStatement visitIfElseStatement(IfElseStatementContext ctx) {
    Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());
    BooleanExpression booleanExpression =
            configureAST(
                    new BooleanExpression(conditionExpression), conditionExpression);

    Statement ifBlock =
            this.unpackStatement(
                    (Statement) this.visit(ctx.tb));
    Statement elseBlock =
            this.unpackStatement(
                    asBoolean(ctx.ELSE())
                            ? (Statement) this.visit(ctx.fb)
                            : EmptyStatement.INSTANCE);

    return configureAST(new IfStatement(booleanExpression, ifBlock, elseBlock), ctx);
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public DoWhileStatement visitDoWhileStmtAlt(DoWhileStmtAltContext ctx) {
    Expression conditionExpression = this.visitExpressionInPar(ctx.expressionInPar());

    BooleanExpression booleanExpression =
            configureAST(
                    new BooleanExpression(conditionExpression),
                    conditionExpression
            );

    Statement loopBlock = this.unpackStatement((Statement) this.visit(ctx.statement()));

    return configureAST(
            new DoWhileStatement(booleanExpression, asBoolean(loopBlock) ? loopBlock : EmptyStatement.INSTANCE),
            ctx);
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
public PropertyNode addProperty(String name,
                                int modifiers,
                                ClassNode type,
                                Expression initialValueExpression,
                                Statement getterBlock,
                                Statement setterBlock) {
    for (PropertyNode pn : getProperties()) {
        if (pn.getName().equals(name)) {
            if (pn.getInitialExpression() == null && initialValueExpression != null)
                pn.getField().setInitialValueExpression(initialValueExpression);

            if (pn.getGetterBlock() == null && getterBlock != null)
                pn.setGetterBlock(getterBlock);

            if (pn.getSetterBlock() == null && setterBlock != null)
                pn.setSetterBlock(setterBlock);

            return pn;
        }
    }
    PropertyNode node =
            new PropertyNode(name, modifiers, type, redirect(), initialValueExpression, getterBlock, setterBlock);
    addProperty(node);
    return node;
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
private MethodNode createConstructorOrMethodNodeForClass(MethodDeclarationContext ctx, ModifierManager modifierManager, String methodName, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code, ClassNode classNode) {
    MethodNode methodNode;
    String className = classNode.getNodeMetaData(CLASS_NAME);
    int modifiers = modifierManager.getClassMemberModifiersOpValue();

    boolean hasReturnType = asBoolean(ctx.returnType());
    boolean hasMethodBody = asBoolean(ctx.methodBody());

    if (!hasReturnType
            && hasMethodBody
            && methodName.equals(className)) { // constructor declaration

        methodNode = createConstructorNodeForClass(methodName, parameters, exceptions, code, classNode, modifiers);
    } else { // class memeber method declaration
        if (!hasReturnType && hasMethodBody && (0 == modifierManager.getModifierCount())) {
            throw createParsingFailedException("Invalid method declaration: " + methodName, ctx);
        }

        methodNode = createMethodNodeForClass(ctx, modifierManager, methodName, returnType, parameters, exceptions, code, classNode, modifiers);
    }

    modifierManager.attachAnnotations(methodNode);
    return methodNode;
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
@Override
public Statement visitBlockStatement(BlockStatementContext ctx) {
    if (asBoolean(ctx.localVariableDeclaration())) {
        return configureAST(this.visitLocalVariableDeclaration(ctx.localVariableDeclaration()), ctx);
    }

    if (asBoolean(ctx.statement())) {
        Object astNode = this.visit(ctx.statement()); //this.configureAST((Statement) this.visit(ctx.statement()), ctx);

        if (astNode instanceof MethodNode) {
            throw createParsingFailedException("Method definition not expected here", ctx);
        } else {
            return (Statement) astNode;
        }
    }

    throw createParsingFailedException("Unsupported block statement: " + ctx.getText(), ctx);
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
public void positionStmtsAfterEnumInitStmts(List<Statement> staticFieldStatements) {
    MethodNode method = getOrAddStaticConstructorNode();
    Statement statement = method.getCode();
    if (statement instanceof BlockStatement) {
        BlockStatement block = (BlockStatement) statement;
        // add given statements for explicitly declared static fields just after enum-special fields
        // are found - the $VALUES binary expression marks the end of such fields.
        List<Statement> blockStatements = block.getStatements();
        ListIterator<Statement> litr = blockStatements.listIterator();
        while (litr.hasNext()) {
            Statement stmt = litr.next();
            if (stmt instanceof ExpressionStatement &&
                    ((ExpressionStatement) stmt).getExpression() instanceof BinaryExpression) {
                BinaryExpression bExp = (BinaryExpression) ((ExpressionStatement) stmt).getExpression();
                if (bExp.getLeftExpression() instanceof FieldExpression) {
                    FieldExpression fExp = (FieldExpression) bExp.getLeftExpression();
                    if (fExp.getFieldName().equals("$VALUES")) {
                        for (Statement tmpStmt : staticFieldStatements) {
                            litr.add(tmpStmt);
                        }
                    }
                }
            }
        }
    }
}
 

import org.codehaus.groovy.ast.stmt.Statement; //导入依赖的package包/类
/**
 * set the script source position
 */
private void configureScriptClassNode() {
    ClassNode scriptClassNode = moduleNode.getScriptClassDummy();

    if (!asBoolean(scriptClassNode)) {
        return;
    }

    List<Statement> statements = moduleNode.getStatementBlock().getStatements();
    if (!statements.isEmpty()) {
        Statement firstStatement = statements.get(0);
        Statement lastStatement = statements.get(statements.size() - 1);

        scriptClassNode.setSourcePosition(firstStatement);
        scriptClassNode.setLastColumnNumber(lastStatement.getLastColumnNumber());
        scriptClassNode.setLastLineNumber(lastStatement.getLastLineNumber());
    }

}