@Override public void expand() { List<Expression> args = new ArrayList<>(); args.add(inferredName); args.add(inferredType); args.addAll(AstUtil.getArgumentList(methodCallExpr)); ArgumentListExpression argsExpr = new ArgumentListExpression(args); AstUtil.copySourcePosition(methodCallExpr.getArguments(), argsExpr); methodCallExpr.setArguments(argsExpr); methodCallExpr.setMethod(new ConstantExpression(methodName + "Impl")); }
private void rewriteArgumentList(MethodCallExpression call, ClassExpression objectExpression) { if (SpockRuntime.class.getName().equals(objectExpression.getType().getName())) { String methodName = call.getMethod().getText(); if (REWRITE_METHOD_ARGS.contains(methodName)) { List<Expression> arguments = new ArrayList<>(((ArgumentListExpression)call.getArguments()).getExpressions()); Expression expression = arguments.get(0); if (expression instanceof VariableExpression && isErrorCollectorExpression(((VariableExpression)expression))) { arguments.set(0, errorCollectorExpression()); } expression = arguments.get(1); if (expression instanceof VariableExpression && isValueRecorderExpression(((VariableExpression)expression))) { arguments.set(1, valueRecorderExpression()); } call.setArguments(new ArgumentListExpression(arguments)); } } }
private Expression transformMethodCall(MethodCallExpression mce, Expression argsExp) { ClassNode classType; if (isNewMethodStyle(mce)) { classType = mce.getObjectExpression().getType(); } else { classType = findMatchingCandidateClass(mce); } if (classType != null) { Expression argsToUse = argsExp; if (classType.getOuterClass() != null && ((classType.getModifiers() & org.objectweb.asm.Opcodes.ACC_STATIC) == 0)) { if (!(argsExp instanceof ArgumentListExpression)) { addError("Non-static inner constructor arguments must be an argument list expression; pass 'this' pointer explicitely as first constructor argument otherwise.", mce); return mce; } final ArgumentListExpression argsListExp = (ArgumentListExpression) argsExp; final List<Expression> argExpList = argsListExp.getExpressions(); final VariableExpression thisVarExp = new VariableExpression("this"); final List<Expression> expressionsWithThis = new ArrayList<Expression>(argExpList.size() + 1); expressionsWithThis.add(thisVarExp); expressionsWithThis.addAll(argExpList); argsToUse = new ArgumentListExpression(expressionsWithThis); } return new ConstructorCallExpression(classType, argsToUse); } // set the args as they might have gotten Newify transformed GROOVY-3491 mce.setArguments(argsExp); return mce; }
@Override public void visitMethodCallExpression(MethodCallExpression expr) { expr.setObjectExpression(replaceExpr(expr.getObjectExpression())); expr.setMethod(replaceExpr(expr.getMethod())); expr.setArguments(replaceExpr(expr.getArguments())); }
@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; }
public void visitMethodCallExpression(MethodCallExpression ex){ if(isTagCall(ex)){ //System.out.println("FOUND TAG CALL "+ex+" and rewriting "); List<Expression> args = ((TupleExpression)ex.getArguments()).getExpressions(); List<Expression> newArgs= new ArrayList<>(); newArgs.add(new ConstantExpression(ex.getMethodAsString())); newArgs.addAll(args); //Automatically add a closure so that scope is available to the tag if(newArgs.size()==0 || !(newArgs.get(newArgs.size()-1) instanceof ClosureExpression)){ newArgs.add(new ClosureExpression(new Parameter[0], new EmptyStatement())); } ex.setArguments(new TupleExpression(newArgs)); ex.setMethod(new ConstantExpression(TAG)); } super.visitMethodCallExpression(ex); } }
public void visitMethodCallExpression(MethodCallExpression ex){ if(isTagCall(ex)){ //System.out.println("FOUND TAG CALL "+ex+" and rewriting "); List<Expression> args = ((TupleExpression)ex.getArguments()).getExpressions(); List<Expression> newArgs= new ArrayList<>(); newArgs.add(new ConstantExpression(ex.getMethodAsString())); newArgs.addAll(args); //Automatically add a closure so that scope is available to the tag if(newArgs.size()==0 || !(newArgs.get(newArgs.size()-1) instanceof ClosureExpression)){ newArgs.add(new ClosureExpression(new Parameter[0], new EmptyStatement())); } ex.setArguments(new TupleExpression(newArgs)); ex.setMethod(new ConstantExpression(TAG)); } super.visitMethodCallExpression(ex); } }
private Expression transformMethodCall(MethodCallExpression mce, Expression args) { ClassNode classType; if (isNewMethodStyle(mce)) { classType = mce.getObjectExpression().getType(); } else { classType = findMatchingCandidateClass(mce); } if (classType != null) { return new ConstructorCallExpression(classType, args); } // set the args as they might have gotten Newify transformed GROOVY-3491 mce.setArguments(args); return mce; }
private Expression transformMethodCall(MethodCallExpression mce, Expression args) { ClassNode classType; if (isNewMethodStyle(mce)) { classType = mce.getObjectExpression().getType(); } else { classType = findMatchingCandidateClass(mce); } if (classType != null) { return new ConstructorCallExpression(classType, args); } // set the args as they might have gotten Newify transformed GROOVY-3491 mce.setArguments(args); return mce; }
private Expression transformMethodCall(MethodCallExpression mce, Expression args) { ClassNode classType; if (isNewMethodStyle(mce)) { classType = mce.getObjectExpression().getType(); } else { classType = findMatchingCandidateClass(mce); } if (classType != null) { return new ConstructorCallExpression(classType, args); } // set the args as they might have gotten Newify transformed GROOVY-3491 mce.setArguments(args); return mce; }
/** * Call {@link #transformStep(ModelASTStep, MethodCallExpression)} if appropriate, after handling any nested steps as well. */ @Nonnull public final MethodCallExpression handleStep(@Nonnull ModelASTStep step, @Nonnull MethodCallExpression methodCall) { // No transformation inside script blocks. if (step instanceof AbstractModelASTCodeBlock) { return methodCall; } TupleExpression originalArgs = (TupleExpression) methodCall.getArguments(); if (step instanceof ModelASTTreeStep && originalArgs.getExpressions().size() > 0) { ArgumentListExpression newArgs = new ArgumentListExpression(); // Technically we can't get here if there 0 expressions, so the loop below is safe. for (int i = 0; i < originalArgs.getExpressions().size() - 1; i++) { newArgs.addExpression(originalArgs.getExpression(i)); } ClosureExpression originalClosure = (ClosureExpression) originalArgs.getExpression(originalArgs.getExpressions().size() - 1); BlockStatement newBlock = block(); for (ModelASTStep nested : ((ModelASTTreeStep) step).getChildren()) { ExpressionStatement es = (ExpressionStatement) nested.getSourceLocation(); newBlock.addStatement(stmt(handleStep(nested, (MethodCallExpression)es.getExpression()))); } originalClosure.setCode(newBlock); newArgs.addExpression(originalClosure); methodCall.setArguments(newArgs); } return transformStep(step, methodCall); }
@Override public void visitMethodCallExpression(MethodCallExpression expr) { expr.setObjectExpression(replaceExpr(expr.getObjectExpression())); expr.setMethod(replaceExpr(expr.getMethod())); expr.setArguments(replaceExpr(expr.getArguments())); }
@Override @Nonnull public MethodCallExpression transformStep(@Nonnull ModelASTStep step, @Nonnull MethodCallExpression methodCall) { if (step.getName().equals("echo")) { ArgumentListExpression newArgs = new ArgumentListExpression(); TupleExpression oldArgs = (TupleExpression)methodCall.getArguments(); for (Expression expr : oldArgs.getExpressions()) { if (expr instanceof ConstantExpression && ((ConstantExpression) expr).getValue() instanceof String) { String origVal = (String)((ConstantExpression)expr).getValue(); newArgs.addExpression(constX(origVal.toUpperCase())); } } methodCall.setArguments(newArgs); } return methodCall; } }
@Override public Expression transform(Expression exp) { if ( exp instanceof MethodCallExpression) { MethodCallExpression me = (MethodCallExpression)exp; Class jeClazz = gtJavaExtensionMethodResolver.findClassWithMethod(me.getMethodAsString()); if (jeClazz != null) { ClassExpression ce = new ClassExpression( new ClassNode(GTJavaExtensionsInvoker.class)); ArgumentListExpression newArgs = new ArgumentListExpression(); ArgumentListExpression args = (ArgumentListExpression)me.getArguments(); newArgs.getExpressions().add(new ClassExpression( new ClassNode(jeClazz))); newArgs.getExpressions().add(new ConstantExpression(me.getMethodAsString())); newArgs.getExpressions().add(me.getObjectExpression()); newArgs.getExpressions().add( new ArrayExpression( new ClassNode(Object.class), args.getExpressions())); me.setMethod( new ConstantExpression("invoke")); me.setArguments(newArgs); me.setObjectExpression(ce); return exp.transformExpression(this); } } return super.transform(exp); } }
@Override @Nonnull public MethodCallExpression transformStep(@Nonnull ModelASTStep step, @Nonnull MethodCallExpression methodCall) { if (step.getName().equals("timeout")) { ArgumentListExpression newArgs = new ArgumentListExpression(); TupleExpression oldArgs = (TupleExpression)methodCall.getArguments(); for (Expression expr : oldArgs.getExpressions()) { if (expr instanceof MapExpression) { MapExpression originalMap = (MapExpression) expr; MapExpression newMap = new MapExpression(); for (MapEntryExpression origEntry : originalMap.getMapEntryExpressions()) { if (origEntry.getKeyExpression() instanceof ConstantExpression && ((ConstantExpression) origEntry.getKeyExpression()).getValue().equals("time")) { newMap.addMapEntryExpression(constX("time"), constX(10)); } else { newMap.addMapEntryExpression(origEntry); } } newArgs.addExpression(newMap); } else { newArgs.addExpression(expr); } } methodCall.setArguments(newArgs); } return methodCall; } }
/** * Attempts to find AstBuilder 'from code' invocations. When found, converts them into calls * to the 'from string' approach. * * @param call the method call expression that may or may not be an AstBuilder 'from code' invocation. */ public void visitMethodCallExpression(MethodCallExpression call) { if (isBuildInvocation(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); } else { // continue normal tree walking call.getObjectExpression().visit(this); call.getMethod().visit(this); call.getArguments().visit(this); } }
call.setSafe(false); call.setImplicitThis(false); call.setArguments(result); call.setGenericsTypes(GenericsType.EMPTY_ARRAY);