public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentsTypes, Context invokationContext, List<ResolvedType> typeParameterValues) { List<MethodUsage> methods = new ArrayList<>(); for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).sorted(new MethodComparator()).collect(Collectors.toList())) { if (method.isBridge() || method.isSynthetic()) continue; ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = new MethodUsage(methodDeclaration); for (int i = 0; i < getTypeParameters().size() && i < typeParameterValues.size(); i++) { ResolvedTypeParameterDeclaration tpToReplace = getTypeParameters().get(i); ResolvedType newValue = typeParameterValues.get(i); methodUsage = methodUsage.replaceTypeParameter(tpToReplace, newValue); } methods.add(methodUsage); } if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(superClass, name, argumentsTypes, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } for (ResolvedReferenceType interfaceDeclaration : getInterfaces()) { Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(interfaceDeclaration.getTypeDeclaration(), name, argumentsTypes, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } Optional<MethodUsage> ref = MethodResolutionLogic.findMostApplicableUsage(methods, name, argumentsTypes, typeSolver); return ref; }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentsTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { List<MethodUsage> methods = new ArrayList<>(); for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).sorted(new MethodComparator()).collect(Collectors.toList())) { if (method.isBridge() || method.isSynthetic()) continue; ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = new MethodUsage(methodDeclaration); for (int i = 0; i < getTypeParameters().size() && i < typeParameterValues.size(); i++) { ResolvedTypeParameterDeclaration tpToReplace = getTypeParameters().get(i); ResolvedType newValue = typeParameterValues.get(i); methodUsage = methodUsage.replaceTypeParameter(tpToReplace, newValue); } methods.add(methodUsage); } if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(superClass, name, argumentsTypes, typeSolver, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } for (ResolvedReferenceType interfaceDeclaration : getInterfaces()) { Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(interfaceDeclaration.getTypeDeclaration(), name, argumentsTypes, typeSolver, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } Optional<MethodUsage> ref = MethodResolutionLogic.findMostApplicableUsage(methods, name, argumentsTypes, typeSolver); return ref; }
@Deprecated public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) { List<ResolvedMethodDeclaration> methods = new ArrayList<>(); Predicate<Method> staticFilter = m -> !staticOnly || (staticOnly && Modifier.isStatic(m.getModifiers())); for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).filter(staticFilter) .sorted(new MethodComparator()).collect(Collectors.toList())) { if (method.isBridge() || method.isSynthetic()) continue; ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); methods.add(methodDeclaration); } if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(superClass, name, argumentsTypes, staticOnly, typeSolver); if (ref.isSolved()) { methods.add(ref.getCorrespondingDeclaration()); } } for (ResolvedReferenceType interfaceDeclaration : getInterfaces()) { SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(interfaceDeclaration.getTypeDeclaration(), name, argumentsTypes, staticOnly, typeSolver); if (ref.isSolved()) { methods.add(ref.getCorrespondingDeclaration()); } } return MethodResolutionLogic.findMostApplicable(methods, name, argumentsTypes, typeSolver); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> argumentsTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { List<MethodUsage> methods = new ArrayList<>(); for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).sorted(new MethodComparator()).collect(Collectors.toList())) { if (method.isBridge() || method.isSynthetic()) continue; ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = new MethodUsage(methodDeclaration); for (int i = 0; i < getTypeParameters().size() && i < typeParameterValues.size(); i++) { ResolvedTypeParameterDeclaration tpToReplace = getTypeParameters().get(i); ResolvedType newValue = typeParameterValues.get(i); methodUsage = methodUsage.replaceTypeParameter(tpToReplace, newValue); } methods.add(methodUsage); } if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(superClass, name, argumentsTypes, typeSolver, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } for (ResolvedReferenceType interfaceDeclaration : getInterfaces()) { Optional<MethodUsage> ref = ContextHelper.solveMethodAsUsage(interfaceDeclaration.getTypeDeclaration(), name, argumentsTypes, typeSolver, invokationContext, typeParameterValues); if (ref.isPresent()) { methods.add(ref.get()); } } Optional<MethodUsage> ref = MethodResolutionLogic.findMostApplicableUsage(methods, name, argumentsTypes, typeSolver); return ref; }
@Deprecated public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> argumentsTypes, boolean staticOnly) { List<ResolvedMethodDeclaration> methods = new ArrayList<>(); Predicate<Method> staticFilter = m -> !staticOnly || (staticOnly && Modifier.isStatic(m.getModifiers())); for (Method method : Arrays.stream(clazz.getDeclaredMethods()).filter((m) -> m.getName().equals(name)).filter(staticFilter) .sorted(new MethodComparator()).collect(Collectors.toList())) { if (method.isBridge() || method.isSynthetic()) continue; ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); methods.add(methodDeclaration); } if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(superClass, name, argumentsTypes, staticOnly, typeSolver); if (ref.isSolved()) { methods.add(ref.getCorrespondingDeclaration()); } } for (ResolvedReferenceType interfaceDeclaration : getInterfaces()) { SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(interfaceDeclaration.getTypeDeclaration(), name, argumentsTypes, staticOnly, typeSolver); if (ref.isSolved()) { methods.add(ref.getCorrespondingDeclaration()); } } return MethodResolutionLogic.findMostApplicable(methods, name, argumentsTypes, typeSolver); }
methods.add(methodDeclaration); if (getSuperClass() != null) { ResolvedClassDeclaration superClass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(superClass, name, argumentsTypes, staticOnly); if (ref.isSolved()) {
@Test public void testGetSuperclassWithoutTypeParameters() { ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit"); assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName()); }
@Test public void testGetSuperclassWithTypeParameters() { ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration"); assertEquals("com.github.javaparser.ast.body.CallableDeclaration", compilationUnit.getSuperClass().getQualifiedName()); assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.CallableDeclaration.T").get().asReferenceType().getQualifiedName()); }