K2: fix "private to this" determination logic in accordance with K1

#KT-61844 Fixed

compiler/fir/analysis-tests/testData/resolve/problems/compilerPhase.fir.txt

@@ -27,8 +27,8 @@ FILE: compilerPhase.kt
             super<R|kotlin/Any|>()
         }
 
-        private/*private to this*/ final val lower: R|CompilerPhase<Context, Data, Data>| = R|<local>/lower|
+        private final val lower: R|CompilerPhase<Context, Data, Data>| = R|<local>/lower|
-            private/*private to this*/ get(): R|CompilerPhase<Context, Data, Data>|
+            private get(): R|CompilerPhase<Context, Data, Data>|
 
         public open override fun invoke(phaseConfig: R|PhaseConfig|, phaserState: R|PhaserState<Data>|, context: R|Context|, input: R|Data|): R|Data| {
             lval output: R|Data| = when () {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
-import org.jetbrains.kotlin.fir.declarations.FirOuterClassTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.utils.effectiveVisibility
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
@@ -26,6 +25,7 @@ import org.jetbrains.kotlin.fir.toEffectiveVisibility
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry
 import org.jetbrains.kotlin.fir.visibilityChecker
+import org.jetbrains.kotlin.types.EnrichedProjectionKind
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment
 
@@ -358,16 +358,21 @@ class FirStatusResolver(
         if (type is ConeTypeParameterType) {
             return !type.lookupTag.typeParameterSymbol.fir.variance.allowsPosition(requiredVariance)
         }
+        // TODO: handle other types (like flexible, DNN, captured, ...) KT-62134
         if (type is ConeClassLikeType) {
             val classLike = type.lookupTag.toSymbol(session)?.fir
             for ((index, argument) in type.typeArguments.withIndex()) {
-                if (classLike?.typeParameters?.getOrNull(index) is FirOuterClassTypeParameterRef) continue
+                val typeParameterRef = classLike?.typeParameters?.getOrNull(index)
-                val (argType, requiredVarianceForArgument) = when (argument) {
+                if (typeParameterRef !is FirTypeParameter) continue
-                    is ConeKotlinTypeProjectionOut -> argument.type to requiredVariance
+                val requiredVarianceForArgument = when (
-                    is ConeKotlinTypeProjectionIn -> argument.type to requiredVariance.opposite()
+                    EnrichedProjectionKind.getEffectiveProjectionKind(typeParameterRef.variance, argument.variance)
-                    is ConeKotlinTypeProjection -> argument.type to Variance.INVARIANT
+                ) {
-                    is ConeStarProjection -> continue
+                    EnrichedProjectionKind.OUT -> requiredVariance
+                    EnrichedProjectionKind.IN -> requiredVariance.opposite()
+                    EnrichedProjectionKind.INV -> Variance.INVARIANT
+                    EnrichedProjectionKind.STAR -> continue // CONFLICTING_PROJECTION error was reported
                 }
+                val argType = argument.type ?: continue
                 if (contradictsWith(argType, requiredVarianceForArgument)) {
                     return true
                 }
@@ -376,6 +381,14 @@ class FirStatusResolver(
         return false
     }
 
+    private val ConeTypeProjection.variance: Variance
+        get() = when (this.kind) {
+            ProjectionKind.STAR -> Variance.OUT_VARIANCE
+            ProjectionKind.IN -> Variance.IN_VARIANCE
+            ProjectionKind.OUT -> Variance.OUT_VARIANCE
+            ProjectionKind.INVARIANT -> Variance.INVARIANT
+        }
+
     private fun resolveVisibility(
         declaration: FirDeclaration,
         containingClass: FirClass?,

compiler/testData/diagnostics/tests/resolve/invoke/privateInvokeOwner.fir.kt

@@ -1,11 +0,0 @@
-// ISSUE: KT-61844
-// FIR_DUMP
-
-class Foo<I, out O>(
-    private val transformer: (I) -> O,
-) {
-    fun <I, O> transform(foo: Foo<I, O>, bar: I) {
-        foo.<!FUNCTION_EXPECTED!>transformer<!>(bar)
-        foo.<!INVISIBLE_REFERENCE!>transformer<!>.invoke(bar)
-    }
-}

compiler/testData/diagnostics/tests/resolve/invoke/privateInvokeOwner.fir.txt

@@ -1,15 +1,15 @@
-FILE: privateInvokeOwner.fir.kt
+FILE: privateInvokeOwner.kt
     public final class Foo<I, out O> : R|kotlin/Any| {
         public constructor<I, out O>(transformer: R|(I) -> O|): R|Foo<I, O>| {
             super<R|kotlin/Any|>()
         }
 
-        private/*private to this*/ final val transformer: R|(I) -> O| = R|<local>/transformer|
+        private final val transformer: R|(I) -> O| = R|<local>/transformer|
-            private/*private to this*/ get(): R|(I) -> O|
+            private get(): R|(I) -> O|
 
         public final fun <I, O> transform(foo: R|Foo<I, O>|, bar: R|I|): R|kotlin/Unit| {
-            R|<local>/foo|.<Expression 'transformer' of type 'kotlin/Function1<I, O>' cannot be invoked as a function>#(R|<local>/bar|)
+            R|<local>/foo|.R|SubstitutionOverride</Foo.transformer: R|(I) -> O|>|.R|SubstitutionOverride<kotlin/Function1.invoke: R|O|>|(R|<local>/bar|)
-            R|<local>/foo|.R|SubstitutionOverride</Foo.transformer: R|(I) -> O|><HIDDEN: /Foo.transformer is invisible>#|.R|SubstitutionOverride<kotlin/Function1.invoke: R|O|>|(R|<local>/bar|)
+            R|<local>/foo|.R|SubstitutionOverride</Foo.transformer: R|(I) -> O|>|.R|SubstitutionOverride<kotlin/Function1.invoke: R|O|>|(R|<local>/bar|)
         }
 
     }

compiler/testData/diagnostics/tests/resolve/invoke/privateInvokeOwner.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // ISSUE: KT-61844
 // FIR_DUMP