[FIR] Rework resolution of declaration statuses

There is introduced algorithm of resolution with jumps: before
  resolution of some class we resolve all status of members of its
  supertypes, so we can properly determine inherited visibility
  and modifiers

compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt

@@ -15,5 +15,5 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.foo("")
-}
+    b.<!HIDDEN!>foo<!>("")
+}

compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.txt

@@ -4,11 +4,11 @@ FILE: main.kt
             super<R|A|>()
         }
 
-        public final override fun foo(s: R|kotlin/String|): R|kotlin/Any?| {
+        protected final override fun foo(s: R|kotlin/String|): R|kotlin/Any?| {
             ^foo Null(null)
         }
 
     }
     public final fun test(b: R|B|): R|kotlin/Unit| {
-        R|<local>/b|.R|/B.foo|(String())
+        R|<local>/b|.<HIDDEN: /B.foo is invisible>#(String())
     }

compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.txt

@@ -6,7 +6,7 @@ FILE: superAny.kt
             super<R|kotlin/Any|>()
         }
 
-        public open override fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
+        public open override operator fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
             ^equals this@R|/B|.super<R|kotlin/Any|>.R|kotlin/Any.equals|(R|<local>/other|)
         }
 
@@ -20,7 +20,7 @@ FILE: superAny.kt
             super<R|B|>()
         }
 
-        public final override fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
+        public final override operator fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
             ^equals this@R|/C|.super<R|B|>.R|/B.equals|(R|<local>/other|)
         }
 

compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.txt

@@ -4,7 +4,7 @@ FILE: methodOfAnyImplementedInInterface.kt
             ^toString String(Hello)
         }
 
-        public open override fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
+        public open override operator fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean| {
             ^equals Boolean(true)
         }
 
@@ -16,7 +16,7 @@ FILE: methodOfAnyImplementedInInterface.kt
     public abstract interface B : R|kotlin/Any| {
         public abstract override fun toString(): R|kotlin/String|
 
-        public abstract override fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean|
+        public abstract override operator fun equals(other: R|kotlin/Any?|): R|kotlin/Boolean|
 
         public abstract override fun hashCode(): R|kotlin/Int|
 

compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.txt

@@ -100,7 +100,7 @@ FILE: protectedVisibility.kt
             super<R|Generic<kotlin/Int>|>(Int(1))
         }
 
-        public final override fun foo(): R|kotlin/Int| {
+        protected final override fun foo(): R|kotlin/Int| {
             ^foo this@R|/DerivedGeneric|.super<R|Generic<kotlin/Int>|>.R|FakeOverride</Generic.foo: R|kotlin/Int|>|()
         }
 

compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.txt

@@ -18,11 +18,11 @@ FILE: typeParameters.kt
             super<R|AbstractList<kotlin/Int>|>()
         }
 
-        public final override fun get(index: R|kotlin/Int|): R|kotlin/Int| {
+        public final override operator fun get(index: R|kotlin/Int|): R|kotlin/Int| {
             ^get Int(42)
         }
 
-        public final override fun concat(other: R|List<kotlin/Int>|): R|List<kotlin/Int>| {
+        public final override infix fun concat(other: R|List<kotlin/Int>|): R|List<kotlin/Int>| {
             ^concat this@R|/SomeList|
         }
 

compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt

@@ -0,0 +1,13 @@
+class A : Foo {
+    override fun foo() {}
+}
+
+typealias Foo = B
+
+interface B {
+    fun foo() {}
+}
+
+fun test(c: A) {
+    c.foo()
+}

compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.txt

@@ -0,0 +1,19 @@
+FILE: statusResolveForTypealiasAsSuperClass.kt
+    public final class A : R|Foo| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final override fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+    public final typealias Foo = R|B|
+    public abstract interface B : R|kotlin/Any| {
+        public open fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+    public final fun test(c: R|A|): R|kotlin/Unit| {
+        R|<local>/c|.R|/A.foo|()
+    }

compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt

@@ -0,0 +1,15 @@
+interface Common {
+    fun <T, R> foo(value: T, producer: (T) -> R): R
+}
+
+class C : B, A {
+    override fun <T, R> foo(value: T, producer: (T) -> R): R = null!!
+}
+
+interface A : Common {
+    override fun <T, R> foo(value: T, producer: (T) -> R): R = null!!
+}
+
+interface B : Common {
+    override fun <T, R> foo(value: T, producer: (T) -> R) = producer(value)
+}

compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.txt

@@ -0,0 +1,27 @@
+FILE: intersectionOverrideWithImplicitTypes.kt
+    public abstract interface Common : R|kotlin/Any| {
+        public abstract fun <T, R> foo(value: R|T|, producer: R|(T) -> R|): R|R|
+
+    }
+    public final class C : R|B|, R|A| {
+        public constructor(): R|C| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final override fun <T, R> foo(value: R|T|, producer: R|(T) -> R|): R|R| {
+            ^foo Null(null)!!
+        }
+
+    }
+    public abstract interface A : R|Common| {
+        public open override fun <T, R> foo(value: R|T|, producer: R|(T) -> R|): R|R| {
+            ^foo Null(null)!!
+        }
+
+    }
+    public abstract interface B : R|Common| {
+        public open override fun <T, R> foo(value: R|T|, producer: R|(T) -> R|): R|R| {
+            ^foo R|<local>/producer|.R|FakeOverride<kotlin/Function1.invoke: R|R|>|(R|<local>/value|)
+        }
+
+    }

compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt

@@ -0,0 +1,18 @@
+// FILE: C.kt
+
+class C : B() {
+    override fun foo() {}
+}
+
+// FILE: B.java
+
+public class B extends A {
+    @java.lang.Override
+    public void foo() {}
+}
+
+// FILE: A.kt
+
+abstract class A {
+    abstract fun foo()
+}

compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.txt

@@ -0,0 +1,19 @@
+FILE: C.kt
+    public final class C : R|B| {
+        public constructor(): R|C| {
+            super<R|B|>()
+        }
+
+        public final override fun foo(): R|kotlin/Unit| {
+        }
+
+    }
+FILE: A.kt
+    public abstract class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        public abstract fun foo(): R|kotlin/Unit|
+
+    }

compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt

@@ -0,0 +1,23 @@
+// ISSUE: KT-38656
+
+// FILE: B.kt
+
+class B : A() {
+    override fun foo(s: String): String = ""
+
+    fun testProtected(): String {
+        return this foo "hello"
+    }
+}
+
+// FILE: A.kt
+
+abstract class A {
+    protected abstract infix fun foo(s: String): String
+}
+
+// FILE: main.kt
+
+fun test(b: B): String {
+    return b <!HIDDEN!>foo<!> "hello" // should be an error
+}

compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.txt

@@ -0,0 +1,28 @@
+FILE: B.kt
+    public final class B : R|A| {
+        public constructor(): R|B| {
+            super<R|A|>()
+        }
+
+        protected final override infix fun foo(s: R|kotlin/String|): R|kotlin/String| {
+            ^foo String()
+        }
+
+        public final fun testProtected(): R|kotlin/String| {
+            ^testProtected this@R|/B|.R|/B.foo|(String(hello))
+        }
+
+    }
+FILE: A.kt
+    public abstract class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        protected abstract infix fun foo(s: R|kotlin/String|): R|kotlin/String|
+
+    }
+FILE: main.kt
+    public final fun test(b: R|B|): R|kotlin/String| {
+        ^test R|<local>/b|.<HIDDEN: /B.foo is invisible>#(String(hello))
+    }

compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.txt

@@ -28,11 +28,11 @@ FILE: delegateWithAnonymousObject.kt
                     super<R|kotlin/Any|>()
                 }
 
