private static ClosureExpression getClosureArgument(MethodCallExpression call) { if (call.getArguments() instanceof TupleExpression) { for (ASTNode node : ((TupleExpression) call.getArguments()).getExpressions()) { if (node instanceof ClosureExpression) { return (ClosureExpression) node; } } } return null; }
private static List<Expression> getNonClosureArguments(MethodCallExpression call) { List<Expression> result = new ArrayList<Expression>(); if (call.getArguments() instanceof TupleExpression) { for (ASTNode node : ((TupleExpression) call.getArguments()).getExpressions()) { if (!(node instanceof ClosureExpression)) { result.add((Expression) node); } } } return result; }
public void visitMethodCallExpression(MethodCallExpression call) { if (!firstMethodCall) return; firstMethodCall = false; String name = call.getMethodAsString(); // the name might be null if the method name is a GString for example if (name == null) return; if (!name.equals("super") && !name.equals("this")) return; type = name; call.getArguments().visit(this); type = null; }
public static Expression getArguments(Expression invocation) { if (invocation instanceof MethodCallExpression) return ((MethodCallExpression) invocation).getArguments(); if (invocation instanceof StaticMethodCallExpression) return ((StaticMethodCallExpression) invocation).getArguments(); if (invocation instanceof ConstructorCallExpression) return ((ConstructorCallExpression) invocation).getArguments(); return null; }
private Expression unrecord(Expression expr) { if (!(expr instanceof MethodCallExpression)) return expr; MethodCallExpression methodExpr = (MethodCallExpression) expr; Expression targetExpr = methodExpr.getObjectExpression(); if (!(targetExpr instanceof VariableExpression)) return expr; VariableExpression var = (VariableExpression)targetExpr; if (!SpockNames.VALUE_RECORDER.equals(var.getName())) return expr; if(!ValueRecorder.RECORD.equals(methodExpr.getMethodAsString())) return expr; return ((ArgumentListExpression)methodExpr.getArguments()).getExpression(1); }
@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 int extractVariableNumber(Expression expr){ if (!(expr instanceof MethodCallExpression)) return -1; MethodCallExpression methodExpr = (MethodCallExpression) expr; Expression targetExpr = methodExpr.getObjectExpression(); if (!(targetExpr instanceof VariableExpression)) return -1; VariableExpression var = (VariableExpression)targetExpr; if (!SpockNames.VALUE_RECORDER.equals(var.getName())) return -1; if(!ValueRecorder.RECORD.equals(methodExpr.getMethodAsString())) return -1; Expression startRecordingEpr = ((ArgumentListExpression) methodExpr.getArguments()).getExpression(0); if (!(startRecordingEpr instanceof MethodCallExpression)) return -1; MethodCallExpression startRecording = (MethodCallExpression) startRecordingEpr; if (!ValueRecorder.START_RECORDING_VALUE.equals(startRecording.getMethodAsString())) return -1; final Expression variableNumExpression = ((ArgumentListExpression) startRecording.getArguments()).getExpression(0); if (! (variableNumExpression instanceof ConstantExpression)) return -1; return (Integer)((ConstantExpression)variableNumExpression).getValue(); }
private boolean usesSimpleMethodArgumentsOnly(MethodCallExpression mce) { Expression arguments = mce.getArguments(); if (arguments instanceof TupleExpression) { TupleExpression tuple = (TupleExpression) arguments; for (Expression exp : tuple.getExpressions()) { if (!isSimpleExpression(exp)) return false; } return true; } return !isSimpleExpression(arguments); }
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)); } } }
public void visitMethodCallExpression(final MethodCallExpression call) { assertExpressionAuthorized(call); Expression receiver = call.getObjectExpression(); final String typeName = receiver.getType().getName(); if (receiversWhiteList != null && !receiversWhiteList.contains(typeName)) { throw new SecurityException("Method calls not allowed on [" + typeName + "]"); } else if (receiversBlackList != null && receiversBlackList.contains(typeName)) { throw new SecurityException("Method calls not allowed on [" + typeName + "]"); } receiver.visit(this); final Expression method = call.getMethod(); checkConstantTypeIfNotMethodNameOrProperty(method); call.getArguments().visit(this); }
public void visitMethodCallExpression(MethodCallExpression mce) { super.visitMethodCallExpression(mce); Expression aexp = mce.getArguments(); if (aexp instanceof TupleExpression) { TupleExpression arguments = (TupleExpression) aexp; for (Expression e : arguments.getExpressions()) { checkForInvalidDeclaration(e); } } else { checkForInvalidDeclaration(aexp); } }
@Override public void visitMethodCallExpression(MethodCallExpression expr) { TextPosition anchor = TextPosition.startOf(expr.getMethod()); List<ExpressionInfo> children = new ArrayList<>(); if (!expr.isImplicitThis()) children.add(convert(expr.getObjectExpression())); children.add(convert(expr.getMethod())); children.add(convert(expr.getArguments())); result = new ExpressionInfo( TextRegion.of(expr), anchor, expr.getMethodAsString(), children); }
public void visitMethodCallExpression(MethodCallExpression call) { call.getObjectExpression().visit(this); call.getMethod().visit(this); call.getArguments().visit(this); }
@Override public void visitMethodCallExpression(MethodCallExpression expression) { if (expression.getNodeMetaData(StatementMeta.class)!=null) return; super.visitMethodCallExpression(expression); Expression object = expression.getObjectExpression(); boolean setTarget = AsmClassGenerator.isThisExpression(object); if (!setTarget) { if (!(object instanceof ClassExpression)) return; setTarget = object.equals(node); } if (!setTarget) return; setMethodTarget(expression, expression.getMethodAsString(), expression.getArguments(), true); }
@Override public void visitMethodCallExpression(MethodCallExpression expr) { expr.setObjectExpression(replaceExpr(expr.getObjectExpression())); expr.setMethod(replaceExpr(expr.getMethod())); expr.setArguments(replaceExpr(expr.getArguments())); }
private Expression transformMethodCallOnThis(final MethodCallExpression call) { Expression method = call.getMethod(); Expression arguments = call.getArguments(); if (method instanceof ConstantExpression) { String methodName = method.getText(); List<MethodNode> methods = traitClass.getMethods(methodName); for (MethodNode methodNode : methods) { if (methodName.equals(methodNode.getName()) && methodNode.isPrivate()) { if (inClosure) { return transformPrivateMethodCallOnThisInClosure(call, arguments, methodName); } return transformPrivateMethodCallOnThis(call, arguments, methodName); } } } if (inClosure) { return transformMethodCallOnThisInClosure(call); } return transformMethodCallOnThisFallBack(call, method, arguments); }
private boolean isClosureCall(MethodCallExpression call) { // are we a local variable? // it should not be an explicitly "this" qualified method call // and the current class should have a possible method ClassNode classNode = controller.getClassNode(); String methodName = call.getMethodAsString(); if (methodName==null) return false; if (!call.isImplicitThis()) return false; if (!AsmClassGenerator.isThisExpression(call.getObjectExpression())) return false; FieldNode field = classNode.getDeclaredField(methodName); if (field == null) return false; if (isStaticInvocation(call) && !field.isStatic()) return false; Expression arguments = call.getArguments(); return ! classNode.hasPossibleMethod(methodName, arguments); }
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); } }
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; }