private static boolean clashesWithOtherParams(String name, Parameter[] params, int i) { for (int j = 0; j < params.length; j++) { if (i == j) continue; if (params[j].getName().equals(name)) return true; } return false; }
private void addVariablesToStack(Parameter[] params) { Set<String> names = new HashSet<String>(varStack.getLast()); for (Parameter param : params) { names.add(param.getName()); } varStack.add(names); }
private static String getParamName(Parameter[] params, int i, String fieldName) { String name = params[i].getName(); while(name.equals(fieldName) || clashesWithOtherParams(name, params, i)) { name = "_" + name; } return name; }
private void verifyParameters(List<Parameter> parameters, AST firstParameterNode) { if (parameters.size() <= 1) return; Parameter first = parameters.get(0); if (firstParamIsVarArg) { throw new ASTRuntimeException(firstParameterNode, "The var-arg parameter " + first.getName() + " must be the last parameter."); } }
public static Parameter[] cloneParams(Parameter[] source) { Parameter[] result = new Parameter[source.length]; for (int i = 0; i < source.length; i++) { Parameter srcParam = source[i]; Parameter dstParam = new Parameter(srcParam.getOriginType(), srcParam.getName()); result[i] = dstParam; } return result; }
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; }
@Override public void visitForLoop(ForStatement forLoop) { Expression exp = forLoop.getCollectionExpression(); exp.visit(this); Parameter loopParam = forLoop.getVariable(); if (loopParam != null) { varStack.getLast().add(loopParam.getName()); } super.visitForLoop(forLoop); }
private static Parameter[] cleanParameters(Parameter[] parameters) { Parameter[] params = new Parameter[parameters.length]; for (int i = 0; i < params.length; i++) { params[i] = new Parameter(cleanType(parameters[i].getType()), parameters[i].getName()); } return params; }
private static List<FieldNode> convertParamsToFields(ClassNode builder, Parameter[] parameters) { List<FieldNode> fieldNodes = new ArrayList<FieldNode>(); for(Parameter parameter: parameters) { Map<String,ClassNode> genericsSpec = createGenericsSpec(builder); ClassNode correctedType = correctToGenericsSpecRecurse(genericsSpec, parameter.getType()); FieldNode fieldNode = new FieldNode(parameter.getName(), parameter.getModifiers(), correctedType, builder, DEFAULT_INITIAL_VALUE); fieldNodes.add(fieldNode); builder.addField(fieldNode); } return fieldNodes; }
private static ClassNode getConstructorArgumentType(Expression arg, ConstructorNode node) { if (!(arg instanceof VariableExpression)) return arg.getType(); VariableExpression vexp = (VariableExpression) arg; String name = vexp.getName(); for (Parameter param : node.getParameters()) { if (param.getName().equals(name)) { return param.getType(); } } return vexp.getType(); }
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 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; } } }
private int addExpression(Parameter[] newParams, ArgumentListExpression arguments, int index, Parameter parameter) { newParams[index++] = parameter; arguments.addExpression( new CastExpression( parameter.getType(), new VariableExpression(parameter.getName()) ) ); return index; }
private static Parameter[] makeRawTypes(Parameter[] params, Map<GenericsType, GenericsType> genericsPlaceholderAndTypeMap) { Parameter[] newParam = new Parameter[params.length]; for (int i = 0; i < params.length; i++) { Parameter oldP = params[i]; ClassNode actualType = GenericsUtils.findActualTypeByGenericsPlaceholderName(oldP.getType().getUnresolvedName(), genericsPlaceholderAndTypeMap); Parameter newP = new Parameter(makeRawType(null == actualType ? oldP.getType() : actualType), oldP.getName()); newParam[i] = newP; } return newParam; }
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()); }
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()); }
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 void addFeatureMetadata(FeatureMethod feature) { AnnotationNode ann = new AnnotationNode(nodeCache.FeatureMetadata); ann.setMember(FeatureMetadata.NAME, new ConstantExpression(feature.getName())); ann.setMember(FeatureMetadata.ORDINAL, new ConstantExpression(feature.getOrdinal())); ann.setMember(FeatureMetadata.LINE, new ConstantExpression(feature.getAst().getLineNumber())); ann.setMember(FeatureMetadata.BLOCKS, blockAnnElems = new ListExpression()); ListExpression paramNames = new ListExpression(); for (Parameter param : feature.getAst().getParameters()) paramNames.addExpression(new ConstantExpression(param.getName())); ann.setMember(FeatureMetadata.PARAMETER_NAMES, paramNames); feature.getAst().addAnnotation(ann); }