org.codehaus.groovy.ast.GroovyCodeVisitor Java Examples

@Override
public void visit(final GroovyCodeVisitor visitor) {
    receiver.visit(visitor);
    if (visitor instanceof AsmClassGenerator) {
        ClassNode topOperand = controller.getOperandStack().getTopOperand();
        ClassNode type = getType();
        if (ClassHelper.GSTRING_TYPE.equals(topOperand) && ClassHelper.STRING_TYPE.equals(type)) {
            // perform regular type conversion
            controller.getOperandStack().doGroovyCast(type);
            return;
        }
        if (ClassHelper.isPrimitiveType(topOperand) && !ClassHelper.isPrimitiveType(type)) {
            controller.getOperandStack().box();
        } else if (!ClassHelper.isPrimitiveType(topOperand) && ClassHelper.isPrimitiveType(type)) {
            controller.getOperandStack().doGroovyCast(type);
        }
        if (StaticTypeCheckingSupport.implementsInterfaceOrIsSubclassOf(topOperand, type)) return;
        controller.getMethodVisitor().visitTypeInsn(CHECKCAST, type.isArray()
                ? BytecodeHelper.getTypeDescription(type)
                : BytecodeHelper.getClassInternalName(type.getName()));
        controller.getOperandStack().replace(type);
    }
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    if (visitor instanceof AsmClassGenerator) {
        AsmClassGenerator acg = (AsmClassGenerator) visitor;
        WriterController controller = acg.getController();
        controller.getTypeChooser().resolveType(leftExpression, controller.getClassNode());
        controller.getTypeChooser().resolveType(rightExpression, controller.getClassNode());
        MethodVisitor mv = controller.getMethodVisitor();
        leftExpression.visit(acg);
        controller.getOperandStack().box();
        rightExpression.visit(acg);
        controller.getOperandStack().box();
        Label l1 = new Label();
        mv.visitJumpInsn(IF_ACMPNE, l1);
        mv.visitInsn(ICONST_1);
        Label l2 = new Label();
        mv.visitJumpInsn(GOTO, l2);
        mv.visitLabel(l1);
        mv.visitInsn(ICONST_0);
        mv.visitLabel(l2);
        controller.getOperandStack().replace(ClassHelper.boolean_TYPE, 2);
    } else {
        super.visit(visitor);
    }
}
 

public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
    source.getAST().getStatementBlock().visit(transformer);
    for (Object method : source.getAST().getMethods()) {
        MethodNode methodNode = (MethodNode) method;
        methodNode.getCode().visit(transformer);
    }
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    if (visitor instanceof AsmClassGenerator) {
        AsmClassGenerator acg = (AsmClassGenerator) visitor;
        WriterController controller = acg.getController();
        MethodVisitor mv = controller.getMethodVisitor();
        objectExpression.visit(acg);
        ClassNode top = controller.getOperandStack().getTopOperand();
        if (ClassHelper.isPrimitiveType(top)) {
            controller.getOperandStack().pop();
            mv.visitInsn(equalsNull ? ICONST_0 : ICONST_1);
            controller.getOperandStack().push(ClassHelper.boolean_TYPE);
            return;
        }
        Label zero = new Label();
        mv.visitJumpInsn(equalsNull ? IFNONNULL : IFNULL, zero);
        mv.visitInsn(ICONST_1);
        Label end = new Label();
        mv.visitJumpInsn(GOTO, end);
        mv.visitLabel(zero);
        mv.visitInsn(ICONST_0);
        mv.visitLabel(end);
        controller.getOperandStack().replace(ClassHelper.boolean_TYPE);
    } else {
        super.visit(visitor);
    }
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    if (visitor instanceof AsmClassGenerator) {
        acg = (AsmClassGenerator) visitor;
    } else {
        originalCall.visit(visitor);
    }
    super.visit(visitor);
}
 

