Set<ASTNode> accessedMethods = (Set<ASTNode>) node.getNodeMetaData(StaticTypesMarker.PV_METHODS_ACCESS); if (accessedMethods==null) return; List<MethodNode> methods = new ArrayList<MethodNode>(node.getAllDeclaredMethods()); methods.addAll(node.getDeclaredConstructors()); if (method.getParameters()==null || method.getParameters().length==0) { arguments = ArgumentListExpression.EMPTY_ARGUMENTS; } else { List<Expression> args = new LinkedList<Expression>(); for (Parameter parameter : methodParameters) { args.add(new VariableExpression(parameter)); arguments = new ArgumentListExpression(args); Statement body = new ExpressionStatement(cce); Expression receiver = method.isStatic()?new ClassExpression(node):new VariableExpression(newParams[0]); MethodCallExpression mce = new MethodCallExpression(receiver, method.getName(), arguments); mce.setMethodTarget(method); ExpressionStatement returnStatement = new ExpressionStatement(mce);
public static boolean copyStatementsWithSuperAdjustment(ClosureExpression pre, BlockStatement body) { Statement preCode = pre.getCode(); boolean changed = false; if (preCode instanceof BlockStatement) { BlockStatement block = (BlockStatement) preCode; List<Statement> statements = block.getStatements(); for (int i = 0; i < statements.size(); i++) { Statement statement = statements.get(i); // adjust the first statement if it's a super call if (i == 0 && statement instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) statement; Expression preExp = es.getExpression(); if (preExp instanceof MethodCallExpression) { MethodCallExpression mce = (MethodCallExpression) preExp; String name = mce.getMethodAsString(); if ("super".equals(name)) { es.setExpression(new ConstructorCallExpression(ClassNode.SUPER, mce.getArguments())); changed = true; } } } body.addStatement(statement); } } return changed; }
public ReturnStatement(ExpressionStatement statement) { this(statement.getExpression()); setStatementLabel(statement.getStatementLabel()); }
private Statement createNewLine(final ASTNode node) { MethodCallExpression mce = new MethodCallExpression( new VariableExpression("this"), "newLine", ArgumentListExpression.EMPTY_ARGUMENTS ); mce.setImplicitThis(true); mce.setSourcePosition(node); ExpressionStatement stmt = new ExpressionStatement(mce); stmt.setSourcePosition(node); return stmt; } }
public void visitExpressionStatement(ExpressionStatement es) { es.setExpression(transform(es.getExpression())); } }
BlockStatement code = new BlockStatement(); code.addStatement(new ReturnStatement(cce)); initMethod.setCode(code); enumClass.addMethod(initMethod); ArgumentListExpression args = new ArgumentListExpression(); args.addExpression(new ConstantExpression(field.getName())); args.addExpression(new ConstantExpression(value)); new ExpressionStatement( new BinaryExpression( new FieldExpression(field), if (tempMin != null) { block.add( new ExpressionStatement( new BinaryExpression( new FieldExpression(minValue), new ExpressionStatement( new BinaryExpression( new FieldExpression(maxValue), new ExpressionStatement( new BinaryExpression(new FieldExpression(values), assign, new ArrayExpression(enumClass, arrayInit))
genericsSpec = GenericsUtils.createGenericsSpec(trait, genericsSpec); MethodNode originalMethod = trait.getMethod(name, params); params[i - 1] = newParam; origParams[i-1] = parameter; argList.addExpression(new VariableExpression(params[i - 1])); MethodCallExpression staticInitCall = new MethodCallExpression( new ClassExpression(helperClassNode), Traits.STATIC_INIT_METHOD, staticInitCall.setMethodTarget(staticInitMethod); cNode.addStaticInitializerStatements(Collections.<Statement>singletonList(new ExpressionStatement( staticInitCall )), false); cNode.addObjectInitializerStatements(new ExpressionStatement( new MethodCallExpression( new ClassExpression(helperClassNode), Traits.INIT_METHOD, new ArgumentListExpression(new VariableExpression("this"))) ));
private static void addMethods(ClassNode enumClass, FieldNode values) { List<MethodNode> methods = enumClass.getMethods(); if (m.getName().equals("next") && m.getParameters().length == 0) hasNext = true; if (m.getName().equals("previous") && m.getParameters().length == 0) hasPrevious = true; if (hasNext && hasPrevious) break; ClassNode enumRef = enumClass.getPlainNodeReference(); BlockStatement code = new BlockStatement(); new ExpressionStatement( new BinaryExpression(new VariableExpression("ordinal"), assign, new ConstantExpression(0)) new ExpressionStatement( new MethodCallExpression( new ExpressionStatement( ArgumentListExpression callArguments = new ArgumentListExpression(); callArguments.addExpression(new ClassExpression(enumClass)); callArguments.addExpression(new VariableExpression("name"));
classNode.addMethod( new MethodNode( "main", ACC_PUBLIC | ACC_STATIC, ClassHelper.VOID_TYPE, new Parameter[] { new Parameter(ClassHelper.STRING_TYPE.makeArray(), "args")}, ClassNode.EMPTY_ARRAY, new ExpressionStatement( new MethodCallExpression( new ClassExpression(ClassHelper.make(InvokerHelper.class)), "runScript", new ArgumentListExpression( new ClassExpression(classNode), new VariableExpression("args")))))); 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( } else { stmt = new ExpressionStatement( new MethodCallExpression( new VariableExpression("super"),
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); for (Expression argument : arguments.getExpressions()) { if (argument instanceof CastExpression) { argument = ((CastExpression) argument).getExpression(); 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);
ClassNode target = field.isStatic() && staticFieldHelper != null ? staticFieldHelper : fieldHelper; if (initialExpression != null) { VariableExpression thisObject = new VariableExpression(selectedMethod.getParameters()[0]); ExpressionStatement initCode = new ExpressionStatement(initialExpression); processBody(thisObject, initCode, trait, helper, fieldHelper, knownFields); if (field.isFinal()) { String baseName = field.isStatic() ? Traits.STATIC_INIT_METHOD : Traits.INIT_METHOD; MethodNode fieldInitializer = new MethodNode( baseName + Traits.remappedFieldName(trait, field.getName()), ACC_STATIC | ACC_PUBLIC | ACC_SYNTHETIC, new Parameter[]{createSelfParameter(trait, field.isStatic())}, ClassNode.EMPTY_ARRAY, returnS(initCode.getExpression()) ); helper.addMethod(fieldInitializer); } else { BlockStatement code = (BlockStatement) selectedMethod.getCode(); MethodCallExpression mce; if (field.isStatic()) { mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_CLASSNODE), "invokeStaticMethod", new ArgumentListExpression( thisObject, new ConstantExpression(Traits.helperSetterName(field)), initCode.getExpression()
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); "Must have a VariableScope by now! for expression: " + expression + " class: " + name); } else { method.setVariableScope(varScope.copy()); BlockStatement block = new BlockStatement(); new ExpressionStatement( new ConstructorCallExpression( ClassNode.SUPER,
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; }
private Expression transformMethodCall(final MethodCallExpression exp) { String name = exp.getMethodAsString(); if (exp.isImplicitThis() && "include".equals(name)) { return tryTransformInclude(exp); } else if (exp.isImplicitThis() && name.startsWith(":")) { List<Expression> args; if (exp.getArguments() instanceof ArgumentListExpression) { args = ((ArgumentListExpression) exp.getArguments()).getExpressions(); } else { args = Collections.singletonList(exp.getArguments()); Expression newArguments = transform(new ArgumentListExpression(new ConstantExpression(name.substring(1)), new ArrayExpression(ClassHelper.OBJECT_TYPE, args))); MethodCallExpression call = new MethodCallExpression( new VariableExpression("this"), "methodMissing", newArguments reformatted.setSourcePosition(exp); ClosureExpression clos = new ClosureExpression(Parameter.EMPTY_ARRAY, new ExpressionStatement(reformatted)); clos.setVariableScope(new VariableScope()); MethodCallExpression stringOf = new MethodCallExpression(new VariableExpression("this"), "stringOf", clos);
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 static Statement createSuperFallback(MethodNode forwarderMethod, ClassNode returnType) { ArgumentListExpression args = new ArgumentListExpression(); Parameter[] forwarderMethodParameters = forwarderMethod.getParameters(); for (final Parameter forwarderMethodParameter : forwarderMethodParameters) { args.addExpression(new VariableExpression(forwarderMethodParameter)); } BinaryExpression instanceOfExpr = new BinaryExpression(new VariableExpression("this"), Token.newSymbol(Types.KEYWORD_INSTANCEOF, -1, -1), new ClassExpression(Traits.GENERATED_PROXY_CLASSNODE)); MethodCallExpression superCall = new MethodCallExpression( new VariableExpression("super"), forwarderMethod.getName(), args ); superCall.setImplicitThis(false); CastExpression proxyReceiver = new CastExpression(Traits.GENERATED_PROXY_CLASSNODE, new VariableExpression("this")); MethodCallExpression getProxy = new MethodCallExpression(proxyReceiver, "getProxyTarget", ArgumentListExpression.EMPTY_ARGUMENTS); getProxy.setImplicitThis(true); StaticMethodCallExpression proxyCall = new StaticMethodCallExpression( ClassHelper.make(InvokerHelper.class), "invokeMethod", new ArgumentListExpression(getProxy, new ConstantExpression(forwarderMethod.getName()), new ArrayExpression(ClassHelper.OBJECT_TYPE, args.getExpressions())) ); IfStatement stmt = new IfStatement( new BooleanExpression(instanceOfExpr), new ExpressionStatement(new CastExpression(returnType,proxyCall)), new ExpressionStatement(superCall) ); return stmt; }
private void printMethod(PrintWriter out, ClassNode clazz, MethodNode methodNode) { if (methodNode.getName().equals("<clinit>")) return; if (methodNode.isPrivate() || !Utilities.isJavaIdentifier(methodNode.getName())) return; if (methodNode.isSynthetic() && methodNode.getName().equals("$getStaticMetaClass")) return; modifiers ^= Opcodes.ACC_ABSTRACT; printModifiers(out, modifiers & ~(clazz.isEnum() ? Opcodes.ACC_ABSTRACT : 0)); } else if (isAbstract(methodNode) && !clazz.isEnum()) { if (clazz.isAnnotationDefinition() && methodNode.hasAnnotationDefault()) { Statement fs = methodNode.getFirstStatement(); if (fs instanceof ExpressionStatement) { ExpressionStatement es = (ExpressionStatement) fs; Expression re = es.getExpression(); out.print(" default "); ClassNode rt = methodNode.getReturnType();
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"); }
public void testConstructor() throws Exception { ClassNode classNode = new ClassNode("Foo", ACC_PUBLIC, ClassHelper.OBJECT_TYPE); 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( classNode.addMethod(new MethodNode("stringDemo", ACC_PUBLIC, ClassHelper.VOID_TYPE, Parameter.EMPTY_ARRAY, ClassNode.EMPTY_ARRAY, block));
protected void addMockCollaborators(String mockType, List<ClassExpression> targetClasses, BlockStatement methodBody) { ArgumentListExpression args = new ArgumentListExpression(); for(ClassExpression ce : targetClasses) { args.addExpression(ce); } methodBody.getStatements().add(0, new ExpressionStatement(new MethodCallExpression(new VariableExpression("this"), "mock" + mockType + 's', args))); }