@Override protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { // ClassCodeVisitorSupport doesn't seem to visit parameters for (Parameter param: node.getParameters()) { visitAnnotations(param); if (param.getInitialExpression() != null) param.getInitialExpression().visit(this); } super.visitConstructorOrMethod(node, isConstructor); }
@Override public void visitConstructor(final ConstructorNode node) { if (shouldSkipMethodNode(node)) { // method has already been visited by a static type checking visitor return; } for (Parameter parameter : node.getParameters()) { if (parameter.getInitialExpression() != null) { parameter.getInitialExpression().visit(this); } } super.visitConstructor(node); }
public static String getParameterText(Parameter node) { if (node == null) return "<unknown>"; String name = node.getName() == null ? "<unknown>" : node.getName(); String type = getClassText(node.getType()); if (node.getInitialExpression() != null) { return type + " " + name + " = " + node.getInitialExpression().getText(); } return type + " " + name; }
private void declare(Parameter[] parameters, ASTNode node) { for (Parameter parameter : parameters) { if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } declare(parameter, node); } }
private static void memorizeInitialExpressions(final MethodNode node) { // add node metadata for default parameters because they are erased by the Verifier if (node.getParameters()!=null) { for (Parameter parameter : node.getParameters()) { parameter.putNodeMetaData(StaticTypesMarker.INITIAL_EXPRESSION, parameter.getInitialExpression()); } } }
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]); } }
super.visitMethod(node); for (Parameter parameter : node.getParameters()) { if (parameter.getInitialExpression() != null) { parameter.getInitialExpression().visit(this);
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); }
exceptions.add(param.getName()); if (param.hasInitialExpression()) { param.getInitialExpression().visit(new CodeVisitorSupport() { @Override public void visitVariableExpression(VariableExpression ve) {
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; }
private static FieldNode createFieldCopy(ClassNode buildee, Parameter param) { Map<String,ClassNode> genericsSpec = createGenericsSpec(buildee); extractSuperClassGenerics(param.getType(), buildee, genericsSpec); ClassNode correctedParamType = correctToGenericsSpecRecurse(genericsSpec, param.getType()); return new FieldNode(param.getName(), ACC_PRIVATE, correctedParamType, buildee, param.getInitialExpression()); }
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; }
new CastExpression( parameter.getType(), parameter.getInitialExpression() new CastExpression( parameter.getType(), parameter.getInitialExpression() if (!parameter.hasInitialExpression()) continue; // GROOVY-8728 make idempotent parameter.putNodeMetaData(Verifier.INITIAL_EXPRESSION, parameter.getInitialExpression()); parameter.setInitialExpression(null);
private void analyseParameters(Parameter[] parameters) { for (Parameter parameter : parameters) { visitType(parameter.getOriginType()); if (parameter.hasInitialExpression()) { parameter.getInitialExpression().visit(this); } } }
public static MethodNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, MethodNode mn) { ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, mn.getReturnType()); Parameter[] origParameters = mn.getParameters(); Parameter[] newParameters = new Parameter[origParameters.length]; for (int i = 0; i < origParameters.length; i++) { Parameter origParameter = origParameters[i]; newParameters[i] = new Parameter(correctToGenericsSpecRecurse(genericsSpec, origParameter.getType()), origParameter.getName(), origParameter.getInitialExpression()); } return new MethodNode(mn.getName(), mn.getModifiers(), correctedType, newParameters, mn.getExceptions(), mn.getCode()); }
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; }
protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { VariableScope oldScope = currentScope; currentScope = node.getVariableScope(); Map<GenericsTypeName, GenericsType> oldPNames = genericParameterNames; genericParameterNames = node.isStatic() && !Traits.isTrait(node.getDeclaringClass()) ? new HashMap<GenericsTypeName, GenericsType>() : new HashMap<GenericsTypeName, GenericsType>(genericParameterNames); resolveGenericsHeader(node.getGenericsTypes()); Parameter[] paras = node.getParameters(); for (Parameter p : paras) { p.setInitialExpression(transform(p.getInitialExpression())); resolveOrFail(p.getType(), p.getType()); visitAnnotations(p); } ClassNode[] exceptions = node.getExceptions(); for (ClassNode t : exceptions) { resolveOrFail(t, node); } resolveOrFail(node.getReturnType(), node); MethodNode oldCurrentMethod = currentMethod; currentMethod = node; super.visitConstructorOrMethod(node, isConstructor); currentMethod = oldCurrentMethod; genericParameterNames = oldPNames; currentScope = oldScope; }
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(); }