/** * @return a value type of this method */ public CtTypeReference<?> getValueType() { if (method.getParameters().isEmpty()) { return method.getType(); } return method.getParameters().get(method.getParameters().size() - 1).getType(); }
@Override @SuppressWarnings("unchecked") public <R> CtMethod<R> getMethod(CtTypeReference<R> returnType, String name, CtTypeReference<?>... parameterTypes) { for (CtTypeMember typeMember : typeMembers) { if (!(typeMember instanceof CtMethod)) { continue; } CtMethod<R> m = (CtMethod<R>) typeMember; if (m.getSimpleName().equals(name)) { if (!m.getType().equals(returnType)) { continue; } boolean cont = m.getParameters().size() == parameterTypes.length; for (int i = 0; cont && (i < m.getParameters().size()) && (i < parameterTypes.length); i++) { if (!m.getParameters().get(i).getType().getQualifiedName().equals(parameterTypes[i].getQualifiedName())) { cont = false; } } if (cont) { return m; } } } return null; }
/** * @param methods * @param key * @return index of the method which best matches the `key` accessor of this field * -1 if it cannot be resolved */ private int getIdxOfBestMatch(List<MMMethod> methods, MMMethodKind key) { MMMethod mmMethod = methods.get(0); if (mmMethod.getActualCtMethod().getParameters().isEmpty()) { return getIdxOfBestMatchByReturnType(methods, key); } else { MMMethod mmGetMethod = getMethod(MMMethodKind.GET); if (mmGetMethod == null) { //we have no getter so we do not know the expected value type. Setters are ambiguous return -1; } return getIdxOfBestMatchByInputParameter(methods, key, mmGetMethod.getReturnType()); } }
/** * For methods, this implementation of signature contains the return type, which corresponds * to what the Java compile and virtual machine call a "descriptor". * * See chapter "8.4.2 Method Signature" of the Java specification */ @Override public <T> void visitCtMethod(CtMethod<T> m) { write(m.getSimpleName()); write("("); for (CtParameter<?> p : m.getParameters()) { scan(p.getType()); write(","); } if (!m.getParameters().isEmpty()) { clearLast(); } write(")"); }
public <T> void visitCtMethod(final spoon.reflect.declaration.CtMethod<T> m) { spoon.reflect.declaration.CtMethod other = ((spoon.reflect.declaration.CtMethod) (this.stack.peek())); enter(m); biScan(spoon.reflect.path.CtRole.ANNOTATION, m.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE_PARAMETER, m.getFormalCtTypeParameters(), other.getFormalCtTypeParameters()); biScan(spoon.reflect.path.CtRole.TYPE, m.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.PARAMETER, m.getParameters(), other.getParameters()); biScan(spoon.reflect.path.CtRole.THROWN, m.getThrownTypes(), other.getThrownTypes()); biScan(spoon.reflect.path.CtRole.BODY, m.getBody(), other.getBody()); biScan(spoon.reflect.path.CtRole.COMMENT, m.getComments(), other.getComments()); exit(m); }
public static boolean hasNoArguments(CtMethod<?> method) { return method.getParameters().isEmpty(); }
public <T> void visitCtMethod(final CtMethod<T> m) { enter(m); scan(CtRole.ANNOTATION, m.getAnnotations()); scan(CtRole.TYPE_PARAMETER, m.getFormalCtTypeParameters()); scan(CtRole.TYPE, m.getType()); scan(CtRole.PARAMETER, m.getParameters()); scan(CtRole.THROWN, m.getThrownTypes()); scan(CtRole.BODY, m.getBody()); scan(CtRole.COMMENT, m.getComments()); exit(m); }
List<CtParameter<?>> adaptedParams = new ArrayList<>(method.getParameters().size()); for (CtParameter<?> parameter : method.getParameters()) { adaptedParams.add(factory.Executable().createParameter(null, adaptType(parameter.getType()),
@java.lang.Override public <T> void visitCtMethod(final spoon.reflect.declaration.CtMethod<T> m) { replaceInListIfExist(m.getAnnotations(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementAnnotationsReplaceListener(m)); replaceInListIfExist(m.getFormalCtTypeParameters(), new spoon.support.visitor.replace.ReplacementVisitor.CtFormalTypeDeclarerFormalCtTypeParametersReplaceListener(m)); replaceElementIfExist(m.getType(), new spoon.support.visitor.replace.ReplacementVisitor.CtTypedElementTypeReplaceListener(m)); replaceInListIfExist(m.getParameters(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableParametersReplaceListener(m)); replaceInSetIfExist(m.getThrownTypes(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableThrownTypesReplaceListener(m)); replaceElementIfExist(m.getBody(), new spoon.support.visitor.replace.ReplacementVisitor.CtExecutableBodyReplaceListener(m)); replaceInListIfExist(m.getComments(), new spoon.support.visitor.replace.ReplacementVisitor.CtElementCommentsReplaceListener(m)); }
/** * Creates a constructor into a target class by copying it from a source * method. * * @param target * the target class * @param source * the method to be copied * @return the new constructor */ @SuppressWarnings("unchecked") public <T> CtConstructor<T> create(CtClass<T> target, CtMethod<?> source) { CtMethod<T> method = (CtMethod<T>) source.clone(); CtConstructor<T> newConstructor = factory.Core().createConstructor(); newConstructor.setAnnotations(method.getAnnotations()); newConstructor.setBody(method.getBody()); newConstructor.setDocComment(method.getDocComment()); newConstructor.setFormalCtTypeParameters(method.getFormalCtTypeParameters()); newConstructor.setModifiers(method.getModifiers()); newConstructor.setParameters(method.getParameters()); target.addConstructor(newConstructor); return newConstructor; }
static boolean overrides(CtMethod<?> m1, CtMethod<?> m2) { if (!m2.getSimpleName().equals(m1.getSimpleName())) return false; return m2.getParameters().equals(m1.getParameters()); }
@Override public <T> void visitCtMethod(CtMethod<T> method) { scanElementsIn(method.getParameters()); }
@Override @SuppressWarnings("unchecked") public <R> CtMethod<R> getMethod(String name, CtTypeReference<?>... parameterTypes) { for (CtMethod<?> m : methods) { if (m.getSimpleName().equals(name)) { boolean cont = m.getParameters().size() == parameterTypes.length; for (int i = 0; cont && (i < m.getParameters().size()) && (i < parameterTypes.length); i++) { // String // s1=m.getParameters().get(i).getType().getQualifiedName(); // String s2=parameterTypes[i].getQualifiedName(); if (!m.getParameters().get(i).getType().equals(parameterTypes[i])) { cont = false; } } if (cont) { return (CtMethod<R>) m; } } } return null; }
@Override public boolean matches(CtMethod<?> element) { return element.getModifiers().contains(ModifierKind.STATIC) && Arrays.stream(NAME_OF_FACTORY_METHOD) .anyMatch(element.getSimpleName().toLowerCase()::contains) && element.getType().equals(type) && element.getParameters().stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType); } }
public <T> void visitCtMethod(final spoon.reflect.declaration.CtMethod<T> m) { spoon.reflect.declaration.CtMethod<T> aCtMethod = m.getFactory().Core().createMethod(); this.builder.copy(m, aCtMethod); aCtMethod.setAnnotations(this.cloneHelper.clone(m.getAnnotations())); aCtMethod.setFormalCtTypeParameters(this.cloneHelper.clone(m.getFormalCtTypeParameters())); aCtMethod.setType(this.cloneHelper.clone(m.getType())); aCtMethod.setParameters(this.cloneHelper.clone(m.getParameters())); aCtMethod.setThrownTypes(this.cloneHelper.clone(m.getThrownTypes())); aCtMethod.setBody(this.cloneHelper.clone(m.getBody())); aCtMethod.setComments(this.cloneHelper.clone(m.getComments())); this.cloneHelper.tailor(m, aCtMethod); this.other = aCtMethod; }
@SuppressWarnings({ "rawtypes", "unused" }) private List<List<CtExpression>> createAllPossibleArgsListForMethod(CtMethod method, List<CtExpression> variables) { try { List<CtParameter> argumentTypes = method.getParameters(); List<List<CtExpression>> argumentCandidates = new ArrayList<>(); for (int j = 0; j < argumentTypes.size(); j++) { CtParameter par = argumentTypes.get(j); List<CtExpression> compatiblePar = new ArrayList<>(); for (CtExpression ctVariableRead : variables) { if (ctVariableRead.getType().isSubtypeOf(par.getType())) { compatiblePar.add(ctVariableRead); } } argumentCandidates.add(compatiblePar); } return argumentCandidates; } catch (Exception e) { e.printStackTrace(); } return null; }
public static List<CtMethod<?>> findMethodsWithTargetType(CtTypeReference<?> type) { if (type == null || type.getTypeDeclaration() == null) { return Collections.emptyList(); } else { return type.getTypeDeclaration().getMethods().stream() .filter(method -> method.getModifiers().contains(ModifierKind.PUBLIC)) // TODO checks this predicate // TODO we could also access to method with default or protected modifiers .filter(method -> !method.getModifiers().contains(ModifierKind.STATIC)) // TODO checks this predicate // TODO we can't amplify test on full static classes with this predicate .filter(method -> !method.getModifiers().contains(ModifierKind.ABSTRACT)) // TODO checks this predicate // TODO maybe we would like to call of abstract method, since the abstract would be implemented // TODO inherited classes. However, the semantic of the test to be amplified may be to test the abstract class .filter(method -> method.getParameters() .stream() .map(CtParameter::getType) .allMatch(ValueCreatorHelper::canGenerateAValueForType) ).collect(Collectors.toList()); } }
public static boolean clashes(CtMethod<?> a, CtMethod<?> b) { if (!a.getSimpleName().equals(b.getSimpleName())) return false; List<CtParameter<?>> aParams = a.getParameters(); List<CtParameter<?>> bParams = b.getParameters(); if (aParams.size() != bParams.size()) return false; for (int i = 0; i < aParams.size(); i++) { CtTypeReference<?> aParam = aParams.get(i).getType(); CtTypeReference<?> bParam = bParams.get(i).getType(); if (aParam.isSubtypeOf(bParam)) continue; if (bParam.isSubtypeOf(aParam)) continue; if (isNumericPrimitive(aParam) && isNumericPrimitive(bParam)) continue; // TODO update when unbox() bug fixed in Spoon return false; } return true; }
public <T> void visitCtMethod(CtMethod<T> m) { if (!m.getFormalTypeParameters().isEmpty()) { scan(m.getFormalTypeParameters()); write(" "); } scan(m.getType()); write(" "); write(m.getSimpleName()); write("("); for (CtParameter<?> p : m.getParameters()) { scan(p.getType()); write(","); } if (!m.getParameters().isEmpty()) { clearLast(); } write(")"); }
public <T> void visitCtMethod(CtMethod<T> m) { enter(m); scan(m.getAnnotations()); scan(m.getType()); scan(m.getParameters()); scanReferences(m.getThrownTypes()); scanReferences(m.getFormalTypeParameters()); scan(m.getBody()); exit(m); }