-                public final override fun getValue(thisRef: R|IssuesListUserProfile|, property: R|kotlin/reflect/KProperty<*>|): R|IssueListView| {
+                public final override operator fun getValue(thisRef: R|IssuesListUserProfile|, property: R|kotlin/reflect/KProperty<*>|): R|IssueListView| {
                     ^getValue R|/IssueListView.IssueListView|()
                 }
 
-                public final override fun setValue(thisRef: R|IssuesListUserProfile|, property: R|kotlin/reflect/KProperty<*>|, value: R|IssueListView|): R|kotlin/Unit| {
+                public final override operator fun setValue(thisRef: R|IssuesListUserProfile|, property: R|kotlin/reflect/KProperty<*>|, value: R|IssueListView|): R|kotlin/Unit| {
                     ^setValue R|/IssueListView.IssueListView|().R|/IssueListView.updateFrom|(R|<local>/value|)
                 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.txt

@@ -14,7 +14,7 @@ FILE: functionX.kt
             super<R|kotlin/Any|>()
         }
 
-        public final override fun invoke(p1: R|kotlin/Int|, p2: R|kotlin/String|): R|kotlin/Unit| {
+        public final override operator fun invoke(p1: R|kotlin/Int|, p2: R|kotlin/String|): R|kotlin/Unit| {
         }
 
     }

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/smartSet.txt

@@ -8,7 +8,7 @@ FILE: smartSet.kt
             public get(): R|kotlin/Int|
             public set(value: R|kotlin/Int|): R|kotlin/Unit|
 
-        public final override fun iterator(): R|kotlin/collections/MutableIterator<T>| {
+        public final override operator fun iterator(): R|kotlin/collections/MutableIterator<T>| {
             ^iterator R|kotlin/TODO|()
         }
 

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

@@ -373,6 +373,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
         runTest("compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt");
     }
 
+    @TestMetadata("statusResolveForTypealiasAsSuperClass.kt")
+    public void testStatusResolveForTypealiasAsSuperClass() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt");
+    }
+
     @TestMetadata("syntheticsVsNormalProperties.kt")
     public void testSyntheticsVsNormalProperties() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/syntheticsVsNormalProperties.kt");
@@ -2661,6 +2666,16 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt");
         }
 
+        @TestMetadata("intersectionOverrideWithImplicitTypes.kt")
+        public void testIntersectionOverrideWithImplicitTypes() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt");
+        }
+
+        @TestMetadata("kotlinJavaKotlinHierarchy.kt")
+        public void testKotlinJavaKotlinHierarchy() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt");
+        }
+
         @TestMetadata("protectedInCompanion.kt")
         public void testProtectedInCompanion() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt");
@@ -2670,5 +2685,10 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
         public void testSingletonConstructors() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt");
         }
+
+        @TestMetadata("visibilityWithOverrides.kt")
+        public void testVisibilityWithOverrides() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt");
+        }
     }
 }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -373,6 +373,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
         runTest("compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt");
     }
 
+    @TestMetadata("statusResolveForTypealiasAsSuperClass.kt")
+    public void testStatusResolveForTypealiasAsSuperClass() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt");
+    }
+
     @TestMetadata("syntheticsVsNormalProperties.kt")
     public void testSyntheticsVsNormalProperties() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/syntheticsVsNormalProperties.kt");
@@ -2661,6 +2666,16 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt");
         }
 
+        @TestMetadata("intersectionOverrideWithImplicitTypes.kt")
+        public void testIntersectionOverrideWithImplicitTypes() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt");
+        }
+
+        @TestMetadata("kotlinJavaKotlinHierarchy.kt")
+        public void testKotlinJavaKotlinHierarchy() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt");
+        }
+
         @TestMetadata("protectedInCompanion.kt")
         public void testProtectedInCompanion() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt");
@@ -2670,5 +2685,10 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
         public void testSingletonConstructors() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt");
         }
+
+        @TestMetadata("visibilityWithOverrides.kt")
+        public void testVisibilityWithOverrides() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt");
+        }
     }
 }

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java

@@ -373,6 +373,11 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         runTest("compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt");
     }
 
+    @TestMetadata("statusResolveForTypealiasAsSuperClass.kt")
+    public void testStatusResolveForTypealiasAsSuperClass() throws Exception {
+        runTest("compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt");
+    }
+
     @TestMetadata("syntheticsVsNormalProperties.kt")
     public void testSyntheticsVsNormalProperties() throws Exception {
         runTest("compiler/fir/analysis-tests/testData/resolve/syntheticsVsNormalProperties.kt");
@@ -2661,6 +2666,16 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt");
         }
 
+        @TestMetadata("intersectionOverrideWithImplicitTypes.kt")
+        public void testIntersectionOverrideWithImplicitTypes() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt");
+        }
+
+        @TestMetadata("kotlinJavaKotlinHierarchy.kt")
+        public void testKotlinJavaKotlinHierarchy() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt");
+        }
+
         @TestMetadata("protectedInCompanion.kt")
         public void testProtectedInCompanion() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt");
@@ -2670,5 +2685,10 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract
         public void testSingletonConstructors() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt");
         }
+
+        @TestMetadata("visibilityWithOverrides.kt")
+        public void testVisibilityWithOverrides() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt");
+        }
     }
 }

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

@@ -5,42 +5,250 @@
 
 package org.jetbrains.kotlin.fir.resolve.transformers
 
-import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirStatement
+import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.LocalClassesNavigationInfo
+import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
+import org.jetbrains.kotlin.fir.scopes.FirScope
+import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.classId
+import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
 import org.jetbrains.kotlin.fir.visitors.compose
 import org.jetbrains.kotlin.fir.visitors.transformSingle
 
 @OptIn(AdapterForResolveProcessor::class)
