public static ResolvedReferenceType undeterminedParameters(ResolvedReferenceTypeDeclaration typeDeclaration, TypeSolver typeSolver) { return new ReferenceTypeImpl(typeDeclaration, typeDeclaration.getTypeParameters().stream().map( ResolvedTypeVariable::new ).collect(Collectors.toList()), typeSolver); }
public static ResolvedReferenceType undeterminedParameters(ResolvedReferenceTypeDeclaration typeDeclaration, TypeSolver typeSolver) { return new ReferenceTypeImpl(typeDeclaration, typeDeclaration.getTypeParameters().stream().map( tp -> new ResolvedTypeVariable(tp) ).collect(Collectors.toList()), typeSolver); }
public static ResolvedReferenceType undeterminedParameters(ResolvedReferenceTypeDeclaration typeDeclaration, TypeSolver typeSolver) { return new ReferenceTypeImpl(typeDeclaration, typeDeclaration.getTypeParameters().stream().map( tp -> new ResolvedTypeVariable(tp) ).collect(Collectors.toList()), typeSolver); }
@Override public ResolvedReferenceType byName(String qualifiedName) { TypeSolver typeSolver = new ReflectionTypeSolver(); ResolvedReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(qualifiedName); if (!typeDeclaration.getTypeParameters().isEmpty()) { throw new UnsupportedOperationException(); } return new ReferenceTypeImpl(typeDeclaration, typeSolver); }
@Override public ResolvedReferenceType byName(String qualifiedName) { TypeSolver typeSolver = new ReflectionTypeSolver(); ResolvedReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(qualifiedName); if (!typeDeclaration.getTypeParameters().isEmpty()) { throw new UnsupportedOperationException(); } return new ReferenceTypeImpl(typeDeclaration, typeSolver); }
@Override public ResolvedReferenceType byName(String qualifiedName) { TypeSolver typeSolver = new ReflectionTypeSolver(); ResolvedReferenceTypeDeclaration typeDeclaration = typeSolver.solveType(qualifiedName); if (!typeDeclaration.getTypeParameters().isEmpty()) { throw new UnsupportedOperationException(); } return new ReferenceTypeImpl(typeDeclaration, typeSolver); }
private static MethodUsage replaceParams(List<ResolvedType> typeParameterValues, ResolvedReferenceTypeDeclaration typeParametrizable, ResolvedMethodDeclaration methodDeclaration) { MethodUsage methodUsage = new MethodUsage(methodDeclaration); int i = 0; // Only replace if we have enough values provided if (typeParameterValues.size() == typeParametrizable.getTypeParameters().size()){ for (ResolvedTypeParameterDeclaration tp : typeParametrizable.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(tp, typeParameterValues.get(i)); i++; } } for (ResolvedTypeParameterDeclaration methodTypeParameter : methodDeclaration.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(methodTypeParameter, new ResolvedTypeVariable(methodTypeParameter)); } return methodUsage; } }
private static MethodUsage replaceParams(List<ResolvedType> typeParameterValues, ResolvedReferenceTypeDeclaration typeParametrizable, ResolvedMethodDeclaration methodDeclaration) { MethodUsage methodUsage = new MethodUsage(methodDeclaration); int i = 0; // Only replace if we have enough values provided if (typeParameterValues.size() == typeParametrizable.getTypeParameters().size()){ for (ResolvedTypeParameterDeclaration tp : typeParametrizable.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(tp, typeParameterValues.get(i)); i++; } } for (ResolvedTypeParameterDeclaration methodTypeParameter : methodDeclaration.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(methodTypeParameter, new ResolvedTypeVariable(methodTypeParameter)); } return methodUsage; } }
private static MethodUsage replaceParams(List<ResolvedType> typeParameterValues, ResolvedReferenceTypeDeclaration typeParametrizable, ResolvedMethodDeclaration methodDeclaration) { MethodUsage methodUsage = new MethodUsage(methodDeclaration); int i = 0; // Only replace if we have enough values provided if (typeParameterValues.size() == typeParametrizable.getTypeParameters().size()){ for (ResolvedTypeParameterDeclaration tp : typeParametrizable.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(tp, typeParameterValues.get(i)); i++; } } for (ResolvedTypeParameterDeclaration methodTypeParameter : methodDeclaration.getTypeParameters()) { methodUsage = methodUsage.replaceTypeParameter(methodTypeParameter, new ResolvedTypeVariable(methodTypeParameter)); } return methodUsage; } }
@Test public void compatibilityShouldConsiderAlsoTypeVariablesPositive() { JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration"); ResolvedReferenceType runtimeException = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(RuntimeException.class, typeSolver); ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolver); ResolvedReferenceType classOfRuntimeType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), runtimeException); MethodUsage mu = constructorDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().getSignature().equals("isThrows(java.lang.Class<? extends java.lang.Throwable>)")).findFirst().get(); assertEquals(true, MethodResolutionLogic.isApplicable(mu, "isThrows", ImmutableList.of(classOfRuntimeType), typeSolver)); } }
@Test public void declaredOnMethodNegativeCase() throws ParseException { CompilationUnit cu = parseSample("ClassTypeParameter"); TypeSolver typeSolver = new ReflectionTypeSolver(); JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver); ClassOrInterfaceDeclaration classDecl = Navigator.demandClass(cu, "Foo"); MethodDeclaration methodDecl = Navigator.demandMethod(classDecl, "usage"); MethodCallExpr callToFoo = (MethodCallExpr) Navigator.findReturnStmt(methodDecl).getExpression().get(); ResolvedMethodDeclaration methodDeclaration = javaParserFacade.solve(callToFoo).getCorrespondingDeclaration(); ResolvedReferenceTypeDeclaration typeDeclaration = methodDeclaration.declaringType(); assertEquals(2, typeDeclaration.getTypeParameters().size()); assertTrue(typeDeclaration.getTypeParameters().get(0) instanceof JavaParserTypeParameter); assertEquals("A", typeDeclaration.getTypeParameters().get(0).getName()); assertEquals(false, typeDeclaration.getTypeParameters().get(0).declaredOnMethod()); assertEquals(true, typeDeclaration.getTypeParameters().get(0).declaredOnType()); assertTrue(typeDeclaration.getTypeParameters().get(1) instanceof JavaParserTypeParameter); assertEquals("B", typeDeclaration.getTypeParameters().get(1).getName()); assertEquals(false, typeDeclaration.getTypeParameters().get(1).declaredOnMethod()); assertEquals(true, typeDeclaration.getTypeParameters().get(1).declaredOnType()); }
List<ResolvedType> TIs = new LinkedList<>(); List<ResolvedType> AIs = originalType.typeParametersValues(); List<ResolvedTypeParameterDeclaration> TPs = originalType.getTypeDeclaration().getTypeParameters(); if (Ti == null && Ai.isWildcard() && Ai.asWildcard().mention(originalType.getTypeDeclaration().getTypeParameters())) { throw new IllegalArgumentException();
List<ResolvedType> TIs = new LinkedList<>(); List<ResolvedType> AIs = originalType.typeParametersValues(); List<ResolvedTypeParameterDeclaration> TPs = originalType.getTypeDeclaration().getTypeParameters(); if (Ti == null && Ai.isWildcard() && Ai.asWildcard().mention(originalType.getTypeDeclaration().getTypeParameters())) { throw new IllegalArgumentException();
@Test public void compatibilityShouldConsiderAlsoTypeVariablesNegative() { JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration"); ResolvedReferenceType stringType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolver); ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolver); assertEquals(true, rawClassType.isRawType()); ResolvedReferenceType classOfStringType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), stringType); MethodUsage mu = constructorDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().getSignature().equals("isThrows(java.lang.Class<? extends java.lang.Throwable>)")).findFirst().get(); assertEquals(false, MethodResolutionLogic.isApplicable(mu, "isThrows", ImmutableList.of(classOfStringType), typeSolver)); }
@Override public List<ResolvedReferenceType> getAncestors() { List<ResolvedReferenceType> ancestors = new ArrayList<>(); ResolvedReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType(); ResolvedTypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0); enumClass = enumClass.deriveTypeParameters(new ResolvedTypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build()); ancestors.add(enumClass); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implementedType : wrappedNode.getImplementedTypes()) { SymbolReference<ResolvedTypeDeclaration> implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId()); if (!implementedDeclRef.isSolved()) { throw new UnsolvedSymbolException(implementedType.getName().getId()); } ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver)); } } return ancestors; }
@Override public List<ResolvedReferenceType> getAncestors(boolean acceptIncompleteList) { List<ResolvedReferenceType> ancestors = new ArrayList<>(); ResolvedReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType(); ResolvedTypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0); enumClass = enumClass.deriveTypeParameters(new ResolvedTypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build()); ancestors.add(enumClass); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implementedType : wrappedNode.getImplementedTypes()) { SymbolReference<ResolvedTypeDeclaration> implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId()); if (!implementedDeclRef.isSolved() && !acceptIncompleteList) { throw new UnsolvedSymbolException(implementedType.getName().getId()); } ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver)); } } return ancestors; }
@Override public List<ResolvedReferenceType> getAncestors() { List<ResolvedReferenceType> ancestors = new ArrayList<>(); ResolvedReferenceType enumClass = ReflectionFactory.typeUsageFor(Enum.class, typeSolver).asReferenceType(); ResolvedTypeParameterDeclaration eTypeParameter = enumClass.getTypeDeclaration().getTypeParameters().get(0); enumClass = enumClass.deriveTypeParameters(new ResolvedTypeParametersMap.Builder().setValue(eTypeParameter, new ReferenceTypeImpl(this, typeSolver)).build()); ancestors.add(enumClass); if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implementedType : wrappedNode.getImplementedTypes()) { SymbolReference<ResolvedTypeDeclaration> implementedDeclRef = new SymbolSolver(typeSolver).solveTypeInType(this, implementedType.getName().getId()); if (!implementedDeclRef.isSolved()) { throw new UnsolvedSymbolException(implementedType.getName().getId()); } ancestors.add(new ReferenceTypeImpl((ResolvedReferenceTypeDeclaration) implementedDeclRef.getCorrespondingDeclaration(), typeSolver)); } } return ancestors; }
@Test public void testSolveMethodNotExistingBecauseOfTypeParameters() { JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration"); SymbolReference<ResolvedMethodDeclaration> res = null; ResolvedReferenceType stringType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode); ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode); ResolvedReferenceType classOfStringType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), stringType); res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(classOfStringType)); assertEquals(false, res.isSolved()); }
@Test public void testReplaceTypeVariables() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedInterfaceDeclaration streamInterface = new ReflectionInterfaceDeclaration(Stream.class, typeResolver); ResolvedReferenceType stream = new ReferenceTypeImpl(streamInterface, typeResolver); ResolvedMethodDeclaration streamMap = streamInterface.getDeclaredMethods().stream().filter(m -> m.getName().equals("map")).findFirst().get(); ResolvedTypeParameterDeclaration streamMapR = streamMap.findTypeParameter("T").get(); ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(streamMapR); stream = stream.deriveTypeParameters(stream.typeParametersMap().toBuilder().setValue(stream.getTypeDeclaration().getTypeParameters().get(0), typeVariable).build()); ResolvedTypeParameterDeclaration tpToReplace = streamInterface.getTypeParameters().get(0); ResolvedType replaced = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver); ResolvedType streamReplaced = stream.replaceTypeVariables(tpToReplace, replaced); assertEquals("java.util.stream.Stream<java.lang.String>", streamReplaced.describe()); }
@Test public void testReplaceTypeVariablesWithLambdaInBetween() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedInterfaceDeclaration streamInterface = new ReflectionInterfaceDeclaration(Stream.class, typeResolver); ResolvedReferenceType stream = new ReferenceTypeImpl(streamInterface, typeResolver); ResolvedMethodDeclaration streamMap = streamInterface.getDeclaredMethods().stream().filter(m -> m.getName().equals("map")).findFirst().get(); ResolvedTypeParameterDeclaration streamMapR = streamMap.findTypeParameter("T").get(); ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(streamMapR); stream = stream.deriveTypeParameters(stream.typeParametersMap().toBuilder().setValue(stream.getTypeDeclaration().getTypeParameters().get(0), typeVariable).build()); ResolvedTypeParameterDeclaration tpToReplace = streamInterface.getTypeParameters().get(0); ResolvedType replaced = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver); ResolvedType streamReplaced = stream.replaceTypeVariables(tpToReplace, replaced); assertEquals("java.util.stream.Stream<java.lang.String>", streamReplaced.describe()); }