/** * Searches all extended or implemented super classes or interfaces for * special classes that differ with the atomics version and replaces them * with the appropriate class. * * @param n */ private static void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) { replaceParentClassesForAtomics(n.getExtendedTypes()); replaceParentClassesForAtomics(n.getImplementedTypes()); }
/** * Searches all extended or implemented super classes or interfaces for * special classes that differ with the atomics version and replaces them * with the appropriate class. * * @param n */ private static void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) { for (ClassOrInterfaceType parent : n.getExtendedTypes()) { if ("ConcurrentCircularArrayQueue".equals(parent.getNameAsString())) { parent.setName("AtomicReferenceArrayQueue"); } else if ("ConcurrentSequencedCircularArrayQueue".equals(parent.getNameAsString())) { parent.setName("SequencedAtomicReferenceArrayQueue"); } else { // Padded super classes are to be renamed and thus so does the // class we must extend. parent.setName(translateQueueName(parent.getNameAsString())); } } }
@Override public List<ResolvedReferenceType> getAncestors() { List<ResolvedReferenceType> ancestors = new ArrayList<>(); if (wrappedNode.getExtendedTypes() != null) { for (ClassOrInterfaceType extended : wrappedNode.getExtendedTypes()) { ancestors.add(toReferenceType(extended)); } } if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implemented : wrappedNode.getImplementedTypes()) { ancestors.add(toReferenceType(implemented)); } } return ancestors; }
@Override public List<ResolvedReferenceType> getAncestors() { List<ResolvedReferenceType> ancestors = new ArrayList<>(); if (wrappedNode.getExtendedTypes() != null) { for (ClassOrInterfaceType extended : wrappedNode.getExtendedTypes()) { ancestors.add(toReferenceType(extended)); } } if (wrappedNode.getImplementedTypes() != null) { for (ClassOrInterfaceType implemented : wrappedNode.getImplementedTypes()) { ancestors.add(toReferenceType(implemented)); } } return ancestors; }
@Override public ResolvedReferenceType getSuperClass() { if (wrappedNode.getExtendedTypes().isEmpty()) { return object(); } else { return toReferenceType(wrappedNode.getExtendedTypes().get(0)); } }
@Override public ResolvedReferenceType getSuperClass() { if (wrappedNode.getExtendedTypes().isEmpty()) { return object(); } else { return toReferenceType(wrappedNode.getExtendedTypes().get(0)); } }
@Override public ResolvedReferenceType getSuperClass() { if (wrappedNode.getExtendedTypes().isEmpty()) { return object(); } else { return toReferenceType(wrappedNode.getExtendedTypes().get(0)); } }
@Override public void visit(ClassOrInterfaceDeclaration n, Void arg) { if (!n.getExtendedTypes().isEmpty() && "SeleniumTestPlan".equals(n.getExtendedTypes().get(0).getName().toString())) { throw new DoNotVisitException("do not analyse SeleniumTestPlan sub classes"); } } }
@Override protected int getNumberOfTypes(CompilationUnit compilationUnit) { TypeDeclaration<?> typeDeclaration = compilationUnit.getType(0); if (typeDeclaration instanceof ClassOrInterfaceDeclaration) { ClassOrInterfaceDeclaration type = (ClassOrInterfaceDeclaration) compilationUnit.getType(0); NodeList<ClassOrInterfaceType> extendedTypes = type.getExtendedTypes(); return extendedTypes.size(); } // If typeDeclaration is not ClassOrInterfaceDeclaration, then it is // EnumDeclaration or AnnotationDeclaration, and none of them have // a getExtendedTypes operation return 0; }
private static void writeClassDeclaration(PrintStream s, ClassOrInterfaceDeclaration c) { s.format("\npublic%s class %s", c.isFinal() ? " final" : "", c.getName()); if (c.getImplementedTypes() != null && !c.getImplementedTypes().isEmpty()) { s.format(" implements"); for (ClassOrInterfaceType iface : c.getImplementedTypes()) { s.append(" " + iface); } } s.append(" {\n"); Preconditions.checkArgument(c.getExtendedTypes().size() == 0); }
private static void writeClassDeclaration(PrintStream s, ClassOrInterfaceDeclaration c) { s.format("\npublic%s class %s", c.isFinal() ? " final" : "", c.getName()); if (c.getImplementedTypes() != null && !c.getImplementedTypes().isEmpty()) { s.format(" implements"); for (ClassOrInterfaceType iface : c.getImplementedTypes()) { s.append(" " + iface); } } s.append(" {\n"); Preconditions.checkArgument(c.getExtendedTypes().size() == 0); }
@Override public List<ResolvedReferenceType> getInterfacesExtended() { List<ResolvedReferenceType> interfaces = new ArrayList<>(); for (ClassOrInterfaceType t : wrappedNode.getExtendedTypes()) { interfaces.add(new ReferenceTypeImpl( solveType(t.getName().getId()).getCorrespondingDeclaration().asInterface(), typeSolver)); } return interfaces; }
@Override protected String getTypeName(CompilationUnit compilationUnit, int index) { ClassOrInterfaceDeclaration type = (ClassOrInterfaceDeclaration) compilationUnit.getType(0); NodeList<ClassOrInterfaceType> extendedTypes = type.getExtendedTypes(); ClassOrInterfaceType extendedType = extendedTypes.get(index); String typeSimpleName = extendedType.getName().getIdentifier(); Optional<ClassOrInterfaceType> scope = extendedType.getScope(); String typeName; if (scope.isPresent()) { String typePackageName = scope.get().toString(); typeName = String.format("%s.%s", typePackageName, typeSimpleName); } else { typeName = typeSimpleName; } return typeName; }
@Override public List<ResolvedFieldDeclaration> fieldsExposedToChild(Node child) { List<ResolvedFieldDeclaration> fields = new LinkedList<>(); fields.addAll(this.wrappedNode.resolve().getDeclaredFields()); this.wrappedNode.getExtendedTypes().forEach(i -> fields.addAll(i.resolve().getAllFieldsVisibleToInheritors())); this.wrappedNode.getImplementedTypes().forEach(i -> fields.addAll(i.resolve().getAllFieldsVisibleToInheritors())); return fields; }
public void calculate(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, CompilationUnit compilationUnit) { List<ClassOrInterfaceType> extendedTypes = classOrInterfaceDeclaration.getExtendedTypes(); for (ClassOrInterfaceType extendedType : extendedTypes) { String extendedTypeName = extendedType.getNameAsString(); String extendedTypePackageName = extendedType .findCompilationUnit() .flatMap(CompilationUnit::getPackageDeclaration) .flatMap(pkg -> Optional.of(pkg.getNameAsString())).orElse("???"); if (typeDao.exist(extendedTypeName, extendedTypePackageName)) { // JDK interfaces are not indexed int extendedInterfaceId = typeDao.getId(extendedTypeName, extendedTypePackageName); int interfaceId = typeDao.getId(classOrInterfaceDeclaration.getNameAsString(), compilationUnit.getPackageDeclaration().get().getNameAsString()); extendsDao.save(new Extends(interfaceId, extendedInterfaceId)); } } } }
private void setAttributes(ClassBuilder builder, ClassOrInterfaceDeclaration n) { builder.withName(n.getNameAsString()); if (isClass(n)) { CanonicalNameFactory factory = new CanonicalNameFactory(packageName, imports); n.getExtendedTypes().stream().findFirst() .ifPresent(parent -> builder.withParent(new Parent(factory.build(parent.getNameAsString())))); } }
@Override public boolean canBeAssignedTo(ResolvedReferenceTypeDeclaration other) { // TODO consider generic types if (this.getQualifiedName().equals(other.getQualifiedName())) { return true; } if (this.wrappedNode.getExtendedTypes() != null) { for (ClassOrInterfaceType type : wrappedNode.getExtendedTypes()) { ResolvedReferenceTypeDeclaration ancestor = (ResolvedReferenceTypeDeclaration) new SymbolSolver(typeSolver).solveType(type); if (ancestor.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; }
@Test(expected = UnsolvedSymbolException.class) public void aClassInDefaultPackageCanBeAccessedFromOutsideTheDefaultPackageImportingIt() { String code = "package myPackage; import B; class A extends B {}"; MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver(); memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B")); ClassOrInterfaceType jpType = JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0); ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(jpType); assertEquals("B", resolvedType.asReferenceType().getQualifiedName()); }
@Test public void aClassInDefaultPackageCanBeAccessedFromTheDefaultPackage() { String code = "class A extends B {}"; MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver(); memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B")); ClassOrInterfaceType jpType = JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0); ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(jpType); assertEquals("B", resolvedType.asReferenceType().getQualifiedName()); }
@Test(expected = UnsolvedSymbolException.class) public void aClassInDefaultPackageCanBeAccessedFromOutsideTheDefaultPackageWithoutImportingIt() { String code = "package myPackage; class A extends B {}"; MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver(); memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B")); ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0)); assertEquals("B", resolvedType.asReferenceType().getQualifiedName()); } }