import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private List<DeclaredType> fillSubTypes(CompilationController cc, DeclaredType dType) {
    List<DeclaredType> subtypes = new ArrayList<>();
    //Set<? extends SearchScopeType> scope = Collections.singleton(new ClassSearchScopeType(prefix));
    Types types = cc.getTypes();
    if (prefix != null && prefix.length() > 2 && lastPrefixDot < 0) {
        //Trees trees = cc.getTrees();
        ClassIndex.NameKind kind = ClassIndex.NameKind.CASE_INSENSITIVE_PREFIX;
        for (ElementHandle<TypeElement> handle : cpi.getClassIndex().getDeclaredTypes(prefix, kind, EnumSet.allOf(ClassIndex.SearchScope.class))) {
            TypeElement te = handle.resolve(cc);
            if (te != null && /*trees.isAccessible(scope, te) &&*/ types.isSubtype(types.getDeclaredType(te), dType)) {
                subtypes.add(types.getDeclaredType(te));
            }
        }
    } else {
        HashSet<TypeElement> elems = new HashSet<>();
        LinkedList<DeclaredType> bases = new LinkedList<>();
        bases.add(dType);
        ClassIndex index = cpi.getClassIndex();
        while (!bases.isEmpty()) {
            DeclaredType head = bases.remove();
            TypeElement elem = (TypeElement) head.asElement();
            if (!elems.add(elem)) {
                continue;
            }
            if (accept(elem)) {
                subtypes.add(head);
            }
            //List<? extends TypeMirror> tas = head.getTypeArguments();
            //boolean isRaw = !tas.iterator().hasNext();
            for (ElementHandle<TypeElement> eh : index.getElements(ElementHandle.create(elem), EnumSet.of(ClassIndex.SearchKind.IMPLEMENTORS), EnumSet.allOf(ClassIndex.SearchScope.class))) {
                TypeElement e = eh.resolve(cc);
                if (e != null) {
                    DeclaredType dt = types.getDeclaredType(e);
                    bases.add(dt);
                }
            }
        }
    }
    return subtypes;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
@NonNull
private static Convertor<String,String> createNameFactory(@NonNull final ClassIndex.ResourceType type) {
    switch (type) {
        case SOURCE:
            return new Convertor<String,String>() {
                @Override
                public String convert(String p) {
                    final int index = p.indexOf('$');                              //NOI18N
                    if (index > 0) {
                        p = p.substring(0, index);
                    }
                    return p;
                }
            };
        case BINARY:
            return Convertors.<String>identity();
        default:
            throw new IllegalArgumentException(String.valueOf(type));
    }
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private void doPackageCompletion(JavaSource js, final String typedPrefix, final int substitutionOffset) throws IOException {
    js.runUserActionTask(new Task<CompilationController>() {

        @Override
        public void run(CompilationController cc) throws Exception {
            if (isCancelled()) {
                return;
            }

            cc.toPhase(Phase.ELEMENTS_RESOLVED);
            ClassIndex ci = cc.getClasspathInfo().getClassIndex();
            int index = substitutionOffset;
            int dotIndex = typedPrefix.lastIndexOf('.'); // NOI18N
            if (dotIndex != -1) {
                index += (dotIndex + 1);  // NOI18N
            }

            addPackages(ci,  typedPrefix, index, CompletionProvider.COMPLETION_ALL_QUERY_TYPE);
        }
    }, true);
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private Set<ClassIndex.SearchScope> toSearchScope(Set<Scope> scope) {
    Set<ClassIndex.SearchScope> sScope = EnumSet.noneOf(ClassIndex.SearchScope.class);
    for(Scope s : scope) {
        switch (s) {
            case DEPENDENCIES: {
                sScope.add(ClassIndex.SearchScope.DEPENDENCIES);
                break;
            }
            case SOURCE: {
                sScope.add(ClassIndex.SearchScope.SOURCE);
                break;
            }
        }
    }
    return sScope;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public static Set<ElementHandle<TypeElement>> findImplementors(final ClasspathInfo cpInfo, final ElementHandle<TypeElement> baseType) {
    final Set<ClassIndex.SearchKind> kind = EnumSet.of(ClassIndex.SearchKind.IMPLEMENTORS);
    final Set<ClassIndex.SearchScope> scope = EnumSet.allOf(ClassIndex.SearchScope.class);
    
    final Set<ElementHandle<TypeElement>> allImplementors = new HashSet<ElementHandle<TypeElement>>();

    ParsingUtils.invokeScanSensitiveTask(cpInfo, new ScanSensitiveTask<CompilationController>(true) {
        @Override
        public void run(CompilationController cc) {
            Set<ElementHandle<TypeElement>> implementors = cpInfo.getClassIndex().getElements(baseType, kind, scope);
            do {
                Set<ElementHandle<TypeElement>> tmpImplementors = new HashSet<ElementHandle<TypeElement>>();
                allImplementors.addAll(implementors);

                for (ElementHandle<TypeElement> element : implementors) {
                    tmpImplementors.addAll(cpInfo.getClassIndex().getElements(element, kind, scope));
                }

                implementors = tmpImplementors;
            } while (!implementors.isEmpty());
        }
    });
    
    return allImplementors;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public JavacPackageInfo(ClasspathInfo cpInfo, ClasspathInfo indexInfo, String simpleName, String fqn, Scope scope) {
    super(simpleName, fqn, scope);
    this.cpInfo = cpInfo;
    this.indexInfo = indexInfo;
    
    switch (scope) {
        case SOURCE: {
            sScope= EnumSet.of(ClassIndex.SearchScope.SOURCE);
            break;
        }
        case DEPENDENCIES: {
            sScope = EnumSet.of(ClassIndex.SearchScope.DEPENDENCIES);
            break;
        }
        default: {
            sScope = Collections.EMPTY_SET;
        }
    }
    
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
@Override
public Collection<SourcePackageInfo> getSubpackages() {
    final ClassIndex index = cpInfo.getClassIndex();
    final List<SourcePackageInfo> pkgs = new ArrayList<SourcePackageInfo>();

    ParsingUtils.invokeScanSensitiveTask(cpInfo, new ScanSensitiveTask<CompilationController>(true) {
        @Override
        public void run(CompilationController cc) {
            for (String pkgName : index.getPackageNames(getBinaryName() + ".", true, sScope)) { // NOI18N
                pkgs.add(new JavacPackageInfo(cpInfo, indexInfo, pkgName, pkgName, getScope()));
            }
        }
    });

    return pkgs;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private Set<ElementHandle<TypeElement>> getImplementorsAsHandles(ClassIndex idx, TypeElement el) {
    LinkedList<ElementHandle<TypeElement>> elements = new LinkedList<ElementHandle<TypeElement>>(
            implementorsQuery(idx, ElementHandle.create(el)));
    Set<ElementHandle<TypeElement>> result = new HashSet<ElementHandle<TypeElement>>();
    while (!elements.isEmpty()) {
        if (canceled) {
            return Collections.emptySet();
        }
        ElementHandle<TypeElement> next = elements.removeFirst();
        if (!result.add(next)) {
            // it is a duplicate; do not query again
            continue;
        }
        Set<ElementHandle<TypeElement>> foundElements = implementorsQuery(idx, next);
        elements.addAll(foundElements);
    }
    return result;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private void btnBrowseClassActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnBrowseClassActionPerformed
    final ClasspathInfo cpi = getClasspathInfo();
    String current = this.source.getText();
    ElementHandle<TypeElement> handle = TypeElementFinder.find(cpi, current, new TypeElementFinder.Customizer() {

        @Override
        public Set<ElementHandle<TypeElement>> query(ClasspathInfo classpathInfo, String textForQuery, ClassIndex.NameKind nameKind, Set<ClassIndex.SearchScope> searchScopes) {
            searchScopes.retainAll(Arrays.asList(ClassIndex.SearchScope.SOURCE));
            return cpi.getClassIndex().getDeclaredTypes(textForQuery, nameKind, searchScopes);
        }

        @Override
        public boolean accept(ElementHandle<TypeElement> typeHandle) {
            return true;
        }
    });
    if (handle == null) {
        return;
    }
    targetClass = handle;
    source.setText(handle.getQualifiedName());
    classNameChanged(null);
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private void addAllTypes(JavadocContext env, EnumSet<ElementKind> kinds, Set<? extends Element> toExclude, String prefix, int substitutionOffset) {
//        String prefix = env.getPrefix();
        CompilationInfo controller = env.javac;
        boolean isCaseSensitive = false;
        ClassIndex.NameKind kind = 
            isCaseSensitive? ClassIndex.NameKind.PREFIX : ClassIndex.NameKind.CASE_INSENSITIVE_PREFIX;
//        ClassIndex.NameKind kind = env.isCamelCasePrefix() ?
//            Utilities.isCaseSensitive() ? ClassIndex.NameKind.CAMEL_CASE : ClassIndex.NameKind.CAMEL_CASE_INSENSITIVE :
//            Utilities.isCaseSensitive() ? ClassIndex.NameKind.PREFIX : ClassIndex.NameKind.CASE_INSENSITIVE_PREFIX;
        Set<ElementHandle<Element>> excludeHandles = null;
        if (toExclude != null) {
            excludeHandles = new HashSet<ElementHandle<Element>>(toExclude.size());
            for (Element el : toExclude) {
                excludeHandles.add(ElementHandle.create(el));
            }
        }
        for(ElementHandle<TypeElement> name : controller.getClasspathInfo().getClassIndex().getDeclaredTypes(prefix, kind, EnumSet.allOf(ClassIndex.SearchScope.class))) {
            if ((excludeHandles == null || !excludeHandles.contains(name)) && !isAnnonInner(name)) {
                items.add(LazyJavaCompletionItem.createTypeItem(name, kinds, substitutionOffset, env.getReferencesCount(), controller.getSnapshot().getSource(), false, false, false, null));
            }
        }
    }
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public static FileObject getFileObjectFromClassName(String qualifiedClassName, Project project) throws IOException {
    FileObject root = findSourceRoot(project);
    ClasspathInfo cpInfo = ClasspathInfo.create(root);
    ClassIndex ci = cpInfo.getClassIndex();
    int beginIndex = qualifiedClassName.lastIndexOf('.')+1;
    String simple = qualifiedClassName.substring(beginIndex);
    Set<ElementHandle<TypeElement>> handles = ci.getDeclaredTypes(
            simple, ClassIndex.NameKind.SIMPLE_NAME, 
            Collections.singleton(ClassIndex.SearchScope.SOURCE));
    for (ElementHandle<TypeElement> handle : handles) {
        if (qualifiedClassName.equals(handle.getQualifiedName())) {
            return SourceUtils.getFile(handle, cpInfo);
        }
    }
    return null;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
/**
 * Find the ElementHandle of TypeElement of clazz in the passed ClassIndex.
 * Look in boot, compile and sources.
 * @param ci ClassIndex in which we are looking.
 * @param clazz class for which TypeElement we are looking
 * @return null if no such EH found in ci otherwise first found class with same fqn.
 */
protected final ElementHandle<TypeElement> getTypeOfClass(ClassIndex ci, String classfqn) {
    String searchedString = getSimpleNameFromFQN(classfqn);
    NameKind kind = NameKind.SIMPLE_NAME;
    Set<SearchScope> searchScope = EnumSet.of(SearchScope.DEPENDENCIES, SearchScope.SOURCE);
    Set<ElementHandle<TypeElement>> res = ci.getDeclaredTypes(searchedString, kind, searchScope);

    // Find if there is a ElementHandle<TypeElement> with same FQN as the ancestor.
    for (ElementHandle<TypeElement> eh : res) {
        String qn = eh.getQualifiedName();
        if (classfqn.equals(qn)) {
            return eh;
        }
    }
    return null;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
/**
 * Get all subtypes (either implemetors or subtypes) of certain TypeElement in the ClassIndex.
 * I.e. find all {@link TypeElement types} that either (transitively) extend or implement the ancestor.
 * @param ci ClassIndex in which we are loooking
 * @param ancestorTE type element that is the ancestor. 
 * @return set of all types that extend / implement ancestor
 */
protected final Set<ElementHandle<TypeElement>> getAllSubtypes(ClassIndex ci, ElementHandle<TypeElement> ancestorTE) {
    Set<ElementHandle<TypeElement>> result = new HashSet<ElementHandle<TypeElement>>();
    LinkedList<ElementHandle<TypeElement>> todo = new LinkedList<ElementHandle<TypeElement>>();
    todo.add(ancestorTE);

    while (!todo.isEmpty()) {
        // the element we will process in this loop
        ElementHandle<TypeElement> curr = todo.removeFirst();
        // All extending of the curr
        Set<ElementHandle<TypeElement>> subtypesOfCurr = getDirectSubtypes(ci, curr);

        if (subtypesOfCurr != null) {// can be null for ancellable tasks
            result.addAll(subtypesOfCurr);
            todo.addAll(subtypesOfCurr);
        }
    }
    return result;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public static ElementHandle<TypeElement> getHandleClassName(String qualifiedClassName,
        Project project) throws IOException {
    FileObject root = MiscUtilities.findSourceRoot(project);
    ClassPathProvider provider = project.getLookup().lookup(
            ClassPathProvider.class);
    ClassPath sourceCp = provider.findClassPath(root, ClassPath.SOURCE);
    ClassPath compileCp = provider.findClassPath(root, ClassPath.COMPILE);
    ClassPath bootCp = provider.findClassPath(root, ClassPath.BOOT);
    ClasspathInfo cpInfo = ClasspathInfo.create(bootCp, compileCp, sourceCp);
    ClassIndex ci = cpInfo.getClassIndex();
    int beginIndex = qualifiedClassName.lastIndexOf('.') + 1;
    String simple = qualifiedClassName.substring(beginIndex);
    Set<ElementHandle<TypeElement>> handles = ci.getDeclaredTypes(
            simple, ClassIndex.NameKind.SIMPLE_NAME,
            EnumSet.of(ClassIndex.SearchScope.SOURCE,
                    ClassIndex.SearchScope.DEPENDENCIES));
    for (final ElementHandle<TypeElement> handle : handles) {
        if (qualifiedClassName.equals(handle.getQualifiedName())) {
            return handle;
        }
    }
    return null;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public  boolean collectDeclaredTypes(
    @NullAllowed final Pattern packageName,
    @NonNull final String typeName,
    @NonNull NameKind kind,
    @NonNull Collection<? super JavaTypeDescription> collector) throws IOException, InterruptedException {
    if (!initIndex()) {
        return false;
    }
    final SearchScope baseSearchScope = isBinary ? ClassIndex.SearchScope.DEPENDENCIES : ClassIndex.SearchScope.SOURCE;
    SearchScopeType searchScope;
    if (packageName != null) {
        //FQN
        final Set<String> allPackages = new HashSet<>();
        index.getPackageNames("", false, allPackages);  //NOI18N
        final Set<? extends String> packages = filterPackages(packageName, allPackages);
        searchScope = ClassIndex.createPackageSearchScope(baseSearchScope, packages.toArray(new String[packages.size()]));
        kind = translateSearchType(typeName, kind);
    } else {
        //simple name
        searchScope = baseSearchScope;
    }
    try {
        index.getDeclaredElements(
            typeName,
            kind,
            Collections.unmodifiableSet(Collections.<SearchScopeType>singleton(searchScope)),
            DocumentUtil.declaredTypesFieldSelector(true, true),
            new JavaTypeDescriptionConvertor(this),
            collector);
    } catch (Index.IndexClosedException ice) {
        //Closed after put into rootCache, ignore
    }
    return true;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
@NonNull
public static Convertor<Document,FileObject> fileObjectConvertor (
        @NonNull final ClassIndex.ResourceType resourceType,
        @NonNull final FileObject... roots) {
    assert resourceType != null;
    assert roots != null;
    return new FileObjectConvertor (resourceType, roots);
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
static Queries.QueryKind translateQueryKind(final ClassIndex.NameKind kind) {
    switch (kind) {
        case SIMPLE_NAME: return Queries.QueryKind.EXACT;
        case PREFIX: return Queries.QueryKind.PREFIX;
        case CASE_INSENSITIVE_PREFIX: return Queries.QueryKind.CASE_INSENSITIVE_PREFIX;
        case CAMEL_CASE: return Queries.QueryKind.CAMEL_CASE;
        case CAMEL_CASE_INSENSITIVE: return Queries.QueryKind.CASE_INSENSITIVE_CAMEL_CASE;
        case REGEXP: return Queries.QueryKind.REGEXP;
        case CASE_INSENSITIVE_REGEXP: return Queries.QueryKind.CASE_INSENSITIVE_REGEXP;
        default: throw new IllegalArgumentException();
    }
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
private FileObjectConvertor (
        @NonNull final ClassIndex.ResourceType type,
        @NonNull final FileObject... roots) {
    this.nameFactory = createNameFactory(type);
    this.filter = createFilter(type);
    this.roots = roots;
}
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public abstract <T> void getDeclaredElements (
@NonNull String name,
@NonNull ClassIndex.NameKind kind,
@NonNull Set<? extends ClassIndex.SearchScopeType> scope,
@NonNull FieldSelector selector,
@NonNull Convertor<? super Document, T> convertor,
@NonNull Collection<? super T> result) throws IOException, InterruptedException;
 

import org.netbeans.api.java.source.ClassIndex; //导入依赖的package包/类
public void testOverruningClassIndexScopes() throws IOException, InterruptedException {
    final ClassIndexImpl index = ClassIndexManager.getDefault().getUsagesQuery(src.toURL(), true);
    assertNotNull(index);
    final List<Document> res = new ArrayList<>(PKG_COUNT*CLZ_IN_PKG_COUNT);
    Set<ClassIndex.SearchScopeType> scopes = new HashSet<>();
    scopes.add(ClassIndex.SearchScope.SOURCE);
    index.getDeclaredElements(
            "", //NOI18N
            ClassIndex.NameKind.PREFIX,
            scopes,
            null,
            Identity.<Document>getInstance(),
            res);
    assertEquals(PKG_COUNT*CLZ_IN_PKG_COUNT, res.size());
    res.clear();
    scopes.clear();
    final Set<String> pkgs = new HashSet<>();
    index.getPackageNames("", true, pkgs);
    assertEquals(PKG_COUNT, pkgs.size());
    scopes.add(ClassIndex.createPackageSearchScope(
        ClassIndex.SearchScope.SOURCE,
        pkgs.toArray(new String[pkgs.size()])));
    index.getDeclaredElements(
            "", //NOI18N
            ClassIndex.NameKind.PREFIX,
            scopes,
            null,
            Identity.<Document>getInstance(),
            res);
    assertEquals(PKG_COUNT*CLZ_IN_PKG_COUNT, res.size());
}