diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt index 13afe98f238..ac36f03e9f6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt @@ -15,5 +15,5 @@ class B : A() { } fun test(b: B) { - b.foo("") -} \ No newline at end of file + b.foo("") +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.txt b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.txt index 927f817f32c..d7f884af2c3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.txt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.txt @@ -4,11 +4,11 @@ FILE: main.kt super() } - 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|/b|.R|/B.foo|(String()) + R|/b|.#(String()) } diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.txt b/compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.txt index c50d37d7cce..c7d0deef600 100644 --- a/compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.txt +++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.txt @@ -6,7 +6,7 @@ FILE: superAny.kt super() } - 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.equals|(R|/other|) } @@ -20,7 +20,7 @@ FILE: superAny.kt super() } - 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.equals|(R|/other|) } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.txt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.txt index b7dc86d0459..cc2c5561ba4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.txt +++ b/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| diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.txt b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.txt index fa5dd7d7f94..8f6ea06016b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.txt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.txt @@ -100,7 +100,7 @@ FILE: protectedVisibility.kt super|>(Int(1)) } - public final override fun foo(): R|kotlin/Int| { + protected final override fun foo(): R|kotlin/Int| { ^foo this@R|/DerivedGeneric|.super|>.R|FakeOverride|() } diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.txt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.txt index 752aa08b62f..17492a1ade3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.txt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.txt @@ -18,11 +18,11 @@ FILE: typeParameters.kt super|>() } - 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|): R|List| { + public final override infix fun concat(other: R|List|): R|List| { ^concat this@R|/SomeList| } diff --git a/compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt b/compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt new file mode 100644 index 00000000000..49aa4b9362c --- /dev/null +++ b/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() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.txt b/compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.txt new file mode 100644 index 00000000000..6eb66459902 --- /dev/null +++ b/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() + } + + 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|/c|.R|/A.foo|() + } diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt new file mode 100644 index 00000000000..76f4d0ec326 --- /dev/null +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt @@ -0,0 +1,15 @@ +interface Common { + fun foo(value: T, producer: (T) -> R): R +} + +class C : B, A { + override fun foo(value: T, producer: (T) -> R): R = null!! +} + +interface A : Common { + override fun foo(value: T, producer: (T) -> R): R = null!! +} + +interface B : Common { + override fun foo(value: T, producer: (T) -> R) = producer(value) +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.txt b/compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.txt new file mode 100644 index 00000000000..ed2a56aa8bd --- /dev/null +++ b/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 foo(value: R|T|, producer: R|(T) -> R|): R|R| + + } + public final class C : R|B|, R|A| { + public constructor(): R|C| { + super() + } + + public final override fun foo(value: R|T|, producer: R|(T) -> R|): R|R| { + ^foo Null(null)!! + } + + } + public abstract interface A : R|Common| { + public open override fun foo(value: R|T|, producer: R|(T) -> R|): R|R| { + ^foo Null(null)!! + } + + } + public abstract interface B : R|Common| { + public open override fun foo(value: R|T|, producer: R|(T) -> R|): R|R| { + ^foo R|/producer|.R|FakeOverride|(R|/value|) + } + + } diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt new file mode 100644 index 00000000000..b3d82ce2e10 --- /dev/null +++ b/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() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.txt b/compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.txt new file mode 100644 index 00000000000..7771cae10cf --- /dev/null +++ b/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() + } + + public final override fun foo(): R|kotlin/Unit| { + } + + } +FILE: A.kt + public abstract class A : R|kotlin/Any| { + public constructor(): R|A| { + super() + } + + public abstract fun foo(): R|kotlin/Unit| + + } diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt new file mode 100644 index 00000000000..9e5875af43c --- /dev/null +++ b/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 foo "hello" // should be an error +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.txt b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.txt new file mode 100644 index 00000000000..ecea6465bbb --- /dev/null +++ b/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() + } + + 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() + } + + 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|/b|.#(String(hello)) + } diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.txt index 843be7a9185..3937029ee7d 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.txt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates/delegateWithAnonymousObject.txt @@ -28,11 +28,11 @@ FILE: delegateWithAnonymousObject.kt super() } - 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|/value|) } diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.txt index 7a456c8bb4c..25d580410b7 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.txt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.txt @@ -14,7 +14,7 @@ FILE: functionX.kt super() } - 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| { } } diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/smartSet.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/smartSet.txt index 89352ac84bb..042dad07fbd 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/smartSet.txt +++ b/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| { + public final override operator fun iterator(): R|kotlin/collections/MutableIterator| { ^iterator R|kotlin/TODO|() } diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java index c14e5774362..8b44fb18910 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java +++ b/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"); + } } } diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java index d17905f8c3d..d0232441e28 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java +++ b/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"); + } } } diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java index 9cc6c71c74a..1aed7329553 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java +++ b/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"); + } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index f4a03aece78..3a927153003 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/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.runStatusResolveForLocalClass(session: FirSession): F { - val transformer = FirStatusResolveTransformer(session) +fun > F.runStatusResolveForLocalClass( + session: FirSession, + scopeSession: ScopeSession, + scopesForLocalClass: List, + localClassesNavigationInfo: LocalClassesNavigationInfo +): F { + val statusComputationSession = StatusComputationSession.ForLocalClassResolution(localClassesNavigationInfo.parentForClass.keys) + val transformer = FirStatusResolveTransformer( + session, + scopeSession, + statusComputationSession, + localClassesNavigationInfo.parentForClass, + FirCompositeScope(scopesForLocalClass) + ) return this.transform(transformer, null).single } -class FirStatusResolveTransformer( - override val session: FirSession -) : FirAbstractTreeTransformer(phase = FirResolvePhase.STATUS) { - private val classes = mutableListOf>() +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<*>?> = 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 { + 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, + private val targetClass: FirClass<*>, + statusComputationSession: StatusComputationSession, + designationMapForLocalClasses: Map, 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 { + 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, 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>) : 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<*>?>, + private val scopeForLocalClass: FirScope? +) : FirAbstractTreeTransformer(phase = FirResolvePhase.STATUS) { + private val classes = mutableListOf>() + 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 { + 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 { return (data ?: declarationStatus).compose() } @@ -55,7 +263,10 @@ class FirStatusResolveTransformer( return result } - override fun transformDeclaration(declaration: FirDeclaration, data: FirDeclarationStatus?): CompositeTransformResult { + override fun transformDeclaration( + declaration: FirDeclaration, + data: FirResolvedDeclarationStatus? + ): CompositeTransformResult { declaration.replaceResolvePhase(transformerPhase) return when (declaration) { is FirCallableDeclaration<*> -> { @@ -81,80 +292,186 @@ class FirStatusResolveTransformer( } } - override fun transformTypeAlias(typeAlias: FirTypeAlias, data: FirDeclarationStatus?): CompositeTransformResult { + override fun transformTypeAlias( + typeAlias: FirTypeAlias, + data: FirResolvedDeclarationStatus? + ): CompositeTransformResult { 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 { - 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 - } + abstract override fun transformRegularClass( + regularClass: FirRegularClass, + data: FirResolvedDeclarationStatus? + ): CompositeTransformResult override fun transformAnonymousObject( anonymousObject: FirAnonymousObject, - data: FirDeclarationStatus? + data: FirResolvedDeclarationStatus? ): CompositeTransformResult { @Suppress("UNCHECKED_CAST") - return storeClass(anonymousObject) { - transformDeclaration(anonymousObject, data) + return transformClass(anonymousObject, data) + } + + @Suppress("UNCHECKED_CAST") + override fun > transformClass( + klass: FirClass, + data: FirResolvedDeclarationStatus? + ): CompositeTransformResult { + 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 } + 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 { + 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 { - 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 { - 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 { - 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 { - 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 { - 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 { - enumEntry.transformStatus(this, enumEntry.resolveStatus(enumEntry.status, containingClass, isLocal = false)) + override fun transformEnumEntry( + enumEntry: FirEnumEntry, + data: FirResolvedDeclarationStatus? + ): CompositeTransformResult { + enumEntry.transformStatus(this, statusResolver.resolveStatus(enumEntry, containingClass, isLocal = false)) return transformDeclaration(enumEntry, data) } override fun transformValueParameter( valueParameter: FirValueParameter, - data: FirDeclarationStatus? + data: FirResolvedDeclarationStatus? ): CompositeTransformResult { @Suppress("UNCHECKED_CAST") return transformDeclaration(valueParameter, data) as CompositeTransformResult @@ -162,91 +479,12 @@ class FirStatusResolveTransformer( override fun transformTypeParameter( typeParameter: FirTypeParameter, - data: FirDeclarationStatus? + data: FirResolvedDeclarationStatus? ): CompositeTransformResult { return transformDeclaration(typeParameter, data) } - override fun transformBlock(block: FirBlock, data: FirDeclarationStatus?): CompositeTransformResult { + override fun transformBlock(block: FirBlock, data: FirResolvedDeclarationStatus?): CompositeTransformResult { return block.compose() } } - -private val > FirClass.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 - } -} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt new file mode 100644 index 00000000000..e6140641054 --- /dev/null +++ b/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 { + if (status is FirResolvedDeclarationStatus) return status + require(status is FirDeclarationStatusImpl) + + @Suppress("UNCHECKED_CAST") + val overriddenStatuses = overriddenExtractor() as List + 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 + ): 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 > FirClass.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 + } +} diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 87192756d6b..36b97e91216 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/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 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 ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt index af0980bfe83..2fcdce4887e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/LocalClassesResolution.kt @@ -38,7 +38,12 @@ fun > F.runAllPhasesForLocalClass( components.scopeSession, components.createCurrentScopeList() ) - runStatusResolveForLocalClass(components.session) + runStatusResolveForLocalClass( + components.session, + components.scopeSession, + components.createCurrentScopeList(), + localClassesNavigationInfo + ) runContractAndBodiesResolutionForLocalClass(components, resolutionMode, localClassesNavigationInfo) return this } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt index 5330639f5d5..c56ccc8f62a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt +++ b/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), diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticPropertyBuilder.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticPropertyBuilder.kt index d675d2c9ceb..6f0ee2f0fa3 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticPropertyBuilder.kt +++ b/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() \ No newline at end of file + FirSyntheticPropertyBuilder().apply { f() }.build() diff --git a/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.fir.kt b/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.fir.kt index 74a068dd880..bde07b70546 100644 --- a/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.fir.kt +++ b/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.protected_fun() } //------------ @@ -82,4 +82,4 @@ interface Q : R { class S : P, Q { internal override fun foo() {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt151.fir.kt b/compiler/testData/diagnostics/tests/scopes/kt151.fir.kt index 00e6dc84c85..3cf914f2bb4 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt151.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt151.fir.kt @@ -10,7 +10,7 @@ class B : A() { } fun test(b: B) { - b.x() + b.x() } @@ -37,4 +37,4 @@ class F : C(), T { class G : C(), T { public override fun foo() {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.fir.kt index 05790b6520b..0a9c5f8b3b7 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.fir.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.fir.kt @@ -40,7 +40,7 @@ class KotlinClass2 : JavaClass() { fun test(a: KotlinClass, b: KotlinClass2) { a.foo() // Error, protected_and_package declared in different package - b.foo() // Error, protected visibility in same package (but could be protected_and_package) + b.foo() // Error, protected visibility in same package (but could be protected_and_package) a.field diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.fir.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.fir.kt index c35ea5d7376..7cb4268c107 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.fir.kt +++ b/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.baz() // Declared in B - x.foobaz() // Declared in B + x.foobaz() // Declared in B } } diff --git a/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.txt b/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.txt index 8c0f8f30744..15575da2ed4 100644 --- a/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.txt +++ b/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.txt @@ -95,13 +95,13 @@ FILE fqName: fileName:/inlineCollectionOfInlineClass.kt CALL 'public abstract fun (): kotlin.Int declared in kotlin.collections.Set' type=kotlin.Int origin=GET_PROPERTY $this: CALL 'private final fun (): kotlin.collections.MutableSet<.IT> declared in .InlineMutableSet' type=kotlin.collections.MutableSet<.IT> origin=GET_PROPERTY $this: GET_VAR ': .InlineMutableSet declared in .InlineMutableSet.' type=.InlineMutableSet origin=null - FUN name:contains visibility:public modality:FINAL <> ($this:.InlineMutableSet, element:.IT) returnType:kotlin.Boolean + FUN name:contains visibility:public modality:FINAL <> ($this:.InlineMutableSet, element:.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: type:.InlineMutableSet VALUE_PARAMETER name:element index:0 type:.IT BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun contains (element: .IT): kotlin.Boolean declared in .InlineMutableSet' + RETURN type=kotlin.Nothing from='public final fun contains (element: .IT): kotlin.Boolean [operator] declared in .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 (): kotlin.collections.MutableSet<.IT> declared in .InlineMutableSet' type=kotlin.collections.MutableSet<.IT> origin=GET_PROPERTY $this: GET_VAR ': .InlineMutableSet declared in .InlineMutableSet.contains' type=.InlineMutableSet origin=null @@ -157,12 +157,12 @@ FILE fqName: 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 (): kotlin.collections.MutableSet<.IT> declared in .InlineMutableSet' type=kotlin.collections.MutableSet<.IT> origin=GET_PROPERTY $this: GET_VAR ': .InlineMutableSet declared in .InlineMutableSet.clear' type=.InlineMutableSet origin=null - FUN name:iterator visibility:public modality:FINAL <> ($this:.InlineMutableSet) returnType:kotlin.collections.MutableIterator<.IT> + FUN name:iterator visibility:public modality:FINAL <> ($this:.InlineMutableSet) returnType:kotlin.collections.MutableIterator<.IT> [operator] overridden: public abstract fun iterator (): kotlin.collections.MutableIterator [operator] declared in kotlin.collections.MutableSet $this: VALUE_PARAMETER name: type:.InlineMutableSet BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.MutableIterator<.IT> declared in .InlineMutableSet' + RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.MutableIterator<.IT> [operator] declared in .InlineMutableSet' CALL 'public abstract fun iterator (): kotlin.collections.MutableIterator [operator] declared in kotlin.collections.MutableSet' type=kotlin.collections.MutableIterator<.IT> origin=null $this: CALL 'private final fun (): kotlin.collections.MutableSet<.IT> declared in .InlineMutableSet' type=kotlin.collections.MutableSet<.IT> origin=GET_PROPERTY $this: GET_VAR ': .InlineMutableSet declared in .InlineMutableSet.iterator' type=.InlineMutableSet origin=null diff --git a/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.txt b/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.txt index a6746834ab8..3afe437a671 100644 --- a/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.txt +++ b/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.txt @@ -232,14 +232,14 @@ FILE fqName: fileName:/genericDelegatedDeepProperty.kt BLOCK_BODY DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name: modality:FINAL visibility:local superTypes:[.IDelegate1<.Value., .CR.>>, T of .>]' - FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..deepO$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:T of . + FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..deepO$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:T of . [operator] overridden: public abstract fun getValue (t: T1 of .IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of .IDelegate1 [operator] declared in .IDelegate1 $this: VALUE_PARAMETER name: type:.additionalText$delegate..deepO$delegate..> VALUE_PARAMETER name:t index:0 type:.Value., .CR.>> VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*> BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . declared in .additionalText$delegate..deepO$delegate.' + RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . [operator] declared in .additionalText$delegate..deepO$delegate.' CALL 'public final fun (): T of .Value declared in .Value' type=T of . origin=GET_PROPERTY $this: GET_VAR 't: .Value., .CR.>> declared in .additionalText$delegate..deepO$delegate..getValue' type=.Value., .CR.>> origin=null FUN name:qux21 visibility:public modality:FINAL ($this:.additionalText$delegate..deepO$delegate..>, t:F21T of .additionalText$delegate..deepO$delegate..qux21) returnType:F21T of .additionalText$delegate..deepO$delegate..qux21 @@ -277,7 +277,7 @@ FILE fqName: fileName:/genericDelegatedDeepProperty.kt $receiver: VALUE_PARAMETER name: type:.Value., .CR.>> BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun (): T of . declared in .additionalText$delegate.' - CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . declared in .additionalText$delegate..deepO$delegate.' type=T of . origin=null + CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . [operator] declared in .additionalText$delegate..deepO$delegate.' type=T of . origin=null $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:deepO$delegate type:.additionalText$delegate..deepO$delegate..> visibility:private [final]' type=.additionalText$delegate..deepO$delegate..> origin=null receiver: GET_VAR ': .additionalText$delegate..> declared in .additionalText$delegate..' type=.additionalText$delegate..> origin=null t: GET_VAR ': .additionalText$delegate..> declared in .additionalText$delegate..' type=.additionalText$delegate..> origin=null @@ -292,14 +292,14 @@ FILE fqName: fileName:/genericDelegatedDeepProperty.kt BLOCK_BODY DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name: modality:FINAL visibility:local superTypes:[.IDelegate1<.Value., .CR.>>, T of .>]' - FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..deepK$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:T of . + FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..deepK$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:T of . [operator] overridden: public abstract fun getValue (t: T1 of .IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of .IDelegate1 [operator] declared in .IDelegate1 $this: VALUE_PARAMETER name: type:.additionalText$delegate..deepK$delegate..> VALUE_PARAMETER name:t index:0 type:.Value., .CR.>> VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*> BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . declared in .additionalText$delegate..deepK$delegate.' + RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . [operator] declared in .additionalText$delegate..deepK$delegate.' CALL 'public final fun foo (): R of .CR declared in .CR' type=T of . origin=null $this: CALL 'public final fun (): IT of .Value declared in .Value' type=.CR.> origin=GET_PROPERTY $this: GET_VAR 't: .Value., .CR.>> declared in .additionalText$delegate..deepK$delegate..getValue' type=.Value., .CR.>> origin=null @@ -323,19 +323,19 @@ FILE fqName: fileName:/genericDelegatedDeepProperty.kt $receiver: VALUE_PARAMETER name: type:.Value., .CR.>> BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun (): T of . declared in .additionalText$delegate.' - CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . declared in .additionalText$delegate..deepK$delegate.' type=T of . origin=null + CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): T of . [operator] declared in .additionalText$delegate..deepK$delegate.' type=T of . origin=null $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:deepK$delegate type:.additionalText$delegate..deepK$delegate..> visibility:private [final]' type=.additionalText$delegate..deepK$delegate..> origin=null receiver: GET_VAR ': .additionalText$delegate..> declared in .additionalText$delegate..' type=.additionalText$delegate..> origin=null t: GET_VAR ': .additionalText$delegate..> declared in .additionalText$delegate..' type=.additionalText$delegate..> origin=null p: PROPERTY_REFERENCE 'private final deepK: T of . [delegated,val]' field=null getter='public final fun (): T of . declared in .additionalText$delegate.' setter=null type=kotlin.reflect.KProperty2<.Value., .CR.>>, *, T of .> origin=PROPERTY_REFERENCE_FOR_DELEGATE - FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:.P., T of .> + FUN name:getValue visibility:public modality:FINAL <> ($this:.additionalText$delegate..>, t:.Value., .CR.>>, p:kotlin.reflect.KProperty<*>) returnType:.P., T of .> [operator] overridden: public abstract fun getValue (t: T1 of .IDelegate1, p: kotlin.reflect.KProperty<*>): R1 of .IDelegate1 [operator] declared in .IDelegate1 $this: VALUE_PARAMETER name: type:.additionalText$delegate..> VALUE_PARAMETER name:t index:0 type:.Value., .CR.>> VALUE_PARAMETER name:p index:1 type:kotlin.reflect.KProperty<*> BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): .P., T of .> declared in .additionalText$delegate.' + RETURN type=kotlin.Nothing from='public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): .P., T of .> [operator] declared in .additionalText$delegate.' CONSTRUCTOR_CALL 'public constructor (p1: P1 of .P, p2: P2 of .P) [primary] declared in .P' type=.P., T of .> origin=null : T of . : T of . @@ -365,7 +365,7 @@ FILE fqName: fileName:/genericDelegatedDeepProperty.kt $receiver: VALUE_PARAMETER name: type:.Value., .CR.>> BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun (): .P., T of .> declared in ' - CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): .P., T of .> declared in .additionalText$delegate.' type=.P., T of .> origin=null + CALL 'public final fun getValue (t: .Value., .CR.>>, p: kotlin.reflect.KProperty<*>): .P., T of .> [operator] declared in .additionalText$delegate.' type=.P., T of .> origin=null $this: GET_FIELD 'FIELD PROPERTY_DELEGATE name:additionalText$delegate type:.additionalText$delegate..> visibility:private [final,static]' type=.additionalText$delegate..> origin=null t: GET_VAR ': .Value., .CR.>> declared in .' type=.Value., .CR.>> origin=null p: PROPERTY_REFERENCE 'public final additionalText: .P., T of .> [delegated,val]' field=null getter='public final fun (): .P., T of .> declared in ' setter=null type=kotlin.reflect.KProperty1<.Value., .CR.>>, .P., T of .>> origin=PROPERTY_REFERENCE_FOR_DELEGATE diff --git a/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt b/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt index 897c17792b2..887af12416c 100644 --- a/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt +++ b/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.txt @@ -17,13 +17,13 @@ FILE fqName: fileName:/implicitNotNullOnPlatformType.kt BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .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:.MySet, element:kotlin.String) returnType:kotlin.Boolean + FUN name:contains visibility:public modality:FINAL <> ($this:.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: type:.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 .MySet' + RETURN type=kotlin.Nothing from='public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in .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:.MySet, elements:kotlin.collections.Collection) returnType:kotlin.Boolean overridden: @@ -40,12 +40,12 @@ FILE fqName: fileName:/implicitNotNullOnPlatformType.kt BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun isEmpty (): kotlin.Boolean declared in .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:.MySet) returnType:kotlin.collections.Iterator + FUN name:iterator visibility:public modality:FINAL <> ($this:.MySet) returnType:kotlin.collections.Iterator [operator] overridden: public abstract fun iterator (): kotlin.collections.Iterator [operator] declared in kotlin.collections.Set $this: VALUE_PARAMETER name: type:.MySet BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.Iterator declared in .MySet' + RETURN type=kotlin.Nothing from='public final fun iterator (): kotlin.collections.Iterator [operator] declared in .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: fileName:/implicitNotNullOnPlatformType.kt VALUE_PARAMETER name:m index:0 type:.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 .MySet' type=kotlin.Boolean origin=null + CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in .MySet' type=kotlin.Boolean origin=null $this: GET_VAR 'm: .MySet declared in .testContains' type=.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 .MySet' type=kotlin.Boolean origin=null + CALL 'public final fun contains (element: kotlin.String): kotlin.Boolean [operator] declared in .MySet' type=kotlin.Boolean origin=null $this: GET_VAR 'm: .MySet declared in .testContains' type=.MySet origin=null element: CONST String type=kotlin.String value="abc" diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.fir.kt index c1517834449..42a1256a292 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.fir.kt +++ b/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.priv() - a.prot() + a.prot() a.int() a.pub() a.priv1 - a.prot1 + a.prot1 a.int1 a.pub1 } @@ -60,12 +60,12 @@ import base.* fun case2() { val a = Case1() a.priv() - a.prot() - a.int() + a.prot() + a.int() a.pub() a.priv1 - a.prot1 - a.int1 + a.prot1 + a.int1 a.pub1 } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve/delegates.txt b/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve/delegates.txt index 8d6ef9a75e0..e1024fee384 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve/delegates.txt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve/delegates.txt @@ -11,11 +11,11 @@ FILE: delegates.kt super() } - 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| { } }