-class FirStatusResolveProcessor(session: FirSession, scopeSession: ScopeSession) :
-    FirTransformerBasedResolveProcessor(session, scopeSession) {
-    override val transformer = FirStatusResolveTransformer(session)
+class FirStatusResolveProcessor(
+    session: FirSession,
+    scopeSession: ScopeSession
+) : FirTransformerBasedResolveProcessor(session, scopeSession) {
+    override val transformer = run {
+        val statusComputationSession = StatusComputationSession.Regular()
+        FirStatusResolveTransformer(
+            session,
+            scopeSession,
+            statusComputationSession
+        )
+    }
 }
 
-fun <F : FirClass<F>> F.runStatusResolveForLocalClass(session: FirSession): F {
-    val transformer = FirStatusResolveTransformer(session)
+fun <F : FirClass<F>> F.runStatusResolveForLocalClass(
+    session: FirSession,
+    scopeSession: ScopeSession,
+    scopesForLocalClass: List<FirScope>,
+    localClassesNavigationInfo: LocalClassesNavigationInfo
+): F {
+    val statusComputationSession = StatusComputationSession.ForLocalClassResolution(localClassesNavigationInfo.parentForClass.keys)
+    val transformer = FirStatusResolveTransformer(
+        session,
+        scopeSession,
+        statusComputationSession,
+        localClassesNavigationInfo.parentForClass,
+        FirCompositeScope(scopesForLocalClass)
+    )
 
     return this.transform<F, Nothing?>(transformer, null).single
 }
 
-class FirStatusResolveTransformer(
-    override val session: FirSession
-) : FirAbstractTreeTransformer<FirDeclarationStatus?>(phase = FirResolvePhase.STATUS) {
-    private val classes = mutableListOf<FirClass<*>>()
+abstract class ResolvedStatusCalculator {
+    abstract fun tryCalculateResolvedStatus(declaration: FirCallableMemberDeclaration<*>): FirResolvedDeclarationStatus
 
-    private val containingClass: FirClass<*>? get() = classes.lastOrNull()
+    object Default : ResolvedStatusCalculator() {
+        override fun tryCalculateResolvedStatus(declaration: FirCallableMemberDeclaration<*>): FirResolvedDeclarationStatus {
+            val status = declaration.status
+            require(status is FirResolvedDeclarationStatus) {
+                "Status of ${declaration.render()} is unresolved"
+            }
+            return status
+        }
+    }
+}
+
+class FirStatusResolveTransformer(
+    session: FirSession,
+    scopeSession: ScopeSession,
+    statusComputationSession: StatusComputationSession,
+    designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?> = mapOf(),
+    scopeForLocalClass: FirScope? = null,
+) : AbstractFirStatusResolveTransformer(session, scopeSession, statusComputationSession, designationMapForLocalClasses, scopeForLocalClass) {
+    override fun FirDeclaration.needResolveMembers(): Boolean {
+        if (this is FirRegularClass) {
+            return statusComputationSession[this] != StatusComputationSession.StatusComputationStatus.Computed
+        }
+        return true
+    }
+
+    override fun FirDeclaration.needResolveNestedClassifiers(): Boolean {
+        return true
+    }
+
+    override fun transformRegularClass(
+        regularClass: FirRegularClass,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirStatement> {
+        val computationStatus = statusComputationSession.startComputing(regularClass)
+        forceResolveStatusesOfSupertypes(regularClass)
+        /*
+         * Status of class may be already calculated if that class was in supertypes of one of previous classes
+         */
+        if (computationStatus != StatusComputationSession.StatusComputationStatus.Computed) {
+            regularClass.transformStatus(this, statusResolver.resolveStatus(regularClass, containingClass, isLocal = false))
+        }
+        return transformClass(regularClass, data).also {
+            statusComputationSession.endComputing(regularClass)
+        }
+    }
+}
+
+private class FirDesignatedStatusResolveTransformer(
+    session: FirSession,
+    scopeSession: ScopeSession,
+    private val designation: Iterator<FirDeclaration>,
+    private val targetClass: FirClass<*>,
+    statusComputationSession: StatusComputationSession,
+    designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?>,
+    scopeForLocalClass: FirScope?,
+) : AbstractFirStatusResolveTransformer(session, scopeSession, statusComputationSession, designationMapForLocalClasses, scopeForLocalClass) {
+    private var currentElement: FirDeclaration? = null
+    private var classLocated = false
+
+    private fun shouldSkipClass(declaration: FirDeclaration): Boolean {
+        if (classLocated) return declaration != targetClass
+        if (currentElement == null && designation.hasNext()) {
+            currentElement = designation.next()
+        }
+        val result = currentElement == declaration
+        if (result) {
+            if (currentElement == targetClass) {
+                classLocated = true
+            }
+            currentElement = null
+        }
+        return false
+    }
+
+    override fun FirDeclaration.needResolveMembers(): Boolean {
+        return classLocated
+    }
+
+    override fun FirDeclaration.needResolveNestedClassifiers(): Boolean {
+        return !classLocated
+    }
+
+    override fun transformRegularClass(
+        regularClass: FirRegularClass,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirStatement> {
+        if (shouldSkipClass(regularClass)) return regularClass.compose()
+        val classLocated = this.classLocated
+        /*
+         * In designated status resolve we should resolve status only of target class and it's members
+         */
+        if (classLocated) {
+            assert(regularClass == targetClass)
+            val computationStatus = statusComputationSession.startComputing(regularClass)
+            forceResolveStatusesOfSupertypes(regularClass)
+            if (computationStatus != StatusComputationSession.StatusComputationStatus.Computed) {
+                updateResolvePhaseOfMembers(regularClass)
+                regularClass.transformStatus(this, statusResolver.resolveStatus(regularClass, containingClass, isLocal = false))
+            }
+        }
+        return transformClass(regularClass, data).also {
+            if (classLocated) statusComputationSession.endComputing(regularClass)
+        }
+    }
+}
+
+sealed class StatusComputationSession {
+    abstract operator fun get(klass: FirClass<*>): StatusComputationStatus
+
+    abstract fun startComputing(klass: FirClass<*>): StatusComputationStatus
+    abstract fun endComputing(klass: FirClass<*>)
+
+    enum class StatusComputationStatus {
+        NotComputed, Computing, Computed
+    }
+
+    class Regular : StatusComputationSession() {
+        private val statusMap = mutableMapOf<FirClass<*>, StatusComputationStatus>()
+            .withDefault { StatusComputationStatus.NotComputed }
+
+        override fun get(klass: FirClass<*>): StatusComputationStatus = statusMap.getValue(klass)
+
+        override fun startComputing(klass: FirClass<*>): StatusComputationStatus {
+            return statusMap.getOrPut(klass) { StatusComputationStatus.Computing }
+        }
+
+        override fun endComputing(klass: FirClass<*>) {
+            statusMap[klass] = StatusComputationStatus.Computed
+        }
+    }
+
+    class ForLocalClassResolution(private val localClasses: Set<FirClass<*>>) : StatusComputationSession() {
+        private val delegate = Regular()
+
+        override fun get(klass: FirClass<*>): StatusComputationStatus {
+            if (klass !in localClasses) return StatusComputationStatus.Computed
+            return delegate[klass]
+        }
+
+        override fun startComputing(klass: FirClass<*>): StatusComputationStatus {
+            return delegate.startComputing(klass)
+        }
+
+        override fun endComputing(klass: FirClass<*>) {
+            delegate.endComputing(klass)
+        }
+    }
+}
+
+abstract class AbstractFirStatusResolveTransformer(
+    final override val session: FirSession,
+    val scopeSession: ScopeSession,
+    protected val statusComputationSession: StatusComputationSession,
+    protected val designationMapForLocalClasses: Map<FirClass<*>, FirClass<*>?>,
+    private val scopeForLocalClass: FirScope?
+) : FirAbstractTreeTransformer<FirResolvedDeclarationStatus?>(phase = FirResolvePhase.STATUS) {
+    private val classes = mutableListOf<FirClass<*>>()
+    protected val statusResolver = FirStatusResolver(session, scopeSession)
+
+    protected val containingClass: FirClass<*>? get() = classes.lastOrNull()
+
+    private val firProvider = session.firProvider
+    private val symbolProvider = session.firSymbolProvider
+
+    protected abstract fun FirDeclaration.needResolveMembers(): Boolean
+    protected abstract fun FirDeclaration.needResolveNestedClassifiers(): Boolean
+
+    override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): CompositeTransformResult<FirFile> {
+        file.replaceResolvePhase(transformerPhase)
+        if (file.needResolveMembers()) {
+            for (declaration in file.declarations) {
+                if (declaration !is FirClassLikeDeclaration<*>) {
+                    declaration.transformSingle(this, data)
+                }
+            }
+        }
+        if (file.needResolveNestedClassifiers()) {
+            for (declaration in file.declarations) {
+                if (declaration is FirClassLikeDeclaration<*>) {
+                    declaration.transformSingle(this, data)
+                }
+            }
+        }
+        return file.compose()
+    }
 
     override fun transformDeclarationStatus(
         declarationStatus: FirDeclarationStatus,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclarationStatus> {
         return (data ?: declarationStatus).compose()
     }
@@ -55,7 +263,10 @@ class FirStatusResolveTransformer(
         return result
     }
 
-    override fun transformDeclaration(declaration: FirDeclaration, data: FirDeclarationStatus?): CompositeTransformResult<FirDeclaration> {
+    override fun transformDeclaration(
+        declaration: FirDeclaration,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirDeclaration> {
         declaration.replaceResolvePhase(transformerPhase)
         return when (declaration) {
             is FirCallableDeclaration<*> -> {
@@ -81,80 +292,186 @@ class FirStatusResolveTransformer(
         }
     }
 
-    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: FirDeclarationStatus?): CompositeTransformResult<FirDeclaration> {
+    override fun transformTypeAlias(
+        typeAlias: FirTypeAlias,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirDeclaration> {
         typeAlias.typeParameters.forEach { transformDeclaration(it, data) }
-        typeAlias.transformStatus(this, typeAlias.resolveStatus(typeAlias.status, containingClass, isLocal = false))
+        typeAlias.transformStatus(this, statusResolver.resolveStatus(typeAlias, containingClass, isLocal = false))
         return transformDeclaration(typeAlias, data)
     }
 
-    override fun transformRegularClass(regularClass: FirRegularClass, data: FirDeclarationStatus?): CompositeTransformResult<FirStatement> {
-        regularClass.transformStatus(this, regularClass.resolveStatus(regularClass.status, containingClass, isLocal = false))
-        @Suppress("UNCHECKED_CAST")
-        return storeClass(regularClass) {
-            regularClass.typeParameters.forEach { it.transformSingle(this, data) }
-            transformDeclaration(regularClass, data)
-        } as CompositeTransformResult<FirStatement>
-    }
+    abstract override fun transformRegularClass(
+        regularClass: FirRegularClass,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirStatement>
 
     override fun transformAnonymousObject(
         anonymousObject: FirAnonymousObject,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirStatement> {
         @Suppress("UNCHECKED_CAST")
-        return storeClass(anonymousObject) {
-            transformDeclaration(anonymousObject, data)
+        return transformClass(anonymousObject, data)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <F : FirClass<F>> transformClass(
+        klass: FirClass<F>,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirStatement> {
+        return storeClass(klass) {
+            klass.typeParameters.forEach { it.transformSingle(this, data) }
+            klass.replaceResolvePhase(transformerPhase)
+            if (klass.needResolveMembers()) {
+                val members = klass.declarations.filter { it !is FirClassLikeDeclaration<*> }
+                members.forEach { it.replaceResolvePhase(transformerPhase) }
+                members.forEach { it.transformSingle(this, data) }
+            }
+            if (klass.needResolveNestedClassifiers()) {
+                for (declaration in klass.declarations) {
+                    if (declaration is FirClassLikeDeclaration<*>) {
+                        declaration.transformSingle(this, data)
+                    }
+                }
+            }
+            klass.compose()
         } as CompositeTransformResult<FirStatement>
     }
 
+    protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) {
+        for (declaration in regularClass.declarations) {
+            if (declaration is FirProperty || declaration is FirSimpleFunction) {
+                declaration.replaceResolvePhase(transformerPhase)
+            }
+        }
+    }
+
+    protected fun forceResolveStatusesOfSupertypes(regularClass: FirRegularClass) {
+        for (superTypeRef in regularClass.superTypeRefs) {
+            forceResolveStatusOfCorrespondingClass(superTypeRef, regularClass)
+        }
+    }
+
+    private fun forceResolveStatusOfCorrespondingClass(typeRef: FirTypeRef, subClass: FirRegularClass?) {
+        val classId = typeRef.coneType.classId ?: return
+        val superClass = when {
+            classId.isLocal -> {
+                requireNotNull(subClass)
+                var parent = designationMapForLocalClasses[subClass] as? FirRegularClass
+                if (parent == null && scopeForLocalClass != null) {
+                    scopeForLocalClass.processClassifiersByName(classId.shortClassName) {
+                        if (it is FirRegularClass && it.classId == classId) {
+                            parent = it
+                        }
+                    }
+                }
+                parent
+            }
+            else -> symbolProvider.getClassLikeSymbolByFqName(classId)?.fir
+        } ?: return
+        when (superClass) {
+            is FirRegularClass -> forceResolveStatusesOfClass(superClass)
+            is FirTypeAlias -> forceResolveStatusOfCorrespondingClass(superClass.expandedTypeRef, subClass = null)
+        }
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    private fun forceResolveStatusesOfClass(regularClass: FirRegularClass) {
+        if (statusComputationSession[regularClass] == StatusComputationSession.StatusComputationStatus.Computed) return
+        val file = firProvider.getFirClassifierContainerFileIfAny(regularClass.symbol)
+        if (regularClass.status is FirResolvedDeclarationStatus) {
+            statusComputationSession.endComputing(regularClass)
+            /*
+             * If regular class has no corresponding file then it is platform class,
+             *   so we need to resolve supertypes of this class because they could
+             *   come from kotlin sources
+             */
+            if (file == null) {
+                forceResolveStatusesOfSupertypes(regularClass)
+            }
+            return
+        }
+        require(file != null)
+        val symbol = regularClass.symbol
+        var declarationToStart: FirDeclaration? = null
+        val designation = designationMapForLocalClasses[regularClass]?.let(::listOf)?.also {
+            declarationToStart = it.first()
+        } ?: buildList<FirDeclaration> {
+            val outerClasses = generateSequence(symbol.classId) { classId ->
+                classId.outerClassId
+            }.mapTo(mutableListOf()) { firProvider.getFirClassifierByFqName(it) }
+            declarationToStart = file
+            this += outerClasses.filterNotNull().asReversed()
+        }
+        if (designation.isEmpty()) return
+
+        val transformer = FirDesignatedStatusResolveTransformer(
+            session,
+            scopeSession,
+            designation.iterator(),
+            regularClass,
+            statusComputationSession,
+            designationMapForLocalClasses,
+            scopeForLocalClass
+        )
+        declarationToStart!!.transformSingle(transformer, null)
+        statusComputationSession.endComputing(regularClass)
+    }
+
     override fun transformPropertyAccessor(
         propertyAccessor: FirPropertyAccessor,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
-        propertyAccessor.transformStatus(this, propertyAccessor.resolveStatus(propertyAccessor.status, containingClass, isLocal = false))
+        propertyAccessor.transformStatus(this, statusResolver.resolveStatus(propertyAccessor, containingClass, isLocal = false))
         @Suppress("UNCHECKED_CAST")
         return transformDeclaration(propertyAccessor, data)
     }
 
     override fun transformConstructor(
         constructor: FirConstructor,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
-        constructor.transformStatus(this, constructor.resolveStatus(constructor.status, containingClass, isLocal = false))
+        constructor.transformStatus(this, statusResolver.resolveStatus(constructor, containingClass, isLocal = false))
         return transformDeclaration(constructor, data)
     }
 
     override fun transformSimpleFunction(
         simpleFunction: FirSimpleFunction,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
-        simpleFunction.transformStatus(this, simpleFunction.resolveStatus(simpleFunction.status, containingClass, isLocal = false))
+        simpleFunction.replaceResolvePhase(transformerPhase)
+        simpleFunction.transformStatus(this, statusResolver.resolveStatus(simpleFunction, containingClass, isLocal = false))
         return transformDeclaration(simpleFunction, data)
     }
 
     override fun transformProperty(
         property: FirProperty,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
-        property.transformStatus(this, property.resolveStatus(property.status, containingClass, isLocal = false))
+        property.replaceResolvePhase(transformerPhase)
+        property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false))
         return transformDeclaration(property, data)
     }
 
     override fun transformField(
         field: FirField,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
-        field.transformStatus(this, field.resolveStatus(field.status, containingClass, isLocal = false))
+        field.transformStatus(this, statusResolver.resolveStatus(field, containingClass, isLocal = false))
         return transformDeclaration(field, data)
     }
 
-    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: FirDeclarationStatus?): CompositeTransformResult<FirDeclaration> {
-        enumEntry.transformStatus(this, enumEntry.resolveStatus(enumEntry.status, containingClass, isLocal = false))
+    override fun transformEnumEntry(
+        enumEntry: FirEnumEntry,
+        data: FirResolvedDeclarationStatus?
+    ): CompositeTransformResult<FirDeclaration> {
+        enumEntry.transformStatus(this, statusResolver.resolveStatus(enumEntry, containingClass, isLocal = false))
         return transformDeclaration(enumEntry, data)
     }
 
     override fun transformValueParameter(
         valueParameter: FirValueParameter,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirStatement> {
         @Suppress("UNCHECKED_CAST")
         return transformDeclaration(valueParameter, data) as CompositeTransformResult<FirStatement>
@@ -162,91 +479,12 @@ class FirStatusResolveTransformer(
 
     override fun transformTypeParameter(
         typeParameter: FirTypeParameter,
-        data: FirDeclarationStatus?
+        data: FirResolvedDeclarationStatus?
     ): CompositeTransformResult<FirDeclaration> {
         return transformDeclaration(typeParameter, data)
     }
 
-    override fun transformBlock(block: FirBlock, data: FirDeclarationStatus?): CompositeTransformResult<FirStatement> {
+    override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): CompositeTransformResult<FirStatement> {
         return block.compose()
     }
 }
-
-private val <F : FirClass<F>> FirClass<F>.modality: Modality?
-    get() = when (this) {
-        is FirRegularClass -> status.modality
-        is FirAnonymousObject -> Modality.FINAL
-        else -> error("Unknown kind of class: ${this::class}")
-    }
-
-fun FirDeclaration.resolveStatus(
-    status: FirDeclarationStatus,
-    containingClass: FirClass<*>?,
-    isLocal: Boolean
-): FirDeclarationStatus {
-    if (status.visibility == Visibilities.Unknown || status.modality == null || status.modality == Modality.OPEN) {
-        val visibility = when (status.visibility) {
-            Visibilities.Unknown -> when {
-                isLocal -> Visibilities.Local
-                this is FirConstructor && containingClass is FirAnonymousObject -> Visibilities.Private
-                else -> resolveVisibility(containingClass)
-            }
-            else -> status.visibility
-        }
-        val modality = status.modality?.let {
-            if (it == Modality.OPEN && containingClass?.classKind == ClassKind.INTERFACE && !hasOwnBodyOrAccessorBody()) {
-                Modality.ABSTRACT
-            } else {
-                it
-            }
-        } ?: resolveModality(containingClass)
-        return (status as FirDeclarationStatusImpl).resolved(visibility, modality)
-    }
-    return status
-}
-
-private fun FirDeclaration.hasOwnBodyOrAccessorBody(): Boolean {
-    return when (this) {
-        is FirSimpleFunction -> this.body != null
-        is FirProperty -> this.initializer != null || this.getter?.body != null || this.setter?.body != null
-        else -> true
-    }
-}
-
-private fun FirDeclaration.resolveVisibility(containingClass: FirClass<*>?): Visibility {
-    // See DescriptorUtils#getDefaultConstructorVisibility in core.descriptors
-    if (this is FirConstructor) {
-        if (containingClass != null &&
-            (containingClass.classKind == ClassKind.ENUM_CLASS || containingClass.classKind == ClassKind.ENUM_ENTRY ||
-                    containingClass.modality == Modality.SEALED)
-        ) {
-            return Visibilities.Private
-        }
-    }
-    return Visibilities.Public // TODO (overrides)
-}
-
-private fun FirDeclaration.resolveModality(containingClass: FirClass<*>?): Modality {
-    return when (this) {
-        is FirRegularClass -> if (classKind == ClassKind.INTERFACE) Modality.ABSTRACT else Modality.FINAL
-        is FirCallableMemberDeclaration<*> -> {
-            when {
-                containingClass == null -> Modality.FINAL
-                containingClass.classKind == ClassKind.INTERFACE -> {
-                    when {
-                        visibility == Visibilities.Private ->
-                            Modality.FINAL
-                        !this.hasOwnBodyOrAccessorBody() ->
-                            Modality.ABSTRACT
-                        else ->
-                            Modality.OPEN
-                    }
-                }
-                else -> {
-                    if (isOverride && containingClass.modality != Modality.FINAL) Modality.OPEN else Modality.FINAL
-                }
-            }
-        }
-        else -> Modality.FINAL
-    }
-}

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

@@ -0,0 +1,209 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.resolve.transformers
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+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.impl.FirResolvedDeclarationStatusImpl
+import org.jetbrains.kotlin.fir.render
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.scopes.ProcessorAction
+import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
+
+class FirStatusResolver(
+    val session: FirSession,
+    val scopeSession: ScopeSession
+) {
+    fun resolveStatus(declaration: FirDeclaration, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return when (declaration) {
+            is FirProperty -> resolveStatus(declaration, containingClass, isLocal)
+            is FirSimpleFunction -> resolveStatus(declaration, containingClass, isLocal)
+            is FirPropertyAccessor -> resolveStatus(declaration, containingClass, isLocal)
+            is FirRegularClass -> resolveStatus(declaration, containingClass, isLocal)
+            is FirTypeAlias -> resolveStatus(declaration, containingClass, isLocal)
+            is FirConstructor -> resolveStatus(declaration, containingClass, isLocal)
+            is FirField -> resolveStatus(declaration, containingClass, isLocal)
+            else -> error("Unsupported declaration type: ${declaration.render()}")
+        }
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    fun resolveStatus(property: FirProperty, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return resolveStatus(property, property.status, containingClass, isLocal) l@{
+            if (containingClass == null) return@l emptyList()
+            buildList {
+                val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
+                scope.processPropertiesByName(property.name) {}
+                scope.processDirectOverriddenPropertiesWithBaseScope(property.symbol) { symbol, _ ->
+                    this += symbol.fir
+                    ProcessorAction.NEXT
+                }
+            }.map {
+                it.status as FirResolvedDeclarationStatus
+            }
+        }
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    fun resolveStatus(function: FirSimpleFunction, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return resolveStatus(function, function.status, containingClass, isLocal) l@{
+            if (containingClass == null) return@l emptyList()
+            buildList {
+                val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
+                scope.processFunctionsByName(function.name) {}
+                scope
+                    .processDirectOverriddenFunctionsWithBaseScope(function.symbol) { symbol, _ ->
+                        (symbol.fir as? FirCallableMemberDeclaration<*>)?.let {
+                            this += it
+                        }
+                        ProcessorAction.NEXT
+                    }
+            }.mapNotNull {
+                it.status as? FirResolvedDeclarationStatus
+            }
+        }
+    }
+
+    fun resolveStatus(
+        regularClass: FirRegularClass,
+        containingClass: FirClass<*>?,
+        isLocal: Boolean
+    ): FirResolvedDeclarationStatus {
+        return resolveStatus(regularClass, regularClass.status, containingClass, isLocal) { emptyList() }
+    }
+
+    fun resolveStatus(
+        typeAlias: FirTypeAlias,
+        containingClass: FirClass<*>?,
+        isLocal: Boolean
+    ): FirResolvedDeclarationStatus {
+        return resolveStatus(typeAlias, typeAlias.status, containingClass, isLocal) { emptyList() }
+    }
+
+    fun resolveStatus(
+        propertyAccessor: FirPropertyAccessor,
+        containingClass: FirClass<*>?,
+        isLocal: Boolean
+    ): FirResolvedDeclarationStatus {
+        return resolveStatus(propertyAccessor, propertyAccessor.status, containingClass, isLocal) { emptyList() }
+    }
+
+    fun resolveStatus(constructor: FirConstructor, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return resolveStatus(constructor, constructor.status, containingClass, isLocal) { emptyList() }
+    }
+
+    fun resolveStatus(field: FirField, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return resolveStatus(field, field.status, containingClass, isLocal) { emptyList() }
+    }
+
+    fun resolveStatus(enumEntry: FirEnumEntry, containingClass: FirClass<*>?, isLocal: Boolean): FirResolvedDeclarationStatus {
+        return resolveStatus(enumEntry, enumEntry.status, containingClass, isLocal) { emptyList() }
+    }
+
+    private inline fun resolveStatus(
+        declaration: FirDeclaration,
+        status: FirDeclarationStatus,
+        containingClass: FirClass<*>?,
+        isLocal: Boolean,
+        overriddenExtractor: () -> List<FirResolvedDeclarationStatus>
+    ): FirResolvedDeclarationStatus {
+        if (status is FirResolvedDeclarationStatus) return status
+        require(status is FirDeclarationStatusImpl)
+
+        @Suppress("UNCHECKED_CAST")
+        val overriddenStatuses = overriddenExtractor() as List<FirResolvedDeclarationStatusImpl>
+        val visibility = when (status.visibility) {
+            Visibilities.Unknown -> when {
+                isLocal -> Visibilities.Local
+                declaration is FirConstructor && containingClass is FirAnonymousObject -> Visibilities.Private
+                else -> resolveVisibility(declaration, containingClass, overriddenStatuses)
+            }
+            else -> status.visibility
+        }
+
+        val modality = status.modality?.let {
+            if (it == Modality.OPEN && containingClass?.classKind == ClassKind.INTERFACE && !declaration.hasOwnBodyOrAccessorBody()) {
+                Modality.ABSTRACT
+            } else {
+                it
+            }
+        } ?: resolveModality(declaration, containingClass)
+        if (overriddenStatuses.isNotEmpty()) {
+            for (modifier in FirDeclarationStatusImpl.Modifier.values()) {
+                status[modifier] = status[modifier] || overriddenStatuses.fold(false) { acc, overriddenStatus ->
+                    acc || overriddenStatus[modifier]
+                }
+            }
+        }
+        return status.resolved(visibility, modality)
+    }
+
+    private fun resolveVisibility(
+        declaration: FirDeclaration,
+        containingClass: FirClass<*>?,
+        overriddenStatuses: List<FirResolvedDeclarationStatusImpl>
+    ): Visibility {
+        if (declaration is FirConstructor && containingClass != null) {
+            val classKind = containingClass.classKind
+            if ((classKind == ClassKind.ENUM_CLASS || classKind == ClassKind.ENUM_ENTRY || containingClass.modality == Modality.SEALED)) {
+                return Visibilities.Private
+            }
+        }
+        return overriddenStatuses.map { it.visibility }
+            .maxWithOrNull { v1, v2 -> Visibilities.compare(v1, v2) ?: -1 }
+            ?.normalize()
+            ?: Visibilities.Public
+    }
+
+    private fun resolveModality(
+        declaration: FirDeclaration,
+        containingClass: FirClass<*>?,
+    ): Modality {
+        return when (declaration) {
+            is FirRegularClass -> if (declaration.classKind == ClassKind.INTERFACE) Modality.ABSTRACT else Modality.FINAL
+            is FirCallableMemberDeclaration<*> -> {
+                when {
+                    containingClass == null -> Modality.FINAL
+                    containingClass.classKind == ClassKind.INTERFACE -> {
+                        when {
+                            declaration.visibility == Visibilities.Private ->
+                                Modality.FINAL
+                            !declaration.hasOwnBodyOrAccessorBody() ->
+                                Modality.ABSTRACT
+                            else ->
+                                Modality.OPEN
+                        }
+                    }
+                    else -> {
+                        if (declaration.isOverride && containingClass.modality != Modality.FINAL) Modality.OPEN else Modality.FINAL
+                    }
+                }
+            }
+            else -> Modality.FINAL
+        }
+
+    }
+}
+
+private val <F : FirClass<F>> FirClass<F>.modality: Modality?
+    get() = when (this) {
+        is FirRegularClass -> status.modality
+        is FirAnonymousObject -> Modality.FINAL
+        else -> error("Unknown kind of class: ${this::class}")
+    }
+
+private fun FirDeclaration.hasOwnBodyOrAccessorBody(): Boolean {
+    return when (this) {
+        is FirSimpleFunction -> this.body != null
+        is FirProperty -> this.initializer != null || this.getter?.body != null || this.setter?.body != null
+        else -> true
+    }
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) : FirPartialBodyResolveTransformer(transformer) {
     private var containingClass: FirRegularClass? = null
+    private val statusResolver: FirStatusResolver = FirStatusResolver(session, scopeSession)
 
     private inline fun <T> withFirArrayOfCallTransformer(block: () -> T): T {
         transformer.expressionsTransformer.enableArrayOfCallTransformation = true
@@ -329,8 +330,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
 
     private fun FirDeclaration.resolveStatus(status: FirDeclarationStatus, containingClass: FirClass<*>? = null): FirDeclarationStatus {
         val containingDeclaration = context.containerIfAny
-        return resolveStatus(
-            status, containingClass as? FirRegularClass, isLocal = containingDeclaration != null && containingClass == null
+        return statusResolver.resolveStatus(
+            this,
+            containingClass as? FirRegularClass,
+            isLocal = containingDeclaration != null && containingClass == null
         )
     }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt

@@ -38,7 +38,12 @@ fun <F : FirClass<F>> F.runAllPhasesForLocalClass(
         components.scopeSession,
         components.createCurrentScopeList()
     )
-    runStatusResolveForLocalClass(components.session)
+    runStatusResolveForLocalClass(
+        components.session,
+        components.scopeSession,
+        components.createCurrentScopeList(),
+        localClassesNavigationInfo
+    )
     runContractAndBodiesResolutionForLocalClass(components, resolutionMode, localClassesNavigationInfo)
     return this
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl.Modifier.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -21,9 +22,9 @@ open class FirDeclarationStatusImpl(
     override val source: FirSourceElement? get() = null
     protected var flags: Int = 0
 
-    private operator fun get(modifier: Modifier): Boolean = (flags and modifier.mask) != 0
+    operator fun get(modifier: Modifier): Boolean = (flags and modifier.mask) != 0
 
-    private operator fun set(modifier: Modifier, value: Boolean) {
+    operator fun set(modifier: Modifier, value: Boolean) {
         flags = if (value) {
             flags or modifier.mask
         } else {
@@ -139,7 +140,7 @@ open class FirDeclarationStatusImpl(
             this[FUN] = value
         }
 
-    private enum class Modifier(val mask: Int) {
+    enum class Modifier(val mask: Int) {
         EXPECT(0x1),
         ACTUAL(0x2),
         OVERRIDE(0x4),

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticPropertyBuilder.kt

@@ -22,7 +22,7 @@ class FirSyntheticPropertyBuilder {
 
     fun build(): FirSyntheticProperty = FirSyntheticProperty(
         session, name, isVar = delegateSetter != null, symbol = symbol,
-        status = FirDeclarationStatusImpl(delegateGetter.visibility, delegateGetter.modality),
+        status = delegateGetter.status,
         resolvePhase = delegateGetter.resolvePhase,
         getter = FirSyntheticPropertyAccessor(delegateGetter, isGetter = true),
         setter = delegateSetter?.let { FirSyntheticPropertyAccessor(it, isGetter = false) }
@@ -30,4 +30,4 @@ class FirSyntheticPropertyBuilder {
 }
 
 fun buildSyntheticProperty(f: FirSyntheticPropertyBuilder.() -> Unit): FirSyntheticProperty =
-    FirSyntheticPropertyBuilder().apply { f() }.build()
+    FirSyntheticPropertyBuilder().apply { f() }.build()

compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.fir.kt

@@ -35,7 +35,7 @@ class G : F() {
 }
 
 fun test_fun_stays_protected(g: G) {
-    g.protected_fun()
+    g.<!HIDDEN!>protected_fun<!>()
 }
 
 //------------
@@ -82,4 +82,4 @@ interface Q : R {
 
 class S : P, Q {
     internal override fun foo() {}
-}
+}

compiler/testData/diagnostics/tests/scopes/kt151.fir.kt

@@ -10,7 +10,7 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.x()
+    b.<!HIDDEN!>x<!>()
 }
 
 
@@ -37,4 +37,4 @@ class F : C(), T {
 
 class G : C(), T {
     public override fun foo() {}
-}
+}

compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.fir.kt

@@ -40,7 +40,7 @@ class KotlinClass2 : JavaClass() {
 
 fun test(a: KotlinClass, b: KotlinClass2) {
     a.<!HIDDEN!>foo<!>() // Error, protected_and_package declared in different package
-    b.foo() // Error, protected visibility in same package (but could be protected_and_package)
+    b.<!HIDDEN!>foo<!>() // Error, protected visibility in same package (but could be protected_and_package)
 
     a.<!HIDDEN!>field<!>
 

compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.fir.kt

@@ -5,7 +5,7 @@ open class A {
     fun bar(x: B) {
         x.foo() // OK, foo declared in A
         x.<!HIDDEN!>baz<!>() // Declared in B
-        x.foobaz() // Declared in B
+        x.<!HIDDEN!>foobaz<!>() // Declared in B
     }
 }
 

compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.txt

@@ -95,13 +95,13 @@ FILE fqName:<root> fileName:/inlineCollectionOfInlineClass.kt
             CALL 'public abstract fun <get-size> (): kotlin.Int declared in kotlin.collections.Set' type=kotlin.Int origin=GET_PROPERTY
               $this: CALL 'private final fun <get-ms> (): kotlin.collections.MutableSet<<root>.IT> declared in <root>.InlineMutableSet' type=kotlin.collections.MutableSet<<root>.IT> origin=GET_PROPERTY
                 $this: GET_VAR '<this>: <root>.InlineMutableSet declared in <root>.InlineMutableSet.<get-size>' type=<root>.InlineMutableSet origin=null
-    FUN name:contains visibility:public modality:FINAL <> ($this:<root>.InlineMutableSet, element:<root>.IT) returnType:kotlin.Boolean
+    FUN name:contains visibility:public modality:FINAL <> ($this:<root>.InlineMutableSet, element:<root>.IT) returnType:kotlin.Boolean [operator]
       overridden:
         public abstract fun contains (element: E of kotlin.collections.Set): kotlin.Boolean [operator] declared in kotlin.collections.Set
       $this: VALUE_PARAMETER name:<this> type:<root>.InlineMutableSet
       VALUE_PARAMETER name:element index:0 type:<root>.IT
       BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun contains (element: <root>.IT): kotlin.Boolean declared in <root>.InlineMutableSet'
+        RETURN type=kotlin.Nothing from='public final fun contains (element: <root>.IT): kotlin.Boolean [operator] declared in <root>.InlineMutableSet'
           CALL 'public abstract fun contains (element: E of kotlin.collections.MutableSet): kotlin.Boolean [fake_override,operator] declared in kotlin.collections.MutableSet' type=kotlin.Boolean origin=null
             $this: CALL 'private final fun <get-ms> (): kotlin.collections.MutableSet<<root>.IT> declared in <root>.InlineMutableSet' type=kotlin.collections.MutableSet<<root>.IT> origin=GET_PROPERTY
               $this: GET_VAR '<this>: <root>.InlineMutableSet declared in <root>.InlineMutableSet.contains' type=<root>.InlineMutableSet origin=null
@@ -157,12 +157,12 @@ FILE fqName:<root> fileName:/inlineCollectionOfInlineClass.kt
         CALL 'public abstract fun clear (): kotlin.Unit declared in kotlin.collections.MutableSet' type=kotlin.Unit origin=null
           $this: CALL 'private final fun <get-ms> (): kotlin.collections.MutableSet<<root>.IT> declared in <root>.InlineMutableSet' type=kotlin.collections.MutableSet<<root>.IT> origin=GET_PROPERTY
             $this: GET_VAR '<this>: <root>.InlineMutableSet declared in <root>.InlineMutableSet.clear' type=<root>.InlineMutableSet origin=null
-    FUN name:iterator visibility:public modality:FINAL <> ($this:<root>.InlineMutableSet) returnType:kotlin.collections.MutableIterator<<root>.IT>
+    FUN name:iterator visibility:public modality:FINAL <> ($this:<root>.InlineMutableSet) returnType:kotlin.collections.MutableIterator<<root>.IT> [operator]
       overridden:
         public abstract fun iterator (): kotlin.collections.MutableIterator<E of kotlin.collections.MutableSet> [operator] declared in kotlin.collections.MutableSet
       $this: VALUE_PARAMETER name:<this> type:<root>.InlineMutableSet
       BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.MutableIterator<<root>.IT> declared in <root>.InlineMutableSet'
+        RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.MutableIterator<<root>.IT> [operator] declared in <root>.InlineMutableSet'
           CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator<E of kotlin.collections.MutableSet> [operator] declared in kotlin.collections.MutableSet' type=kotlin.collections.MutableIterator<<root>.IT> origin=null
             $this: CALL 'private final fun <get-ms> (): kotlin.collections.MutableSet<<root>.IT> declared in <root>.InlineMutableSet' type=kotlin.collections.MutableSet<<root>.IT> origin=GET_PROPERTY
               $this: GET_VAR '<this>: <root>.InlineMutableSet declared in <root>.InlineMutableSet.iterator' type=<root>.InlineMutableSet origin=null

compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.txt

@@ -232,14 +232,14 @@ FILE fqName:<root> fileName:/genericDelegatedDeepProperty.kt
                         BLOCK_BODY
                           DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
                           INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:<no name provided> modality:FINAL visibility:local superTypes:[<root>.IDelegate1<<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, T of <root>.<get-additionalText>>]'
-                      FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:T of <root>.<get-additionalText>
+                      FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:T of <root>.<get-additionalText> [operator]
                         overridden:
                           public abstract fun getValue (t: T1 of <root>.IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of <root>.IDelegate1 [operator] declared in <root>.IDelegate1
                         $this: VALUE_PARAMETER name:<this> type:<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>>
                         VALUE_PARAMETER name:t index:0 type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
                         VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*>
                         BLOCK_BODY
-                          RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>'
+                          RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> [operator] declared in <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>'
                             CALL 'public final fun <get-value1> (): T of <root>.Value declared in <root>.Value' type=T of <root>.<get-additionalText> origin=GET_PROPERTY
                               $this: GET_VAR 't: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> declared in <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>.getValue' type=<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> origin=null
                       FUN name:qux21 visibility:public modality:FINAL <F21T> ($this:<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>>, t:F21T of <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>.qux21) returnType:F21T of <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>.qux21
@@ -277,7 +277,7 @@ FILE fqName:<root> fileName:/genericDelegatedDeepProperty.kt
                 $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
                 BLOCK_BODY
                   RETURN type=kotlin.Nothing from='public final fun <get-deepO> (): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>'
-                    CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>' type=T of <root>.<get-additionalText> origin=null
+                    CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> [operator] declared in <root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided>' type=T of <root>.<get-additionalText> origin=null
                       $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:deepO$delegate type:<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>> visibility:private [final]' type=<root>.additionalText$delegate.<no name provided>.deepO$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
                         receiver: GET_VAR '<this>: <root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>.<get-deepO>' type=<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
                       t: GET_VAR '<this>: <root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>.<get-deepO>' type=<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
@@ -292,14 +292,14 @@ FILE fqName:<root> fileName:/genericDelegatedDeepProperty.kt
                         BLOCK_BODY
                           DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
                           INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:<no name provided> modality:FINAL visibility:local superTypes:[<root>.IDelegate1<<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, T of <root>.<get-additionalText>>]'
-                      FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:T of <root>.<get-additionalText>
+                      FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:T of <root>.<get-additionalText> [operator]
                         overridden:
                           public abstract fun getValue (t: T1 of <root>.IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of <root>.IDelegate1 [operator] declared in <root>.IDelegate1
                         $this: VALUE_PARAMETER name:<this> type:<root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided><T of <root>.<get-additionalText>>
                         VALUE_PARAMETER name:t index:0 type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
                         VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*>
                         BLOCK_BODY
-                          RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided>'
+                          RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> [operator] declared in <root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided>'
                             CALL 'public final fun foo (): R of <root>.CR declared in <root>.CR' type=T of <root>.<get-additionalText> origin=null
                               $this: CALL 'public final fun <get-value2> (): IT of <root>.Value declared in <root>.Value' type=<root>.CR<T of <root>.<get-additionalText>> origin=GET_PROPERTY
                                 $this: GET_VAR 't: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> declared in <root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided>.getValue' type=<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> origin=null
@@ -323,19 +323,19 @@ FILE fqName:<root> fileName:/genericDelegatedDeepProperty.kt
                 $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
                 BLOCK_BODY
                   RETURN type=kotlin.Nothing from='public final fun <get-deepK> (): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>'
-                    CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided>' type=T of <root>.<get-additionalText> origin=null
+                    CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): T of <root>.<get-additionalText> [operator] declared in <root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided>' type=T of <root>.<get-additionalText> origin=null
                       $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:deepK$delegate type:<root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided><T of <root>.<get-additionalText>> visibility:private [final]' type=<root>.additionalText$delegate.<no name provided>.deepK$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
                         receiver: GET_VAR '<this>: <root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>.<get-deepK>' type=<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
                       t: GET_VAR '<this>: <root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>.<get-deepK>' type=<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
                       p: PROPERTY_REFERENCE 'private final deepK: T of <root>.<get-additionalText> [delegated,val]' field=null getter='public final fun <get-deepK> (): T of <root>.<get-additionalText> declared in <root>.additionalText$delegate.<no name provided>' setter=null type=kotlin.reflect.KProperty2<<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, *, T of <root>.<get-additionalText>> origin=PROPERTY_REFERENCE_FOR_DELEGATE
-            FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:<root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>>
+            FUN name:getValue visibility:public modality:FINAL <> ($this:<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>>, t:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p:kotlin.reflect.KProperty<*>) returnType:<root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> [operator]
               overridden:
                 public abstract fun getValue (t: T1 of <root>.IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of <root>.IDelegate1 [operator] declared in <root>.IDelegate1
               $this: VALUE_PARAMETER name:<this> type:<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>>
               VALUE_PARAMETER name:t index:0 type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
               VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*>
               BLOCK_BODY
-                RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>'
+                RETURN type=kotlin.Nothing from='public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> [operator] declared in <root>.additionalText$delegate.<no name provided>'
                   CONSTRUCTOR_CALL 'public constructor <init> (p1: P1 of <root>.P, p2: P2 of <root>.P) [primary] declared in <root>.P' type=<root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> origin=null
                     <class: P1>: T of <root>.<get-additionalText>
                     <class: P2>: T of <root>.<get-additionalText>
@@ -365,7 +365,7 @@ FILE fqName:<root> fileName:/genericDelegatedDeepProperty.kt
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-additionalText> <T> (): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> declared in <root>'
-          CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> declared in <root>.additionalText$delegate.<no name provided>' type=<root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> origin=null
+          CALL 'public final fun getValue (t: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, p: kotlin.reflect.KProperty<*>): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> [operator] declared in <root>.additionalText$delegate.<no name provided>' type=<root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> origin=null
             $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:additionalText$delegate type:<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> visibility:private [final,static]' type=<root>.additionalText$delegate.<no name provided><T of <root>.<get-additionalText>> origin=null
             t: GET_VAR '<this>: <root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> declared in <root>.<get-additionalText>' type=<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>> origin=null
             p: PROPERTY_REFERENCE 'public final additionalText: <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> [delegated,val]' field=null getter='public final fun <get-additionalText> <T> (): <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>> declared in <root>' setter=null type=kotlin.reflect.KProperty1<<root>.Value<T of <root>.<get-additionalText>, <root>.CR<T of <root>.<get-additionalText>>>, <root>.P<T of <root>.<get-additionalText>, T of <root>.<get-additionalText>>> origin=PROPERTY_REFERENCE_FOR_DELEGATE

compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt

@@ -17,13 +17,13 @@ FILE fqName:<root> fileName:/implicitNotNullOnPlatformType.kt
         BLOCK_BODY
           RETURN type=kotlin.Nothing from='public final fun <get-size> (): kotlin.Int declared in <root>.MySet'
             CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null
-    FUN name:contains visibility:public modality:FINAL <> ($this:<root>.MySet, element:kotlin.String) returnType:kotlin.Boolean
+    FUN name:contains visibility:public modality:FINAL <> ($this:<root>.MySet, element:kotlin.String) returnType:kotlin.Boolean [operator]
       overridden:
         public abstract fun contains (element: E of kotlin.collections.Set): kotlin.Boolean [operator] declared in kotlin.collections.Set
       $this: VALUE_PARAMETER name:<this> type:<root>.MySet
       VALUE_PARAMETER name:element index:0 type:kotlin.String
       BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun contains (element: kotlin.String): kotlin.Boolean declared in <root>.MySet'
+        RETURN type=kotlin.Nothing from='public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in <root>.MySet'
           CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null
     FUN name:containsAll visibility:public modality:FINAL <> ($this:<root>.MySet, elements:kotlin.collections.Collection<kotlin.String>) returnType:kotlin.Boolean
       overridden:
@@ -40,12 +40,12 @@ FILE fqName:<root> fileName:/implicitNotNullOnPlatformType.kt
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun isEmpty (): kotlin.Boolean declared in <root>.MySet'
           CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null
-    FUN name:iterator visibility:public modality:FINAL <> ($this:<root>.MySet) returnType:kotlin.collections.Iterator<kotlin.String>
+    FUN name:iterator visibility:public modality:FINAL <> ($this:<root>.MySet) returnType:kotlin.collections.Iterator<kotlin.String> [operator]
       overridden:
         public abstract fun iterator (): kotlin.collections.Iterator<E of kotlin.collections.Set> [operator] declared in kotlin.collections.Set
       $this: VALUE_PARAMETER name:<this> type:<root>.MySet
       BLOCK_BODY
-        RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.Iterator<kotlin.String> declared in <root>.MySet'
+        RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.Iterator<kotlin.String> [operator] declared in <root>.MySet'
           CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
@@ -70,10 +70,10 @@ FILE fqName:<root> fileName:/implicitNotNullOnPlatformType.kt
     VALUE_PARAMETER name:m index:0 type:<root>.MySet
     BLOCK_BODY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit
-        CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean declared in <root>.MySet' type=kotlin.Boolean origin=null
+        CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in <root>.MySet' type=kotlin.Boolean origin=null
           $this: GET_VAR 'm: <root>.MySet declared in <root>.testContains' type=<root>.MySet origin=null
           element: GET_FIELD 'FIELD IR_EXTERNAL_JAVA_DECLARATION_STUB name:STRING type:kotlin.String? visibility:public [static]' type=kotlin.String? origin=GET_PROPERTY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit
-        CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean declared in <root>.MySet' type=kotlin.Boolean origin=null
+        CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in <root>.MySet' type=kotlin.Boolean origin=null
           $this: GET_VAR 'm: <root>.MySet declared in <root>.testContains' type=<root>.MySet origin=null
           element: CONST String type=kotlin.String value="abc"

compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.fir.kt

@@ -41,12 +41,12 @@ class Case1 : AbstractClassCase1(){
 fun case1(){
     val a = Case1()
     a.<!HIDDEN!>priv<!>()
-    a.prot()
+    a.<!HIDDEN!>prot<!>()
     a.int()
     a.pub()
 
     a.<!HIDDEN!>priv1<!>
-    a.prot1
+    a.<!HIDDEN!>prot1<!>
     a.int1
     a.pub1
 }
@@ -60,12 +60,12 @@ import base.*
 fun case2() {
     val a = Case1()
     a.<!HIDDEN!>priv<!>()
-    a.prot()
-    a.int()
+    a.<!HIDDEN!>prot<!>()
+    a.<!HIDDEN!>int<!>()
     a.pub()
 
     a.<!HIDDEN!>priv1<!>
-    a.prot1
-    a.int1
+    a.<!HIDDEN!>prot1<!>
+    a.<!HIDDEN!>int1<!>
     a.pub1
 }

idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve/delegates.txt

@@ -11,11 +11,11 @@ FILE: delegates.kt
             super<R|kotlin/Any|>()
         }
 
-        public final override [BODY_RESOLVE] fun getValue(thisRef: R|kotlin/Any?|, property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
+        public final override operator [BODY_RESOLVE] fun getValue(thisRef: R|kotlin/Any?|, property: R|kotlin/reflect/KProperty<*>|): R|kotlin/Int| {
             ^getValue Int(1)
         }
 
-        public final override [BODY_RESOLVE] fun setValue(thisRef: R|kotlin/Any?|, property: R|kotlin/reflect/KProperty<*>|, value: R|kotlin/Int|): R|kotlin/Unit| {
+        public final override operator [BODY_RESOLVE] fun setValue(thisRef: R|kotlin/Any?|, property: R|kotlin/reflect/KProperty<*>|, value: R|kotlin/Int|): R|kotlin/Unit| {
         }
 
     }