FIR: support don't use builder inference if possible

In this commit we upgrade FIR builder inference logic from
the compiler version to 1.7. FIR-based compiler now works with
"don't use builder inference" flag always ON and supports switching
the flag "use builder inference only if needed". To do it,
ContraintSystemCompleter (FIR) and KotlinConstraintSystemCompleter (FE 1.0)
are made similar with extracting some common parts into
ConstraintSystemCompletionContext.

Test status: one BB test fails after this commit (KT-49285).
Also we have a crush in DFA logic in FIR bootstrap test and somehow
questionable behavior in FIR diagnostic test. However,
two BB tests were fixed, the 3rd case from KT-49925 were also fixed.

#KT-49925 Fixed

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintSystemCompletionContext.kt

@@ -5,33 +5,109 @@
 
 package org.jetbrains.kotlin.resolve.calls.inference.components
 
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemBuilder
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintSystemError
 import org.jetbrains.kotlin.resolve.calls.inference.model.FixVariableConstraintPosition
 import org.jetbrains.kotlin.resolve.calls.inference.model.VariableWithConstraints
+import org.jetbrains.kotlin.resolve.calls.model.PostponedAtomWithRevisableExpectedType
+import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtomMarker
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
 import org.jetbrains.kotlin.types.model.TypeVariableMarker
 
