From 76e192fc8af728a78a52215b11af953ab72bb7e5 Mon Sep 17 00:00:00 2001 From: Tianyu Geng Date: Wed, 1 Sep 2021 13:30:02 -0700 Subject: [PATCH] FIR Checker: check AMBIGUOUS_ANONYMOUS_TYPE_INFERRED Also change org.jetbrains.kotlin.fir.types.TypeUtilsKt#hideLocalTypeIfNeeded to skip approximating anonymous objects if there are multiple super type refs so that resolution behaves the same (for uncompilable code). Note that this change does not implement check for ApproximateAnonymousReturnTypesInPrivateInlineFunctions as the check is already turned on in 1.5 and will likely not needed when FIR becomes stable. --- .../diagnostics/KtFirDataClassConverters.kt | 9 +++ .../api/fir/diagnostics/KtFirDiagnostics.kt | 5 ++ .../fir/diagnostics/KtFirDiagnosticsImpl.kt | 8 +++ .../diagnostics/FirDiagnosticsList.kt | 3 + .../fir/analysis/diagnostics/FirErrors.kt | 1 + .../checkers/CommonDeclarationCheckers.kt | 1 + .../FirAmbiguousAnonymousTypeChecker.kt | 45 ++++++++++++ .../declaration/FirAnnotationChecker.kt | 2 - .../diagnostics/FirDefaultErrorMessages.kt | 2 + .../FirDeclarationsResolveTransformer.kt | 8 +-- .../jetbrains/kotlin/fir/types/TypeUtils.kt | 71 +++++++++++-------- .../ambiguousObjectExpressionType.fir.kt | 50 ++++++------- ...approximateReturnedAnonymousObjects.fir.kt | 8 +-- .../inline/returnedAnonymousObjects.fir.kt | 8 +-- 14 files changed, 149 insertions(+), 72 deletions(-) create mode 100644 compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt index 221c08cd1b4..0cf81332038 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt @@ -1960,6 +1960,15 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert token, ) } + add(FirErrors.AMBIGUOUS_ANONYMOUS_TYPE_INFERRED) { firDiagnostic -> + AmbiguousAnonymousTypeInferredImpl( + firDiagnostic.a.map { coneKotlinType -> + firSymbolBuilder.typeBuilder.buildKtType(coneKotlinType) + }, + firDiagnostic as FirPsiDiagnostic, + token, + ) + } add(FirErrors.MANY_IMPL_MEMBER_NOT_IMPLEMENTED) { firDiagnostic -> ManyImplMemberNotImplementedImpl( firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(firDiagnostic.a.fir), diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt index e15471e1c70..c02919f5f2d 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt @@ -1397,6 +1397,11 @@ sealed class KtFirDiagnostic : KtDiagnosticWithPsi { abstract val invisibleDeclaration: KtCallableSymbol } + abstract class AmbiguousAnonymousTypeInferred : KtFirDiagnostic() { + override val diagnosticClass get() = AmbiguousAnonymousTypeInferred::class + abstract val superTypes: List + } + abstract class ManyImplMemberNotImplemented : KtFirDiagnostic() { override val diagnosticClass get() = ManyImplMemberNotImplemented::class abstract val classOrObject: KtClassLikeSymbol diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index f5167fd6b11..0633af6dbb7 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -2232,6 +2232,14 @@ internal class InvisibleAbstractMemberFromSuperWarningImpl( override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) } +internal class AmbiguousAnonymousTypeInferredImpl( + override val superTypes: List, + firDiagnostic: FirPsiDiagnostic, + override val token: ValidityToken, +) : KtFirDiagnostic.AmbiguousAnonymousTypeInferred(), KtAbstractFirDiagnostic { + override val firDiagnostic: FirPsiDiagnostic by weakRef(firDiagnostic) +} + internal class ManyImplMemberNotImplementedImpl( override val classOrObject: KtClassLikeSymbol, override val missingDeclaration: KtCallableSymbol, diff --git a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt index 45b5a402649..b73cc77d8ff 100644 --- a/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt +++ b/compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt @@ -714,6 +714,9 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") { parameter>("classOrObject") parameter>("invisibleDeclaration") } + val AMBIGUOUS_ANONYMOUS_TYPE_INFERRED by error(PositioningStrategy.DECLARATION_SIGNATURE) { + parameter>("superTypes") + } val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error(PositioningStrategy.DECLARATION_NAME) { parameter>("classOrObject") parameter>("missingDeclaration") diff --git a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index 05a3ac60c64..cabc160aa2e 100644 --- a/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -404,6 +404,7 @@ object FirErrors { val ABSTRACT_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) val ABSTRACT_CLASS_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) val INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER by deprecationError2, FirCallableSymbol<*>>(ProhibitInvisibleAbstractMethodsInSuperclasses, SourceElementPositioningStrategies.DECLARATION_NAME) + val AMBIGUOUS_ANONYMOUS_TYPE_INFERRED by error1>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE) val MANY_IMPL_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) val MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) val OVERRIDING_FINAL_MEMBER_BY_DELEGATION by error2, FirCallableSymbol<*>>(SourceElementPositioningStrategies.DECLARATION_NAME) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt index 22302c60539..b906875997c 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt @@ -28,6 +28,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirCyclicTypeBoundsChecker, FirExpectActualDeclarationChecker, FirInvalidAndDangerousCharactersChecker, + FirAmbiguousAnonymousTypeChecker, ) override val functionCheckers: Set diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt new file mode 100644 index 00000000000..7028e57260e --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAmbiguousAnonymousTypeChecker.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2021 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.declaration + +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.isInline +import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol +import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.types.shouldHideLocalType +import org.jetbrains.kotlin.fir.types.toSymbol +import org.jetbrains.kotlin.fir.types.visibilityForApproximation + +object FirAmbiguousAnonymousTypeChecker : FirBasicDeclarationChecker() { + override fun check(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter) { + if (declaration !is FirSimpleFunction && declaration !is FirProperty) return + require(declaration is FirCallableDeclaration) + if (context.containingDeclarations.any { it.isLocalMember || it is FirAnonymousObject }) return + + if (!shouldHideLocalType( + declaration.visibilityForApproximation(context.containingDeclarations.lastOrNull()), + declaration.isInline + ) + ) return + + val classSymbol = declaration.returnTypeRef.coneType.toSymbol(context.session) ?: return + if (classSymbol is FirAnonymousObjectSymbol) { + // Any anonymous object that has only one super type is already approximated to the super type by + // org.jetbrains.kotlin.fir.types.TypeUtilsKt#hideLocalTypeIfNeeded. Hence, any remaining anonymous object must have more than + // one super types and hence are ambiguous. + reporter.reportOn( + declaration.source, + FirErrors.AMBIGUOUS_ANONYMOUS_TYPE_INFERRED, + classSymbol.resolvedSuperTypeRefs.map { it.coneType }, + context + ) + } + } +} \ No newline at end of file diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt index c59ebce83e9..66e8753ee76 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirAnnotationChecker.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.analysis.checkers.declaration -import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget @@ -18,7 +17,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.hasBackingField import org.jetbrains.kotlin.fir.expressions.FirAnnotation -import org.jetbrains.kotlin.fir.expressions.argumentMapping import org.jetbrains.kotlin.fir.languageVersionSettings import org.jetbrains.kotlin.fir.packageFqName import org.jetbrains.kotlin.fir.resolve.fqName diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt index c5baf304507..121753e0c8b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt @@ -51,6 +51,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ACTUAL_TYPE_ALIAS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ACTUAL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ACTUAL_WITHOUT_EXPECT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ACTUALS +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_ANONYMOUS_TYPE_INFERRED import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_EXPECTS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUOUS_SUPER import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUMENT_MUST_BE_CONST @@ -1068,6 +1069,7 @@ class FirDefaultErrorMessages { RENDER_CLASS_OR_OBJECT, DECLARATION_NAME ) + map.put(AMBIGUOUS_ANONYMOUS_TYPE_INFERRED, "Right-hand side has anonymous type. Please specify type explicitly", NOT_RENDERED) map.put( MANY_IMPL_MEMBER_NOT_IMPLEMENTED, "{0} must override {1} because it inherits many implementations of it", 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 6be6ff2f51d..ca5373fa61a 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 @@ -51,14 +51,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor private val statusResolver: FirStatusResolver = FirStatusResolver(session, scopeSession) private fun FirDeclaration.visibilityForApproximation(): Visibility { - if (this !is FirMemberDeclaration) return Visibilities.Local val container = context.containers.getOrNull(context.containers.size - 2) - val containerVisibility = - if (container == null) Visibilities.Public - else (container as? FirRegularClass)?.visibility ?: Visibilities.Local - if (containerVisibility == Visibilities.Local || visibility == Visibilities.Local) return Visibilities.Local - if (containerVisibility == Visibilities.Private) return Visibilities.Private - return visibility + return visibilityForApproximation(container) } private inline fun withFirArrayOfCallTransformer(block: () -> T): T { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt index fd3759f723f..fdcc60d0919 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/types/TypeUtils.kt @@ -8,9 +8,8 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.* -import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject -import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration -import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap import org.jetbrains.kotlin.fir.resolve.toSymbol @@ -334,39 +333,51 @@ private fun FirTypeRef.hideLocalTypeIfNeeded( containingCallableVisibility: Visibility?, isInlineFunction: Boolean = false ): FirTypeRef { - if (containingCallableVisibility == null) { + if (!shouldHideLocalType(containingCallableVisibility, isInlineFunction)) return this + val firClass = + (((this as? FirResolvedTypeRef) + ?.type as? ConeClassLikeType) + ?.lookupTag as? ConeClassLookupTagWithFixedSymbol) + ?.symbol?.fir + if (firClass !is FirAnonymousObject) { + // NB: local classes are acceptable here, but reported by EXPOSED_* checkers as errors return this } - // Approximate types for non-private (all but package private or private) members. - // Also private inline functions, as per KT-33917. - if (containingCallableVisibility == Visibilities.Public || - containingCallableVisibility == Visibilities.Protected || - containingCallableVisibility == Visibilities.Internal || - (containingCallableVisibility == Visibilities.Private && isInlineFunction) - ) { - val firClass = - (((this as? FirResolvedTypeRef) - ?.type as? ConeClassLikeType) - ?.lookupTag as? ConeClassLookupTagWithFixedSymbol) - ?.symbol?.fir - if (firClass !is FirAnonymousObject) { - // NB: local classes are acceptable here, but reported by EXPOSED_* checkers as errors - return this - } - if (firClass.superTypeRefs.size > 1) { - return buildErrorTypeRef { - diagnostic = ConeSimpleDiagnostic("Cannot hide local type ${firClass.render()}") - } - } - val superType = firClass.superTypeRefs.single() - if (superType is FirResolvedTypeRef) { - val newKind = source?.kind - return if (newKind is FirFakeSourceElementKind) superType.copyWithNewSourceKind(newKind) else superType - } + if (firClass.superTypeRefs.size > 1) { + // NB: don't approximate so members can be resolved. The error is reported by FirAmbiguousAnonymousTypeChecker. + return this + } + val superType = firClass.superTypeRefs.single() + if (superType is FirResolvedTypeRef) { + val newKind = source?.kind + return if (newKind is FirFakeSourceElementKind) superType.copyWithNewSourceKind(newKind) else superType } return this } +fun shouldHideLocalType(containingCallableVisibility: Visibility?, isInlineFunction: Boolean): Boolean { + if (containingCallableVisibility == null) { + return false + } + // Approximate types for non-private (all but package private or private) members. + // Also private inline functions, as per KT-33917. + return containingCallableVisibility == Visibilities.Public || + containingCallableVisibility == Visibilities.Protected || + containingCallableVisibility == Visibilities.Internal || + (containingCallableVisibility == Visibilities.Private && isInlineFunction) +} + +fun FirDeclaration.visibilityForApproximation(container: FirDeclaration?): Visibility { + if (this !is FirMemberDeclaration) return Visibilities.Local + val containerVisibility = + if (container == null || container is FirFile) Visibilities.Public + else (container as? FirRegularClass)?.visibility ?: Visibilities.Local + if (containerVisibility == Visibilities.Local || visibility == Visibilities.Local) return Visibilities.Local + if (containerVisibility == Visibilities.Private) return Visibilities.Private + return visibility +} + + fun ConeTypeContext.captureFromArgumentsInternal(type: ConeKotlinType, status: CaptureStatus): ConeKotlinType? { val capturedArguments = captureArguments(type, status) ?: return null return if (type is ConeFlexibleType) { diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt index 8fafa1214af..8d209447626 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.fir.kt @@ -16,15 +16,15 @@ class Foo { privateProperty.f2() } - protected val protectedProperty = object : MyClass(), MyTrait {} + protected val protectedProperty = object : MyClass(), MyTrait {} - val internalProperty = object : MyClass(), MyTrait {} + val internalProperty = object : MyClass(), MyTrait {} - internal val internal2Property = object : MyClass(), MyTrait {} + internal val internal2Property = object : MyClass(), MyTrait {} - public val publicProperty = object : MyClass(), MyTrait {} + public val publicProperty = object : MyClass(), MyTrait {} - val propertyWithGetter + val propertyWithGetter get() = object: MyClass(), MyTrait {} @@ -35,13 +35,13 @@ class Foo { privateFunction().f2() } - protected fun protectedFunction() = object : MyClass(), MyTrait {} + protected fun protectedFunction() = object : MyClass(), MyTrait {} - fun internalFunction() = object : MyClass(), MyTrait {} + fun internalFunction() = object : MyClass(), MyTrait {} - internal fun internal2Function() = object : MyClass(), MyTrait {} + internal fun internal2Function() = object : MyClass(), MyTrait {} - public fun publicFunction() = object : MyClass(), MyTrait {} + public fun publicFunction() = object : MyClass(), MyTrait {} @@ -53,13 +53,13 @@ class Foo { privatePropertyInner.f2() } - protected val protectedProperty = object : MyClass(), MyTrait {} + protected val protectedProperty = object : MyClass(), MyTrait {} - val internalProperty = object : MyClass(), MyTrait {} + val internalProperty = object : MyClass(), MyTrait {} - internal val internal2Property = object : MyClass(), MyTrait {} + internal val internal2Property = object : MyClass(), MyTrait {} - public val publicProperty = object : MyClass(), MyTrait {} + public val publicProperty = object : MyClass(), MyTrait {} private fun privateFunctionInner() = object : MyClass(), MyTrait {} @@ -69,13 +69,13 @@ class Foo { privateFunctionInner().f2() } - protected fun protectedFunction() = object : MyClass(), MyTrait {} + protected fun protectedFunction() = object : MyClass(), MyTrait {} - fun internalFunction() = object : MyClass(), MyTrait {} + fun internalFunction() = object : MyClass(), MyTrait {} - internal fun internal2Function() = object : MyClass(), MyTrait {} + internal fun internal2Function() = object : MyClass(), MyTrait {} - public fun publicFunction() = object : MyClass(), MyTrait {} + public fun publicFunction() = object : MyClass(), MyTrait {} } @@ -93,21 +93,21 @@ class Foo { private val packagePrivateProperty = object : MyClass(), MyTrait {} -protected val packageProtectedProperty = object : MyClass(), MyTrait {} +protected val packageProtectedProperty = object : MyClass(), MyTrait {} -val packageInternalProperty = object : MyClass(), MyTrait {} +val packageInternalProperty = object : MyClass(), MyTrait {} -internal val packageInternal2Property = object : MyClass(), MyTrait {} +internal val packageInternal2Property = object : MyClass(), MyTrait {} -public val packagePublicProperty = object : MyClass(), MyTrait {} +public val packagePublicProperty = object : MyClass(), MyTrait {} -protected fun packageProtectedFunction() = object : MyClass(), MyTrait {} +protected fun packageProtectedFunction() = object : MyClass(), MyTrait {} -fun packageInternalFunction() = object : MyClass(), MyTrait {} +fun packageInternalFunction() = object : MyClass(), MyTrait {} -internal fun packageInternal2Function() = object : MyClass(), MyTrait {} +internal fun packageInternal2Function() = object : MyClass(), MyTrait {} -public fun packagePublicFunction() = object : MyClass(), MyTrait {} +public fun packagePublicFunction() = object : MyClass(), MyTrait {} fun fooPackage() { val packageLocalVar = object : MyClass(), MyTrait {} diff --git a/compiler/testData/diagnostics/tests/inline/approximateReturnedAnonymousObjects.fir.kt b/compiler/testData/diagnostics/tests/inline/approximateReturnedAnonymousObjects.fir.kt index 298cb10d9be..6e949204ffa 100644 --- a/compiler/testData/diagnostics/tests/inline/approximateReturnedAnonymousObjects.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/approximateReturnedAnonymousObjects.fir.kt @@ -11,7 +11,7 @@ private inline fun foo2(crossinline f: () -> Int) = object : I1 { fun bar(): Int = f() } -private inline fun foo3(crossinline f: () -> Int) = object : I1, I2 { +private inline fun foo3(crossinline f: () -> Int) = object : I1, I2 { fun bar(): Int = f() } @@ -36,11 +36,11 @@ fun test2(b: Boolean) { } fun test3(b: Boolean) { - var x = | { super() } public final fun bar(): R|kotlin/Int| { ^bar R|/f|.R|SubstitutionOverride|() }}")!>foo3 { 1 } + var x = ")!>foo3 { 1 } if (b) { - x = | { super() } public final fun bar(): R|kotlin/Int| { ^bar R|/f|.R|SubstitutionOverride|() }}")!>foo3 { 2 } + x = ")!>foo3 { 2 } } - x.bar() + x.bar() } fun test4(b: Boolean) { diff --git a/compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.fir.kt b/compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.fir.kt index 45af611f7d9..716c9dcd5f8 100644 --- a/compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.fir.kt @@ -11,7 +11,7 @@ private inline fun foo2(crossinline f: () -> Int) = object : I1 { fun bar(): Int = f() } -private inline fun foo3(crossinline f: () -> Int) = object : I1, I2 { +private inline fun foo3(crossinline f: () -> Int) = object : I1, I2 { fun bar(): Int = f() } @@ -36,11 +36,11 @@ fun test2(b: Boolean) { } fun test3(b: Boolean) { - var x = | { super() } public final fun bar(): R|kotlin/Int| { ^bar R|/f|.R|SubstitutionOverride|() }}")!>foo3 { 1 } + var x = ")!>foo3 { 1 } if (b) { - x = | { super() } public final fun bar(): R|kotlin/Int| { ^bar R|/f|.R|SubstitutionOverride|() }}")!>foo3 { 2 } + x = ")!>foo3 { 2 } } - x.bar() + x.bar() } fun test4(b: Boolean) {