From 2257393d89cec08af235639a66b212c04fc13d8e Mon Sep 17 00:00:00 2001
From: peter <peter@jetbrains.com>
Date: Fri, 10 Jun 2016 10:32:32 +0200
Subject: [PATCH] stub hierarchy searcher: honor includeAnonymous parameter

---
 .../impl/SingleClassHierarchy.java             | 18 ++++++++++++++++++
 .../search/StubHierarchyInheritorSearcher.java | 10 +++++-----
 .../psi/stubsHierarchy/ClassHierarchy.java     |  2 ++
 3 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/SingleClassHierarchy.java b/java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/SingleClassHierarchy.java
index 0bd87dde71f2..27f9ae3d3e39 100644
--- a/java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/SingleClassHierarchy.java
+++ b/java/java-impl/src/com/intellij/psi/stubsHierarchy/impl/SingleClassHierarchy.java
@@ -36,6 +36,7 @@ import java.util.*;
 public class SingleClassHierarchy extends ClassHierarchy {
   private final BitSet myCoveredFiles;
   private final BitSet myAmbiguousSupers;
+  private final BitSet myAnonymous;
   private final List<StubClassAnchor> myCoveredClasses;
   private final StubClassAnchor[] myClassAnchors;
   private final StubClassAnchor[] myClassAnchorsByFileIds;
@@ -49,6 +50,7 @@ public class SingleClassHierarchy extends ClassHierarchy {
     excludeUncoveredFiles(classSymbols);
     connectSubTypes(classSymbols);
     myAmbiguousSupers = calcAmbiguousSupers(classSymbols);
+    myAnonymous = calcAnonymous(classSymbols);
     myCoveredClasses = Collections.unmodifiableList(ContainerUtil.filter(myClassAnchors, this::isCovered));
   }
 
@@ -63,6 +65,17 @@ public class SingleClassHierarchy extends ClassHierarchy {
     return ambiguousSupers;
   }
 
+  @NotNull
+  private static BitSet calcAnonymous(ClassSymbol[] classSymbols) {
+    BitSet answer = new BitSet();
+    for (ClassSymbol symbol : classSymbols) {
+      if (!symbol.isHierarchyIncomplete() && symbol.myShortName == NamesEnumerator.NO_NAME) {
+        answer.set(symbol.myClassAnchor.myId);
+      }
+    }
+    return answer;
+  }
+
   @NotNull
   private static BitSet calcCoveredFiles(ClassSymbol[] classSymbols) {
     BitSet problematicFiles = new BitSet();
@@ -127,6 +140,11 @@ public class SingleClassHierarchy extends ClassHierarchy {
     return myAmbiguousSupers.get(((StubClassAnchor)anchor).myId);
   }
 
+  @Override
+  public boolean isAnonymous(@NotNull SmartClassAnchor anchor) {
+    return myAnonymous.get(((StubClassAnchor)anchor).myId);
+  }
+
   @NotNull
   @Override
   public GlobalSearchScope restrictToUncovered(@NotNull GlobalSearchScope scope) {
diff --git a/java/java-indexing-impl/src/com/intellij/psi/impl/search/StubHierarchyInheritorSearcher.java b/java/java-indexing-impl/src/com/intellij/psi/impl/search/StubHierarchyInheritorSearcher.java
index 51a2fc51c7e1..7835ca4d0842 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/impl/search/StubHierarchyInheritorSearcher.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/impl/search/StubHierarchyInheritorSearcher.java
@@ -50,14 +50,14 @@ public class StubHierarchyInheritorSearcher extends QueryExecutorBase<PsiClass,
   }
 
   @Override
-  public void processQuery(@NotNull DirectClassInheritorsSearch.SearchParameters queryParameters, @NotNull Processor<PsiClass> consumer) {
-    if (!(queryParameters.getScope() instanceof GlobalSearchScope) || !isSearching()) return;
+  public void processQuery(@NotNull DirectClassInheritorsSearch.SearchParameters p, @NotNull Processor<PsiClass> consumer) {
+    if (!(p.getScope() instanceof GlobalSearchScope) || !isSearching()) return;
 
-    PsiClass base = queryParameters.getClassToProcess();
-    GlobalSearchScope scope = (GlobalSearchScope)queryParameters.getScope();
+    PsiClass base = p.getClassToProcess();
+    GlobalSearchScope scope = (GlobalSearchScope)p.getScope();
     ClassHierarchy hierarchy = HierarchyService.getHierarchy(base.getProject());
     for (SmartClassAnchor anchor : hierarchy.getDirectSubtypeCandidates(base)) {
-      if (!processCandidate(consumer, base, scope, hierarchy, anchor)) {
+      if ((p.includeAnonymous() || !hierarchy.isAnonymous(anchor)) && !processCandidate(consumer, base, scope, hierarchy, anchor)) {
         return;
       }
     }
diff --git a/java/java-indexing-impl/src/com/intellij/psi/stubsHierarchy/ClassHierarchy.java b/java/java-indexing-impl/src/com/intellij/psi/stubsHierarchy/ClassHierarchy.java
index 74c5cccedc2a..2a2cbcc6d110 100644
--- a/java/java-indexing-impl/src/com/intellij/psi/stubsHierarchy/ClassHierarchy.java
+++ b/java/java-indexing-impl/src/com/intellij/psi/stubsHierarchy/ClassHierarchy.java
@@ -48,6 +48,8 @@ public abstract class ClassHierarchy {
    */
   public abstract boolean hasAmbiguousSupers(@NotNull SmartClassAnchor anchor);
 
+  public abstract boolean isAnonymous(@NotNull SmartClassAnchor anchor);
+
   /**
    * @return the given scope restricted to the files not covered by this hierarchy, to use usual PSI/resolve-based inheritor search in it
    */