public static Statement returnS(Expression expr) { return new ReturnStatement(new ExpressionStatement(expr)); }
private static void setMethodDefaultValue(MethodNode mn, Method m) { Object defaultValue = m.getDefaultValue(); ConstantExpression cExp = ConstantExpression.NULL; if (defaultValue!=null) cExp = new ConstantExpression(defaultValue); mn.setCode(new ReturnStatement(cExp)); mn.setAnnotationDefault(true); }
protected Statement returnStatement(AST node) { AST exprNode = node.getFirstChild(); // This will pick up incorrect sibling node if 'node' is a plain 'return' // //if (exprNode == null) { // exprNode = node.getNextSibling(); //} Expression expression = exprNode == null ? ConstantExpression.NULL : expression(exprNode); ReturnStatement returnStatement = new ReturnStatement(expression); configureAST(returnStatement, node); return returnStatement; }
protected static void setPropertyGetterDispatcher(BlockStatement block, Expression thiz, Parameter[] parameters) { List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>(); gStringStrings.add(new ConstantExpression("")); gStringStrings.add(new ConstantExpression("")); List<Expression> gStringValues = new ArrayList<Expression>(); gStringValues.add(new VariableExpression(parameters[0])); block.addStatement( new ReturnStatement( new PropertyExpression( thiz, new GStringExpression("$name", gStringStrings, gStringValues) ) ) ); }
/** * A helper method that can be used to evaluate expressions as found in annotation * parameters. For example, it will evaluate a constant, be it referenced directly as * an integer or as a reference to a field. * <p> * If this method throws an exception, then the expression cannot be evaluated on its own. * * @param expr the expression to be evaluated * @param config the compiler configuration * @return the result of the expression */ public static Object evaluateExpression(Expression expr, CompilerConfiguration config) { String className = "Expression$" + UUID.randomUUID().toString().replace('-', '$'); ClassNode node = new ClassNode(className, Opcodes.ACC_PUBLIC, OBJECT_TYPE); ReturnStatement code = new ReturnStatement(expr); addGeneratedMethod(node, "eval", Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, code); CompilerConfiguration copyConf = new CompilerConfiguration(config); CompilationUnit cu = new CompilationUnit(copyConf); cu.addClassNode(node); cu.compile(Phases.CLASS_GENERATION); @SuppressWarnings("unchecked") List<GroovyClass> classes = (List<GroovyClass>) cu.getClasses(); Class aClass = cu.getClassLoader().defineClass(className, classes.get(0).getBytes()); try { return aClass.getMethod("eval").invoke(null); } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException e) { throw new GroovyBugError(e); } }
@SuppressWarnings("unchecked") private void createDataProcessorMethod() { if (dataProcessorVars.isEmpty()) return; dataProcessorStats.add( new ReturnStatement( new ArrayExpression( ClassHelper.OBJECT_TYPE, (List) dataProcessorVars))); BlockStatement blockStat = new BlockStatement(dataProcessorStats, new VariableScope()); new DataProcessorVariableRewriter().visitBlockStatement(blockStat); whereBlock.getParent().getParent().getAst().addMethod( new MethodNode( InternalIdentifiers.getDataProcessorName(whereBlock.getParent().getAst().getName()), Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, ClassHelper.OBJECT_TYPE, dataProcessorParams.toArray(new Parameter[dataProcessorParams.size()]), ClassNode.EMPTY_ARRAY, blockStat)); }
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); }
protected static void setMethodDispatcherCode(BlockStatement block, Expression thiz, Parameter[] parameters) { List<ConstantExpression> gStringStrings = new ArrayList<ConstantExpression>(); gStringStrings.add(new ConstantExpression("")); gStringStrings.add(new ConstantExpression("")); List<Expression> gStringValues = new ArrayList<Expression>(); gStringValues.add(new VariableExpression(parameters[0])); block.addStatement( new ReturnStatement( new MethodCallExpression( thiz, new GStringExpression("$name", gStringStrings, gStringValues), new ArgumentListExpression( new SpreadExpression(new VariableExpression(parameters[1])) ) ) ) ); }
Statement code = new ReturnStatement(ae); helper.addMethod("value", ACC_PUBLIC + ACC_STATIC, ClassHelper.OBJECT_TYPE.makeArray().makeArray(),
new Parameter[]{args}, ClassNode.EMPTY_ARRAY, new ReturnStatement(doCall1arg))); Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new ReturnStatement(doCallNoArgs)));
annDefault = resolver.resolveType(Type.getType(((TypeWrapper) annDefault).desc)); result.setCode(new ReturnStatement(new ConstantExpression(annDefault))); result.setAnnotationDefault(true); } else { result.setCode(new ReturnStatement(ConstantExpression.NULL));
final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); return returnStatement; ExpressionStatement expStmt = (ExpressionStatement) statement; Expression expr = expStmt.getExpression(); ReturnStatement ret = new ReturnStatement(expr); ret.setSourcePosition(expr); ret.setStatementLabel(statement.getStatementLabel()); if (doAdd) list.set(idx, last); if (!statementReturns(last)) { final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); if (doAdd) list.add(returnStatement); ReturnStatement ret = new ReturnStatement(ConstantExpression.NULL); ret.setSourcePosition(block); listener.returnStatementAdded(ret); final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); return returnStatement; final List list = new ArrayList(); list.add(statement); final ReturnStatement returnStatement = new ReturnStatement(ConstantExpression.NULL); listener.returnStatementAdded(returnStatement); list.add(returnStatement);
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; }
public void testMethods() throws Exception { ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); classNode.addConstructor(new ConstructorNode(ACC_PUBLIC, null)); Statement statementA = new ReturnStatement(new ConstantExpression("calledA")); Statement statementB = new ReturnStatement(new ConstantExpression("calledB")); Statement emptyStatement = new BlockStatement(); classNode.addMethod(new MethodNode("a", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementA)); classNode.addMethod(new MethodNode("b", ACC_PUBLIC, null, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, statementB)); classNode.addMethod(new MethodNode("noReturnMethodA", ACC_PUBLIC, null, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement)); classNode.addMethod(new MethodNode("noReturnMethodB", ACC_PUBLIC, ClassHelper.OBJECT_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement)); classNode.addMethod(new MethodNode("c", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, emptyStatement)); Class fooClass = loadClass(classNode); assertTrue("Loaded a new class", fooClass != null); Object bean = fooClass.newInstance(); assertTrue("Created instance of class: " + bean, bean != null); assertCallMethod(bean, "a", "calledA"); assertCallMethod(bean, "b", "calledB"); assertCallMethod(bean, "noReturnMethodA", null); assertCallMethod(bean, "noReturnMethodB", null); assertCallMethod(bean, "c", null); }
code.addStatement(new ReturnStatement(cce)); initMethod.setCode(code); enumClass.addMethod(initMethod);
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); }
code.addStatement(new ExpressionStatement(expression)); } else { code.addStatement(new ReturnStatement(expression));
parameters, ClassNode.EMPTY_ARRAY, new ReturnStatement( new MethodCallExpression( VariableExpression.THIS_EXPRESSION, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, new ReturnStatement(fieldExp));
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)); valuesMethod.setCode(code); enumClass.addMethod(valuesMethod); new ReturnStatement( new MethodCallExpression(new FieldExpression(values), "getAt", new VariableExpression("ordinal")) new ReturnStatement( new MethodCallExpression(new FieldExpression(values), "getAt", new VariableExpression("ordinal")) new ReturnStatement( new MethodCallExpression(new ClassExpression(ClassHelper.Enum_Type), "valueOf", callArguments)
private void addHolderClassIdiomBody(BlockStatement body, FieldNode fieldNode, Expression initExpr) { final ClassNode declaringClass = fieldNode.getDeclaringClass(); final ClassNode fieldType = fieldNode.getType(); final int visibility = ACC_PRIVATE | ACC_STATIC; final String fullName = declaringClass.getName() + "$" + fieldType.getNameWithoutPackage() + "Holder_" + fieldNode.getName().substring(1); final InnerClassNode holderClass = new InnerClassNode(declaringClass, fullName, visibility, ClassHelper.OBJECT_TYPE); final String innerFieldName = "INSTANCE"; holderClass.addField(innerFieldName, ACC_PRIVATE | ACC_STATIC | ACC_FINAL, fieldType, initExpr); final Expression innerField = new PropertyExpression(new ClassExpression(holderClass), innerFieldName); declaringClass.getModule().addClass(holderClass); body.addStatement(new ReturnStatement(innerField)); }