public String toString() { return super.toString() + "[name:" + name + ((type == null) ? "" : " type: " + type.getName()) + ", hasDefaultValue: " + this.hasInitialExpression() + "]"; }
private void declare(Parameter[] parameters, ASTNode node) { for (Parameter parameter : parameters) { if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } declare(parameter, node); } }
protected void addDefaultParameters(DefaultArgsAction action, MethodNode method) { final Parameter[] parameters = method.getParameters(); final Expression[] saved = new Expression[parameters.length]; for (int i = 0; i < parameters.length; i++) { if (parameters[i].hasInitialExpression()) saved[i] = parameters[i].getInitialExpression(); } super.addDefaultParameters(action, method); for (int i = 0; i < parameters.length; i++) { if (saved[i] != null) parameters[i].setInitialExpression(saved[i]); } }
ClassNode arg = j >= args.length ? null : args[j]; if (arg == null || !isAssignableTo(arg, paramType)) { if (!param.hasInitialExpression() && (ptype == null || !ptype.equals(paramType))) { return -1; // no default value j++; if (!paramType.equals(arg)) dist += getDistance(arg, paramType); if (param.hasInitialExpression()) { ptype = arg; } else {
protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { for (Parameter p : node.getParameters()) { if (p.hasInitialExpression()) { Expression init = p.getInitialExpression(); p.setInitialExpression(transform(init)); } } super.visitConstructorOrMethod(node, isConstructor); }
private static void removeInitialValues(Parameter[] params) { for (int i = 0; i < params.length; i++) { if (params[i].hasInitialExpression()) { Parameter p = new Parameter(params[i].getType(), params[i].getName()); p.setOriginType(p.getOriginType()); params[i] = p; } } }
for (final Parameter param : node.getParameters()) { exceptions.add(param.getName()); if (param.hasInitialExpression()) { param.getInitialExpression().visit(new CodeVisitorSupport() { @Override
for (int i = size - 1; i >= 0; i--) { Parameter parameter = parameters[i]; if (parameter != null && parameter.hasInitialExpression()) { counter++; int k = 1; for (Parameter parameter : parameters) { if (k > counter - j && parameter != null && parameter.hasInitialExpression()) { k++; } else if (parameter != null && parameter.hasInitialExpression()) { newParams[index++] = parameter; k++;
private List<Expression> buildParams(Parameter[] origParams, Parameter[] params, Map<String, ClassNode> genericsSpec, boolean copyParameterAnnotations) { List<Expression> theArgs = new ArrayList<Expression>(); for (int i = 0; i < origParams.length; i++) { Parameter p = origParams[i]; ClassNode newType = correctToGenericsSpecRecurse(genericsSpec, p.getType()); params[i] = p.hasInitialExpression() ? param(newType, p.getName(), p.getInitialExpression()) : param(newType, p.getName()); if (copyParameterAnnotations) { params[i].addAnnotations(copyAnnotatedNodeAnnotations(origParams[i], MY_TYPE_NAME)); } theArgs.add(varX(p.getName(), newType)); } return theArgs; }
for (int i = size - 1; i >= 0; i--) { Parameter parameter = parameters[i]; if (parameter != null && parameter.hasInitialExpression()) { paramValues.add(i); paramValues.add( throw new GroovyBugError("Parameter should not be null for method " + methodNode.getName()); } else { if (k > counter - j && parameter.hasInitialExpression()) { arguments.addExpression( new CastExpression( } else if (parameter.hasInitialExpression()) { index = addExpression(newParams, arguments, index, parameter); k++; if (!parameter.hasInitialExpression()) continue; // GROOVY-8728 make idempotent
public void setParameters(Parameter[] parameters) { invalidateCachedData(); VariableScope scope = new VariableScope(); this.parameters = parameters; if (parameters != null && parameters.length > 0) { for (Parameter para : parameters) { if (para.hasInitialExpression()) { this.hasDefaultValue = true; } para.setInStaticContext(isStatic()); scope.putDeclaredVariable(para); } } setVariableScope(scope); }
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); }
@Override protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { this.currentMethod = node; visitAnnotations(node); visitClassCodeContainer(node.getCode()); // GROOVY-5681: initial expressions should be visited too! for (Parameter param : node.getParameters()) { if (param.hasInitialExpression()) { param.getInitialExpression().visit(this); } visitAnnotations(param); } this.currentMethod = 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; }
private void analyseParameters(Parameter[] parameters) { for (Parameter parameter : parameters) { visitType(parameter.getOriginType()); if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } } }
if (!parameter.hasInitialExpression()) { nonDefaultParameters++;
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; }
private boolean processImplicitNamedParam(MethodNode mNode, Parameter mapParam, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { boolean required = fromParam.hasInitialExpression(); String name = fromParam.getName(); if (hasDuplicates(mNode, propNames, name)) return false; AnnotationNode namedParam = new AnnotationNode(NAMED_PARAM_TYPE); namedParam.addMember("value", constX(name)); namedParam.addMember("type", classX(fromParam.getType())); namedParam.addMember("required", constX(required, true)); mapParam.addAnnotation(namedParam); args.addExpression(propX(varX(mapParam), name)); return true; }
private boolean processExplicitNamedParam(MethodNode mNode, Parameter mapParam, BlockStatement inner, ArgumentListExpression args, List<String> propNames, Parameter fromParam) { AnnotationNode namedParam = fromParam.getAnnotations(NAMED_PARAM_TYPE).get(0); boolean required = memberHasValue(namedParam, "required", true); if (getMemberStringValue(namedParam, "value") == null) { namedParam.addMember("value", constX(fromParam.getName())); } String name = getMemberStringValue(namedParam, "value"); if (getMemberValue(namedParam, "type") == null) { namedParam.addMember("type", classX(fromParam.getType())); } if (hasDuplicates(mNode, propNames, name)) return false; // TODO check specified type is assignable from declared param type? // ClassNode type = getMemberClassValue(namedParam, "type"); if (required) { if (fromParam.hasInitialExpression()) { addError("Error during " + MY_TYPE_NAME + " processing. A required parameter can't have an initial value.", mNode); return false; } inner.addStatement(new AssertStatement(boolX(callX(varX(mapParam), "containsKey", args(constX(name)))), plusX(new ConstantExpression("Missing required named argument '" + name + "'. Keys found: "), callX(varX(mapParam), "keySet")))); } args.addExpression(propX(varX(mapParam), name)); mapParam.addAnnotation(namedParam); fromParam.getAnnotations().remove(namedParam); return true; }
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(); }