private static ClassOrInterfaceType classType(String className) { return new ClassOrInterfaceType(null, className); }
private static boolean isRefType(Type in, String className) { // Does not check type parameters if (in instanceof ClassOrInterfaceType) { return (className.equals(((ClassOrInterfaceType) in).getNameAsString())); } return false; }
private static void replaceParentClassesForAtomics(NodeList<ClassOrInterfaceType> types) { for (ClassOrInterfaceType parent : types) { if ("BaseLinkedQueue".equals(parent.getNameAsString())) { parent.setName("BaseLinkedAtomicQueue"); } else { // Padded super classes are to be renamed and thus so does the // class we must extend. parent.setName(translateQueueName(parent.getNameAsString())); } } }
private static ClassOrInterfaceType atomicRefArrayType(ArrayType in) { ClassOrInterfaceType out = new ClassOrInterfaceType(null, "AtomicReferenceArray"); out.setTypeArguments(in.getComponentType()); return out; }
@Nonnull @Override protected String getName(@Nonnull ClassOrInterfaceType referencedType) { return referencedType.getName(); }
protected boolean typeParameterWithSameNameIsDefined(@Nonnull ClassOrInterfaceType nestedClassOrInterface) { if (nestedClassOrInterface.getScope() != null) { return false; } for (Set<String> definedTypeNames : this.definedTypeParameters) { if (definedTypeNames.contains(nestedClassOrInterface.getName())) { return true; } } return false; }
private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { String className = classOrInterfaceType.getName().getId(); if (classOrInterfaceType.getScope().isPresent()) { // look for the qualified name (for example class of type Rectangle2D.Double) className = classOrInterfaceType.getScope().get().toString() + "." + className; } SymbolReference<ResolvedTypeDeclaration> ref = solveType(className, typeSolver); if (!ref.isSolved()) { Optional<ClassOrInterfaceType> localScope = classOrInterfaceType.getScope(); if (localScope.isPresent()) { String localName = localScope.get().getName().getId() + "." + classOrInterfaceType.getName().getId(); ref = solveType(localName, typeSolver); } } if (!ref.isSolved()) { throw new UnsolvedSymbolException(classOrInterfaceType.getName().getId()); } if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } List<ResolvedType> superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); } }
@Override public ClassOrInterfaceType doMerge(ClassOrInterfaceType first, ClassOrInterfaceType second) { ClassOrInterfaceType cift = new ClassOrInterfaceType(); cift.setName(first.getName()); cift.setScope(first.getScope()); cift.setTypeArgs(first.getTypeArgs()); cift.setAnnotations(mergeCollections(first.getAnnotations(), second.getAnnotations())); return cift; }
private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { SymbolReference<? extends ResolvedTypeDeclaration> ref = null; if (classOrInterfaceType.toString().indexOf('.') > -1) { ref = typeSolver.tryToSolveType(classOrInterfaceType.toString()); } if (ref == null || !ref.isSolved()) { ref = solveType(classOrInterfaceType.toString(), typeSolver); } if (!ref.isSolved()) { ref = solveType(classOrInterfaceType.getName().getId(), typeSolver); } if (!ref.isSolved()) { throw new UnsolvedSymbolException(classOrInterfaceType.getName().getId()); } if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } List<ResolvedType> superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); } }
@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; }
public boolean doIsEquals(ClassOrInterfaceType first, ClassOrInterfaceType second) { if(!StringUtils.equals(first.getName(),second.getName())) return false; List<Type> firstTypeArgs = first.getTypeArgs(); List<Type> secondTypeArgs = second.getTypeArgs(); if(isAllNotNull(first.getScope(),second.getScope())){ if(!isEquals(first.getScope(),second.getScope())) return false; }else if(!isAllNull(first.getScope(),second.getScope())){ return false;
private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { SymbolReference<? extends ResolvedTypeDeclaration> ref = null; String typeName = classOrInterfaceType.getName().getId(); if (classOrInterfaceType.getScope().isPresent()) { typeName = classOrInterfaceType.getScope().get().asString() + "." + typeName; } if (typeName.indexOf('.') > -1) { ref = typeSolver.tryToSolveType(typeName); } if (ref == null || !ref.isSolved()) { ref = solveType(typeName); } if (!ref.isSolved() && classOrInterfaceType.getScope().isPresent()) { ref = solveType(classOrInterfaceType.getName().getId()); } if (!ref.isSolved()) { throw new UnsolvedSymbolException(classOrInterfaceType.getName().getId()); } if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } List<ResolvedType> superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); } }
private boolean hasModule(List<Expression> moduleList, String packageName) { for (Expression moduleExpr : moduleList) { if (moduleExpr instanceof ObjectCreationExpr) { ObjectCreationExpr objectCreationExpr = (ObjectCreationExpr) moduleExpr; if (packageName.equals(objectCreationExpr.getType().toString())) { return true; } } } return false; }
@Nullable @Override protected Qualifier getScopeQualifier(@Nonnull ClassOrInterfaceType referencedType) { ClassOrInterfaceType scope = referencedType.getScope(); return scope == null ? null : new ClassOrInterfaceTypeQualifier(scope, this); }
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)); } } } }
if (classOrInterfaceType.getTypeArguments().isPresent()) { typeParameters = classOrInterfaceType.getTypeArguments().get().stream().map((pt) -> convertToUsage(pt, context)).collect(Collectors.toList());
@Override public Type visit(final ClassOrInterfaceType n, final Context ctx) { String name = name(n); Type type = ctx.resolveType(n, name) .orElseThrow(() -> new IllegalArgumentException("Type not found: " + name)); List<Type> args = n.getTypeArgs().stream() .map(it -> it.accept(new TypeCollector(), ctx)) .filter(it -> it != null) .collect(Collectors.toList()); if (args.size() > 0) { type = Types.newParameterizedType(type, args.toArray(new Type[args.size()])); } return type; }
/** * Check if the list of class or interface contains a class which name is given in the <code>simpleNames</code> set. * * @param klassList The list of class or interface * @param simpleNames a set of class simple name. * @return <code>true</code> if the list contains a class or interface which name is present in the * <code>simpleNames</code> set. */ private boolean containsClassName(List<ClassOrInterfaceType> klassList, Set<String> simpleNames) { for (ClassOrInterfaceType ctype : klassList) { if (simpleNames.contains(ctype.getName())) { return true; } } return false; } }
@Nonnull private static String getFullQualifier(@Nonnull ClassOrInterfaceType classOrInterfaceType) { StringBuilder buffy = new StringBuilder(classOrInterfaceType.getName()); while ((classOrInterfaceType = classOrInterfaceType.getScope()) != null) { buffy.insert(0, '.'); buffy.insert(0, classOrInterfaceType.getName()); } return buffy.toString(); }
private ResolvedReferenceType toReferenceType(ClassOrInterfaceType classOrInterfaceType) { String className = classOrInterfaceType.getName().getId(); if (classOrInterfaceType.getScope().isPresent()) { // look for the qualified name (for example class of type Rectangle2D.Double) className = classOrInterfaceType.getScope().get().toString() + "." + className; } SymbolReference<ResolvedTypeDeclaration> ref = solveType(className, typeSolver); if (!ref.isSolved()) { Optional<ClassOrInterfaceType> localScope = classOrInterfaceType.getScope(); if (localScope.isPresent()) { String localName = localScope.get().getName().getId() + "." + classOrInterfaceType.getName().getId(); ref = solveType(localName, typeSolver); } } if (!ref.isSolved()) { throw new UnsolvedSymbolException(classOrInterfaceType.getName().getId()); } if (!classOrInterfaceType.getTypeArguments().isPresent()) { return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), typeSolver); } List<ResolvedType> superClassTypeParameters = classOrInterfaceType.getTypeArguments().get() .stream().map(ta -> new LazyType(v -> JavaParserFacade.get(typeSolver).convert(ta, ta))) .collect(Collectors.toList()); return new ReferenceTypeImpl(ref.getCorrespondingDeclaration().asReferenceType(), superClassTypeParameters, typeSolver); } }