private Expression rewriteToSpockRuntimeCall(MethodNode method, Expression condition, Expression message, List<Expression> additionalArgs) { List<Expression> args = new ArrayList<>(); MethodCallExpression result = AstUtil.createDirectMethodCall( new ClassExpression(resources.getAstNodeCache().SpockRuntime), method, new ArgumentListExpression(args)); args.add(new VariableExpression(SpockNames.ERROR_COLLECTOR, resources.getAstNodeCache().ErrorCollector)); args.add(AstUtil.createDirectMethodCall( new VariableExpression(SpockNames.VALUE_RECORDER), resources.getAstNodeCache().ValueRecorder_Reset, ArgumentListExpression.EMPTY_ARGUMENTS)); args.add(new ConstantExpression(resources.getSourceText(condition))); args.add(new ConstantExpression(condition.getLineNumber())); args.add(new ConstantExpression(condition.getColumnNumber())); // the following means that "assert x, exprEvaluatingToNull" will be // treated the same as "assert x"; but probably it doesn't matter too much args.add(message == null ? ConstantExpression.NULL : message); args.addAll(additionalArgs); result.setSourcePosition(condition); return result; } }
private Expression createFieldHelperCall(Expression exp, ClassNode weavedType, String propName) { String method = Traits.helperGetterName(new FieldNode(propName, 0, ClassHelper.OBJECT_TYPE, weavedType, null)); MethodCallExpression mce = new MethodCallExpression( createFieldHelperReceiver(), method, ArgumentListExpression.EMPTY_ARGUMENTS ); mce.setSourcePosition(exp); mce.setImplicitThis(false); return mce; }
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; } }
private Expression transformFieldExpression(final FieldExpression exp) { FieldNode field = exp.getField(); MethodCallExpression mce = new MethodCallExpression( createFieldHelperReceiver(), Traits.helperGetterName(field), ArgumentListExpression.EMPTY_ARGUMENTS ); mce.setSourcePosition(exp); mce.setImplicitThis(false); markDynamicCall(mce, field, field.isStatic()); return mce; }
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; }
call.setSafe(exp.isSafe()); call.setSpreadSafe(exp.isSpreadSafe()); call.setSourcePosition(exp); return call; } catch (IllegalArgumentException e) {
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; }
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; }
call.setSafe(exp.isSafe()); call.setSpreadSafe(exp.isSpreadSafe()); call.setSourcePosition(exp); return call; } else if (name!=null && name.startsWith("$")) { reformatted.setSafe(exp.isSafe()); reformatted.setSpreadSafe(exp.isSpreadSafe()); reformatted.setSourcePosition(exp); clos); stringOf.setImplicitThis(true); stringOf.setSourcePosition(reformatted); return stringOf;
Expression transformStaticMethodCallExpression(final StaticMethodCallExpression orig) { MethodNode target = (MethodNode) orig.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET); if (target != null) { MethodCallExpression call = new MethodCallExpression( new ClassExpression(orig.getOwnerType()), orig.getMethod(), orig.getArguments() ); call.setMethodTarget(target); call.setSourcePosition(orig); call.copyNodeMetaData(orig); return transformer.transform(call); } return transformer.superTransform(orig); }
); callGetModel.setImplicitThis(true); callGetModel.setSourcePosition(left); MethodCallExpression mce = new MethodCallExpression( callGetModel, new ArgumentListExpression(new ConstantExpression(varName), right) ); mce.setSourcePosition(left); mce.setImplicitThis(false); return transform(mce);
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; }
@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); }
call.setSpreadSafe(spreadSafe); call.setMethodTarget(setterMethod); call.setSourcePosition(location); return call;
private Expression convertInOperatorToTernary(final BinaryExpression bin, final Expression rightExpression, final Expression leftExpression) { MethodCallExpression call = new MethodCallExpression( rightExpression, "isCase", leftExpression ); call.setMethodTarget((MethodNode) bin.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET)); call.setSourcePosition(bin); call.copyNodeMetaData(bin); TernaryExpression tExp = new TernaryExpression( new BooleanExpression( new BinaryExpression(rightExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null)) ), new BinaryExpression(leftExpression, Token.newSymbol("==", -1, -1), new ConstantExpression(null)), call ); return staticCompilationTransformer.transform(tExp); }
result.setSpreadSafe(exp.isSpreadSafe()); result.setSafe(exp.isSafe()); result.setSourcePosition(exp); return result;