protected static ClassNode[] extractTypesFromParameters(final Parameter[] parameters) { ClassNode[] params = new ClassNode[parameters.length]; for (int i = 0; i < params.length; i++) { params[i] = parameters[i].getType(); } return params; }
static boolean isVargs(Parameter[] params) { if (params.length == 0) return false; if (params[params.length - 1].getType().isArray()) return true; return false; }
private static boolean hasEqualParameterTypes(Parameter[] first, Parameter[] second) { if (first.length != second.length) return false; for (int i = 0; i < first.length; i++) { String ft = first[i].getType().getName(); String st = second[i].getType().getName(); if (ft.equals(st)) continue; return false; } return true; }
private static boolean isVargs(Parameter[] p) { if (p.length==0) return false; ClassNode clazz = p[p.length-1].getType(); return (clazz.isArray()); }
private static boolean hasGenerics(Parameter[] param) { if (param.length == 0) return false; for (int i = 0; i < param.length; i++) { ClassNode type = param[i].getType(); if (hasGenerics(type)) return true; } return false; }
private void checkGenericsUsage(ASTNode ref, Parameter[] params) { for (Parameter p : params) { checkGenericsUsage(ref, p.getType()); } }
public static String getMethodDescriptor(ClassNode returnType, Parameter[] parameters) { StringBuilder buffer = new StringBuilder(100); buffer.append("("); for (Parameter parameter : parameters) { buffer.append(getTypeDescription(parameter.getType())); } buffer.append(")"); buffer.append(getTypeDescription(returnType)); return buffer.toString(); }
/** * @deprecated use MethodNodeUtils#methodDescriptorWithoutReturnType(MethodNode) instead */ @Deprecated public static String makeDescriptorWithoutReturnType(MethodNode mn) { StringBuilder sb = new StringBuilder(); sb.append(mn.getName()).append(':'); for (Parameter p : mn.getParameters()) { sb.append(p.getType()).append(','); } return sb.toString(); }
private static boolean equalParametersNormal(MethodNode m1, MethodNode m2) { Parameter[] p1 = m1.getParameters(); Parameter[] p2 = m2.getParameters(); if (p1.length != p2.length) return false; for (int i = 0; i < p2.length; i++) { ClassNode type = p2[i].getType(); ClassNode parameterType = p1[i].getType(); if (!parameterType.equals(type)) return false; } return true; }
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 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()); }
private void makeLocalVariablesOffset(Parameter[] paras, boolean isInStaticContext) { resetVariableIndex(isInStaticContext); for (Parameter para : paras) { makeNextVariableID(para.getType(), false); } localVariableOffset = nextVariableIndex; resetVariableIndex(isInStaticContext); }
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 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; }
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 visitMethod(MethodNode node) { Parameter[] parameters = node.getParameters(); for (Parameter param : parameters) { ClassNode paramType = param.getType(); checkGenericsUsage(paramType, paramType.redirect()); } ClassNode returnType = node.getReturnType(); checkGenericsUsage(returnType, returnType.redirect()); super.visitMethod(node); }
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()); }