private void solveTypeDecl(ClassOrInterfaceDeclaration node) { ResolvedTypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(node); if (typeDeclaration.isClass()) { out.println("\n[ Class " + typeDeclaration.getQualifiedName() + " ]"); for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllSuperClasses()) { out.println(" superclass: " + sc.getQualifiedName()); } for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllInterfaces()) { out.println(" interface: " + sc.getQualifiedName()); } } }
@Override public ResolvedType visit(SuperExpr node, Boolean solveLambdas) { ResolvedTypeDeclaration typeOfNode = facade.getTypeDeclaration(facade.findContainingTypeDecl(node)); if (typeOfNode instanceof ResolvedClassDeclaration) { return ((ResolvedClassDeclaration) typeOfNode).getSuperClass(); } else { throw new UnsupportedOperationException(node.getClass().getCanonicalName()); } }
public SymbolReference<ResolvedConstructorDeclaration> solveConstructor(List<ResolvedType> argumentsTypes, TypeSolver typeSolver) { if (typeDeclaration instanceof ResolvedClassDeclaration) { return ConstructorResolutionLogic.findMostApplicable(((ResolvedClassDeclaration) typeDeclaration).getConstructors(), argumentsTypes, typeSolver); } return SymbolReference.unsolved(ResolvedConstructorDeclaration.class); } }
@Test public void resolveReferenceToImportedType() throws ParseException { CompilationUnit cu = parseSample("Navigator"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator"); MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType"); Parameter param = method.getParameters().get(0); ResolvedClassDeclaration compilationUnitDecl = createMock(ResolvedClassDeclaration.class); expect(compilationUnitDecl.getName()).andReturn("CompilationUnit"); expect(compilationUnitDecl.getQualifiedName()).andReturn("com.github.javaparser.ast.CompilationUnit"); TypeSolver typeSolver = createMock(TypeSolver.class); expect(typeSolver.getRoot()).andReturn(typeSolver); expect(typeSolver.solveType("java.lang.Object")).andReturn(new ReflectionClassDeclaration(Object.class, typeSolver)); expect(typeSolver.tryToSolveType("com.github.javaparser.ast.CompilationUnit")).andReturn(SymbolReference.solved(compilationUnitDecl)); SymbolSolver symbolSolver = new SymbolSolver(typeSolver); replay(typeSolver, compilationUnitDecl); SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("CompilationUnit", param); assertEquals(true, ref.isSolved()); assertEquals("CompilationUnit", ref.getCorrespondingDeclaration().getName()); assertEquals("com.github.javaparser.ast.CompilationUnit", ref.getCorrespondingDeclaration().getQualifiedName()); verify(typeSolver, compilationUnitDecl); }
@Override public boolean canBeAssignedTo(ResolvedReferenceTypeDeclaration other) { // TODO consider generic types if (this.getQualifiedName().equals(other.getQualifiedName())) { return true; } ResolvedClassDeclaration superclass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); if (superclass != null) { // We want to avoid infinite recursion in case of Object having Object as ancestor if (Object.class.getCanonicalName().equals(superclass.getQualifiedName())) { return true; } if (superclass.canBeAssignedTo(other)) { return true; } } if (this.wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType type : wrappedNode.getImplementedTypes()) { ResolvedReferenceTypeDeclaration ancestor = (ResolvedReferenceTypeDeclaration) new SymbolSolver(typeSolver).solveType(type); if (ancestor.canBeAssignedTo(other)) { return true; } } } return false; }
ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration)node; ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration)node.getParentNode().get(); ResolvedClassDeclaration resolvedClass = resolveDeclaration(classOrInterfaceDeclaration, ResolvedClassDeclaration.class).asClass(); ResolvedConstructorDeclaration resolved = resolvedClass.getConstructors().stream().filter(c -> ((JavaParserConstructorDeclaration)c).getWrappedNode() == constructorDeclaration).findFirst().get(); if (resultClass.isInstance(resolved)) { return resultClass.cast(resolved);
winningCandidate = other; } else { if (winningCandidate.declaringType().getQualifiedName() .equals(other.declaringType().getQualifiedName())) { possibleAmbiguity = true; } else {
@Override public String getName() { return this.classDeclaration.getName(); }
@Test public void testTypeParamValue() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); ResolvedClassDeclaration abstractList = new ReflectionClassDeclaration(AbstractList.class, typeResolver); ResolvedClassDeclaration abstractCollection = new ReflectionClassDeclaration(AbstractCollection.class, typeResolver); ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver); ResolvedInterfaceDeclaration collection = new ReflectionInterfaceDeclaration(Collection.class, typeResolver); ResolvedInterfaceDeclaration iterable = new ReflectionInterfaceDeclaration(Iterable.class, typeResolver); ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver); ResolvedReferenceType arrayListOfString = new ReferenceTypeImpl(arraylist, ImmutableList.of(string), typeResolver); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(arraylist.getTypeParameters().get(0))); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(abstractList.getTypeParameters().get(0))); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(abstractCollection.getTypeParameters().get(0))); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(list.getTypeParameters().get(0))); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(collection.getTypeParameters().get(0))); assertEquals(Optional.of(string), arrayListOfString.typeParamValue(iterable.getTypeParameters().get(0))); }
@Test public void testGetAllInterfaces() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); // Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess assertEquals(ImmutableSet.of(Serializable.class.getCanonicalName(), Cloneable.class.getCanonicalName(), List.class.getCanonicalName(), RandomAccess.class.getCanonicalName(), Collection.class.getCanonicalName(), Iterable.class.getCanonicalName()), arraylist.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet())); }
@Test public void testGetAllSuperclasses() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); assertEquals(ImmutableSet.of(Object.class.getCanonicalName(), AbstractCollection.class.getCanonicalName(), AbstractList.class.getCanonicalName()), arraylist.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet())); ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver); assertEquals(ImmutableSet.of(Object.class.getCanonicalName()), string.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet())); }
@Test public void testAllAncestors() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); Map<String, ResolvedReferenceType> ancestors = new HashMap<>(); arraylist.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a)); assertEquals(9, ancestors.size()); ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(arraylist.getTypeParameters().get(0)); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(RandomAccess.class, typeResolver), typeResolver), ancestors.get("java.util.RandomAccess")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractCollection.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.util.AbstractCollection")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.util.List")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Cloneable.class, typeResolver), typeResolver), ancestors.get("java.lang.Cloneable")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.util.Collection")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractList.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.util.AbstractList")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.lang.Iterable")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Serializable.class, typeResolver), typeResolver), ancestors.get("java.io.Serializable")); }
@Test public void resolveReferenceToClassInJavaLang() throws ParseException { CompilationUnit cu = parseSample("Navigator"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator"); MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType"); Parameter param = method.getParameters().get(1); ResolvedClassDeclaration stringDecl = createMock(ResolvedClassDeclaration.class); expect(stringDecl.getName()).andReturn("String"); expect(stringDecl.getQualifiedName()).andReturn("java.lang.String"); TypeSolver typeSolver = createMock(TypeSolver.class); expect(typeSolver.tryToSolveType("me.tomassetti.symbolsolver.javaparser.String")).andReturn(SymbolReference.unsolved(ResolvedReferenceTypeDeclaration.class)); expect(typeSolver.getRoot()).andReturn(typeSolver); expect(typeSolver.solveType("java.lang.Object")).andReturn(new ReflectionClassDeclaration(Object.class, typeSolver)); expect(typeSolver.tryToSolveType("java.lang.String")).andReturn(SymbolReference.solved(stringDecl)); SymbolSolver symbolSolver = new SymbolSolver(typeSolver); replay(typeSolver, stringDecl); SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("String", param); assertEquals(true, ref.isSolved()); assertEquals("String", ref.getCorrespondingDeclaration().getName()); assertEquals("java.lang.String", ref.getCorrespondingDeclaration().getQualifiedName()); verify(typeSolver, stringDecl); }
@Override public boolean canBeAssignedTo(ResolvedReferenceTypeDeclaration other) { // TODO consider generic types if (this.getQualifiedName().equals(other.getQualifiedName())) { return true; } ResolvedClassDeclaration superclass = (ResolvedClassDeclaration) getSuperClass().getTypeDeclaration(); if (superclass != null) { // We want to avoid infinite recursion in case of Object having Object as ancestor if (Object.class.getCanonicalName().equals(superclass.getQualifiedName())) { return true; } if (superclass.canBeAssignedTo(other)) { return true; } } if (this.wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType type : wrappedNode.getImplementedTypes()) { ResolvedReferenceTypeDeclaration ancestor = (ResolvedReferenceTypeDeclaration) new SymbolSolver(typeSolver).solveType(type); if (ancestor.canBeAssignedTo(other)) { return true; } } } return false; }
ConstructorDeclaration constructorDeclaration = (ConstructorDeclaration)node; ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration)node.getParentNode().get(); ResolvedClassDeclaration resolvedClass = resolveDeclaration(classOrInterfaceDeclaration, ResolvedClassDeclaration.class).asClass(); ResolvedConstructorDeclaration resolved = resolvedClass.getConstructors().stream().filter(c -> ((JavaParserConstructorDeclaration)c).getWrappedNode() == constructorDeclaration).findFirst().get(); if (resultClass.isInstance(resolved)) { return resultClass.cast(resolved);
winningCandidate = other; } else { if (winningCandidate.declaringType().getQualifiedName() .equals(other.declaringType().getQualifiedName())) { possibleAmbiguity = true; } else {
@Override public String getName() { return classDeclaration.getName(); }
@Test public void testGetAllAncestorsOnRawType() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); ResolvedReferenceType rawArrayList = new ReferenceTypeImpl(arraylist, typeResolver); Map<String, ResolvedReferenceType> ancestors = new HashMap<>(); rawArrayList.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a)); assertEquals(9, ancestors.size()); ResolvedTypeVariable tv = new ResolvedTypeVariable(arraylist.getTypeParameters().get(0)); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(RandomAccess.class, typeResolver), typeResolver), ancestors.get("java.util.RandomAccess")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractCollection.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.AbstractCollection")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.List")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Cloneable.class, typeResolver), typeResolver), ancestors.get("java.lang.Cloneable")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.Collection")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractList.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.AbstractList")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.lang.Iterable")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Serializable.class, typeResolver), typeResolver), ancestors.get("java.io.Serializable")); }
@Test public void resolveReferenceUsingQualifiedName() throws ParseException { CompilationUnit cu = parseSample("Navigator2"); com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator"); MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType"); Parameter param = method.getParameters().get(0); ResolvedClassDeclaration compilationUnitDecl = createMock(ResolvedClassDeclaration.class); expect(compilationUnitDecl.getName()).andReturn("CompilationUnit"); expect(compilationUnitDecl.getQualifiedName()).andReturn("com.github.javaparser.ast.CompilationUnit"); TypeSolver typeSolver = createMock(TypeSolver.class); //expect(typeSolver.tryToSolveType("java.lang.com.github.javaparser.ast.CompilationUnit")).andReturn(SymbolReference.unsolved(ClassDeclaration.class)); expect(typeSolver.getRoot()).andReturn(typeSolver); expect(typeSolver.solveType("java.lang.Object")).andReturn(new ReflectionClassDeclaration(Object.class, typeSolver)); expect(typeSolver.tryToSolveType("com.github.javaparser.ast.CompilationUnit")).andReturn(SymbolReference.solved(compilationUnitDecl)); SymbolSolver symbolSolver = new SymbolSolver(typeSolver); replay(typeSolver, compilationUnitDecl); SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("com.github.javaparser.ast.CompilationUnit", param); assertEquals(true, ref.isSolved()); assertEquals("CompilationUnit", ref.getCorrespondingDeclaration().getName()); assertEquals("com.github.javaparser.ast.CompilationUnit", ref.getCorrespondingDeclaration().getQualifiedName()); verify(typeSolver, compilationUnitDecl); }
private void solveTypeDecl(ClassOrInterfaceDeclaration node) { ResolvedTypeDeclaration typeDeclaration = JavaParserFacade.get(typeSolver).getTypeDeclaration(node); if (typeDeclaration.isClass()) { out.println("\n[ Class " + typeDeclaration.getQualifiedName() + " ]"); for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllSuperClasses()) { out.println(" superclass: " + sc.getQualifiedName()); } for (ResolvedReferenceType sc : typeDeclaration.asClass().getAllInterfaces()) { out.println(" interface: " + sc.getQualifiedName()); } } }