[NI] Run completion on subatoms of error calls

Call transformer previously ran completion of argument atoms
only for non-error candidates. This led to missing diagnostics,
i.e. from collection literal resolver.

Now arguments of calls resolved to error descriptor are completed,
with exception to not found provideDelegate calls.
provideDelegate's subatoms are not completed after failure, because
it is a part of delegate competion, which does not end with
unresolved provideDelegate.
Completing after provideDelegate failure removes constraint system
from resolved arguments, which breaks resolve for get/setValue.

^KT-33592 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/DelegatedPropertyInferenceSession.kt

@@ -49,8 +49,8 @@ class DelegatedPropertyInferenceSession(
 
     private fun ResolvedCallAtom.addConstraintForThis(descriptor: CallableDescriptor, commonSystem: ConstraintSystemBuilder) {
         val typeOfThis = variableDescriptor.extensionReceiverParameter?.type
-                ?: variableDescriptor.dispatchReceiverParameter?.type
-                ?: builtIns.nullableNothingType
+            ?: variableDescriptor.dispatchReceiverParameter?.type
+            ?: builtIns.nullableNothingType
 
         val valueParameterForThis = descriptor.valueParameters.getOrNull(0) ?: return
         val substitutedType = freshVariablesSubstitutor.safeSubstitute(valueParameterForThis.type.unwrap())
@@ -85,6 +85,8 @@ class DelegatedPropertyInferenceSession(
     ): Map<TypeConstructor, UnwrappedType> = emptyMap()
 
     override fun writeOnlyStubs(callInfo: SingleCallResolutionResult): Boolean = false
+
+    override fun shouldCompleteResolvedSubAtomsOf(resolvedCallAtom: ResolvedCallAtom) = true
 }
 
 object InferenceSessionForExistingCandidates : InferenceSession {
@@ -104,4 +106,7 @@ object InferenceSessionForExistingCandidates : InferenceSession {
 
     override fun writeOnlyStubs(callInfo: SingleCallResolutionResult): Boolean = false
     override fun callCompleted(resolvedAtom: ResolvedAtom): Boolean = false
+    override fun shouldCompleteResolvedSubAtomsOf(resolvedCallAtom: ResolvedCallAtom): Boolean {
+        return !ErrorUtils.isError(resolvedCallAtom.candidateDescriptor)
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/inference/CoroutineInferenceSession.kt

@@ -107,6 +107,8 @@ class CoroutineInferenceSession(
         return commonSystem.fixedTypeVariables.cast() // TODO: SUB
     }
 
+    override fun shouldCompleteResolvedSubAtomsOf(resolvedCallAtom: ResolvedCallAtom) = true
+
     private fun createNonFixedTypeToVariableSubstitutor(): NewTypeSubstitutorByConstructorMap {
         val bindings = hashMapOf<TypeConstructor, UnwrappedType>()
         for ((variable, nonFixedType) in stubsForPostponedVariables) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/KotlinToResolvedCallTransformer.kt

@@ -138,7 +138,7 @@ class KotlinToResolvedCallTransformer(
                     typeApproximator, missingSupertypesResolver
                 )
 
-                if (!ErrorUtils.isError(candidate.candidateDescriptor)) {
+                if (context.inferenceSession.shouldCompleteResolvedSubAtomsOf(candidate)) {
                     candidate.subResolvedAtoms?.forEach { subKtPrimitive ->
                         ktPrimitiveCompleter.completeAll(subKtPrimitive)
                     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ManyCandidatesResolver.kt

@@ -61,6 +61,8 @@ abstract class ManyCandidatesResolver<D : CallableDescriptor>(
     override fun callCompleted(resolvedAtom: ResolvedAtom): Boolean =
         !completedCalls.add(resolvedAtom)
 
+    override fun shouldCompleteResolvedSubAtomsOf(resolvedCallAtom: ResolvedCallAtom) = true
+
     fun resolveCandidates(resolutionCallbacks: KotlinResolutionCallbacks): List<ResolutionResultCallInfo<D>> {
         val resolvedCallsInfo = partiallyResolvedCallsInfo.toList()
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt

@@ -73,6 +73,8 @@ class ResolvedAtomCompleter(
     }
 
     fun completeAll(resolvedAtom: ResolvedAtom) {
+        if (!resolvedAtom.analyzed)
+            return
         resolvedAtom.subResolvedAtoms?.forEach { subKtPrimitive ->
             completeAll(subKtPrimitive)
         }