public static String getMethodName(Expression invocation) { if (invocation instanceof MethodCallExpression) { return ((MethodCallExpression) invocation).getMethodAsString(); } if (invocation instanceof StaticMethodCallExpression) { return ((StaticMethodCallExpression) invocation).getMethod(); } return null; }
private static boolean checkIsBuiltInMethodCall(MethodCallExpression expr) { if (!AstUtil.isThisOrSuperExpression(expr.getObjectExpression())) return false; return Identifiers.BUILT_IN_METHODS.contains(expr.getMethodAsString()); }
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; }
private static boolean isCallOnClosure(final MethodCallExpression expr) { MethodNode target = expr.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET); return expr.isImplicitThis() && !"call".equals(expr.getMethodAsString()) && (target == StaticTypeCheckingVisitor.CLOSURE_CALL_VARGS || target == StaticTypeCheckingVisitor.CLOSURE_CALL_NO_ARG || target == StaticTypeCheckingVisitor.CLOSURE_CALL_ONE_ARG); }
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); }
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(); }
public void visitMethodCallExpression(MethodCallExpression methodCall) { if (defaultScriptMethods.contains(methodCall.getMethodAsString())) { visited = true; isImplicitThis = methodCall.isImplicitThis(); } }
private static boolean checkIsConditionBlock(MethodCallExpression methodCallExpr) { ClassNode targetType = methodCallExpr.getObjectExpression().getType(); String methodName = methodCallExpr.getMethodAsString(); List<MethodNode> methods = targetType.getMethods(methodName); for (MethodNode method : methods) { for (AnnotationNode annotation : method.getAnnotations()) { if (annotation.getClassNode().getName().equals(ConditionBlock.class.getName())) return true; } } return false; } }
@Override public void visitMethodCallExpression(MethodCallExpression call) { Expression objectExpression = call.getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression ve = (VariableExpression) objectExpression; if (ve.isThisExpression()) { addError("Can't access instance method '" + call.getMethodAsString() + "' for a constructor parameter default value", param); return; } } super.visitMethodCallExpression(call); }
private boolean forbidUseOfSuperInFixtureMethod(MethodCallExpression expr) { Method currMethod = resources.getCurrentMethod(); Expression target = expr.getObjectExpression(); if (currMethod instanceof FixtureMethod && target instanceof VariableExpression && ((VariableExpression)target).isSuperExpression() && currMethod.getName().equals(expr.getMethodAsString())) { resources.getErrorReporter().error(expr, "A base class fixture method should not be called explicitly " + "because it is always invoked automatically by the framework"); return true; } return false; }
@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); }
private boolean handleImplicitCallOnMethodParam(MethodCallExpression expr) { if (!expr.isImplicitThis()) return false; String methodName = expr.getMethodAsString(); List<Parameter> params = Arrays.asList(resources.getCurrentMethod().getAst().getParameters()); for (Parameter param : params) { if (param.getName().equals(methodName)) { expr.setMethod(new ConstantExpression("call")); expr.setObjectExpression(new VariableExpression(methodName)); return true; } } return false; }
private boolean handleOldCall(MethodCallExpression expr) { if (!currSpecialMethodCall.isOldCall(expr)) return false; if (!(block instanceof ThenBlock)) { resources.getErrorReporter().error(expr, "old() is only allowed in 'then' blocks"); return true; } expr.setMethod(new ConstantExpression(expr.getMethodAsString() + "Impl")); List<Expression> args = AstUtil.getArgumentList(expr); VariableExpression oldValue = resources.captureOldValue(args.get(0)); args.set(0, oldValue); if (currClosure != null) { oldValue.setClosureSharedVariable(true); currClosure.getVariableScope().putReferencedLocalVariable(oldValue); } return true; }
@Override public void visitMethodCallExpression(MethodCallExpression mce) { if (inSpecialConstructorCall && !isInnerClass(currentMethod.getDeclaringClass())) { Expression objectExpression = mce.getObjectExpression(); if (objectExpression instanceof VariableExpression) { VariableExpression ve = (VariableExpression) objectExpression; if (ve.isThisExpression()) { addError("Can't access instance method '" + mce.getMethodAsString() + "' before the class is constructed", mce); return; } } } super.visitMethodCallExpression(mce); }
@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); }
private Expression addGuard(MethodCallExpression mce) { // only add guard to methods of the form: logVar.logMethod(params) if (!(mce.getObjectExpression() instanceof VariableExpression)) { return null; } VariableExpression variableExpression = (VariableExpression) mce.getObjectExpression(); if (!variableExpression.getName().equals(logFieldName) || !(variableExpression.getAccessedVariable() instanceof DynamicVariable)) { return null; } String methodName = mce.getMethodAsString(); if (methodName == null) return null; if (!loggingStrategy.isLoggingMethod(methodName)) return null; // also don't bother with guard if we have "simple" method args // since there is no saving if (usesSimpleMethodArgumentsOnly(mce)) return null; variableExpression.setAccessedVariable(logNode); return loggingStrategy.wrapLoggingMethodCall(variableExpression, methodName, mce); }
@Override protected boolean makeDirectCall(final Expression origin, final Expression receiver, final Expression message, final Expression arguments, final MethodCallerMultiAdapter adapter, final boolean implicitThis, final boolean containsSpreadExpression) { if (origin instanceof MethodCallExpression && receiver instanceof VariableExpression && ((VariableExpression) receiver).isSuperExpression()) { ClassNode superClass = receiver.getNodeMetaData(StaticCompilationMetadataKeys.PROPERTY_OWNER); if (superClass!=null && !controller.getCompileStack().isLHS()) { // GROOVY-7300 MethodCallExpression mce = (MethodCallExpression) origin; MethodNode node = superClass.getDeclaredMethod(mce.getMethodAsString(), Parameter.EMPTY_ARRAY); mce.setMethodTarget(node); } } return super.makeDirectCall(origin, receiver, message, arguments, adapter, implicitThis, containsSpreadExpression); }
public static SpecialMethodCall parse(MethodCallExpression methodCallExpr, @Nullable BinaryExpression binaryExpr) { boolean builtInCall = checkIsBuiltInMethodCall(methodCallExpr); boolean conditionBlock = checkIsConditionBlock(methodCallExpr); if (!(builtInCall || conditionBlock)) return null; String methodName = methodCallExpr.getMethodAsString(); Expression inferredName; Expression inferredType; if (binaryExpr != null && binaryExpr.getOperation().getType() == Types.ASSIGN && binaryExpr.getRightExpression() == methodCallExpr) { inferredName = AstUtil.getVariableName(binaryExpr); inferredType = AstUtil.getVariableType(binaryExpr); } else { binaryExpr = null; // not part of this special method call inferredName = ConstantExpression.NULL; inferredType = ConstantExpression.NULL; } ClosureExpression closureExpr = null; List<Expression> arguments = AstUtil.getArgumentList(methodCallExpr); if (!arguments.isEmpty()) { Expression lastArg = CollectionUtil.getLastElement(arguments); if (lastArg instanceof ClosureExpression) { closureExpr = (ClosureExpression) lastArg; } } return new SpecialMethodCall(methodName, inferredName, inferredType, methodCallExpr, binaryExpr, closureExpr, conditionBlock); }
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); }
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); } }