@Nullable @Override protected Qualifier getScopeQualifier(@Nonnull ClassOrInterfaceType referencedType) { ClassOrInterfaceType scope = referencedType.getScope(); return scope == null ? null : new ClassOrInterfaceTypeQualifier(scope, this); }
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; }
@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 String name(ClassOrInterfaceType n) { StringBuilder sb = new StringBuilder(); while (n != null) { String name = n.getName(); if (sb.length() == 0) { sb.append(name); } else { if (Character.isLowerCase(name.charAt(0))) { sb.insert(0, name + "."); } else { sb.insert(0, name + "$"); } } n = n.getScope(); } return sb.toString(); }
private static boolean isSyntacticallyAPackageOrTypeName(Node name) { // A name is syntactically classified as a PackageOrTypeName in these contexts: // // 1. To the left of the "." in a qualified TypeName if (whenParentIs(ClassOrInterfaceType.class, name, (p, c) -> p.getScope().isPresent() && p.getScope().get() == c && (isSyntacticallyATypeName(p) || isSyntacticallyAPackageOrTypeName(p)))) { return true; } // 2. In a type-import-on-demand declaration (ยง7.5.2) if (whenParentIs(ImportDeclaration.class, name, (p, c) -> !p.isStatic() && p.isAsterisk() && p.getName() == name)) { return true; } return false; }
@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; }
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); if (!ref.isSolved()) { Optional<ClassOrInterfaceType> localScope = classOrInterfaceType.getScope(); if (localScope.isPresent()) { String localName = localScope.get().getName().getId() + "." + classOrInterfaceType.getName().getId(); ref = solveType(localName); } } 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 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); } }
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); } }
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); } }
@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; }