private Statement rewriteMethodCondition(MethodCallExpression condition, Expression message, boolean explicit) { MethodCallExpression rewritten; int lastVariableNum; final Expression converted = convert(condition); rewritten = (MethodCallExpression) unrecord(converted); lastVariableNum = extractVariableNumber(converted); List<Expression> args = new ArrayList<>(); args.add(rewritten.getObjectExpression()); args.add(rewritten.getMethod()); args.add(AstUtil.toArgumentArray(AstUtil.getArgumentList(rewritten), resources)); // rewriting has produced N/A's that haven't been realized yet, so do that now args.add(realizeNas(new ConstantExpression(rewritten.isSafe()))); args.add(new ConstantExpression(explicit)); args.add(new ConstantExpression(lastVariableNum)); return surroundWithTryCatch( condition, message, rewriteToSpockRuntimeCall( resources.getAstNodeCache().SpockRuntime_VerifyMethodCondition, condition, message, args)); }
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; }
/** * Identifies a method call expression on {@link DefaultGroovyMethods#is(Object, Object)} and if recognized, transforms it into a {@link CompareIdentityExpression}. * @param call a method call to be transformed * @return null if the method call is not DGM#is, or {@link CompareIdentityExpression} */ private static Expression tryTransformIsToCompareIdentity(MethodCallExpression call) { if (call.isSafe()) return null; MethodNode methodTarget = call.getMethodTarget(); if (methodTarget instanceof ExtensionMethodNode && "is".equals(methodTarget.getName()) && methodTarget.getParameters().length==1) { methodTarget = ((ExtensionMethodNode) methodTarget).getExtensionMethodNode(); ClassNode owner = methodTarget.getDeclaringClass(); if (DGM_CLASSNODE.equals(owner)) { Expression args = call.getArguments(); if (args instanceof ArgumentListExpression) { ArgumentListExpression arguments = (ArgumentListExpression) args; List<Expression> exprs = arguments.getExpressions(); if (exprs.size() == 1) { CompareIdentityExpression cid = new CompareIdentityExpression(call.getObjectExpression(), exprs.get(0)); cid.setSourcePosition(call); return cid; } } } } return null; } }
call.setSafe(exp.isSafe()); call.setSpreadSafe(exp.isSpreadSafe()); call.setSourcePosition(exp);
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; }
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 void makeInvokeMethodCall(MethodCallExpression call, boolean useSuper, MethodCallerMultiAdapter adapter) { // receiver // we operate on GroovyObject if possible Expression objectExpression = call.getObjectExpression(); // message name Expression messageName = new CastExpression(ClassHelper.STRING_TYPE, call.getMethod()); if (useSuper) { ClassNode classNode = controller.isInClosure() ? controller.getOutermostClass() : controller.getClassNode(); // GROOVY-4035 ClassNode superClass = classNode.getSuperClass(); makeCall(call, new ClassExpression(superClass), objectExpression, messageName, call.getArguments(), adapter, call.isSafe(), call.isSpreadSafe(), false ); } else { makeCall(call, objectExpression, messageName, call.getArguments(), adapter, call.isSafe(), call.isSpreadSafe(), call.isImplicitThis() ); } }
protected void storeType(Expression exp, ClassNode cn) { if (exp instanceof VariableExpression && ((VariableExpression) exp).isClosureSharedVariable() && isPrimitiveType(cn)) { cn = getWrapper(cn); } else if (exp instanceof MethodCallExpression && ((MethodCallExpression) exp).isSafe() && isPrimitiveType(cn)) { cn = getWrapper(cn); } else if (exp instanceof PropertyExpression && ((PropertyExpression) exp).isSafe() && isPrimitiveType(cn)) {
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 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; }
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; }
@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); }
result.setImplicitThis(false); result.setSourcePosition(expr); result.setSafe(expr.isSafe()); result.setSpreadSafe(expr.isSpreadSafe()); result.setMethodTarget(StaticTypeCheckingVisitor.CLOSURE_CALL_VARGS);
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;
result.setSafe(mce.isSafe()); result.setImplicitThis(mce.isImplicitThis()); result.setSpreadSafe(mce.isSpreadSafe());
protected Expression transformMethodCallExpression(MethodCallExpression mce) { Expression args = transform(mce.getArguments()); Expression method = transform(mce.getMethod()); Expression object = transform(mce.getObjectExpression()); MethodCallExpression result = new MethodCallExpression(object, method, args); result.setSafe(mce.isSafe()); result.setImplicitThis(mce.isImplicitThis()); result.setSpreadSafe(mce.isSpreadSafe()); result.setSourcePosition(mce); return result; }
protected Expression transformMethodCallExpression(MethodCallExpression mce) { Expression args = transform(mce.getArguments()); Expression method = transform(mce.getMethod()); Expression object = transform(mce.getObjectExpression()); MethodCallExpression result = new MethodCallExpression(object, method, args); result.setSafe(mce.isSafe()); result.setImplicitThis(mce.isImplicitThis()); result.setSpreadSafe(mce.isSpreadSafe()); result.setSourcePosition(mce); return result; }