-interface ConstraintSystemCompletionContext : VariableFixationFinder.Context, ResultTypeResolver.Context {
-    val allTypeVariables: Map<TypeConstructorMarker, TypeVariableMarker>
-    override val notFixedTypeVariables: Map<TypeConstructorMarker, VariableWithConstraints>
-    override val fixedTypeVariables: Map<TypeConstructorMarker, KotlinTypeMarker>
-    override val postponedTypeVariables: List<TypeVariableMarker>
+abstract class ConstraintSystemCompletionContext : VariableFixationFinder.Context, ResultTypeResolver.Context {
+    abstract val allTypeVariables: Map<TypeConstructorMarker, TypeVariableMarker>
+    abstract override val notFixedTypeVariables: Map<TypeConstructorMarker, VariableWithConstraints>
+    abstract override val fixedTypeVariables: Map<TypeConstructorMarker, KotlinTypeMarker>
+    abstract override val postponedTypeVariables: List<TypeVariableMarker>
 
-    fun getBuilder(): ConstraintSystemBuilder
+    abstract fun getBuilder(): ConstraintSystemBuilder
 
     // type can be proper if it not contains not fixed type variables
-    fun canBeProper(type: KotlinTypeMarker): Boolean
+    abstract fun canBeProper(type: KotlinTypeMarker): Boolean
 
-    fun containsOnlyFixedOrPostponedVariables(type: KotlinTypeMarker): Boolean
-    fun containsOnlyFixedVariables(type: KotlinTypeMarker): Boolean
+    abstract fun containsOnlyFixedOrPostponedVariables(type: KotlinTypeMarker): Boolean
+    abstract fun containsOnlyFixedVariables(type: KotlinTypeMarker): Boolean
 
     // mutable operations
-    fun addError(error: ConstraintSystemError)
+    abstract fun addError(error: ConstraintSystemError)
 
-    fun fixVariable(variable: TypeVariableMarker, resultType: KotlinTypeMarker, position: FixVariableConstraintPosition<*>)
+    abstract fun fixVariable(variable: TypeVariableMarker, resultType: KotlinTypeMarker, position: FixVariableConstraintPosition<*>)
 
-    fun couldBeResolvedWithUnrestrictedBuilderInference(): Boolean
-    fun processForkConstraints()
+    abstract fun couldBeResolvedWithUnrestrictedBuilderInference(): Boolean
+    abstract fun processForkConstraints()
+
+    fun <A : PostponedResolvedAtomMarker> analyzeArgumentWithFixedParameterTypes(
+        languageVersionSettings: LanguageVersionSettings,
+        postponedArguments: List<A>,
+        analyze: (A) -> Unit
+    ): Boolean {
+        val useBuilderInferenceOnlyIfNeeded =
+            languageVersionSettings.supportsFeature(LanguageFeature.UseBuilderInferenceOnlyIfNeeded)
+        val argumentToAnalyze = if (useBuilderInferenceOnlyIfNeeded) {
+            findPostponedArgumentWithFixedInputTypes(postponedArguments)
+        } else {
+            findPostponedArgumentWithFixedOrPostponedInputTypes(postponedArguments)
+        }
+
+        if (argumentToAnalyze != null) {
+            analyze(argumentToAnalyze)
+            return true
+        }
+
+        return false
+    }
+
+    fun <A : PostponedResolvedAtomMarker> analyzeNextReadyPostponedArgument(
+        languageVersionSettings: LanguageVersionSettings,
+        postponedArguments: List<A>,
+        completionMode: ConstraintSystemCompletionMode,
+        analyze: (A) -> Unit
+    ): Boolean {
+        if (completionMode == ConstraintSystemCompletionMode.FULL) {
+            val argumentWithTypeVariableAsExpectedType = findPostponedArgumentWithRevisableExpectedType(postponedArguments)
+
+            if (argumentWithTypeVariableAsExpectedType != null) {
+                analyze(argumentWithTypeVariableAsExpectedType)
+                return true
+            }
+        }
+
+        return analyzeArgumentWithFixedParameterTypes(languageVersionSettings, postponedArguments, analyze)
+    }
+
+    fun <A : PostponedResolvedAtomMarker> analyzeRemainingNotAnalyzedPostponedArgument(
+        postponedArguments: List<A>,
+        analyze: (A) -> Unit
+    ): Boolean {
+        val remainingNotAnalyzedPostponedArgument = postponedArguments.firstOrNull { !it.analyzed }
+
+        if (remainingNotAnalyzedPostponedArgument != null) {
+            analyze(remainingNotAnalyzedPostponedArgument)
+            return true
+        }
+
+        return false
+    }
+
+    fun <A : PostponedResolvedAtomMarker> hasLambdaToAnalyze(
+        languageVersionSettings: LanguageVersionSettings,
+        postponedArguments: List<A>
+    ): Boolean {
+        return analyzeArgumentWithFixedParameterTypes(languageVersionSettings, postponedArguments) {}
+    }
+
+    // Avoiding smart cast from filterIsInstanceOrNull looks dirty
+    private fun <A : PostponedResolvedAtomMarker> findPostponedArgumentWithRevisableExpectedType(postponedArguments: List<A>): A? =
+        postponedArguments.firstOrNull { argument -> argument is PostponedAtomWithRevisableExpectedType }
+
+    private fun <T : PostponedResolvedAtomMarker> findPostponedArgumentWithFixedOrPostponedInputTypes(
+        postponedArguments: List<T>
+    ) = postponedArguments.firstOrNull { argument -> argument.inputTypes.all { containsOnlyFixedOrPostponedVariables(it) } }
+
+    private fun <T : PostponedResolvedAtomMarker> findPostponedArgumentWithFixedInputTypes(
+        postponedArguments: List<T>
+    ) = postponedArguments.firstOrNull { argument -> argument.inputTypes.all { containsOnlyFixedVariables(it) } }
 }

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt

@@ -20,12 +20,12 @@ import kotlin.math.max
 class NewConstraintSystemImpl(
     private val constraintInjector: ConstraintInjector,
     val typeSystemContext: TypeSystemInferenceExtensionContext
-) : TypeSystemInferenceExtensionContext by typeSystemContext,
+) : ConstraintSystemCompletionContext(),
+    TypeSystemInferenceExtensionContext by typeSystemContext,
     NewConstraintSystem,
     ConstraintSystemBuilder,
     ConstraintInjector.Context,
     ResultTypeResolver.Context,
-    ConstraintSystemCompletionContext,
     PostponedArgumentsAnalyzerContext
 {
     private val utilContext = constraintInjector.constraintIncorporator.utilContext