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 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; } }
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); }
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(), 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); }
@Test public void testGetGenericParameters() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedInterfaceDeclaration map = new ReflectionInterfaceDeclaration(Map.class, typeResolver); ResolvedMethodDeclaration put = map.getAllMethods().stream().filter(m -> m.getName().equals("put")).findFirst().get().getDeclaration(); assertEquals(true, put.getParam(0).getType().isTypeVariable()); assertEquals(true, put.getParam(0).getType().asTypeParameter().declaredOnType()); assertEquals("java.util.Map.K", put.getParam(0).getType().asTypeParameter().getQualifiedName()); assertEquals(true, put.getParam(1).getType().isTypeVariable()); assertEquals(true, put.getParam(1).getType().asTypeParameter().declaredOnType()); assertEquals("java.util.Map.V", put.getParam(1).getType().asTypeParameter().getQualifiedName()); } }
@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 resolveMethodDeclaration() throws ParseException { TypeSolver typeSolver = new ReflectionTypeSolver(); CompilationUnit cu = parseSample("SymbolResolverExample"); new JavaSymbolSolver(typeSolver).inject(cu); MethodDeclaration methodDeclaration = cu.getClassByName("A").get().getMethods().get(0); ResolvedMethodDeclaration resolvedMethodDeclaration = methodDeclaration.resolve(); assertEquals("foo", resolvedMethodDeclaration.getName()); assertEquals("A[]", resolvedMethodDeclaration.getReturnType().describe()); assertEquals("java.lang.String[]", resolvedMethodDeclaration.getParam(0).getType().describe()); assertEquals("int[]", resolvedMethodDeclaration.getParam(1).getType().describe()); }
return refMethod.getCorrespondingDeclaration().getParam(pos).getType();
return refMethod.getCorrespondingDeclaration().getParam(pos).getType();
return refMethod.getCorrespondingDeclaration().getParam(pos).getType();
@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()); }