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); }
protected void inferDiamondType(final ConstructorCallExpression cce, final ClassNode lType) { // check if constructor call expression makes use of the diamond operator ClassNode node = cce.getType(); if (node.isUsingGenerics() && node.getGenericsTypes() != null && node.getGenericsTypes().length == 0) { ArgumentListExpression argumentListExpression = InvocationWriter.makeArgumentList(cce.getArguments()); if (argumentListExpression.getExpressions().isEmpty()) { adjustGenerics(lType, node); } else { ClassNode type = getType(argumentListExpression.getExpression(0)); if (type.isUsingGenerics()) { adjustGenerics(type, node); } } // store inferred type on CCE storeType(cce, node); } }
&& parametersOfMethodContainingSAM[i].getType().isArray()) continue; Expression callArg = originalMethodCallArguments.getExpression(i);
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(); }
numberOfArguments = ae.getExpressions().size(); for (int i = 0; i < numberOfArguments; i++) { Expression argument = ae.getExpression(i); argument.visit(controller.getAcg()); operandStack.box();
/** * In the case of a <em>Object.with { ... }</em> call, this method is supposed to retrieve * the inferred closure return type. * * @param callArguments the argument list from the <em>Object#with(Closure)</em> call, ie. a single closure expression * @return the inferred closure return type or <em>null</em> */ protected ClassNode getInferredReturnTypeFromWithClosureArgument(Expression callArguments) { if (!(callArguments instanceof ArgumentListExpression)) return null; ArgumentListExpression argList = (ArgumentListExpression) callArguments; ClosureExpression closure = (ClosureExpression) argList.getExpression(0); visitClosureExpression(closure); if (getInferredReturnType(closure) != null) { return getInferredReturnType(closure); } return null; }
&& isNumberType(getType(argumentList.getExpression(0)))) { ClassNode right = getType(argumentList.getExpression(0)); ClassNode resultType = getMathResultType(NUMBER_OPS.get(name), receiver, right, name); if (resultType != null) {
/** * @param callArguments * @param receiver * @deprecated this method is unused, replaced with {@link DelegatesTo} inference. */ @Deprecated protected void checkClosureParameters(final Expression callArguments, final ClassNode receiver) { if (callArguments instanceof ArgumentListExpression) { ArgumentListExpression argList = (ArgumentListExpression) callArguments; ClosureExpression closure = (ClosureExpression) argList.getExpression(0); Parameter[] parameters = closure.getParameters(); if (parameters.length > 1) { addStaticTypeError("Unexpected number of parameters for a with call", argList); } else if (parameters.length == 1) { Parameter param = parameters[0]; if (!param.isDynamicTyped() && !isAssignableTo(receiver, param.getType().redirect())) { addStaticTypeError("Expected parameter type: " + receiver.toString(false) + " but was: " + param.getType().redirect().toString(false), param); } } closure.putNodeMetaData(StaticTypesMarker.DELEGATION_METADATA, new DelegationMetadata( receiver, Closure.DELEGATE_FIRST, typeCheckingContext.delegationMetadata )); } }
private boolean hasClosureArgument(ArgumentListExpression arguments) { return arguments != null && arguments.getExpressions().size() == 1 && (arguments.getExpression(0) instanceof ClosureExpression); }
if (args.length > 0 && typeCheckingContext.getEnclosingClosure() != null && argumentList.getExpression(0) instanceof VariableExpression && ((VariableExpression) argumentList.getExpression(0)).isThisExpression() && call.getType() instanceof InnerClassNode && call.getType().getOuterClass().equals(args[0]) &&
private void visitMethodCallOnDetachedCriteria(ClassNode classNode, ArgumentListExpression arguments) { if (arguments.getExpressions().size() > 0) { Expression expression = arguments.getExpression(arguments.getExpressions().size() - 1); if (expression instanceof ClosureExpression) { ClosureExpression closureExpression = (ClosureExpression) expression; transformClosureExpression(classNode, closureExpression); } } }
private static ClosureExpression getClosure(String name, MethodCallExpression expression) { Expression method = expression.getMethod(); if (method instanceof ConstantExpression && name.equals(((ConstantExpression) method).getValue())) { return (ClosureExpression) ((ArgumentListExpression) expression .getArguments()).getExpression(0); } return null; }
public static Pair<ClassExpression, ClosureExpression> getClassAndClosureArgs(MethodCall methodCall) { if (!(methodCall.getArguments() instanceof ArgumentListExpression)) { return null; } ArgumentListExpression args = (ArgumentListExpression) methodCall.getArguments(); if (args.getExpressions().size() == 2 && args.getExpression(0) instanceof ClassExpression && args.getExpression(1) instanceof ClosureExpression) { return Pair.of((ClassExpression) args.getExpression(0), (ClosureExpression) args.getExpression(1)); } else { return null; } }
ClosureExpression associationQuery = (ClosureExpression) arguments.getExpression(0); BlockStatement currentBody = closureAndArguments.getCurrentBody(); ArgumentListExpression argList = closureAndArguments.getArguments();
public static ClassExpression getClassArg(MethodCall methodCall) { if (!(methodCall.getArguments() instanceof ArgumentListExpression)) { return null; } ArgumentListExpression args = (ArgumentListExpression) methodCall.getArguments(); if (args.getExpressions().size() == 1 && args.getExpression(0) instanceof ClassExpression) { return (ClassExpression) args.getExpression(0); } else { return null; } }
public static ClosureExpression getSingleClosureArg(MethodCall methodCall) { if (!(methodCall.getArguments() instanceof ArgumentListExpression)) { return null; } ArgumentListExpression args = (ArgumentListExpression) methodCall.getArguments(); if (args.getExpressions().size() == 1 && args.getExpression(0) instanceof ClosureExpression) { return (ClosureExpression) args.getExpression(0); } else { return null; } }
private static boolean areEquals(Parameter[] parameters, ArgumentListExpression arguments) { if (parameters.length != arguments.getExpressions().size()) { return false; } for (int i = 0; i < parameters.length; i++) { // If they aren't the same type return false if (!parameters[i].getType().equals(arguments.getExpression(i).getType())) { return false; } } return true; }
if (args.getExpression(0) instanceof MapExpression && args.getExpression(1) instanceof VariableExpression) { } else if (args.getExpression(0) instanceof VariableExpression) { Expression arg = args.getExpression(0); if (arg instanceof VariableExpression) {
private void transformVariableExpression(MethodCallExpression call, int index) { ArgumentListExpression args = (ArgumentListExpression) call.getArguments(); VariableExpression arg = (VariableExpression) args.getExpression(index); if (!isDynamicVar(arg)) { return; } // Matches: task args?, <identifier>, args? or task(args?, <identifier>, args?) // Map to: task(args?, '<identifier>', args?) String taskName = arg.getText(); call.setMethod(new ConstantExpression("task")); args.getExpressions().set(index, new ConstantExpression(taskName)); }
numberOfArguments = ae.getExpressions().size(); for (int i = 0; i < numberOfArguments; i++) { Expression argument = ae.getExpression(i); argument.visit(controller.getAcg()); operandStack.box();