private List<ResolvedType> formalParameterTypes(ResolvedMethodDeclaration methodDeclaration) { List<ResolvedType> types = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { types.add(methodDeclaration.getParam(i).getType()); } return types; }
private List<ResolvedType> formalParameterTypes(ResolvedMethodDeclaration methodDeclaration) { List<ResolvedType> types = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { types.add(methodDeclaration.getParam(i).getType()); } return types; }
private List<ResolvedType> formalParameterTypes(ResolvedMethodDeclaration methodDeclaration) { List<ResolvedType> types = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { types.add(methodDeclaration.getParam(i).getType()); } return types; }
private static MethodUsage instantiationSetToMethodUsage(ResolvedMethodDeclaration methodDeclaration, InstantiationSet instantiationSet) { if (instantiationSet.isEmpty()) { return new MethodUsage(methodDeclaration); } List<ResolvedType> paramTypes = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { paramTypes.add(instantiationSet.apply(methodDeclaration.getParam(i).getType())); } ResolvedType returnType = instantiationSet.apply(methodDeclaration.getReturnType()); return new MethodUsage(methodDeclaration, paramTypes, returnType); }
private static MethodUsage instantiationSetToMethodUsage(ResolvedMethodDeclaration methodDeclaration, InstantiationSet instantiationSet) { if (instantiationSet.isEmpty()) { return new MethodUsage(methodDeclaration); } List<ResolvedType> paramTypes = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { paramTypes.add(instantiationSet.apply(methodDeclaration.getParam(i).getType())); } ResolvedType returnType = instantiationSet.apply(methodDeclaration.getReturnType()); return new MethodUsage(methodDeclaration, paramTypes, returnType); }
private static MethodUsage instantiationSetToMethodUsage(ResolvedMethodDeclaration methodDeclaration, InstantiationSet instantiationSet) { if (instantiationSet.isEmpty()) { return new MethodUsage(methodDeclaration); } List<ResolvedType> paramTypes = new LinkedList<>(); for (int i=0;i<methodDeclaration.getNumberOfParams();i++) { paramTypes.add(instantiationSet.apply(methodDeclaration.getParam(i).getType())); } ResolvedType returnType = instantiationSet.apply(methodDeclaration.getReturnType()); return new MethodUsage(methodDeclaration, paramTypes, returnType); }
private static ResolvedType getMethodsExplicitAndVariadicParameterType(ResolvedMethodDeclaration method, int i) { int numberOfParams = method.getNumberOfParams(); if (i < numberOfParams) { return method.getParam(i).getType(); } else if (method.hasVariadicParameter()) { return method.getParam(numberOfParams - 1).getType(); } else { return null; } }
public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) { ResolvedType returnType = replaceTypeParams(methodDeclaration.getReturnType(), context); List<ResolvedType> params = new ArrayList<>(); for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) { ResolvedType replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), context); params.add(replaced); } // We now look at the type parameter for the method which we can derive from the parameter types // and then we replace them in the return type // Map<TypeParameterDeclaration, Type> determinedTypeParameters = new HashMap<>(); InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); for (int i = 0; i < methodDeclaration.getNumberOfParams() - (methodDeclaration.hasVariadicParameter() ? 1 : 0); i++) { ResolvedType formalParamType = methodDeclaration.getParam(i).getType(); ResolvedType actualParamType = parameterTypes.get(i); inferenceContext.addPair(formalParamType, actualParamType); } returnType = inferenceContext.resolve(inferenceContext.addSingle(returnType)); return new MethodUsage(methodDeclaration, params, returnType); }
public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) { ResolvedType returnType = replaceTypeParams(methodDeclaration.getReturnType(), typeSolver, context); List<ResolvedType> params = new ArrayList<>(); for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) { ResolvedType replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), typeSolver, context); params.add(replaced); } // We now look at the type parameter for the method which we can derive from the parameter types // and then we replace them in the return type // Map<TypeParameterDeclaration, Type> determinedTypeParameters = new HashMap<>(); InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); for (int i = 0; i < methodDeclaration.getNumberOfParams() - (methodDeclaration.hasVariadicParameter() ? 1 : 0); i++) { ResolvedType formalParamType = methodDeclaration.getParam(i).getType(); ResolvedType actualParamType = parameterTypes.get(i); inferenceContext.addPair(formalParamType, actualParamType); } returnType = inferenceContext.resolve(inferenceContext.addSingle(returnType)); return new MethodUsage(methodDeclaration, params, returnType); }
public MethodUsage resolveTypeVariables(Context context, List<ResolvedType> parameterTypes) { ResolvedType returnType = replaceTypeParams(methodDeclaration.getReturnType(), typeSolver, context); List<ResolvedType> params = new ArrayList<>(); for (int i = 0; i < methodDeclaration.getNumberOfParams(); i++) { ResolvedType replaced = replaceTypeParams(methodDeclaration.getParam(i).getType(), typeSolver, context); params.add(replaced); } // We now look at the type parameter for the method which we can derive from the parameter types // and then we replace them in the return type // Map<TypeParameterDeclaration, Type> determinedTypeParameters = new HashMap<>(); InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); for (int i = 0; i < methodDeclaration.getNumberOfParams() - (methodDeclaration.hasVariadicParameter() ? 1 : 0); i++) { ResolvedType formalParamType = methodDeclaration.getParam(i).getType(); ResolvedType actualParamType = parameterTypes.get(i); inferenceContext.addPair(formalParamType, actualParamType); } returnType = inferenceContext.resolve(inferenceContext.addSingle(returnType)); return new MethodUsage(methodDeclaration, params, returnType); }
@Test public void testGetDeclaredMethods() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedReferenceTypeDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver); List<ResolvedMethodDeclaration> methods = list.getDeclaredMethods().stream() .sorted((a, b) -> a.getName().compareTo(b.getName())) .collect(Collectors.toList()); assertEquals(28, methods.size()); assertEquals("clear", methods.get(4).getName()); assertEquals(true, methods.get(4).isAbstract()); assertEquals(0, methods.get(4).getNumberOfParams()); assertEquals("contains", methods.get(5).getName()); assertEquals(true, methods.get(5).isAbstract()); assertEquals(1, methods.get(5).getNumberOfParams()); assertEquals(true, methods.get(5).getParam(0).getType().isReferenceType()); assertEquals(Object.class.getCanonicalName(), methods.get(5).getParam(0).getType().asReferenceType().getQualifiedName()); }
@Test public void testGetDeclaredMethods() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedReferenceTypeDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver); List<ResolvedMethodDeclaration> methods = string.getDeclaredMethods().stream() .filter(m -> m.accessSpecifier() != AccessSpecifier.PRIVATE && m.accessSpecifier() != AccessSpecifier.DEFAULT) .sorted((a, b) -> a.getName().compareTo(b.getName())) .collect(Collectors.toList()); assertEquals(67, methods.size()); assertEquals("charAt", methods.get(0).getName()); assertEquals(false, methods.get(0).isAbstract()); assertEquals(1, methods.get(0).getNumberOfParams()); assertEquals("int", methods.get(0).getParam(0).getType().describe()); assertEquals("concat", methods.get(6).getName()); assertEquals(false, methods.get(6).isAbstract()); assertEquals(1, methods.get(6).getNumberOfParams()); assertEquals("java.lang.String", methods.get(6).getParam(0).getType().describe()); }
@Test public void methodDeclarationResolve() throws IOException { File f = adaptPath(new File("src/test/resources/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java")); CompilationUnit cu = parseWithSymbolResolution(f); ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0); assertEquals("CompilationUnit", classDeclaration.getNameAsString()); MethodDeclaration declaration = classDeclaration.getMethodsByName("getComments").get(0); ResolvedMethodDeclaration resolvedDeclaration = declaration.resolve(); assertEquals("getComments", resolvedDeclaration.getName()); assertEquals(0, resolvedDeclaration.getNumberOfParams()); }
@Test public void solveMethodWithPrimitiveParameters() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); ResolvedType intType = ResolvedPrimitiveType.INT; SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo3", ImmutableList.of(intType), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams()); }
@Test public void solveMethodOverrideCase() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo1", ImmutableList.of(), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams()); }
@Test public void solveMethodSimpleCase() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo0", ImmutableList.of(), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams()); }
@Test public void solveMethodInheritedCase() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo2", ImmutableList.of(), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("Super", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams()); }
@Test public void solveMethodWithMoreSpecializedParameter() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo4", ImmutableList.of(stringType), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams()); }
@Test public void solveMethodStaticallyImportedWithAsterisk() throws ParseException, IOException { CompilationUnit cu = parseSample("CompilationUnitWithImports"); Context context = new CompilationUnitContext(cu, typeSolver); CombinedTypeSolver typeSolver = new CombinedTypeSolver(); typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar"))); typeSolver.add(new ReflectionTypeSolver()); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("assertFalse", ImmutableList.of(ResolvedPrimitiveType.BOOLEAN), false, typeSolver); assertEquals(true, ref.isSolved()); assertEquals("assertFalse", ref.getCorrespondingDeclaration().getName()); assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams()); assertEquals("boolean", ref.getCorrespondingDeclaration().getParam(0).getType().describe()); assertEquals(true, ref.getCorrespondingDeclaration().getParam(0).getType().isPrimitive()); }
@Test public void solveMethodStaticallyImportedWithoutAsterisk() throws ParseException, IOException { CompilationUnit cu = parseSample("CompilationUnitSymbols"); Context context = new CompilationUnitContext(cu, typeSolver); CombinedTypeSolver typeSolver = new CombinedTypeSolver(); typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar"))); typeSolver.add(new ReflectionTypeSolver()); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("assertEquals", ImmutableList.of(NullType.INSTANCE, NullType.INSTANCE), false, typeSolver); assertEquals(true, ref.isSolved()); assertEquals("assertEquals", ref.getCorrespondingDeclaration().getName()); assertEquals(2, ref.getCorrespondingDeclaration().getNumberOfParams()); assertEquals("java.lang.Object", ref.getCorrespondingDeclaration().getParam(0).getType().asReferenceType().getQualifiedName()); assertEquals("java.lang.Object", ref.getCorrespondingDeclaration().getParam(1).getType().asReferenceType().getQualifiedName()); }