@Override
protected GroovyCodeVisitor getTransformer(ASTNode[] nodes, SourceUnit sourceUnit) {
    // todo : are there other import types that can be specified?
    return new AstBuilderInvocationTrap(
        sourceUnit.getAST().getImports(),
        sourceUnit.getAST().getStarImports(),
        sourceUnit.getSource(),
        sourceUnit
    );
}
 

public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
    source.getAST().getStatementBlock().visit(transformer);
    for (Object method : source.getAST().getMethods()) {
        MethodNode methodNode = (MethodNode) method;
        methodNode.getCode().visit(transformer);
    }
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    if (visitor instanceof AsmClassGenerator) {
        if (variable==null) {
            AsmClassGenerator acg = (AsmClassGenerator) visitor;
            WriterController controller = acg.getController();
            variable = new ExpressionAsVariableSlot(controller, expression);
        }
        variable.visit(visitor);
    } else {
        expression.visit(visitor);
    }
}
 

public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
    source.getAST().getStatementBlock().visit(transformer);
    for (Object method : source.getAST().getMethods()) {
        MethodNode methodNode = (MethodNode) method;
        methodNode.getCode().visit(transformer);
    }
}
 

private static void checkReturnInObjectInitializer(List<Statement> init) {
    GroovyCodeVisitor visitor = new CodeVisitorSupport() {
        @Override
        public void visitClosureExpression(ClosureExpression expression) {
            // return is OK in closures in object initializers
        }
        @Override
        public void visitReturnStatement(ReturnStatement statement) {
            throw new RuntimeParserException("'return' is not allowed in object initializer", statement);
        }
    };
    for (Statement stmt : init) {
        stmt.visit(visitor);
    }
}
 

public static void visitScriptCode(SourceUnit source, GroovyCodeVisitor transformer) {
    source.getAST().getStatementBlock().visit(transformer);
    for (Object method : source.getAST().getMethods()) {
        MethodNode methodNode = (MethodNode) method;
        methodNode.getCode().visit(transformer);
    }
}
 

private static boolean isAccessingInstanceMembersOfEnclosingClass(final MethodNode syntheticLambdaMethodNode) {
    boolean[] result = new boolean[1];

    GroovyCodeVisitor visitor = new CodeVisitorSupport() {
        @Override
        public void visitVariableExpression(final VariableExpression expression) {
            if (expression.isThisExpression()) {
                result[0] = true;
            }
        }
    };
    syntheticLambdaMethodNode.getCode().visit(visitor);

    return result[0];
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    super.visit(visitor);
    if (visitor instanceof AsmClassGenerator) {
        // ignore the return of the call
        ((AsmClassGenerator) visitor).getController().getOperandStack().pop();
    }
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    if (visitor instanceof AsmClassGenerator) {
        AsmClassGenerator generator = (AsmClassGenerator) visitor;
        controller = generator.getController();
    }
    super.visit(visitor);
}
 

public void visit(GroovyCodeVisitor visitor) {
    AnnotationNode node = (AnnotationNode) getValue();
    Map<String, Expression> attrs = node.getMembers();
    for (Expression expr : attrs.values()) {
        expr.visit(visitor);
    }
    super.visit(visitor);
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    super.visit(visitor);
    if (visitor instanceof AsmClassGenerator) {
        tmp.remove(((AsmClassGenerator) visitor).getController());
    }
}
 

public void visit(final GroovyCodeVisitor visitor) {
    visitor.visitPropertyExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitClassExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitUnaryPlusExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitSpreadMapExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitClosureExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitSpreadExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitVariableExpression(this);
}
 

public void visit(final GroovyCodeVisitor visitor) {
    visitor.visitTupleExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitAttributeExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitPrefixExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitShortTernaryExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitPostfixExpression(this);
}
 

public void visit(GroovyCodeVisitor visitor) {
    visitor.visitBitwiseNegationExpression(this);
}
 

@Override
public void visit(final GroovyCodeVisitor visitor) {
    for (Expression expression : expressions) {
        expression.visit(visitor);
    }
}