From c64575f4a21a4c22569fe37ff4d784a996080c01 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 14 Feb 2024 12:02:53 +0200 Subject: [PATCH] [FIR] Move check for _private-to-this_ visibility into checker ^KT-55446 ^KT-65790 Fixed --- .../checkers/CommonExpressionCheckers.kt | 1 + .../FirPrivateToThisAccessChecker.kt | 158 ++++++++++++++++++ .../kotlin/fir/resolve/LookupTagUtils.kt | 6 + .../resolve/transformers/FirStatusResolver.kt | 109 +----------- .../privateToThis/FunctionCall.fir.kt | 2 +- .../variance/privateToThis/FunctionCall.kt | 2 +- .../variance/privateToThis/GetVal.fir.kt | 2 +- .../tests/variance/privateToThis/GetVal.kt | 2 +- .../variance/privateToThis/SetVar.fir.kt | 2 +- .../tests/variance/privateToThis/SetVar.kt | 2 +- .../tests/visibility/privateToThis.fir.kt | 11 ++ .../tests/visibility/privateToThis.fir.txt | 24 ++- .../tests/visibility/privateToThis.kt | 11 ++ .../tests/visibility/privateToThis.txt | 11 ++ .../visibility/privateToThisExotic.fir.kt | 3 +- .../tests/visibility/privateToThisExotic.kt | 1 - .../visibility/PrivateToThis.fir.k2.txt | 22 +-- .../kotlin/descriptors/Visibilities.kt | 1 + 18 files changed, 239 insertions(+), 131 deletions(-) create mode 100644 compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirPrivateToThisAccessChecker.kt diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt index d5d3ac98e55..b9a5a4b49c4 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonExpressionCheckers.kt @@ -54,6 +54,7 @@ object CommonExpressionCheckers : ExpressionCheckers() { FirMissingDependencyClassChecker, FirMissingDependencySupertypeInQualifiedAccessExpressionsChecker, FirArrayOfNothingQualifierChecker, + FirPrivateToThisAccessChecker, ) override val callCheckers: Set diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirPrivateToThisAccessChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirPrivateToThisAccessChecker.kt new file mode 100644 index 00000000000..1929335ee98 --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirPrivateToThisAccessChecker.kt @@ -0,0 +1,158 @@ +/* + * Copyright 2010-2024 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.analysis.checkers.expression + +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.diagnostics.* +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.containingClassLookupTag +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.visibility +import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression +import org.jetbrains.kotlin.fir.expressions.toReference +import org.jetbrains.kotlin.fir.references.FirResolvedErrorReference +import org.jetbrains.kotlin.fir.references.FirThisReference +import org.jetbrains.kotlin.fir.references.resolved +import org.jetbrains.kotlin.fir.references.toResolvedCallableSymbol +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeSetterVisibilityError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeVisibilityError +import org.jetbrains.kotlin.fir.resolve.toClassSymbol +import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.SymbolInternals +import org.jetbrains.kotlin.fir.symbols.impl.* +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.unwrapFakeOverrides +import org.jetbrains.kotlin.types.EnrichedProjectionKind +import org.jetbrains.kotlin.types.Variance + +object FirPrivateToThisAccessChecker : FirQualifiedAccessExpressionChecker(MppCheckerKind.Common) { + override fun check(expression: FirQualifiedAccessExpression, context: CheckerContext, reporter: DiagnosticReporter) { + val reference = expression.calleeReference.resolved ?: return + if (reference is FirResolvedErrorReference) { + // If there was a visibility diagnostic, no need to report another one about visibility + when (reference.diagnostic) { + is ConeVisibilityError, + is ConeSetterVisibilityError -> return + } + } + val dispatchReceiver = expression.dispatchReceiver ?: return + val symbol = reference.toResolvedCallableSymbol(discardErrorReference = true) ?: return + if (symbol.visibility != Visibilities.Private) return + val session = context.session + val containingClassSymbol = symbol.containingClassLookupTag()?.toClassSymbol(session) + + if (!isPrivateToThis(symbol.unwrapFakeOverrides(), containingClassSymbol, session)) return + + val invisible = when (val receiverReference = dispatchReceiver.toReference(session)) { + is FirThisReference -> receiverReference.boundSymbol != containingClassSymbol + else -> true + } + + if (invisible) { + reporter.reportOn( + source = expression.source, + factory = FirErrors.INVISIBLE_REFERENCE, + symbol, + Visibilities.PrivateToThis, + symbol.callableId.classId, + context, + ) + } + } + + private fun isPrivateToThis( + symbol: FirCallableSymbol<*>, + containingClassSymbol: FirClassSymbol<*>?, + session: FirSession + ): Boolean { + if (containingClassSymbol == null) return false + if (symbol is FirConstructorSymbol) return false + if (containingClassSymbol.typeParameterSymbols.all { it.variance == Variance.INVARIANT }) return false + + if (symbol.receiverParameter?.typeRef?.coneType?.contradictsWith(Variance.IN_VARIANCE, session) == true) { + return true + } + if (symbol.resolvedReturnType.contradictsWith( + if (symbol is FirPropertySymbol && symbol.isVar) Variance.INVARIANT + else Variance.OUT_VARIANCE, + session + ) + ) { + return true + } + if (symbol is FirFunctionSymbol<*>) { + for (parameter in symbol.valueParameterSymbols) { + if (parameter.resolvedReturnType.contradictsWith(Variance.IN_VARIANCE, session)) { + return true + } + } + } + return false + } + + private fun ConeKotlinType.contradictsWith(requiredVariance: Variance, session: FirSession): Boolean { + when (this) { + is ConeLookupTagBasedType -> { + if (this is ConeTypeParameterType) { + return !this.lookupTag.typeParameterSymbol.variance.allowsPosition(requiredVariance) + } + if (this is ConeClassLikeType) { + // It's safe to access fir here, because later we access only variance of type parameters of the class + // And variance can not be changed after raw fir stage + @OptIn(SymbolInternals::class) + val classLike = this.lookupTag.toSymbol(session)?.fir ?: return false + for ((index, argument) in this.typeArguments.withIndex()) { + val typeParameterRef = classLike.typeParameters.getOrNull(index) + if (typeParameterRef !is FirTypeParameter) continue + val requiredVarianceForArgument = when ( + EnrichedProjectionKind.getEffectiveProjectionKind(typeParameterRef.variance, argument.variance) + ) { + EnrichedProjectionKind.OUT -> requiredVariance + EnrichedProjectionKind.IN -> requiredVariance.opposite() + EnrichedProjectionKind.INV -> Variance.INVARIANT + EnrichedProjectionKind.STAR -> continue // CONFLICTING_PROJECTION error was reported + } + val argType = argument.type ?: continue + if (argType.contradictsWith(requiredVarianceForArgument, session)) { + return true + } + } + } + } + is ConeFlexibleType -> { + return lowerBound.contradictsWith(requiredVariance, session) + } + is ConeDefinitelyNotNullType -> { + return original.contradictsWith(requiredVariance, session) + } + is ConeIntersectionType -> { + return this.intersectedTypes.any { it.contradictsWith(requiredVariance, session) } + } + is ConeCapturedType -> { + // Looks like not possible here + return false + } + is ConeIntegerConstantOperatorType, + is ConeIntegerLiteralConstantType, + is ConeStubTypeForChainInference, + is ConeStubTypeForTypeVariableInSubtyping, + is ConeTypeVariableType, + -> return false + } + return false + } + + private val ConeTypeProjection.variance: Variance + get() = when (this.kind) { + ProjectionKind.STAR -> Variance.OUT_VARIANCE + ProjectionKind.IN -> Variance.IN_VARIANCE + ProjectionKind.OUT -> Variance.OUT_VARIANCE + ProjectionKind.INVARIANT -> Variance.INVARIANT + } +} diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt index 238bd1b6f1f..4568eeebb2d 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/LookupTagUtils.kt @@ -61,6 +61,12 @@ fun ConeClassLikeLookupTag.toSymbol(useSiteSession: FirSession): FirClassLikeSym } } +/** + * @see toSymbol + */ +fun ConeClassLikeLookupTag.toClassSymbol(session: FirSession): FirClassSymbol<*>? = + toSymbol(session) as? FirClassSymbol<*> + /** * @see toSymbol */ 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 index 4fb8337a289..0d2582567d9 100644 --- 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 @@ -15,15 +15,12 @@ import org.jetbrains.kotlin.fir.extensions.FirStatusTransformerExtension import org.jetbrains.kotlin.fir.extensions.extensionService import org.jetbrains.kotlin.fir.extensions.statusTransformerExtensions import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.scopes.ProcessorAction import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope import org.jetbrains.kotlin.fir.toEffectiveVisibility import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.fir.visibilityChecker -import org.jetbrains.kotlin.types.EnrichedProjectionKind -import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment class FirStatusResolver( @@ -41,7 +38,7 @@ class FirStatusResolver( ) private val MODIFIERS_FROM_OVERRIDDEN: List = - FirDeclarationStatusImpl.Modifier.values().toList() - NOT_INHERITED_MODIFIERS + FirDeclarationStatusImpl.Modifier.entries - NOT_INHERITED_MODIFIERS } private val extensionStatusTransformers = session.extensionService.statusTransformerExtensions @@ -247,18 +244,7 @@ class FirStatusResolver( isLocal -> Visibilities.Local else -> resolveVisibility(declaration, containingClass, containingProperty, overriddenStatuses) } - - Visibilities.Private -> when { - declaration is FirPropertyAccessor -> if (containingProperty?.visibility == Visibilities.PrivateToThis) { - Visibilities.PrivateToThis - } else { - Visibilities.Private - } - - isPrivateToThis(declaration, containingClass) -> Visibilities.PrivateToThis - else -> Visibilities.Private - } - + Visibilities.Private -> Visibilities.Private else -> status.visibility } @@ -317,97 +303,6 @@ class FirStatusResolver( return status.resolved(visibility, modality, effectiveVisibility) } - private fun isPrivateToThis( - declaration: FirDeclaration, - containingClass: FirClass?, - ): Boolean { - if (containingClass == null) return false - if (declaration !is FirCallableDeclaration) return false - if (declaration is FirConstructor) return false - if (containingClass.typeParameters.all { it.symbol.variance == Variance.INVARIANT }) return false - - if (declaration.receiverParameter?.typeRef?.contradictsWith(Variance.IN_VARIANCE) == true) { - return true - } - if (declaration.returnTypeRef.contradictsWith( - if (declaration is FirProperty && declaration.isVar) Variance.INVARIANT - else Variance.OUT_VARIANCE - ) - ) { - return true - } - if (declaration is FirFunction) { - for (parameter in declaration.valueParameters) { - if (parameter.returnTypeRef.contradictsWith(Variance.IN_VARIANCE)) { - return true - } - } - } - return false - } - - private fun FirTypeRef.contradictsWith(requiredVariance: Variance): Boolean { - val type = coneTypeSafe() ?: return false - return contradictsWith(type, requiredVariance) - } - - private fun contradictsWith(type: ConeKotlinType, requiredVariance: Variance): Boolean { - when (type) { - is ConeLookupTagBasedType -> { - if (type is ConeTypeParameterType) { - return !type.lookupTag.typeParameterSymbol.fir.variance.allowsPosition(requiredVariance) - } - if (type is ConeClassLikeType) { - val classLike = type.lookupTag.toSymbol(session)?.fir - for ((index, argument) in type.typeArguments.withIndex()) { - val typeParameterRef = classLike?.typeParameters?.getOrNull(index) - if (typeParameterRef !is FirTypeParameter) continue - val requiredVarianceForArgument = when ( - EnrichedProjectionKind.getEffectiveProjectionKind(typeParameterRef.variance, argument.variance) - ) { - EnrichedProjectionKind.OUT -> requiredVariance - EnrichedProjectionKind.IN -> requiredVariance.opposite() - EnrichedProjectionKind.INV -> Variance.INVARIANT - EnrichedProjectionKind.STAR -> continue // CONFLICTING_PROJECTION error was reported - } - val argType = argument.type ?: continue - if (contradictsWith(argType, requiredVarianceForArgument)) { - return true - } - } - } - } - is ConeFlexibleType -> { - return contradictsWith(type.lowerBound, requiredVariance) - } - is ConeDefinitelyNotNullType -> { - return contradictsWith(type.original, requiredVariance) - } - is ConeIntersectionType -> { - return type.intersectedTypes.any { contradictsWith(it, requiredVariance) } - } - is ConeCapturedType -> { - // Looks like not possible here - return false - } - is ConeIntegerConstantOperatorType, - is ConeIntegerLiteralConstantType, - is ConeStubTypeForChainInference, - is ConeStubTypeForTypeVariableInSubtyping, - is ConeTypeVariableType, - -> return false - } - return false - } - - private val ConeTypeProjection.variance: Variance - get() = when (this.kind) { - ProjectionKind.STAR -> Variance.OUT_VARIANCE - ProjectionKind.IN -> Variance.IN_VARIANCE - ProjectionKind.OUT -> Variance.OUT_VARIANCE - ProjectionKind.INVARIANT -> Variance.INVARIANT - } - private fun resolveVisibility( declaration: FirDeclaration, containingClass: FirClass?, diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt index b04690f6481..7c3486ff637 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.fir.kt @@ -14,7 +14,7 @@ class Test { apply(foo()) apply(this.foo()) with(Test()) { - apply(foo()) // resolved to this@Test.foo + apply(foo()) // K1: this@Test.foo, K2: this@with.foo, see KT-55446 apply(this.foo()) apply(this@with.foo()) apply(this@Test.foo()) diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt index 877764454d2..a8949238279 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt @@ -14,7 +14,7 @@ class Test { apply(foo()) apply(this.foo()) with(Test()) { - apply(foo()) // resolved to this@Test.foo + apply(foo()) // K1: this@Test.foo, K2: this@with.foo, see KT-55446 apply(this.foo()) apply(this@with.foo()) apply(this@Test.foo()) diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt index 61622ca5eba..3d76206d331 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.fir.kt @@ -14,7 +14,7 @@ class Test { apply(i) apply(this.i) with(Test()) { - apply(i) // resolved to this@Test.i + apply(i) // K1: this@Test.i, K2: this@with.i, see KT-55446 apply(this.i) apply(this@with.i) apply(this@Test.i) diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt index 51aa6dd34ee..4216151ea31 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt @@ -14,7 +14,7 @@ class Test { apply(i) apply(this.i) with(Test()) { - apply(i) // resolved to this@Test.i + apply(i) // K1: this@Test.i, K2: this@with.i, see KT-55446 apply(this.i) apply(this@with.i) apply(this@Test.i) diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt index 1f9d8ef2c99..c6e8ecf9b3a 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt @@ -14,7 +14,7 @@ class Test { i = getT() this.i = getT() with(Test()) { - i = getT() // resolved to this@Test.i + i = getT() // K1: this@Test.i, K2: this@with.i, see KT-55446 this.i = getT() this@with.i = getT() this@Test.i = getT() diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt index 35a199d2403..7739ac7f3ca 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt @@ -14,7 +14,7 @@ class Test { i = getT() this.i = getT() with(Test()) { - i = getT() // resolved to this@Test.i + i = getT() // K1: this@Test.i, K2: this@with.i, see KT-55446 this.i = getT() this@with.i = getT() this@Test.i = getT() diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.kt b/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.kt index d16ce063fc1..0c9a77907cd 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.kt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.kt @@ -1,5 +1,6 @@ // FIR_DUMP +// explicit types class A(t: T) { private val t: T = t // PRIVATE_TO_THIS @@ -24,3 +25,13 @@ class A(t: T) { } } } + +// implicit types +class C(t: T) { + private val t: T = t + private val tt = t + + fun foo(a: C) { + val x: String = a.tt + } +} diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.txt b/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.txt index 5391bfd8227..35f557dce0e 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.txt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThis.fir.txt @@ -4,8 +4,8 @@ FILE: privateToThis.fir.kt super() } - private/*private to this*/ final val t: R|T| = R|/t| - private/*private to this*/ get(): R|T| + private final val t: R|T| = R|/t| + private get(): R|T| private final val i: R|A.B| = this@R|/A|.R|SubstitutionOverride|() private get(): R|A.B| @@ -16,11 +16,11 @@ FILE: privateToThis.fir.kt } public final fun foo(a: R|A|): R|kotlin/Unit| { - lval x: R|kotlin/String| = R|/a|.R|SubstitutionOverride#| + lval x: R|kotlin/String| = R|/a|.R|SubstitutionOverride| } public final fun bar(a: R|A<*>|): R|kotlin/Unit| { - R|/a|.R|SubstitutionOverride#| + R|/a|.R|SubstitutionOverride| } public final inner class B : R|kotlin/Any| { @@ -35,3 +35,19 @@ FILE: privateToThis.fir.kt } } + public final class C : R|kotlin/Any| { + public constructor(t: R|T|): R|C| { + super() + } + + private final val t: R|T| = R|/t| + private get(): R|T| + + private final val tt: R|T| = R|/t| + private get(): R|T| + + public final fun foo(a: R|C|): R|kotlin/Unit| { + lval x: R|kotlin/String| = R|/a|.R|SubstitutionOverride| + } + + } diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThis.kt b/compiler/testData/diagnostics/tests/visibility/privateToThis.kt index 4228d8cf616..18e15325e31 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThis.kt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThis.kt @@ -1,5 +1,6 @@ // FIR_DUMP +// explicit types class A(t: T) { private val t: T = t // PRIVATE_TO_THIS @@ -24,3 +25,13 @@ class A(t: T) { } } } + +// implicit types +class C(t: T) { + private val t: T = t + private val tt = t + + fun foo(a: C) { + val x: String = a.tt + } +} diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThis.txt b/compiler/testData/diagnostics/tests/visibility/privateToThis.txt index b9933e64f68..1020e474ba4 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThis.txt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThis.txt @@ -19,3 +19,14 @@ public final class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + +public final class C { + public constructor C(/*0*/ t: T) + private/*private to this*/ final val t: T + private/*private to this*/ final val tt: T + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(/*0*/ a: C): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.fir.kt b/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.fir.kt index 9f4509ba5db..efffe801cbf 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.fir.kt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.fir.kt @@ -20,7 +20,6 @@ class Foo : Base<T>() { fun bar(f: Foo) { val dnn = f.dnn - // This case (and any other with non-denotable type) requires KT-55446 to be fixed - val flex = f.flex + val flex = f.flex } } diff --git a/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.kt b/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.kt index 7e338f963d4..0123eb3b9ee 100644 --- a/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.kt +++ b/compiler/testData/diagnostics/tests/visibility/privateToThisExotic.kt @@ -20,7 +20,6 @@ class Foo : Base<T>() { fun bar(f: Foo) { val dnn = f.dnn - // This case (and any other with non-denotable type) requires KT-55446 to be fixed val flex = f.flex } } diff --git a/compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.fir.k2.txt b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.fir.k2.txt index acfd25259d6..ccd848b35cb 100644 --- a/compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.fir.k2.txt +++ b/compiler/testData/loadJava/compiledKotlin/visibility/PrivateToThis.fir.k2.txt @@ -1,19 +1,19 @@ public final class A : R|kotlin/Any| { - private/*private to this*/ final fun bas(): R|I| + private final fun bas(): R|I| - private/*private to this*/ final val foo: R|I| - private/*private to this*/ get(): R|I| + private final val foo: R|I| + private get(): R|I| - private/*private to this*/ final var bar: R|I| - private/*private to this*/ get(): R|I| - private/*private to this*/ set(value: R|I|): R|kotlin/Unit| + private final var bar: R|I| + private get(): R|I| + private set(value: R|I|): R|kotlin/Unit| - private/*private to this*/ final val val_with_accessors: R|I| - private/*private to this*/ get(): R|I| + private final val val_with_accessors: R|I| + private get(): R|I| - private/*private to this*/ final var var_with_accessors: R|I| - private/*private to this*/ get(): R|I| - private/*private to this*/ set(value: R|I|): R|kotlin/Unit| + private final var var_with_accessors: R|I| + private get(): R|I| + private set(value: R|I|): R|kotlin/Unit| public constructor(): R|test/A| diff --git a/core/compiler.common/src/org/jetbrains/kotlin/descriptors/Visibilities.kt b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/Visibilities.kt index 79eb548ade6..15533d83646 100644 --- a/core/compiler.common/src/org/jetbrains/kotlin/descriptors/Visibilities.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/Visibilities.kt @@ -10,6 +10,7 @@ object Visibilities { override fun mustCheckInImports(): Boolean = true } + // K2 doesn't use this visibility, see KT-55446 for details object PrivateToThis : Visibility("private_to_this", isPublicAPI = false) { override val internalDisplayName: String get() = "private/*private to this*/"