Revert "[FIR] Implement INVISIBLE_SETTER"

This reverts commit b3d7ed56

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirVisibilityChecker.kt

@@ -5,23 +5,22 @@
 
 package org.jetbrains.kotlin.fir
 
-import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.*
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirThisReceiverExpression
-import org.jetbrains.kotlin.fir.references.impl.FirExplicitSuperReference
-import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.Candidate
 import org.jetbrains.kotlin.fir.resolve.calls.FirSyntheticFunctionSymbol
 import org.jetbrains.kotlin.fir.resolve.calls.ReceiverValue
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
+import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
+import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
-import org.jetbrains.kotlin.fir.types.toSymbol
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 
@@ -117,13 +116,7 @@ abstract class FirVisibilityChecker : FirSessionComponent {
 
             Visibilities.Protected -> {
                 val ownerId = symbol.getOwnerId()
-                ownerId != null && canSeeProtectedMemberOf(
-                    containingDeclarations,
-                    dispatchReceiver,
-                    ownerId,
-                    symbol.fir is FirSyntheticPropertyAccessor,
-                    session
-                )
+                ownerId != null && canSeeProtectedMemberOf(containingDeclarations, dispatchReceiver, ownerId, session)
             }
 
             else -> platformVisibilityCheck(
@@ -178,43 +171,22 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     }
 
     private fun canSeeProtectedMemberOf(
-        containingUseSiteClassSymbol: FirClassSymbol<*>,
+        containingUseSiteClass: FirClass,
         dispatchReceiver: ReceiverValue?,
-        ownerId: ClassId,
-        isSyntheticProperty: Boolean,
-        session: FirSession
+        ownerId: ClassId, session: FirSession
     ): Boolean {
         dispatchReceiver?.ownerIfCompanion(session)?.let { companionOwnerClassId ->
-            if (containingUseSiteClassSymbol.isSubClass(companionOwnerClassId, session)) return true
+            if (containingUseSiteClass.isSubClass(companionOwnerClassId, session)) return true
         }
 
-        if (containingUseSiteClassSymbol.isSubClass(ownerId, session)) {
-            val receiverExpression = dispatchReceiver?.receiverExpression
-            if (receiverExpression == null ||
-                receiverExpression is FirThisReceiverExpression ||
-                (receiverExpression is FirQualifiedAccessExpression && receiverExpression.calleeReference is FirExplicitSuperReference) ||
-                dispatchReceiver.type.toSymbol(session).isSubClass(containingUseSiteClassSymbol.classId, session)
-            ) {
-                return true
-            }
-
-            if (isSyntheticProperty) {
-                return if (session.languageVersionSettings.supportsFeature(LanguageFeature.ImproveReportingDiagnosticsOnProtectedMembersOfBaseClass))
-                    containingUseSiteClassSymbol.classId.packageFqName == ownerId.packageFqName
-                else
-                    true
-            }
-        }
-
-        return false
+        // TODO: Add check for receiver, see org.jetbrains.kotlin.descriptors.Visibility#doesReceiverFitForProtectedVisibility
+        return containingUseSiteClass.isSubClass(ownerId, session)
     }
 
-    private fun FirBasedSymbol<*>?.isSubClass(ownerId: ClassId, session: FirSession): Boolean {
-        val classSymbol = this as? FirClassSymbol<*> ?: return false
-        val classId = classSymbol.classId
+    private fun FirClass.isSubClass(ownerId: ClassId, session: FirSession): Boolean {
         if (classId.isSame(ownerId)) return true
 
-        return lookupSuperTypes(classSymbol, lookupInterfaces = true, deep = true, session).any { superType ->
+        return lookupSuperTypes(this, lookupInterfaces = true, deep = true, session).any { superType ->
             (superType as? ConeClassLikeType)?.fullyExpandedType(session)?.lookupTag?.classId?.isSame(ownerId) == true
         }
     }
@@ -235,16 +207,14 @@ abstract class FirVisibilityChecker : FirSessionComponent {
     protected fun canSeeProtectedMemberOf(
         containingDeclarationOfUseSite: List<FirDeclaration>,
         dispatchReceiver: ReceiverValue?,
-        ownerId: ClassId,
-        isSyntheticProperty: Boolean,
-        session: FirSession
+        ownerId: ClassId, session: FirSession
     ): Boolean {
         if (canSeePrivateMemberOf(containingDeclarationOfUseSite, ownerId, session)) return true
 
         for (containingDeclaration in containingDeclarationOfUseSite) {
             if (containingDeclaration !is FirClass) continue
             val boundSymbol = containingDeclaration.symbol
-            if (canSeeProtectedMemberOf(boundSymbol.fir.symbol, dispatchReceiver, ownerId, isSyntheticProperty, session)) return true
+            if (canSeeProtectedMemberOf(boundSymbol.fir, dispatchReceiver, ownerId, session)) return true
         }
 
         return false

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt

@@ -49,20 +49,9 @@ fun lookupSuperTypes(
     useSiteSession: FirSession,
     supertypeSupplier: SupertypeSupplier = SupertypeSupplier.Default,
     substituteTypes: Boolean = false
-): List<ConeClassLikeType> {
-    return lookupSuperTypes(klass.symbol, lookupInterfaces, deep, useSiteSession, supertypeSupplier, substituteTypes)
-}
-
-fun lookupSuperTypes(
-    classSymbol: FirClassSymbol<*>,
-    lookupInterfaces: Boolean,
-    deep: Boolean,
-    useSiteSession: FirSession,
-    supertypeSupplier: SupertypeSupplier = SupertypeSupplier.Default,
-    substituteTypes: Boolean = false
 ): List<ConeClassLikeType> {
     return SmartList<ConeClassLikeType>().also {
-        classSymbol.collectSuperTypes(it, SmartSet.create(), deep, lookupInterfaces, substituteTypes, useSiteSession, supertypeSupplier)
+        klass.symbol.collectSuperTypes(it, SmartSet.create(), deep, lookupInterfaces, substituteTypes, useSiteSession, supertypeSupplier)
     }
 }