diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchyInfoImpl.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchyInfoImpl.java index c6ab4d331181..3f94f8d2a66f 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchyInfoImpl.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchyInfoImpl.java @@ -16,38 +16,75 @@ package com.intellij.compiler.backwardRefs; import com.intellij.compiler.CompilerDirectHierarchyInfo; -import com.intellij.openapi.util.Couple; +import com.intellij.openapi.application.ReadAction; +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.fileTypes.FileType; +import com.intellij.openapi.project.Project; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiManager; +import com.intellij.psi.PsiNamedElement; +import com.intellij.psi.impl.source.PsiFileWithStubSupport; import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.util.ObjectUtils; import org.jetbrains.annotations.NotNull; import java.util.Map; import java.util.stream.Stream; class CompilerHierarchyInfoImpl implements CompilerDirectHierarchyInfo { + private final static Logger LOG = Logger.getInstance(CompilerHierarchyInfoImpl.class); + + private final PsiNamedElement myBaseClass; private final GlobalSearchScope myDirtyScope; private final GlobalSearchScope mySearchScope; - private final Couple> myCandidatePerFile; + private final Project myProject; + private final FileType mySearchFileType; + private final CompilerHierarchySearchType mySearchType; + private final Map myCandidatePerFile; - CompilerHierarchyInfoImpl(Couple> candidatePerFile, + CompilerHierarchyInfoImpl(Map candidatesPerFile, + PsiNamedElement baseClass, GlobalSearchScope dirtyScope, - GlobalSearchScope searchScope) { - myCandidatePerFile = candidatePerFile; + GlobalSearchScope searchScope, + Project project, + FileType searchFileType, + CompilerHierarchySearchType searchType) { + myCandidatePerFile = candidatesPerFile; + myBaseClass = baseClass; myDirtyScope = dirtyScope; mySearchScope = searchScope; + myProject = project; + mySearchFileType = searchFileType; + mySearchType = searchType; } @Override @NotNull public Stream getHierarchyChildren() { - return selectClassesInScope(myCandidatePerFile.getFirst(), mySearchScope); - } + PsiManager psiManager = PsiManager.getInstance(myProject); + final LanguageLightRefAdapter adapter = ObjectUtils.notNull(CompilerReferenceServiceImpl.findAdapterForFileType(mySearchFileType)); + return myCandidatePerFile + .entrySet() + .stream() + .filter(e -> mySearchScope.contains(e.getKey())) + .flatMap(e -> { + final VirtualFile file = e.getKey(); + final Object[] definitions = e.getValue(); - @Override - @NotNull - public Stream getHierarchyChildCandidates() { - return selectClassesInScope(myCandidatePerFile.getSecond(), mySearchScope); + final PsiElement[] hierarchyChildren = ReadAction.compute(() -> { + final PsiFileWithStubSupport psiFile = (PsiFileWithStubSupport)psiManager.findFile(file); + return mySearchType.performSearchInFile(definitions, myBaseClass, psiFile, adapter); + }); + + if (hierarchyChildren.length == definitions.length) { + return Stream.of(hierarchyChildren); + } + else { + LOG.assertTrue(mySearchType == CompilerHierarchySearchType.DIRECT_INHERITOR, "Should not happens for functional expression search"); + return Stream.of(hierarchyChildren).filter(c -> ReadAction.compute(() -> adapter.isDirectInheritor(c, myBaseClass))); + } + }); } @Override @@ -55,8 +92,4 @@ class CompilerHierarchyInfoImpl implements CompilerDirectHierarchyInfo { public GlobalSearchScope getDirtyScope() { return myDirtyScope; } - - private static Stream selectClassesInScope(Map classesPerFile, GlobalSearchScope searchScope) { - return classesPerFile.entrySet().stream().filter(e -> searchScope.contains(e.getKey())).flatMap(e -> Stream.of(e.getValue())); - } } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java index 9c9eebcfa714..eec3b5c94f22 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerHierarchySearchType.java @@ -26,40 +26,49 @@ import java.util.Collection; enum CompilerHierarchySearchType { DIRECT_INHERITOR { @Override - PsiElement[] performSearchInFile(Collection definitions, + PsiElement[] performSearchInFile(Object[] definitions, PsiNamedElement baseElement, - ByteArrayEnumerator nameEnumerator, PsiFileWithStubSupport file, LanguageLightRefAdapter adapter) { - return adapter.findDirectInheritorCandidatesInFile((Collection)definitions, nameEnumerator, file, baseElement); + return adapter.findDirectInheritorCandidatesInFile((String[])definitions, file, baseElement); } @Override Class getRequiredClass(LanguageLightRefAdapter adapter) { return adapter.getHierarchyObjectClass(); } + + @Override + Object[] convertIdToSearchableArray(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator) { + return lightRef.stream().map(r -> byteArrayEnumerator.getName(((LightRef.LightClassHierarchyElementDef)r).getName())).toArray(String[]::new); + } }, FUNCTIONAL_EXPRESSION { @Override - PsiElement[] performSearchInFile(Collection definitions, + PsiElement[] performSearchInFile(Object[] definitions, PsiNamedElement baseElement, - ByteArrayEnumerator nameEnumerator, PsiFileWithStubSupport file, LanguageLightRefAdapter adapter) { - return adapter.findFunExpressionsInFile((Collection)definitions, file); + return adapter.findFunExpressionsInFile((Integer[])definitions, file); } @Override Class getRequiredClass(LanguageLightRefAdapter adapter) { return adapter.getFunExprClass(); } + + @Override + Object[] convertIdToSearchableArray(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator) { + return lightRef.stream().map(r -> ((LightRef.LightFunExprDef) r).getId()).toArray(Integer[]::new); + } }; - abstract PsiElement[] performSearchInFile(Collection definitions, + abstract PsiElement[] performSearchInFile(Object[] definitions, PsiNamedElement baseElement, - ByteArrayEnumerator nameEnumerator, PsiFileWithStubSupport file, LanguageLightRefAdapter adapter); abstract Class getRequiredClass(LanguageLightRefAdapter adapter); + + abstract Object[] convertIdToSearchableArray(Collection lightRef, ByteArrayEnumerator byteArrayEnumerator); } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java index 0b90cd79dde1..f61d16e43872 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceReader.java @@ -16,21 +16,14 @@ package com.intellij.compiler.backwardRefs; import com.intellij.compiler.server.BuildManager; -import com.intellij.openapi.application.ReadAction; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.fileTypes.FileType; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Couple; import com.intellij.openapi.vfs.VfsUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileWithId; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiManager; -import com.intellij.psi.PsiNamedElement; -import com.intellij.psi.impl.source.PsiFileWithStubSupport; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.util.containers.Queue; -import gnu.trove.THashMap; import gnu.trove.THashSet; import gnu.trove.TIntHashSet; import org.jetbrains.annotations.NotNull; @@ -78,25 +71,23 @@ class CompilerReferenceReader { * 1st map: inheritors. Can be used without explicit inheritance verification * 2nd map: candidates. One need to check that these classes are really direct inheritors */ - @Nullable - Couple> getDirectInheritors(@NotNull PsiNamedElement baseClass, - @NotNull LightRef searchElement, - @NotNull GlobalSearchScope searchScope, - @NotNull GlobalSearchScope dirtyScope, - @NotNull Project project, - @NotNull FileType fileType, - @NotNull CompilerHierarchySearchType searchType) { + @NotNull + Map getDirectInheritors(@NotNull LightRef searchElement, + @NotNull GlobalSearchScope searchScope, + @NotNull GlobalSearchScope dirtyScope, + @NotNull FileType fileType, + @NotNull CompilerHierarchySearchType searchType) { Collection candidates; synchronized (myHierarchyLock) { candidates = myIndex.getBackwardHierarchyMap().get(searchElement); } - if (candidates == null) return Couple.of(Collections.emptyMap(), Collections.emptyMap()); + if (candidates == null) return Collections.emptyMap(); GlobalSearchScope effectiveSearchScope = GlobalSearchScope.notScope(dirtyScope).intersectWith(searchScope); LanguageLightRefAdapter adapter = CompilerReferenceServiceImpl.findAdapterForFileType(fileType); LOG.assertTrue(adapter != null, "adapter is null for file type: " + fileType); Class requiredLightRefClass = searchType.getRequiredClass(adapter); - Map> candidatesPerFile; + Map candidatesPerFile; synchronized (myReferenceLock) { candidatesPerFile = candidates .stream() @@ -114,28 +105,10 @@ class CompilerReferenceReader { } }) .filter(Objects::nonNull) - .collect(groupingBy(x -> x.containingFile, mapping(x -> x.def, toList()))); + .collect(groupingBy(x -> x.containingFile, mapping(x -> x.def, collectingAndThen(toList(), l -> searchType.convertIdToSearchableArray(l, myIndex.getByteSeqEum()))))); } - if (candidatesPerFile.isEmpty()) return Couple.of(Collections.emptyMap(), Collections.emptyMap()); - - Map inheritors = new THashMap<>(candidatesPerFile.size()); - Map inheritorCandidates = new THashMap<>(); - - final PsiManager psiManager = ReadAction.compute(() -> PsiManager.getInstance(project)); - - candidatesPerFile.forEach((file, directInheritors) -> ReadAction.run(() -> { - final PsiFileWithStubSupport psiFile = (PsiFileWithStubSupport) psiManager.findFile(file); - final PsiElement[] currInheritors = searchType.performSearchInFile(directInheritors, baseClass, myIndex.getByteSeqEum(), psiFile, adapter); - if (currInheritors.length == directInheritors.size()) { - inheritors.put(file, currInheritors); - } - else { - inheritorCandidates.put(file, currInheritors); - } - })); - - return Couple.of(inheritors, inheritorCandidates); + return candidatesPerFile.isEmpty() ? Collections.emptyMap() : candidatesPerFile; } @NotNull diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceServiceImpl.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceServiceImpl.java index d4685e646ca6..cb7b09226521 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceServiceImpl.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/CompilerReferenceServiceImpl.java @@ -30,7 +30,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.ProjectFileIndex; import com.intellij.openapi.roots.ProjectRootManager; import com.intellij.openapi.roots.impl.LibraryScopeCache; -import com.intellij.openapi.util.Couple; import com.intellij.openapi.util.ModificationTracker; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileWithId; @@ -185,32 +184,31 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple } @Nullable - private CompilerDirectHierarchyInfo getHierarchyInfo(@NotNull PsiNamedElement aClass, - @NotNull GlobalSearchScope useScope, - @NotNull GlobalSearchScope searchScope, - @NotNull FileType searchFileType, - @NotNull CompilerHierarchySearchType searchType) { + private CompilerHierarchyInfoImpl getHierarchyInfo(@NotNull PsiNamedElement aClass, + @NotNull GlobalSearchScope useScope, + @NotNull GlobalSearchScope searchScope, + @NotNull FileType searchFileType, + @NotNull CompilerHierarchySearchType searchType) { if (!isServiceEnabledFor(aClass) || searchScope == LibraryScopeCache.getInstance(myProject).getLibrariesOnlyScope()) return null; - Couple> directInheritorsAndCandidates = - CachedValuesManager.getCachedValue(aClass, () -> CachedValueProvider.Result.create( - new ConcurrentFactoryMap>>() { + Map candidatesPerFile = ReadAction.compute(() -> CachedValuesManager.getCachedValue(aClass, () -> CachedValueProvider.Result.create( + new ConcurrentFactoryMap>() { @Nullable @Override - protected Couple> create(HierarchySearchKey key) { + protected Map create(HierarchySearchKey key) { return calculateDirectInheritors(aClass, useScope, key.mySearchFileType, key.mySearchType); } - }, PsiModificationTracker.MODIFICATION_COUNT, this)).get(new HierarchySearchKey(searchType, searchFileType)); + }, PsiModificationTracker.MODIFICATION_COUNT, this)).get(new HierarchySearchKey(searchType, searchFileType))); - if (directInheritorsAndCandidates == null) return null; + if (candidatesPerFile == null) return null; GlobalSearchScope dirtyScope = myDirtyModulesHolder.getDirtyScope(); if (ElementPlace.LIB == ReadAction.compute(() -> ElementPlace.get(aClass.getContainingFile().getVirtualFile(), myProjectFileIndex))) { dirtyScope = dirtyScope.union(LibraryScopeCache.getInstance(myProject).getLibrariesOnlyScope()); } - return new CompilerHierarchyInfoImpl(directInheritorsAndCandidates, dirtyScope, searchScope); + return new CompilerHierarchyInfoImpl(candidatesPerFile, aClass, dirtyScope, searchScope, myProject, searchFileType, searchType); } private boolean isServiceEnabledFor(PsiElement element) { @@ -223,11 +221,10 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple return myReader != null && isEnabled(); } - private Couple> calculateDirectInheritors(@NotNull PsiNamedElement aClass, - @NotNull GlobalSearchScope useScope, - @NotNull FileType searchFileType, - @NotNull CompilerHierarchySearchType searchType) { - + private Map calculateDirectInheritors(@NotNull PsiNamedElement aClass, + @NotNull GlobalSearchScope useScope, + @NotNull FileType searchFileType, + @NotNull CompilerHierarchySearchType searchType) { final CompilerElementInfo searchElementInfo = asCompilerElements(aClass, false); if (searchElementInfo == null) return null; LightRef searchElement = searchElementInfo.searchElements[0]; @@ -235,7 +232,7 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple myReadDataLock.lock(); try { if (myReader == null) return null; - return myReader.getDirectInheritors(aClass, searchElement, useScope, myDirtyModulesHolder.getDirtyScope(), myProject, searchFileType, searchType); + return myReader.getDirectInheritors(searchElement, useScope, myDirtyModulesHolder.getDirtyScope(), searchFileType, searchType); } finally { myReadDataLock.unlock(); } @@ -276,14 +273,15 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple myReadDataLock.lock(); try { if (myReader == null) return null; - VirtualFile file = ReadAction.compute(() -> PsiUtilCore.getVirtualFile(psiElement)); + VirtualFile file = PsiUtilCore.getVirtualFile(psiElement); + if (file == null) return null; ElementPlace place = ElementPlace.get(file, myProjectFileIndex); if (place == null || (place == ElementPlace.SRC && myDirtyModulesHolder.contains(file))) { return null; } final LanguageLightRefAdapter adapter = findAdapterForFileType(file.getFileType()); if (adapter == null) return null; - final LightRef ref = ReadAction.compute(() -> adapter.asLightUsage(psiElement, myReader.getNameEnumerator())); + final LightRef ref = adapter.asLightUsage(psiElement, myReader.getNameEnumerator()); if (ref == null) return null; if (place == ElementPlace.LIB && buildHierarchyForLibraryElements) { final List elements = adapter.getHierarchyRestrictedToLibraryScope(ref, @@ -304,8 +302,6 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple } finally { myReadDataLock.unlock(); } - - } private void closeReaderIfNeed() { @@ -454,4 +450,8 @@ public class CompilerReferenceServiceImpl extends CompilerReferenceService imple return 31 * mySearchType.hashCode() + mySearchFileType.hashCode(); } } + + private static class RawSearchResult { + + } } diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/DirtyModulesHolder.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/DirtyModulesHolder.java index fecd5fdfa147..6e2a801d746e 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/DirtyModulesHolder.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/DirtyModulesHolder.java @@ -19,6 +19,7 @@ import com.intellij.openapi.application.ReadAction; import com.intellij.openapi.editor.Document; import com.intellij.openapi.fileEditor.FileDocumentManager; import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; import com.intellij.openapi.util.UserDataHolderBase; import com.intellij.openapi.vfs.*; import com.intellij.psi.PsiDocumentManager; @@ -70,23 +71,27 @@ class DirtyModulesHolder extends UserDataHolderBase { } GlobalSearchScope getDirtyScope() { - return CachedValuesManager.getManager(myService.getProject()).getCachedValue(this, () -> - CachedValueProvider.Result.create(calculateDirtyModules(), PsiModificationTracker.MODIFICATION_COUNT, VirtualFileManager.getInstance(), myService)); + final Project project = myService.getProject(); + synchronized (myLock) { + if (myCompilationPhase) { + return GlobalSearchScope.allScope(project); + } + return ReadAction.compute(() -> CachedValuesManager.getManager(project).getCachedValue(this, () -> + CachedValueProvider.Result.create(calculateDirtyModules(), PsiModificationTracker.MODIFICATION_COUNT, VirtualFileManager.getInstance(), myService))); + } } private GlobalSearchScope calculateDirtyModules() { - synchronized (myLock) { - final Set dirtyModules = new THashSet<>(myVFSChangedModules); - for (Document document : myFileDocManager.getUnsavedDocuments()) { - final Module m = getModuleForSourceContentFile(myFileDocManager.getFile(document)); - if (m != null) dirtyModules.add(m); - } - for (Document document : ReadAction.compute(() -> myPsiDocManager.getUncommittedDocuments())) { - final Module m = getModuleForSourceContentFile(ObjectUtils.notNull(myPsiDocManager.getPsiFile(document)).getVirtualFile()); - if (m != null) dirtyModules.add(m); - } - return dirtyModules.stream().map(Module::getModuleWithDependentsScope).reduce(GlobalSearchScope.EMPTY_SCOPE, (s1, s2) -> s1.union(s2)); + final Set dirtyModules = new THashSet<>(myVFSChangedModules); + for (Document document : myFileDocManager.getUnsavedDocuments()) { + final Module m = getModuleForSourceContentFile(myFileDocManager.getFile(document)); + if (m != null) dirtyModules.add(m); } + for (Document document : myPsiDocManager.getUncommittedDocuments()) { + final Module m = getModuleForSourceContentFile(ObjectUtils.notNull(myPsiDocManager.getPsiFile(document)).getVirtualFile()); + if (m != null) dirtyModules.add(m); + } + return dirtyModules.stream().map(Module::getModuleWithDependentsScope).reduce(GlobalSearchScope.EMPTY_SCOPE, (s1, s2) -> s1.union(s2)); } boolean contains(VirtualFile file) { diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java index 1318d0c9e911..cbb4031165d7 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/JavaLightUsageAdapter.java @@ -35,7 +35,6 @@ import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; import org.jetbrains.jps.backwardRefs.LightRef; import java.util.ArrayList; -import java.util.Collection; import java.util.List; import java.util.Set; @@ -113,25 +112,28 @@ public class JavaLightUsageAdapter implements LanguageLightRefAdapter { @NotNull @Override - public PsiClass[] findDirectInheritorCandidatesInFile(@NotNull Collection classes, - @NotNull ByteArrayEnumerator byteArrayEnumerator, + public PsiClass[] findDirectInheritorCandidatesInFile(@NotNull String[] internalNames, @NotNull PsiFileWithStubSupport file, @NotNull PsiNamedElement superClass) { - String[] internalNames = classes.stream().map(LightRef.NamedLightRef::getName).map(byteArrayEnumerator::getName).toArray(String[]::new); return JavaCompilerElementRetriever.retrieveClassesByInternalNames(internalNames, superClass, file); } @NotNull @Override - public PsiFunctionalExpression[] findFunExpressionsInFile(@NotNull Collection funExpressions, + public PsiFunctionalExpression[] findFunExpressionsInFile(@NotNull Integer[] funExpressions, @NotNull PsiFileWithStubSupport file) { - TIntHashSet requiredIndices = new TIntHashSet(funExpressions.size()); - for (LightRef.LightFunExprDef funExpr : funExpressions) { - requiredIndices.add(funExpr.getId()); + TIntHashSet requiredIndices = new TIntHashSet(funExpressions.length); + for (int funExpr : funExpressions) { + requiredIndices.add(funExpr); } return JavaCompilerElementRetriever.retrieveFunExpressionsByIndices(requiredIndices, file); } + @Override + public boolean isDirectInheritor(PsiElement candidate, PsiNamedElement baseClass) { + return ((PsiClass) candidate).isInheritor((PsiClass) baseClass, false); + } + private static boolean mayBeVisibleOutsideOwnerFile(@NotNull PsiElement element) { if (!(element instanceof PsiModifierListOwner)) return true; if (((PsiModifierListOwner)element).hasModifierProperty(PsiModifier.PRIVATE)) return false; diff --git a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java index ca8b29ba4278..fb4ff7f739f4 100644 --- a/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java +++ b/java/compiler/impl/src/com/intellij/compiler/backwardRefs/LanguageLightRefAdapter.java @@ -25,7 +25,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.backwardRefs.ByteArrayEnumerator; import org.jetbrains.jps.backwardRefs.LightRef; -import java.util.Collection; import java.util.List; import java.util.Set; @@ -77,8 +76,7 @@ public interface LanguageLightRefAdapter { * found elements really inheritors. */ @NotNull - PsiElement[] findDirectInheritorCandidatesInFile(@NotNull Collection internalNames, - @NotNull ByteArrayEnumerator byteArrayEnumerator, + PsiElement[] findDirectInheritorCandidatesInFile(@NotNull String[] internalNames, @NotNull PsiFileWithStubSupport file, @NotNull PsiNamedElement superClass); @@ -87,6 +85,8 @@ public interface LanguageLightRefAdapter { * @return functional expressions for given functional type. Should return */ @NotNull - PsiElement[] findFunExpressionsInFile(@NotNull Collection indices, + PsiElement[] findFunExpressionsInFile(@NotNull Integer[] indices, @NotNull PsiFileWithStubSupport file); + + boolean isDirectInheritor(PsiElement candidate, PsiNamedElement baseClass); } diff --git a/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java b/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java index b05b74168eb2..5557746a8e83 100644 --- a/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java +++ b/java/java-indexing-impl/src/com/intellij/compiler/CompilerDirectHierarchyInfo.java @@ -31,12 +31,6 @@ public interface CompilerDirectHierarchyInfo { @NotNull Stream getHierarchyChildren(); - /** - * Must be explicitly checked do they are really direct children in hierarchy of classes or functional expressions - */ - @NotNull - Stream getHierarchyChildCandidates(); - /** * A scope where compiler based index search was not performed */ diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java index e560f6b752e5..8e90f6e63580 100644 --- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java +++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaDirectInheritorsSearcher.java @@ -81,8 +81,7 @@ public class JavaDirectInheritorsSearcher implements QueryExecutor classStream, @NotNull Processor consumer, - boolean acceptAnonymous, - boolean checkInheritance, - PsiClass baseClass) { + boolean acceptAnonymous) { if (!acceptAnonymous) { classStream = classStream.filter(c -> !(c instanceof PsiAnonymousClass)); } return ContainerUtil.process(classStream.iterator(), e -> { ProgressManager.checkCanceled(); PsiClass c = (PsiClass) e; - if (checkInheritance && ReadAction.compute(() -> !c.isInheritor(baseClass, false))) return true; return consumer.process(c); }); } diff --git a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTest.java b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTest.java index 6b625fd3b942..e89d1f37be4f 100644 --- a/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTest.java +++ b/java/java-tests/testSrc/com/intellij/compiler/CompilerReferencesTest.java @@ -16,7 +16,6 @@ package com.intellij.compiler; import com.intellij.JavaTestUtil; -import com.intellij.codeInsight.completion.AbstractCompilerAwareTest; import com.intellij.compiler.backwardRefs.CompilerReferenceServiceImpl; import com.intellij.openapi.fileTypes.StdFileTypes; import com.intellij.openapi.vfs.VirtualFile; @@ -104,9 +103,6 @@ public class CompilerReferencesTest extends CompilerReferencesTestBase { assertOneOf(inheritor.getName(), "FooImpl", "FooImpl2", "FooInsideMethodImpl"); } } - - Collection candidates = directInheritorInfo.getHierarchyChildCandidates().map(PsiClass.class::cast).collect(Collectors.toList()); - assertEmpty(candidates); } public void testHierarchyOfLibClass() {