public static boolean hasImplicitParameter(ClosureExpression expr) { return expr.getParameters() != null && expr.getParameters().length == 0; }
@Override public void visitClosureExpression(ClosureExpression ce) { addVariablesToStack(ce.getParameters()); super.visitClosureExpression(ce); varStack.removeLast(); }
private ClassNode getTypeFromClosureArguments(Parameter parameter, TypeCheckingContext.EnclosingClosure enclosingClosure) { ClosureExpression closureExpression = enclosingClosure.getClosureExpression(); ClassNode[] closureParamTypes = (ClassNode[]) closureExpression.getNodeMetaData(StaticTypesMarker.CLOSURE_ARGUMENTS); if (closureParamTypes == null) return null; final Parameter[] parameters = closureExpression.getParameters(); String name = parameter.getName(); if (parameters != null) { if (parameters.length == 0) { return "it".equals(name) && closureParamTypes.length != 0 ? closureParamTypes[0] : null; } for (int index = 0; index < parameters.length; index++) { if (name.equals(parameters[index].getName())) { return closureParamTypes.length > index ? closureParamTypes[index] : null; } } } return null; }
protected Expression transformClosureExpression(ClosureExpression ce) { boolean oldInClosure = inClosure; inClosure = true; if (ce.getParameters() != null) { for (Parameter p : ce.getParameters()) { if (p.hasInitialExpression()) { p.setInitialExpression(transform(p.getInitialExpression())); } } } Statement code = ce.getCode(); if (code != null) code.visit(this); inClosure = oldInClosure; return ce; }
@Override public void visitClosureExpression(ClosureExpression expression) { if (expression.isSynthetic()) { return; } Parameter[] origParams = expression.getParameters(); for (Parameter p : origParams) { p.setModifiers(p.getModifiers() | Modifier.FINAL); } super.visitClosureExpression(expression); }
Expression transformClosureExpression(final ClosureExpression expr) { Parameter[] parameters = expr.getParameters(); if (parameters!=null) { for (Parameter parameter : parameters) { if (parameter.hasInitialExpression()) { parameter.setInitialExpression(transformer.transform(parameter.getInitialExpression())); } } } Statement code = expr.getCode(); transformer.visitClassCodeContainer(code); return transformer.superTransform(expr); }
private void doInferClosureParameterTypes(final ClassNode receiver, final Expression arguments, final ClosureExpression expression, final MethodNode selectedMethod, final Expression hintClass, Expression resolverClass, final Expression options) { List<ClassNode[]> closureSignatures = getSignaturesFromHint(expression, selectedMethod, hintClass, options); List<ClassNode[]> candidates = new LinkedList<ClassNode[]>(); Parameter[] closureParams = expression.getParameters(); for (ClassNode[] signature : closureSignatures) {
ClosureExpression ce = (ClosureExpression) exp; ce.getVariableScope().putReferencedLocalVariable((Parameter) parameter.get()); Parameter[] params = ce.getParameters(); if (params == null) { params = Parameter.EMPTY_ARRAY;
public void visitClosureExpression(ClosureExpression expression) { pushState(); expression.setVariableScope(currentScope); if (expression.isParameterSpecified()) { Parameter[] parameters = expression.getParameters(); for (Parameter parameter : parameters) { parameter.setInStaticContext(currentScope.isInStaticContext()); if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } declare(parameter, expression); } } else if (expression.getParameters() != null) { Parameter var = new Parameter(ClassHelper.OBJECT_TYPE, "it"); var.setInStaticContext(currentScope.isInStaticContext()); currentScope.putDeclaredVariable(var); } super.visitClosureExpression(expression); markClosureSharedVariables(); popState(); }
private ClassNode inferSAMTypeGenericsInAssignment(ClassNode samUsage, MethodNode sam, ClassNode closureType, ClosureExpression closureExpression) { // if the sam type or closure type do not provide generics information, // we cannot infer anything, thus we simply return the provided samUsage GenericsType[] samGt = samUsage.getGenericsTypes(); GenericsType[] closureGt = closureType.getGenericsTypes(); if (samGt == null || closureGt == null) return samUsage; // extract the generics from the return type Map<GenericsTypeName, GenericsType> connections = new HashMap<GenericsTypeName, GenericsType>(); extractGenericsConnections(connections, getInferredReturnType(closureExpression), sam.getReturnType()); // next we get the block parameter types and set the generics // information just like before // TODO: add vargs handling Parameter[] closureParams = closureExpression.getParameters(); Parameter[] methodParams = sam.getParameters(); for (int i = 0; i < closureParams.length; i++) { ClassNode fromClosure = closureParams[i].getType(); ClassNode fromMethod = methodParams[i].getType(); extractGenericsConnections(connections, fromClosure, fromMethod); } ClassNode result = applyGenericsContext(connections, samUsage.redirect()); return result; }
/** * @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 )); } }
protected Expression transformClosureExpression(ClosureExpression ce) { boolean oldInClosure = inClosure; inClosure = true; Parameter[] paras = ce.getParameters(); if (paras != null) { for (Parameter para : paras) { ClassNode t = para.getType(); resolveOrFail(t, ce); visitAnnotations(para); if (para.hasInitialExpression()) { para.setInitialExpression(transform(para.getInitialExpression())); } visitAnnotations(para); } } Statement code = ce.getCode(); if (code != null) code.visit(this); inClosure = oldInClosure; return ce; }
Parameter[] parameters = expression.getParameters(); if (parameters != null) { for (Parameter parameter : parameters) {
ClassNode[] blockParameterTypes = (ClassNode[]) openBlock.getNodeMetaData(StaticTypesMarker.CLOSURE_ARGUMENTS); if (blockParameterTypes == null) { Parameter[] p = openBlock.getParameters(); if (p == null) {
Parameter[] closureParams = ((ClosureExpression) expression).getParameters(); ClassNode[] closureParamTypes = extractTypesFromParameters(closureParams); if (expression.getNodeMetaData(StaticTypesMarker.CLOSURE_ARGUMENTS) != null) {
Parameter[] parameters = ((ClosureExpression) objectExpression).getParameters(); typeCheckClosureCall(callArguments, args, parameters); ClassNode data = getInferredReturnType(objectExpression);
Parameter[] parameters = ((ClosureExpression) rightExpression).getParameters(); leftExpression.putNodeMetaData(StaticTypesMarker.CLOSURE_ARGUMENTS, parameters); } else if (rightExpression instanceof VariableExpression &&
Parameter[] parameters = expression.getParameters(); if (parameters == null) { parameters = Parameter.EMPTY_ARRAY;
@Override public void visitClosureExpression(ClosureExpression ce) { addVariablesToStack(ce.getParameters()); super.visitClosureExpression(ce); varStack.removeLast(); }
@Override public void visitClosureExpression(ClosureExpression node) { if (isInside(node, line, column)) { super.visitClosureExpression(node); if (node.isParameterSpecified()) { for (Parameter parameter : node.getParameters()) { isInside(parameter, line, column); } } } }