FIR: Fix synthetic type variables to independent stub types

compiler/fir/cones/src/org/jetbrains/kotlin/fir/types/ConeTypes.kt

@@ -322,7 +322,11 @@ fun ConeIntersectionType.mapTypes(func: (ConeKotlinType) -> ConeKotlinType): Con
     return ConeIntersectionType(intersectedTypes.map(func), alternativeType?.let(func))
 }
 
-data class ConeStubTypeConstructor(val variable: ConeTypeVariable, val isTypeVariableInSubtyping: Boolean) : TypeConstructorMarker
+data class ConeStubTypeConstructor(
+    val variable: ConeTypeVariable,
+    val isTypeVariableInSubtyping: Boolean,
+    val isForFixation: Boolean = false,
+) : TypeConstructorMarker
 
 sealed class ConeStubType(val constructor: ConeStubTypeConstructor, override val nullability: ConeNullability) : StubTypeMarker,
     ConeSimpleKotlinType() {
@@ -363,6 +367,9 @@ open class ConeStubTypeForBuilderInference(constructor: ConeStubTypeConstructor,
     )
 }
 
+class ConeStubTypeForFixation(constructor: ConeStubTypeConstructor, nullability: ConeNullability) :
+    ConeStubTypeForBuilderInference(constructor, nullability)
+
 class ConeStubTypeForTypeVariableInSubtyping(constructor: ConeStubTypeConstructor, nullability: ConeNullability) :
     ConeStubType(constructor, nullability) {
     constructor(variable: ConeTypeVariable, nullability: ConeNullability) : this(

compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt

@@ -435,6 +435,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
     override fun TypeConstructorMarker.unwrapStubTypeVariableConstructor(): TypeConstructorMarker {
         if (this !is ConeStubTypeConstructor) return this
         if (this.isTypeVariableInSubtyping) return this
+        if (this.isForFixation) return this
         return this.variable.typeConstructor
     }
 

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

@@ -226,17 +226,23 @@ class ConstraintSystemCompleter(private val components: BodyResolveComponents, p
 
             val variableWithConstraints = notFixedTypeVariables.getValue(variableForFixation.variable)
 
-            if (variableForFixation.hasProperConstraint) {
+            when {
+                variableForFixation.hasProperConstraint -> {
                     fixVariable(asConstraintSystemCompletionContext(), topLevelType, variableWithConstraints, postponedArguments)
                     return true
-            } else if (context.inferenceSession.isSyntheticTypeVariable(variableWithConstraints.typeVariable)) {
+                }
-                val variable = variableWithConstraints.typeVariable as ConeTypeVariable
+                context.inferenceSession.isSyntheticTypeVariable(variableWithConstraints.typeVariable) -> {
-                context.inferenceSession.fixSyntheticTypeVariableWithNotEnoughInformation(variable, asConstraintSystemCompletionContext())
+                    context.inferenceSession.fixSyntheticTypeVariableWithNotEnoughInformation(
+                        variableWithConstraints.typeVariable as ConeTypeVariable,
+                        asConstraintSystemCompletionContext()
+                    )
                     return true
-            } else {
+                }
+                else -> {
                     processVariableWhenNotEnoughInformation(this, variableWithConstraints, topLevelAtoms)
                 }
             }
+        }
 
         return false
     }

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

@@ -112,15 +112,16 @@ class FirDelegatedPropertyInferenceSession(
     private fun createNonFixedTypeToVariableSubstitutor(): ConeSubstitutor {
         val typeContext = components.session.typeContext
 
-        val bindings = mutableMapOf<TypeConstructorMarker, ConeKotlinType>()
+        val bindings = mutableMapOf<TypeVariableMarker, ConeKotlinType>()
-        for ((variable, stubType) in stubTypesByTypeVariable) {
+        for ((variable, synthetic) in syntheticTypeVariableByTypeVariable) {
-            bindings[stubType.constructor] = variable.defaultType(typeContext) as ConeKotlinType
+            bindings[synthetic] = variable.defaultType(typeContext) as ConeKotlinType
         }
 
         return object : AbstractConeSubstitutor(typeContext) {
             override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
                 if (type !is ConeStubType) return null
-                return bindings[type.constructor].updateNullabilityIfNeeded(type)
+                if (type.constructor.isTypeVariableInSubtyping) return null
+                return bindings[type.constructor.variable].updateNullabilityIfNeeded(type)
             }
         }
     }
@@ -151,9 +152,13 @@ class FirDelegatedPropertyInferenceSession(
         typeVariable: TypeVariableMarker,
         completionContext: ConstraintSystemCompletionContext
     ) {
+        typeVariable as ConeTypeVariable
         completionContext.fixVariable(
             typeVariable,
-            stubTypeBySyntheticTypeVariable[typeVariable]!!,
+            ConeStubTypeForFixation(
+                ConeStubTypeConstructor(typeVariable, isTypeVariableInSubtyping = false, isForFixation = true),
+                ConeNullability.create(typeVariable.defaultType.isMarkedNullable)
+            ),
             ConeFixVariableConstraintPosition(typeVariable)
         )
     }