[FIR] Add base class for PostponedResolvedAtomMarker to FIR

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/AbstractManyCandidatesInferenceSession.kt

@@ -13,10 +13,8 @@ import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.candidate
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
-import org.jetbrains.kotlin.fir.resolve.transformers.FirCallCompletionResultsWriterTransformer
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.coneTypeUnsafe
-import org.jetbrains.kotlin.fir.visitors.transformSingle
 import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem
 import org.jetbrains.kotlin.resolve.calls.inference.buildAbstractResultingSubstitutor
 import org.jetbrains.kotlin.resolve.calls.inference.components.KotlinConstraintSystemCompleter

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/InferenceCompletion.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.resolve.calls.inference.components.TypeVariableDirec
 import org.jetbrains.kotlin.resolve.calls.inference.components.VariableFixationFinder
 import org.jetbrains.kotlin.resolve.calls.inference.model.NewConstraintSystemImpl
 import org.jetbrains.kotlin.resolve.calls.inference.model.VariableWithConstraints
-import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtom
 import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtomMarker
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
@@ -97,12 +96,13 @@ private fun Candidate.hasProperNonTrivialLowerConstraints(components: InferenceC
 
 class ConstraintSystemCompleter(val components: InferenceComponents) {
     private val variableFixationFinder = VariableFixationFinder(components.trivialConstraintTypeInferenceOracle)
+
     fun complete(
         c: KotlinConstraintSystemCompleter.Context,
         completionMode: KotlinConstraintSystemCompleter.ConstraintSystemCompletionMode,
         topLevelAtoms: List<FirStatement>,
         candidateReturnType: ConeKotlinType,
-        analyze: (PostponedResolvedAtomMarker) -> Unit
+        analyze: (PostponedResolvedAtom) -> Unit
     ) {
 
         while (true) {
@@ -198,7 +198,7 @@ class ConstraintSystemCompleter(val components: InferenceComponents) {
     private fun analyzePostponeArgumentIfPossible(
         c: KotlinConstraintSystemCompleter.Context,
         topLevelAtoms: List<FirStatement>,
-        analyze: (PostponedResolvedAtomMarker) -> Unit
+        analyze: (PostponedResolvedAtom) -> Unit
     ): Boolean {
         for (argument in getOrderedNotAnalyzedPostponedArguments(topLevelAtoms)) {
             if (canWeAnalyzeIt(c, argument)) {
@@ -209,8 +209,8 @@ class ConstraintSystemCompleter(val components: InferenceComponents) {
         return false
     }
 
-    private fun getOrderedNotAnalyzedPostponedArguments(topLevelAtoms: List<FirStatement>): List<PostponedResolvedAtomMarker> {
-        val notAnalyzedArguments = arrayListOf<PostponedResolvedAtomMarker>()
+    private fun getOrderedNotAnalyzedPostponedArguments(topLevelAtoms: List<FirStatement>): List<PostponedResolvedAtom> {
+        val notAnalyzedArguments = arrayListOf<PostponedResolvedAtom>()
         for (primitive in topLevelAtoms) {
             primitive.processAllContainingCallCandidates(
                 // TODO: remove this argument and relevant parameter
@@ -218,7 +218,7 @@ class ConstraintSystemCompleter(val components: InferenceComponents) {
                 processBlocks = true
             ) { candidate ->
                 candidate.postponedAtoms.forEach {
-                    notAnalyzedArguments.addIfNotNull(it.safeAs<PostponedResolvedAtomMarker>()?.takeUnless { it.analyzed })
+                    notAnalyzedArguments.addIfNotNull(it.safeAs<PostponedResolvedAtom>()?.takeUnless { it.analyzed })
                 }
             }
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArguments.kt

@@ -44,11 +44,6 @@ fun Candidate.preprocessLambdaArgument(
         // TODO: add SAM conversion processing
         val lambdaType = createFunctionalType(resolvedArgument.parameters, resolvedArgument.receiver, resolvedArgument.returnType)
         csBuilder.addSubtypeConstraint(lambdaType, expectedType, SimpleConstraintSystemConstraintPosition)
-//        val lambdaType = createFunctionType(
-//            csBuilder.builtIns, Annotations.EMPTY, resolvedArgument.receiver,
-//            resolvedArgument.parameters, null, resolvedArgument.returnType, resolvedArgument.isSuspend
-//        )
-//        csBuilder.addSubtypeConstraint(lambdaType, expectedType, ArgumentConstraintPosition(argument))
     }
 
     postponedAtoms += resolvedArgument
@@ -203,6 +198,12 @@ private fun ConeKotlinType.extractParametersForFunctionalType(
 
 class TypeVariableForLambdaReturnType(val argument: FirAnonymousFunction, name: String) : ConeTypeVariable(name)
 
+sealed class PostponedResolvedAtom : PostponedResolvedAtomMarker {
+    abstract override val inputTypes: Collection<ConeKotlinType>
+    abstract override val outputType: ConeKotlinType?
+    override var analyzed: Boolean = false
+}
+
 class ResolvedLambdaAtom(
     val atom: FirAnonymousFunction,
     val isSuspend: Boolean,
@@ -210,21 +211,9 @@ class ResolvedLambdaAtom(
     val parameters: List<ConeKotlinType>,
     val returnType: ConeKotlinType,
     val typeVariableForLambdaReturnType: TypeVariableForLambdaReturnType?
-) : PostponedResolvedAtomMarker {
-    override var analyzed: Boolean = false
+) : PostponedResolvedAtom() {
     lateinit var returnStatements: Collection<FirStatement>
 
-//    lateinit var resultArguments: List<KotlinCallArgument>
-//        private set
-
-//    fun setAnalyzedResults(
-//        resultArguments: List<KotlinCallArgument>,
-//        subResolvedAtoms: List<ResolvedAtom>
-//    ) {
-//        this.resultArguments = resultArguments
-//        setAnalyzedResults(subResolvedAtoms)
-//    }
-
     override val inputTypes: Collection<ConeKotlinType> get() = receiver?.let { parameters + it } ?: parameters
     override val outputType: ConeKotlinType get() = returnType
 }
@@ -234,8 +223,7 @@ class ResolvedCallableReferenceAtom(
     val expectedType: ConeKotlinType?,
     val lhs: DoubleColonLHS?,
     private val session: FirSession
-) : PostponedResolvedAtomMarker {
-    override var analyzed: Boolean = false
+) : PostponedResolvedAtom() {
     var postponed: Boolean = false
 
     var resultingCandidate: Pair<Candidate, CandidateApplicability>? = null

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt

@@ -49,8 +49,7 @@ class PostponedArgumentsAnalyzer(
 
     fun analyze(
         c: PostponedArgumentsAnalyzer.Context,
-//        resolutionCallbacks: KotlinResolutionCallbacks,
-        argument: PostponedResolvedAtomMarker,
+        argument: PostponedResolvedAtom,
         candidate: Candidate
         //diagnosticsHolder: KotlinDiagnosticsHolder
     ) {
@@ -66,8 +65,6 @@ class PostponedArgumentsAnalyzer(
             is ResolvedCallableReferenceAtom -> processCallableReference(argument, candidate)
 //
 //            is ResolvedCollectionLiteralAtom -> TODO("Not supported")
-
-            else -> error("Unexpected resolved primitive: ${argument.javaClass.canonicalName}")
         }
     }
 

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.inference.components
 import org.jetbrains.kotlin.resolve.calls.inference.model.Constraint
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintKind
 import org.jetbrains.kotlin.resolve.calls.inference.model.VariableWithConstraints
-import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtom
+import org.jetbrains.kotlin.resolve.calls.model.PostponedResolvedAtomMarker
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.model.FlexibleTypeMarker
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
@@ -32,7 +32,7 @@ private typealias Variable = VariableWithConstraints
 
 class TypeVariableDirectionCalculator(
     private val c: VariableFixationFinder.Context,
-    private val postponedKtPrimitives: List<PostponedResolvedAtom>,
+    private val postponedKtPrimitives: List<PostponedResolvedAtomMarker>,
     topLevelType: KotlinTypeMarker
 ) {
     enum class ResolveDirection {