public void visitMethod(MethodNode node) { Statement statement = node.getCode(); if (!node.isVoidMethod()) { if (statement != null) // it happens with @interface methods { final Statement code = addReturnsIfNeeded(statement, node.getVariableScope()); if (doAdd) node.setCode(code); } } else if (!node.isAbstract() && node.getReturnType().redirect()!=ClassHelper.VOID_TYPE) { if (!(statement instanceof BytecodeSequence)) { BlockStatement newBlock = new BlockStatement(); Statement code = node.getCode(); if (code instanceof BlockStatement) { newBlock.setVariableScope(((BlockStatement) code).getVariableScope()); } if (statement instanceof BlockStatement) { newBlock.addStatements(((BlockStatement)statement).getStatements()); } else { newBlock.addStatement(statement); } final ReturnStatement returnStatement = ReturnStatement.RETURN_NULL_OR_VOID; listener.returnStatementAdded(returnStatement); newBlock.addStatement(returnStatement); newBlock.setSourcePosition(statement); if (doAdd) node.setCode(newBlock); } } }
private void handleMainMethodIfPresent(List methods) { boolean found = false; for (Iterator iter = methods.iterator(); iter.hasNext();) { MethodNode node = (MethodNode) iter.next(); if(node.getName().equals("main")) { if (node.isStatic() && node.getParameters().length == 1) { boolean retTypeMatches, argTypeMatches; ClassNode argType = node.getParameters()[0].getType(); ClassNode retType = node.getReturnType(); argTypeMatches = (argType.equals(ClassHelper.OBJECT_TYPE) || argType.getName().contains("String[]")); retTypeMatches = (retType == ClassHelper.VOID_TYPE || retType == ClassHelper.OBJECT_TYPE); if(retTypeMatches && argTypeMatches) { if(found) { throw new RuntimeException("Repetitive main method found."); } else { found = true; } // if script has both loose statements as well as main(), then main() is ignored if(statementBlock.isEmpty()) { addStatement(node.getCode()); } iter.remove(); } } } } }
public static BlockStatement block(Statement... stmts) { BlockStatement block = new BlockStatement(); for (Statement stmt : stmts) block.addStatement(stmt); return block; }
public static BlockStatement block(VariableScope varScope, List<Statement> stmts) { BlockStatement block = new BlockStatement(); block.setVariableScope(varScope); for (Statement stmt : stmts) block.addStatement(stmt); return block; }
private BlockStatement getBlockStatement(MethodNode targetMethod, Statement code) { BlockStatement toBlock; if (code instanceof BlockStatement) { toBlock = (BlockStatement) code; } else { toBlock = new BlockStatement(); toBlock.addStatement(code); targetMethod.setCode(toBlock); } return toBlock; }
MethodNode valuesMethod = new MethodNode("values", PUBLIC_FS, enumRef.makeArray(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, null); valuesMethod.setSynthetic(true); BlockStatement code = new BlockStatement(); MethodCallExpression cloneCall = new MethodCallExpression(new FieldExpression(values), "clone", MethodCallExpression.NO_ARGUMENTS); cloneCall.setMethodTarget(values.getType().getMethod("clone", Parameter.EMPTY_ARRAY)); code.addStatement(new ReturnStatement(cloneCall)); BlockStatement code = new BlockStatement(); BlockStatement ifStatement = new BlockStatement(); ifStatement.addStatement( new ExpressionStatement( new BinaryExpression(new VariableExpression("ordinal"), assign, new ConstantExpression(0)) code.addStatement( new ExpressionStatement( code.addStatement( new IfStatement( new BooleanExpression(new BinaryExpression( code.addStatement( BlockStatement code = new BlockStatement(); BlockStatement ifStatement = new BlockStatement(); ifStatement.addStatement( code.addStatement( new ExpressionStatement(
public void call(ArgumentListExpression arguments, Parameter[] newParams, MethodNode method) { final BlockStatement code = new BlockStatement(); MethodNode newMethod = new MethodNode(method.getName(), method.getModifiers(), method.getReturnType(), newParams, method.getExceptions(), code); ClassNode type = argument.getType(); if (type instanceof InnerClassNode && ((InnerClassNode) type).isAnonymous()) { type.setEnclosingMethod(newMethod); DeclarationExpression declarationExpression = new DeclarationExpression(localVariable, Token.newSymbol(Types.EQUAL, -1, -1), new ConstructorCallExpression(ClassHelper.makeReference(), param.getInitialExpression())); code.addStatement(new ExpressionStatement(declarationExpression)); code.getVariableScope().putDeclaredVariable(localVariable); MethodCallExpression expression = new MethodCallExpression(VariableExpression.THIS_EXPRESSION, method.getName(), arguments); expression.setMethodTarget(method); expression.setImplicitThis(true); if (method.isVoidMethod()) { code.addStatement(new ExpressionStatement(expression)); } else { code.addStatement(new ReturnStatement(expression)); newMethod.addAnnotations(annotations); MethodNode oldMethod = node.getDeclaredMethod(method.getName(), newParams); if (oldMethod != null) { throw new RuntimeParserException(
target = staticFieldHelper; mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_CLASSNODE), "invokeStaticMethod", thisObject, new ConstantExpression(Traits.helperSetterName(field)), initCode.getExpression() mce = new MethodCallExpression( new CastExpression(createReceiverType(field.isStatic(), fieldHelper), thisObject), Traits.helperSetterName(field), ); mce.setImplicitThis(false); mce.setSourcePosition(initialExpression); code.addStatement(new ExpressionStatement(mce)); target.addMethod( Traits.helperSetterName(field), ACC_PUBLIC | ACC_ABSTRACT,
protected ClassNode createStatementsClass() { ClassNode classNode = getScriptClassDummy(); if (classNode.getName().endsWith("package-info")) { return classNode; MethodNode methodNode = new MethodNode("run", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementBlock); methodNode.setIsScriptBody(); classNode.addMethod(methodNode); classNode.addConstructor(ACC_PUBLIC, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new BlockStatement()); if (classNode.getSuperClass().getDeclaredConstructor(SCRIPT_CONTEXT_CTOR) != null) { stmt = new ExpressionStatement( new ConstructorCallExpression(ClassNode.SUPER, new ArgumentListExpression(
ClassNode outerClass = controller.getOutermostClass(); MethodNode methodNode = controller.getMethodNode(); String name = classNode.getName() + "$" boolean staticMethodOrInStaticClass = controller.isStaticMethod() || classNode.isStaticClass(); removeInitialValues(localVariableParams); InnerClassNode answer = new InnerClassNode(classNode, name, mods, ClassHelper.CLOSURE_TYPE.getPlainNodeReference()); answer.setEnclosingMethod(controller.getMethodNode()); answer.setSynthetic(true); method.setSourcePosition(expression); BlockStatement block = new BlockStatement(); VariableExpression outer = new VariableExpression("_outerInstance", outerClass); outer.setSourcePosition(expression); block.getVariableScope().putReferencedLocalVariable(outer); VariableExpression thisObject = new VariableExpression("_thisObject", classNode); thisObject.setSourcePosition(expression); block.getVariableScope().putReferencedLocalVariable(thisObject); TupleExpression conArgs = new TupleExpression(outer, thisObject); block.addStatement( new ExpressionStatement( new ConstructorCallExpression( ClassNode.SUPER,
private void createSharedFieldGetter(Field field) { String getterName = "get" + MetaClassHelper.capitalize(field.getName()); MethodNode getter = spec.getAst().getMethod(getterName, Parameter.EMPTY_ARRAY); if (getter != null) { errorReporter.error(field.getAst(), "@Shared field '%s' conflicts with method '%s'; please rename either of them", field.getName(), getter.getName()); return; } BlockStatement getterBlock = new BlockStatement(); getter = new MethodNode(getterName, determineVisibilityForSharedFieldAccessor(field) | Opcodes.ACC_SYNTHETIC, field.getAst().getType(), Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, getterBlock); getterBlock.addStatement( new ReturnStatement( new ExpressionStatement( new AttributeExpression( getSharedInstance(), // use internal name new ConstantExpression(field.getAst().getName()))))); getter.setSourcePosition(field.getAst()); spec.getAst().addMethod(getter); }
private void addReturnIfNeeded(MethodNode node) { Statement statement = node.getCode(); if (!node.isVoidMethod()) { if (statement != null) // it happens with @interface methods node.setCode(addReturnsIfNeeded(statement, node.getVariableScope())); } else if (!node.isAbstract()) { if (!(statement instanceof BytecodeSequence)) { BlockStatement newBlock = new BlockStatement(); if (statement instanceof BlockStatement) { newBlock.addStatements(((BlockStatement)statement).getStatements()); } else { newBlock.addStatement(statement); } newBlock.addStatement(ReturnStatement.RETURN_NULL_OR_VOID); newBlock.setSourcePosition(statement); node.setCode(newBlock); } } }
final BlockStatement preBody = new BlockStatement(); boolean superInPre = false; if (pre != null) { final BlockStatement body = new BlockStatement(); Statement propInit = handler.createPropInit(xform, anno, cNode, pNode, null); if (propInit != null) { body.addStatement(propInit); body.addStatement(stmt(ctorX(ClassNode.SUPER, args(superParams)))); if (!preBody.isEmpty()) { body.addStatements(preBody.getStatements()); Statement propInit = handler.createPropInit(xform, anno, cNode, pNode, null); if (propInit != null) { body.addStatement(propInit); body.addStatement(post.getCode()); if (sourceUnit != null && !body.isEmpty()) { VariableScopeVisitor scopeVisitor = new VariableScopeVisitor(sourceUnit); scopeVisitor.visitClass(cNode); if (body.isEmpty()) { body.addStatement(new ExpressionStatement(ConstantExpression.EMPTY_EXPRESSION));
private static Statement createDelegatingForwarder(final MethodNode forwarderMethod, final ClassNode next) { // generates --> next$Trait$Helper.method(this, arg1, arg2) TraitHelpersTuple helpers = Traits.findHelpers(next); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new VariableExpression("this")); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } StaticMethodCallExpression delegateCall = new StaticMethodCallExpression( helpers.getHelper(), forwarderMethod.getName(), args ); Statement result; if (ClassHelper.VOID_TYPE.equals(forwarderMethod.getReturnType())) { BlockStatement stmt = new BlockStatement(); stmt.addStatement(new ExpressionStatement(delegateCall)); stmt.addStatement(new ReturnStatement(new ConstantExpression(null))); result = stmt; } else { result = new ReturnStatement(delegateCall); } return result; }
protected void assertIterate(String methodName, Expression listExpression) throws Exception { ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null)); classNode.addProperty(new PropertyNode("bar", ACC_PUBLIC, ClassHelper.STRING_TYPE, classNode, null, null, null)); Statement loopStatement = createPrintlnStatement(new VariableExpression("i")); BlockStatement block = new BlockStatement(); block.addStatement(new ExpressionStatement(new DeclarationExpression(new VariableExpression("list"), Token.newSymbol("=", 0, 0), listExpression))); block.addStatement(new ForStatement(new Parameter(ClassHelper.DYNAMIC_TYPE, "i"), new VariableExpression("list"), loopStatement)); classNode.addMethod(new MethodNode(methodName, ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, block)); Class fooClass = loadClass(classNode); assertTrue("Loaded a new class", fooClass != null); Object bean = fooClass.newInstance(); assertTrue("Managed to create bean", bean != null); System.out.println("################ Now about to invoke method"); try { InvokerHelper.invokeMethod(bean, methodName, null); } catch (InvokerInvocationException e) { System.out.println("Caught: " + e.getCause()); e.getCause().printStackTrace(); fail("Should not have thrown an exception"); } System.out.println("################ Done"); }
compositeStringExpr.addValue(new VariableExpression("user")); compositeStringExpr.addString(new ConstantExpression("!")); BlockStatement block = new BlockStatement(); block.addStatement( new ExpressionStatement( new DeclarationExpression( new VariableExpression("user"), Token.newSymbol("=", -1, -1), new ConstantExpression("World")))); block.addStatement( new ExpressionStatement( new DeclarationExpression(new VariableExpression("str"), Token.newSymbol("=", -1, -1), compositeStringExpr))); block.addStatement( new ExpressionStatement( new MethodCallExpression(VariableExpression.THIS_EXPRESSION, "println", new VariableExpression("str")))); block.addStatement( new ExpressionStatement( new DeclarationExpression( new VariableExpression("text"), Token.newSymbol("=", -1, -1), new MethodCallExpression(new VariableExpression("str"), "toString", MethodCallExpression.NO_ARGUMENTS)))); block.addStatement( new AssertStatement( new BooleanExpression( classNode.addMethod(new MethodNode("stringDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, block));
String name = getUniqueName(params, node); Parameter thisPara = new Parameter(classNode.getOuterClass().getPlainNodeReference(), name); newParams[0] = thisPara; node.setParameters(newParams); block = new BlockStatement(); } else if (!(code instanceof BlockStatement)) { block = new BlockStatement(); block.addStatement(code); } else { block = (BlockStatement) code; BlockStatement newCode = new BlockStatement(); addFieldInit(thisPara, thisField, newCode); ConstructorCallExpression cce = getFirstIfSpecialConstructorCall(block); if (cce == null) { cce = new ConstructorCallExpression(ClassNode.SUPER, new TupleExpression()); block.getStatements().add(0, new ExpressionStatement(cce)); VariableExpression ve = new VariableExpression(thisPara.getName()); ve.setAccessedVariable(thisPara); expressions.add(0, ve); block.getStatements().add(1, newCode);
private static MethodNode createBuildMethodForMethod(AnnotationNode anno, ClassNode buildee, MethodNode mNode, Parameter[] params) { String buildMethodName = getMemberStringValue(anno, "buildMethodName", "build"); final BlockStatement body = new BlockStatement(); ClassNode returnType; if (mNode instanceof ConstructorNode) { returnType = newClass(buildee); body.addStatement(returnS(ctorX(newClass(mNode.getDeclaringClass()), args(params)))); } else { body.addStatement(returnS(callX(newClass(mNode.getDeclaringClass()), mNode.getName(), args(params)))); returnType = newClass(mNode.getReturnType()); } return new MethodNode(buildMethodName, ACC_PUBLIC, returnType, NO_PARAMS, NO_EXCEPTIONS, body); }
private void createDataProviderMethod(Expression dataProviderExpr, int nextDataVariableIndex) { instanceFieldAccessChecker.check(dataProviderExpr); dataProviderExpr = dataProviderExpr.transformExpression(new DataTablePreviousVariableTransformer()); MethodNode method = new MethodNode( InternalIdentifiers.getDataProviderName(whereBlock.getParent().getAst().getName(), dataProviderCount++), Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, ClassHelper.OBJECT_TYPE, getPreviousParameters(nextDataVariableIndex), ClassNode.EMPTY_ARRAY, new BlockStatement( Arrays.<Statement>asList( new ReturnStatement( new ExpressionStatement(dataProviderExpr))), new VariableScope())); method.addAnnotation(createDataProviderAnnotation(dataProviderExpr, nextDataVariableIndex)); whereBlock.getParent().getParent().getAst().addMethod(method); }
private void addPrecondition(MethodNode method, BlockStatement blockStatement) { final BlockStatement modifiedMethodCode = new BlockStatement(); modifiedMethodCode.addStatements(blockStatement.getStatements()); if (method.getCode() instanceof BlockStatement) { BlockStatement methodBlock = (BlockStatement) method.getCode(); for (Statement statement : methodBlock.getStatements()) { if (method instanceof ConstructorNode && statement instanceof ExpressionStatement && ((ExpressionStatement) statement).getExpression() instanceof ConstructorCallExpression) { modifiedMethodCode.getStatements().add(0, statement); } else { modifiedMethodCode.getStatements().add(statement); } } } else { modifiedMethodCode.addStatement(method.getCode()); } method.setCode(modifiedMethodCode); } }