Support isSuccessful in SuccessfulResultCollector

Since now SuccessfulResultCollector do not run computation of
resultingApplicability for error candidate before
getFinalCandidates(). It is very useful because we can do not run
all checks for error candidates if we have not-error candidate.

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerResolver.kt

@@ -208,14 +208,7 @@ class TowerResolver {
 
         abstract fun getFinalCandidates(): Collection<C>
 
-        fun pushCandidates(candidates: Collection<C>) {
+        abstract fun pushCandidates(candidates: Collection<C>)
-            val filteredCandidates = candidates.filter {
-                it.resultingApplicability != ResolutionCandidateApplicability.HIDDEN
-            }
-            if (filteredCandidates.isNotEmpty()) addCandidates(filteredCandidates)
-        }
-
-        protected abstract fun addCandidates(candidates: Collection<C>)
     }
 
     class AllCandidatesCollector<C : Candidate>: ResultCollector<C>() {
@@ -225,33 +218,51 @@ class TowerResolver {
 
         override fun getFinalCandidates(): Collection<C> = allCandidates
 
-        override fun addCandidates(candidates: Collection<C>) {
+        override fun pushCandidates(candidates: Collection<C>) {
-            allCandidates.addAll(candidates)
+            candidates.filterNotTo(allCandidates) {
-        }
+                it.resultingApplicability == ResolutionCandidateApplicability.HIDDEN
-    }
-
-    class SuccessfulResultCollector<C : Candidate>: ResultCollector<C>() {
-        private var currentCandidates: Collection<C> = emptyList()
-        private var currentLevel: ResolutionCandidateApplicability? = null
-
-        override fun getSuccessfulCandidates(): Collection<C>? = getResolved()
-
-        fun getResolved() = currentCandidates.takeIf { currentLevel == ResolutionCandidateApplicability.RESOLVED }
-
-        fun getResolvedLowPriority() = currentCandidates.takeIf { currentLevel == ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY }
-
-        fun getErrors() = currentCandidates.takeIf {
-            currentLevel == null || currentLevel!! > ResolutionCandidateApplicability.RESOLVED_LOW_PRIORITY
-        }
-
-        override fun getFinalCandidates() = getResolved() ?: getResolvedLowPriority() ?: getErrors() ?: emptyList()
-
-        override fun addCandidates(candidates: Collection<C>) {
-            val minimalLevel = candidates.map { it.resultingApplicability }.min()!!
-            if (currentLevel == null || currentLevel!! > minimalLevel) {
-                currentLevel = minimalLevel
-                currentCandidates = candidates.filter { it.resultingApplicability == minimalLevel }
             }
         }
     }
+
+    class SuccessfulResultCollector<C : Candidate> : ResultCollector<C>() {
+        private var candidateGroups = arrayListOf<Collection<C>>()
+        private var isSuccessful = false
+
+        override fun getSuccessfulCandidates(): Collection<C>? {
+            if (!isSuccessful) return null
+            val firstGroupWithResolved = candidateGroups.firstOrNull {
+                it.any { it.resultingApplicability == ResolutionCandidateApplicability.RESOLVED }
+            } ?: return null
+            
+            return firstGroupWithResolved.filter { it.resultingApplicability == ResolutionCandidateApplicability.RESOLVED }
+        }
+
+        override fun pushCandidates(candidates: Collection<C>) {
+            val thereIsSuccessful = candidates.any { it.isSuccessful }
+            if (!isSuccessful && !thereIsSuccessful) {
+                candidateGroups.add(candidates)
+                return
+            }
+
+            if (!isSuccessful) {
+                candidateGroups.clear()
+                isSuccessful = true
+            }
+            if (thereIsSuccessful) {
+                candidateGroups.add(candidates.filter { it.isSuccessful })
+            }
+        }
+
+        override fun getFinalCandidates(): Collection<C> {
+            val moreSuitableGroup = candidateGroups.minBy { it.groupApplicability } ?: return emptyList()
+            val groupApplicability = moreSuitableGroup.groupApplicability
+            if (groupApplicability == ResolutionCandidateApplicability.HIDDEN) return emptyList()
+
+            return moreSuitableGroup.filter { it.resultingApplicability == groupApplicability }
+        }
+        
+        private val Collection<C>.groupApplicability get() = 
+            minBy { it.resultingApplicability }?.resultingApplicability ?: ResolutionCandidateApplicability.HIDDEN 
+    }
 }