private Expression transformMethodCallOnThisFallBack(final MethodCallExpression call, final Expression method, final Expression arguments) { MethodCallExpression transformed = new MethodCallExpression( weaved, method, transform(arguments) ); transformed.setSourcePosition(call); transformed.setSafe(call.isSafe()); transformed.setSpreadSafe(call.isSpreadSafe()); transformed.setImplicitThis(false); return transformed; }
@Override protected boolean handleTargetMethodCallExpression(MethodCallExpression call) { ClosureExpression closureExpression = getClosureArgument(call); List<Expression> otherArgs = getNonClosureArguments(call); String source = convertClosureToSource(closureExpression); // parameter order is build(CompilePhase, boolean, String) otherArgs.add(new ConstantExpression(source)); call.setArguments(new ArgumentListExpression(otherArgs)); call.setMethod(new ConstantExpression("buildFromBlock")); call.setSpreadSafe(false); call.setSafe(false); call.setImplicitThis(false); return false; }
call.setSafe(exp.isSafe()); call.setSpreadSafe(exp.isSpreadSafe()); call.setSourcePosition(exp);
private Expression transformPrivateMethodCallOnThis(final MethodCallExpression call, final Expression arguments, final String methodName) { ArgumentListExpression newArgs = createArgumentList(arguments); MethodCallExpression transformed = new MethodCallExpression( new VariableExpression("this"), methodName, newArgs ); transformed.setSourcePosition(call); transformed.setSafe(call.isSafe()); transformed.setSpreadSafe(call.isSpreadSafe()); transformed.setImplicitThis(true); return transformed; }
private Expression transformPrivateMethodCallOnThisInClosure(final MethodCallExpression call, final Expression arguments, final String methodName) { ArgumentListExpression newArgs = createArgumentList(arguments); MethodCallExpression transformed = new MethodCallExpression( new ClassExpression(traitHelperClass), methodName, newArgs ); transformed.setSourcePosition(call); transformed.setSafe(call.isSafe()); transformed.setSpreadSafe(call.isSpreadSafe()); transformed.setImplicitThis(true); return transformed; }
public Expression transformExpression(ExpressionTransformer transformer) { MethodCallExpression answer = new MethodCallExpression(transformer.transform(objectExpression), transformer.transform(method), transformer.transform(arguments)); answer.setSafe(safe); answer.setSpreadSafe(spreadSafe); answer.setImplicitThis(implicitThis); answer.setGenericsTypes(genericsTypes); answer.setSourcePosition(this); answer.setMethodTarget(target); answer.copyNodeMetaData(this); return answer; }
private Expression transformMethodCallOnThisInClosure(final MethodCallExpression call) { MethodCallExpression transformed = new MethodCallExpression( (Expression) call.getReceiver(), call.getMethod(), transform(call.getArguments()) ); transformed.setSourcePosition(call); transformed.setSafe(call.isSafe()); transformed.setSpreadSafe(call.isSpreadSafe()); transformed.setImplicitThis(call.isImplicitThis()); return transformed; }
public void writeInvokeMethod(MethodCallExpression call) { if (isClosureCall(call)) { // let's invoke the closure method invokeClosure(call.getArguments(), call.getMethodAsString()); } else { boolean isSuperMethodCall = usesSuper(call); MethodCallerMultiAdapter adapter = invokeMethod; if (isSuperMethodCall && call.isSafe()) { // safe is not necessary here because "super" is always not null // but keeping the flag would trigger a VerifyError (see GROOVY-6045) call.setSafe(false); } if (AsmClassGenerator.isThisExpression(call.getObjectExpression())) adapter = invokeMethodOnCurrent; if (isSuperMethodCall) adapter = invokeMethodOnSuper; if (isStaticInvocation(call)) adapter = invokeStaticMethod; makeInvokeMethodCall(call, isSuperMethodCall, adapter); } }
private void makeDynamicGetProperty(final Expression receiver, final String methodName, final boolean safe) { MethodNode target = safe?INVOKERHELPER_GETPROPERTYSAFE_METHOD:INVOKERHELPER_GETPROPERTY_METHOD; MethodCallExpression mce = new MethodCallExpression( new ClassExpression(INVOKERHELPER_TYPE), target.getName(), new ArgumentListExpression(receiver, new ConstantExpression(methodName)) ); mce.setSafe(false); mce.setImplicitThis(false); mce.setMethodTarget(target); mce.visit(controller.getAcg()); }
private Expression transformSuperMethodCall(final MethodCallExpression call) { String method = call.getMethodAsString(); if (method == null) { throwSuperError(call); } Expression arguments = transform(call.getArguments()); ArgumentListExpression superCallArgs = new ArgumentListExpression(); if (arguments instanceof ArgumentListExpression) { ArgumentListExpression list = (ArgumentListExpression) arguments; for (Expression expression : list) { superCallArgs.addExpression(expression); } } else { superCallArgs.addExpression(arguments); } MethodCallExpression transformed = new MethodCallExpression( weaved, Traits.getSuperTraitMethodName(traitClass, method), superCallArgs ); transformed.setSourcePosition(call); transformed.setSafe(call.isSafe()); transformed.setSpreadSafe(call.isSpreadSafe()); transformed.setImplicitThis(false); return transformed; }
private static MethodCallExpression transformToMopSuperCall(final ClassNode superCallReceiver, final MethodCallExpression expr) { MethodNode mn = expr.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET); String mopName = MopWriter.getMopMethodName(mn, false); MethodNode direct = new MethodNode( mopName, ACC_PUBLIC | ACC_SYNTHETIC, mn.getReturnType(), mn.getParameters(), mn.getExceptions(), EmptyStatement.INSTANCE ); direct.setDeclaringClass(superCallReceiver); MethodCallExpression result = new MethodCallExpression( new VariableExpression("this"), mopName, expr.getArguments() ); result.setImplicitThis(true); result.setSpreadSafe(false); result.setSafe(false); result.setSourcePosition(expr); result.setMethodTarget(direct); return result; }
protected Expression transformMethodCallExpression(MethodCallExpression mce) { Expression args = transform(mce.getArguments()); Expression method = transform(mce.getMethod()); Expression object = transform(mce.getObjectExpression()); resolveGenericsTypes(mce.getGenericsTypes()); MethodCallExpression result = new MethodCallExpression(object, method, args); result.setSafe(mce.isSafe()); result.setImplicitThis(mce.isImplicitThis()); result.setSpreadSafe(mce.isSpreadSafe()); result.setSourcePosition(mce); result.setGenericsTypes(mce.getGenericsTypes()); result.setMethodTarget(mce.getMethodTarget()); return result; }
); call.setImplicitThis(implicitThis); call.setSafe(safe); call.setSpreadSafe(spreadSafe); call.setMethodTarget(setterMethod);
@Override public void visitMethodCallExpression(MethodCallExpression expr) { // at runtime, condition AST is only parsed up to phase conversion, // and hence looks differently in cases where groovyc inserts ".call" // in phase semantic analysis; we need to compensate for that // (in other cases, ".call" is only inserted after transform has // run, and hence we don't need to compensate) boolean objectExprSeenAsMethodNameAtRuntime = !expr.isImplicitThis() && expr.getObjectExpression() instanceof VariableExpression && "call".equals(expr.getMethodAsString()) && (!AstUtil.hasPlausibleSourcePosition(expr.getMethod()) // before GROOVY-4344 fix || (expr.getMethod().getColumnNumber() == expr.getObjectExpression().getColumnNumber())); // after GROOVY-4344 fix MethodCallExpression conversion = new MethodCallExpression( expr.isImplicitThis() ? expr.getObjectExpression() : convert(expr.getObjectExpression()), objectExprSeenAsMethodNameAtRuntime ? expr.getMethod() : convert(expr.getMethod()), convert(expr.getArguments())); conversion.setSafe(expr.isSafe()); conversion.setSpreadSafe(expr.isSpreadSafe()); conversion.setSourcePosition(expr); result = record(conversion); }
private static void createSoftGetter(FieldNode fieldNode, Expression initExpr, ClassNode type) { final BlockStatement body = new BlockStatement(); final Expression fieldExpr = varX(fieldNode); final Expression resExpr = varX("res", type); final MethodCallExpression callExpression = callX(fieldExpr, "get"); callExpression.setSafe(true); body.addStatement(declS(resExpr, callExpression)); final Statement mainIf = ifElseS(notNullX(resExpr), stmt(resExpr), block( assignS(resExpr, initExpr), assignS(fieldExpr, ctorX(SOFT_REF, resExpr)), stmt(resExpr))); if (fieldNode.isVolatile()) { body.addStatement(ifElseS( notNullX(resExpr), stmt(resExpr), new SynchronizedStatement(syncTarget(fieldNode), block( assignS(resExpr, callExpression), mainIf) ) )); } else { body.addStatement(mainIf); } addMethod(fieldNode, body, type); }
new ArgumentListExpression(field.isStatic()?new ConstantExpression(null):receiver, arguments)); mce.setMethodTarget(methodNode); mce.setSafe(safe); mce.setSpreadSafe(spreadSafe); mce.setImplicitThis(implicitThis);
); call.setImplicitThis(implicitThis); call.setSafe(safe); call.setMethodTarget(GROOVYOBJECT_GETPROPERTY_METHOD); call.visit(controller.getAcg());
result.setImplicitThis(false); result.setSpreadSafe(exp.isSpreadSafe()); result.setSafe(exp.isSafe()); result.setSourcePosition(exp); return result;
MethodCallExpression transformed = callX(object, method, args); transformed.setImplicitThis(mce.isImplicitThis()); transformed.setSafe(mce.isSafe()); transformed.setSourcePosition(mce); return transformed;