From 93378b1a04ee918c245366d4cd224902f5a8eebd Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 16 Nov 2021 16:57:51 +0300 Subject: [PATCH] [FE 1.0] Resolve private constructors of sealed classes same as for regular classes ^KT-44866 ^KT-49729 --- .../api/descriptors/Fe10AnalysisFacade.kt | 6 +- .../components/KtFe10OverrideInfoProvider.kt | 6 +- .../components/KtFe10VisibilityChecker.kt | 22 +++-- ...FactoryForDuplicateSignatureDiagnostics.kt | 5 +- .../checkers/JavaTypeAccessibilityChecker.kt | 12 ++- .../ProtectedSyntheticExtensionCallChecker.kt | 9 +- .../synthetic/syntheticExtensionsUtils.kt | 10 +- .../cfg/ControlFlowInformationProviderImpl.kt | 4 +- .../kotlin/resolve/LazyExplicitImportScope.kt | 8 +- .../kotlin/resolve/OverrideResolver.kt | 14 +-- .../resolve/QualifiedExpressionResolver.kt | 10 +- .../kotlin/resolve/calls/CandidateResolver.kt | 25 +++-- .../ProtectedConstructorCallChecker.kt | 11 ++- .../calls/tower/NewResolutionOldInference.kt | 8 +- .../resolve/calls/tower/PSICallResolver.kt | 2 +- .../kotlin/resolve/lazy/FileScopeFactory.kt | 6 +- .../kotlin/resolve/lazy/LazyImportScope.kt | 3 +- .../DoubleColonExpressionResolver.kt | 10 +- .../psi2ir/generators/ClassGenerator.kt | 2 +- .../descriptors/DescriptorVisibilityUtils.kt | 56 +++++++++++ .../calls/components/ResolutionParts.kt | 11 ++- .../CallableReferencesCandidateFactory.kt | 2 +- .../resolve/calls/tower/ImplicitScopeTower.kt | 3 + .../kotlin/resolve/calls/tower/TowerLevels.kt | 5 +- .../kotlin/config/LanguageVersionSettings.kt | 1 + .../load/java/JavaDescriptorVisibilities.java | 23 ++++- .../descriptors/DescriptorVisibilities.java | 99 +++++++++++++++---- .../descriptors/DescriptorVisibility.kt | 7 +- .../kotlin/resolve/OverridingUtil.java | 12 ++- .../stubs/ClassFileToSourceStubConverter.kt | 4 +- .../compiler/impl/KJvmReplCompleter.kt | 11 ++- 31 files changed, 294 insertions(+), 113 deletions(-) create mode 100644 compiler/resolution/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilityUtils.kt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt index 4479ad412b2..52b712c90e7 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt @@ -11,6 +11,7 @@ import com.intellij.openapi.vfs.VirtualFile import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver @@ -47,4 +48,7 @@ class Fe10AnalysisContext( val builtIns: KotlinBuiltIns get() = resolveSession.moduleDescriptor.builtIns -} \ No newline at end of file + + val languageVersionSettings: LanguageVersionSettings + get() = resolveSession.languageVersionSettings +} diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt index 18f7e649121..da0653c8801 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisibleWithAnyReceiver import org.jetbrains.kotlin.resolve.findOriginalTopMostOverriddenDescriptors import org.jetbrains.kotlin.util.ImplementationStatus @@ -31,7 +31,7 @@ internal class KtFe10OverrideInfoProvider( override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean = withValidityAssertion { val memberDescriptor = getSymbolDescriptor(memberSymbol) as? DeclarationDescriptorWithVisibility ?: return false val classDescriptor = getSymbolDescriptor(classSymbol) ?: return false - return DescriptorVisibilities.isVisibleWithAnyReceiver(memberDescriptor, classDescriptor) + return isVisibleWithAnyReceiver(memberDescriptor, classDescriptor, analysisSession.analysisContext.languageVersionSettings) } override fun getImplementationStatus( @@ -53,4 +53,4 @@ internal class KtFe10OverrideInfoProvider( val containingClassDescriptor = originalCallableDescriptor.containingDeclaration as? ClassDescriptor ?: return null return containingClassDescriptor.toKtClassifierSymbol(analysisContext) as? KtClassOrObjectSymbol } -} \ No newline at end of file +} diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt index 4ee7145c334..0858518e150 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt +++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt @@ -7,8 +7,8 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components import com.intellij.psi.PsiElement import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker -import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode +import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.getResolutionScope @@ -17,9 +17,11 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisible import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.KtCallableDeclaration +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtPsiUtil import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension @@ -52,14 +54,20 @@ internal class KtFe10VisibilityChecker( val bindingContext = analysisContext.analyze(receiverExpression, AnalysisMode.PARTIAL) val receiverType = bindingContext.getType(receiverExpression) ?: return false val explicitReceiver = ExpressionReceiver.create(receiverExpression, receiverType, bindingContext) - return DescriptorVisibilities.isVisible(explicitReceiver, targetDescriptor, useSiteDescriptor) + return isVisible( + explicitReceiver, + targetDescriptor, + useSiteDescriptor, + analysisContext.languageVersionSettings + ) } else { val bindingContext = analysisContext.analyze(useSiteDeclaration, AnalysisMode.FULL) val lexicalScope = position.getResolutionScope(bindingContext) if (lexicalScope != null) { - return lexicalScope.getImplicitReceiversHierarchy() - .any { DescriptorVisibilities.isVisible(it.value, targetDescriptor, useSiteDescriptor) } + return lexicalScope.getImplicitReceiversHierarchy().any { + isVisible(it.value, targetDescriptor, useSiteDescriptor, analysisContext.languageVersionSettings) + } } } @@ -75,4 +83,4 @@ private fun findContainingNonLocalDeclaration(element: PsiElement): KtCallableDe } return null -} \ No newline at end of file +} diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt index f03e73ba718..5ddee9ac14b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt @@ -24,7 +24,6 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.* import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.org.objectweb.asm.commons.Method -import java.util.* private val EXTERNAL_SOURCES_KINDS = arrayOf( JvmDeclarationOriginKind.CLASS_MEMBER_DELEGATION_TO_DEFAULT_IMPL, @@ -49,7 +48,7 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( bindingContext: BindingContext, private val diagnostics: DiagnosticSink, moduleName: String, - languageVersionSettings: LanguageVersionSettings, + val languageVersionSettings: LanguageVersionSettings, useOldInlineClassesManglingScheme: Boolean, shouldGenerate: (JvmDeclarationOrigin) -> Boolean, ) : SignatureCollectingClassBuilderFactory(builderFactory, shouldGenerate) { @@ -231,7 +230,7 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( descriptor.getParentJavaStaticClassScope()?.run { getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) .filter { - it is FunctionDescriptor && DescriptorVisibilities.isVisibleIgnoringReceiver(it, descriptor) + it is FunctionDescriptor && DescriptorVisibilityUtils.isVisibleIgnoringReceiver(it, descriptor, languageVersionSettings) } .forEach(::processMember) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaTypeAccessibilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaTypeAccessibilityChecker.kt index 4b9ece0b228..faef50f8c1c 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaTypeAccessibilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaTypeAccessibilityChecker.kt @@ -16,9 +16,10 @@ package org.jetbrains.kotlin.resolve.jvm.checkers +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor import org.jetbrains.kotlin.psi.KtExpression @@ -58,26 +59,27 @@ class JavaTypeAccessibilityChecker : AdditionalTypeChecker { private fun findInaccessibleJavaClasses(type: KotlinType, c: ResolutionContext<*>): Collection { val scopeOwner = c.scope.ownerDescriptor val inaccessibleJavaClasses = LinkedHashSet() - findInaccessibleJavaClassesRec(type, scopeOwner, inaccessibleJavaClasses) + findInaccessibleJavaClassesRec(type, scopeOwner, inaccessibleJavaClasses, c.languageVersionSettings) return inaccessibleJavaClasses } private fun findInaccessibleJavaClassesRec( type: KotlinType, scopeOwner: DeclarationDescriptor, - inaccessibleClasses: MutableCollection + inaccessibleClasses: MutableCollection, + languageVersionSettings: LanguageVersionSettings ) { val declarationDescriptor = type.constructor.declarationDescriptor if (declarationDescriptor is JavaClassDescriptor) { - if (!DescriptorVisibilities.isVisibleIgnoringReceiver(declarationDescriptor, scopeOwner)) { + if (!DescriptorVisibilityUtils.isVisibleIgnoringReceiver(declarationDescriptor, scopeOwner, languageVersionSettings)) { inaccessibleClasses.add(declarationDescriptor) } } for (typeProjection in type.arguments) { if (typeProjection.isStarProjection) continue - findInaccessibleJavaClassesRec(typeProjection.type, scopeOwner, inaccessibleClasses) + findInaccessibleJavaClassesRec(typeProjection.type, scopeOwner, inaccessibleClasses, languageVersionSettings) } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ProtectedSyntheticExtensionCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ProtectedSyntheticExtensionCallChecker.kt index 51da0a11dcf..5b947e11c1b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ProtectedSyntheticExtensionCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/ProtectedSyntheticExtensionCallChecker.kt @@ -19,8 +19,9 @@ package org.jetbrains.kotlin.resolve.jvm.checkers import com.intellij.psi.PsiElement import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.DescriptorVisibility +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisible import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3 import org.jetbrains.kotlin.diagnostics.Errors @@ -62,7 +63,7 @@ object ProtectedSyntheticExtensionCallChecker : CallChecker { val from = context.scope.ownerDescriptor // Already reported - if (!DescriptorVisibilities.isVisibleIgnoringReceiver(descriptor, from)) return + if (!DescriptorVisibilityUtils.isVisibleIgnoringReceiver(descriptor, from, context.languageVersionSettings)) return if (resolvedCall.dispatchReceiver != null && resolvedCall.extensionReceiver !is ReceiverValue) return @@ -74,7 +75,9 @@ object ProtectedSyntheticExtensionCallChecker : CallChecker { context.languageVersionSettings ) - if (receiverTypes.none { DescriptorVisibilities.isVisible(getReceiverValueWithSmartCast(null, it), sourceFunction, from) }) { + if (receiverTypes.none { + isVisible(getReceiverValueWithSmartCast(null, it), sourceFunction, from, context.languageVersionSettings) + }) { context.trace.report(error.on(reportOn, descriptor, descriptor.visibility, from)) } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/syntheticExtensionsUtils.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/syntheticExtensionsUtils.kt index 028421c481f..78bbad1b283 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/syntheticExtensionsUtils.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/syntheticExtensionsUtils.kt @@ -20,9 +20,9 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor import org.jetbrains.kotlin.load.java.sam.SamAdapterDescriptor -import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.kotlin.resolve.calls.tower.NewResolvedCallImpl +import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue fun FunctionDescriptor.hasJavaOriginInHierarchy(): Boolean { @@ -46,9 +46,13 @@ fun syntheticVisibility(originalDescriptor: DeclarationDescriptorWithVisibility, override fun isVisible( receiver: ReceiverValue?, what: DeclarationDescriptorWithVisibility, - from: DeclarationDescriptor + from: DeclarationDescriptor, + useSpecialRulesForPrivateSealedConstructors: Boolean ) = originalVisibility.isVisible( - if (isUsedForExtension) DescriptorVisibilities.ALWAYS_SUITABLE_RECEIVER else receiver, originalDescriptor, from + if (isUsedForExtension) DescriptorVisibilities.ALWAYS_SUITABLE_RECEIVER else receiver, + originalDescriptor, + from, + useSpecialRulesForPrivateSealedConstructors ) override fun mustCheckInImports() = throw UnsupportedOperationException("Should never be called for this visibility") diff --git a/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt b/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt index 7f825b4c756..a67a599fd47 100644 --- a/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt +++ b/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt @@ -490,9 +490,9 @@ class ControlFlowInformationProviderImpl private constructor( val receiverValue = expression.getResolvedCall(trace.bindingContext)?.getDispatchReceiverWithSmartCast() - if (DescriptorVisibilities.isVisible(receiverValue, variableDescriptor, descriptor) + if (DescriptorVisibilityUtils.isVisible(receiverValue, variableDescriptor, descriptor, languageVersionSettings) && setterDescriptor != null - && !DescriptorVisibilities.isVisible(receiverValue, setterDescriptor, descriptor) + && !DescriptorVisibilityUtils.isVisible(receiverValue, setterDescriptor, descriptor, languageVersionSettings) ) { report( Errors.INVISIBLE_SETTER.on( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyExplicitImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyExplicitImportScope.kt index 8ee763ea62f..7ca59c879c6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyExplicitImportScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyExplicitImportScope.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.resolve import com.intellij.util.SmartList +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.incremental.components.NoLookupLocation @@ -29,6 +30,7 @@ import org.jetbrains.kotlin.utils.Printer import org.jetbrains.kotlin.utils.addIfNotNull class LazyExplicitImportScope( + private val languageVersionSettings: LanguageVersionSettings, private val packageOrClassDescriptor: DeclarationDescriptor, private val packageFragmentForVisibilityCheck: PackageFragmentDescriptor?, private val declaredName: Name, @@ -148,6 +150,8 @@ class LazyExplicitImportScope( else -> null } - private fun Collection.choseOnlyVisibleOrAll() = - filter { isVisible(it, packageFragmentForVisibilityCheck, position = QualifierPosition.IMPORT) }.takeIf { it.isNotEmpty() } ?: this + private fun Collection.choseOnlyVisibleOrAll(): Collection = + filter { isVisible(it, packageFragmentForVisibilityCheck, position = QualifierPosition.IMPORT, languageVersionSettings) } + .takeIf { it.isNotEmpty() } + ?: this } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt index e0d8f2180a3..33d2907e3cd 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.useSpecialRulesForPrivateSealedConstructors import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2 import org.jetbrains.kotlin.diagnostics.DiagnosticFactoryWithPsiElement import org.jetbrains.kotlin.diagnostics.Errors.* @@ -41,7 +42,6 @@ import org.jetbrains.kotlin.resolve.calls.util.isOrOverridesSynthesized import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner import org.jetbrains.kotlin.types.checker.NewKotlinTypeCheckerImpl -import org.jetbrains.kotlin.types.TypeRefinement import org.jetbrains.kotlin.utils.addToStdlib.assertedCast import java.util.* @@ -366,7 +366,7 @@ class OverrideResolver( override fun nothingToOverride(overriding: CallableMemberDescriptor) { trace.report(NOTHING_TO_OVERRIDE.on(member, declared)) } - } + }, languageVersionSettings ) } else if (!overriddenDescriptors.isEmpty() && !overridesBackwardCompatibilityHelper.overrideCanBeOmitted(declared)) { val overridden = overriddenDescriptors.first() @@ -854,7 +854,8 @@ class OverrideResolver( private fun checkOverridesForMemberMarkedOverride( declared: CallableMemberDescriptor, kotlinTypeRefiner: KotlinTypeRefiner, - reportError: CheckOverrideReportForDeclaredMemberStrategy + reportError: CheckOverrideReportForDeclaredMemberStrategy, + languageVersionSettings: LanguageVersionSettings ) { val overriddenDescriptors = declared.overriddenDescriptors @@ -868,7 +869,7 @@ class OverrideResolver( val invisibleOverriddenDescriptor = findInvisibleOverriddenDescriptor( - declared, declaringClass, kotlinTypeRefiner + declared, declaringClass, kotlinTypeRefiner, languageVersionSettings ) if (invisibleOverriddenDescriptor != null) { reportError.cannotOverrideInvisibleMember(declared, invisibleOverriddenDescriptor) @@ -953,7 +954,8 @@ class OverrideResolver( private fun findInvisibleOverriddenDescriptor( declared: CallableMemberDescriptor, declaringClass: ClassDescriptor, - kotlinTypeRefiner: KotlinTypeRefiner + kotlinTypeRefiner: KotlinTypeRefiner, + languageVersionSettings: LanguageVersionSettings ): CallableMemberDescriptor? { @OptIn(TypeRefinement::class) for (supertype in kotlinTypeRefiner.refineSupertypes(declaringClass)) { @@ -962,7 +964,7 @@ class OverrideResolver( all.addAll(supertype.memberScope.getContributedVariables(declared.name, NoLookupLocation.WHEN_CHECK_OVERRIDES)) for (fromSuper in all) { if (OverridingUtil.DEFAULT.isOverridableBy(fromSuper, declared, null).result == OVERRIDABLE) { - if (OverridingUtil.isVisibleForOverride(declared, fromSuper)) { + if (OverridingUtil.isVisibleForOverride(declared, fromSuper, languageVersionSettings.useSpecialRulesForPrivateSealedConstructors)) { throw IllegalStateException( "Descriptor " + fromSuper + " is overridable by " + declared + " and visible but does not appear in its getOverriddenDescriptors()" diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt index 806d0619127..c8609e1a9a5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt @@ -336,6 +336,7 @@ class QualifiedExpressionResolver(val languageVersionSettings: LanguageVersionSe (resolvedDescriptor as? TypeAliasDescriptor)?.let { it.classDescriptor ?: return null } ?: resolvedDescriptor return LazyExplicitImportScope( + languageVersionSettings, packageOrClassDescriptor, packageFragmentForVisibilityCheck, lastPart.name, @@ -739,7 +740,7 @@ class QualifiedExpressionResolver(val languageVersionSettings: LanguageVersionSe ) { referenceExpression ?: return if (descriptors.size > 1) { - val visibleDescriptors = descriptors.filter { isVisible(it, shouldBeVisibleFrom, position) } + val visibleDescriptors = descriptors.filter { isVisible(it, shouldBeVisibleFrom, position, languageVersionSettings) } when { visibleDescriptors.isEmpty() -> { val descriptor = descriptors.first() as DeclarationDescriptorWithVisibility @@ -782,7 +783,7 @@ class QualifiedExpressionResolver(val languageVersionSettings: LanguageVersionSe } else { shouldBeVisibleFrom } - if (!isVisible(descriptor, fromToCheck, position)) { + if (!isVisible(descriptor, fromToCheck, position, languageVersionSettings)) { trace.report(Errors.INVISIBLE_REFERENCE.on(referenceExpression, descriptor, descriptor.visibility, descriptor)) } } @@ -836,7 +837,8 @@ class QualifiedExpressionResolver(val languageVersionSettings: LanguageVersionSe internal fun isVisible( descriptor: DeclarationDescriptor, shouldBeVisibleFrom: DeclarationDescriptor?, - position: QualifierPosition + position: QualifierPosition, + languageVersionSettings: LanguageVersionSettings ): Boolean { if (descriptor !is DeclarationDescriptorWithVisibility || shouldBeVisibleFrom == null) return true @@ -845,7 +847,7 @@ internal fun isVisible( if (DescriptorVisibilities.isPrivate(visibility)) return DescriptorVisibilities.inSameFile(descriptor, shouldBeVisibleFrom) if (!visibility.mustCheckInImports()) return true } - return DescriptorVisibilities.isVisibleIgnoringReceiver(descriptor, shouldBeVisibleFrom) + return DescriptorVisibilityUtils.isVisibleIgnoringReceiver(descriptor, shouldBeVisibleFrom, languageVersionSettings) } internal enum class QualifierPosition { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt index 7c8d19da795..53c4e046b6e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt @@ -12,17 +12,12 @@ import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.diagnostics.Errors.* +import org.jetbrains.kotlin.diagnostics.Errors.EXPANDED_TYPE_CANNOT_BE_CONSTRUCTED +import org.jetbrains.kotlin.diagnostics.Errors.SUPER_CANT_BE_EXTENSION_RECEIVER import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.calls.CallTransformer.CallForImplicitInvoke -import org.jetbrains.kotlin.resolve.calls.util.ResolveArgumentsMode -import org.jetbrains.kotlin.resolve.calls.util.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS -import org.jetbrains.kotlin.resolve.calls.util.getEffectiveExpectedType -import org.jetbrains.kotlin.resolve.calls.util.getErasedReceiverType -import org.jetbrains.kotlin.resolve.calls.util.isInvokeCallOnExpressionWithBothReceivers -import org.jetbrains.kotlin.resolve.calls.util.isSafeCall import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker import org.jetbrains.kotlin.resolve.calls.context.* import org.jetbrains.kotlin.resolve.calls.inference.SubstitutionFilteringInternalResolveAnnotations @@ -33,7 +28,8 @@ import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.* import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory import org.jetbrains.kotlin.resolve.calls.smartcasts.SmartCastManager import org.jetbrains.kotlin.resolve.calls.smartcasts.getReceiverValueWithSmartCast -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject +import org.jetbrains.kotlin.resolve.calls.util.* +import org.jetbrains.kotlin.resolve.calls.util.ResolveArgumentsMode.SHAPE_FUNCTION_ARGUMENTS import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver import org.jetbrains.kotlin.resolve.scopes.receivers.Receiver import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue @@ -44,7 +40,6 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.types.expressions.DoubleColonExpressionResolver import org.jetbrains.kotlin.types.typeUtil.containsTypeProjectionsInTopLevelArguments import org.jetbrains.kotlin.types.typeUtil.makeNotNullable -import java.util.* import kotlin.math.min class CandidateResolver( @@ -185,8 +180,11 @@ class CandidateResolver( receiverArgument: ReceiverValue?, smartCastType: KotlinType? ): ResolutionStatus { - val invisibleMember = DescriptorVisibilities.findInvisibleMember( - getReceiverValueWithSmartCast(receiverArgument, smartCastType), candidateDescriptor, scope.ownerDescriptor + val invisibleMember = DescriptorVisibilityUtils.findInvisibleMember( + getReceiverValueWithSmartCast(receiverArgument, smartCastType), + candidateDescriptor, + scope.ownerDescriptor, + languageVersionSettings ) return if (invisibleMember != null) { tracing.invisibleMember(trace, invisibleMember) @@ -205,9 +203,10 @@ class CandidateResolver( private fun CallCandidateResolutionContext<*>.isCandidateVisible( receiverArgument: ReceiverValue?, smartCastType: KotlinType? - ) = DescriptorVisibilities.findInvisibleMember( + ) = DescriptorVisibilityUtils.findInvisibleMember( getReceiverValueWithSmartCast(receiverArgument, smartCastType), - candidateDescriptor, scope.ownerDescriptor + candidateDescriptor, scope.ownerDescriptor, + languageVersionSettings ) == null private fun CallCandidateResolutionContext<*>.checkExtensionReceiver() = checkAndReport { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ProtectedConstructorCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ProtectedConstructorCallChecker.kt index 9d725c0632a..1cc16392a0d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ProtectedConstructorCallChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ProtectedConstructorCallChecker.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve.calls.checkers import com.intellij.psi.PsiElement import org.jetbrains.kotlin.descriptors.ConstructorDescriptor import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.psi.KtConstructorCalleeExpression @@ -37,7 +38,7 @@ object ProtectedConstructorCallChecker : CallChecker { if (actualConstructor.visibility.normalize() != DescriptorVisibilities.PROTECTED) return // Error already reported - if (!DescriptorVisibilities.isVisibleWithAnyReceiver(descriptor, scopeOwner)) return + if (!DescriptorVisibilityUtils.isVisibleWithAnyReceiver(descriptor, scopeOwner, context.languageVersionSettings)) return val calleeExpression = resolvedCall.call.calleeExpression @@ -55,7 +56,13 @@ object ProtectedConstructorCallChecker : CallChecker { // And without ProtectedConstructorCallChecker such calls would be allowed only because they are performed within subclass // of constructor owner @Suppress("DEPRECATION") - if (DescriptorVisibilities.findInvisibleMember(DescriptorVisibilities.FALSE_IF_PROTECTED, descriptor, scopeOwner) == actualConstructor.original) { + if (DescriptorVisibilityUtils.findInvisibleMember( + DescriptorVisibilities.FALSE_IF_PROTECTED, + descriptor, + scopeOwner, + context.languageVersionSettings + ) == actualConstructor.original + ) { context.trace.report(Errors.PROTECTED_CONSTRUCTOR_NOT_IN_SUPER_CALL.on(reportOn, descriptor)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt index 89d8517a1eb..faef82cb818 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt @@ -32,10 +32,6 @@ import org.jetbrains.kotlin.resolve.TemporaryBindingTrace import org.jetbrains.kotlin.resolve.calls.CallResolver import org.jetbrains.kotlin.resolve.calls.CallTransformer import org.jetbrains.kotlin.resolve.calls.CandidateResolver -import org.jetbrains.kotlin.resolve.calls.util.isBinaryRemOperator -import org.jetbrains.kotlin.resolve.calls.util.isConventionCall -import org.jetbrains.kotlin.resolve.calls.util.isInfixCall -import org.jetbrains.kotlin.resolve.calls.util.createLookupLocation import org.jetbrains.kotlin.resolve.calls.context.* import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceSupport import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic @@ -48,7 +44,7 @@ import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory import org.jetbrains.kotlin.resolve.calls.tasks.* -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject +import org.jetbrains.kotlin.resolve.calls.util.* import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver import org.jetbrains.kotlin.resolve.descriptorUtil.hasDynamicExtensionAnnotation import org.jetbrains.kotlin.resolve.scopes.* @@ -381,6 +377,8 @@ class NewResolutionOldInference( override val isNewInferenceEnabled: Boolean get() = resolutionContext.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) + override val languageVersionSettings: LanguageVersionSettings + get() = resolutionContext.languageVersionSettings override fun interceptFunctionCandidates( resolutionScope: ResolutionScope, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt index 2f2eab86c23..6256c501660 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/PSICallResolver.kt @@ -50,7 +50,6 @@ import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContext import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments import org.jetbrains.kotlin.utils.addToStdlib.compactIfPossible import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull -import java.util.* class PSICallResolver( private val typeResolver: TypeResolver, @@ -395,6 +394,7 @@ class PSICallResolver( override val syntheticScopes: SyntheticScopes get() = this@PSICallResolver.syntheticScopes override val isDebuggerContext: Boolean get() = context.isDebuggerContext override val isNewInferenceEnabled: Boolean get() = context.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) + override val languageVersionSettings: LanguageVersionSettings get() = context.languageVersionSettings override val lexicalScope: LexicalScope get() = context.scope override val typeApproximator: TypeApproximator get() = this@PSICallResolver.typeApproximator override val implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter get() = this@PSICallResolver.implicitsResolutionFilter diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt index 68c045b9773..26f6c08f0f5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/FileScopeFactory.kt @@ -269,7 +269,11 @@ class FileScopeFactory( override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { if (name in excludedNames) return null val classifier = scope.getContributedClassifier(name, location) ?: return null - val visible = DescriptorVisibilities.isVisibleIgnoringReceiver(classifier as DeclarationDescriptorWithVisibility, fromDescriptor) + val visible = DescriptorVisibilityUtils.isVisibleIgnoringReceiver( + classifier as DeclarationDescriptorWithVisibility, + fromDescriptor, + components.languageVersionSettings + ) return classifier.takeIf { filteringKind == if (visible) FilteringKind.VISIBLE_CLASSES else FilteringKind.INVISIBLE_CLASSES } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt index a0f77d91c53..21e13c0be9b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt @@ -23,6 +23,7 @@ import gnu.trove.THashSet import org.jetbrains.kotlin.builtins.PlatformToKotlinClassMapper import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisibleIgnoringReceiver import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.incremental.KotlinLookupLocation import org.jetbrains.kotlin.incremental.components.LookupLocation @@ -240,7 +241,7 @@ class LazyImportScope( val visibility = (descriptor as DeclarationDescriptorWithVisibility).visibility val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES if (!visibility.mustCheckInImports()) return includeVisible - return DescriptorVisibilities.isVisibleIgnoringReceiver(descriptor, components.moduleDescriptor) == includeVisible + return isVisibleIgnoringReceiver(descriptor, components.moduleDescriptor, components.languageVersionSettings) == includeVisible } override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt index 20361eb3ace..80d60c89ac8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt @@ -25,9 +25,6 @@ import org.jetbrains.kotlin.psi.psiUtil.checkReservedYield import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElementSelector import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.calls.CallResolver -import org.jetbrains.kotlin.resolve.calls.util.ResolveArgumentsMode -import org.jetbrains.kotlin.resolve.calls.util.getCalleeExpressionIfAny -import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall import org.jetbrains.kotlin.resolve.calls.checkers.isBuiltInCoroutineContext import org.jetbrains.kotlin.resolve.calls.context.* import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceSession @@ -35,9 +32,7 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResultsUtil import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory -import org.jetbrains.kotlin.resolve.calls.util.CallMaker -import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject -import org.jetbrains.kotlin.resolve.calls.util.createValueParametersForInvokeInFunctionType +import org.jetbrains.kotlin.resolve.calls.util.* import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns import org.jetbrains.kotlin.resolve.scopes.receivers.ClassQualifier import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver @@ -50,7 +45,6 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner import org.jetbrains.kotlin.types.expressions.FunctionWithBigAritySupport.LanguageVersionDependent import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo import org.jetbrains.kotlin.types.expressions.typeInfoFactory.noTypeInfo -import org.jetbrains.kotlin.types.TypeRefinement import org.jetbrains.kotlin.types.typeUtil.* import org.jetbrains.kotlin.utils.yieldIfNotNull import java.util.* @@ -846,7 +840,7 @@ class DoubleColonExpressionResolver( ): Boolean { val receiver = receiverTypeFor(descriptor, lhs)?.let(::TransientReceiver) val setter = descriptor.setter - return descriptor.isVar && (setter == null || DescriptorVisibilities.isVisible(receiver, setter, scopeOwnerDescriptor)) + return descriptor.isVar && (setter == null || DescriptorVisibilities.isVisible(receiver, setter, scopeOwnerDescriptor, false)) } fun createKCallableTypeForReference( diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt index 548f92c8c7c..5269930fa72 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt @@ -155,7 +155,7 @@ class ClassGenerator( context.extensions.getParentClassStaticScope(classDescriptor)?.run { for (parentStaticMember in getContributedDescriptors()) { if (parentStaticMember is FunctionDescriptor && - DescriptorVisibilities.isVisibleIgnoringReceiver(parentStaticMember, classDescriptor) + DescriptorVisibilityUtils.isVisibleIgnoringReceiver(parentStaticMember, classDescriptor, context.languageVersionSettings) ) { val fakeOverride = createFakeOverrideDescriptorForParentStaticMember(classDescriptor, parentStaticMember) declarationGenerator.generateFakeOverrideDeclaration(fakeOverride, ktClassOrObject)?.let { diff --git a/compiler/resolution/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilityUtils.kt b/compiler/resolution/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilityUtils.kt new file mode 100644 index 00000000000..cb6cbb25cbf --- /dev/null +++ b/compiler/resolution/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilityUtils.kt @@ -0,0 +1,56 @@ +/* + * 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.descriptors + +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.descriptors.DescriptorVisibilities.* +import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue + + +object DescriptorVisibilityUtils { + @JvmStatic + fun findInvisibleMember( + receiver: ReceiverValue?, + what: DeclarationDescriptorWithVisibility, + from: DeclarationDescriptor, + languageVersionSettings: LanguageVersionSettings + ): DeclarationDescriptorWithVisibility? { + return findInvisibleMember(receiver, what, from, languageVersionSettings.useSpecialRulesForPrivateSealedConstructors) + } + + @JvmStatic + fun isVisible( + receiver: ReceiverValue?, + what: DeclarationDescriptorWithVisibility, + from: DeclarationDescriptor, + languageVersionSettings: LanguageVersionSettings + ): Boolean { + return isVisible(receiver, what, from, languageVersionSettings.useSpecialRulesForPrivateSealedConstructors) + } + + @JvmStatic + fun isVisibleIgnoringReceiver( + what: DeclarationDescriptorWithVisibility, + from: DeclarationDescriptor, + languageVersionSettings: LanguageVersionSettings + ): Boolean { + return isVisibleIgnoringReceiver(what, from, languageVersionSettings.useSpecialRulesForPrivateSealedConstructors) + } + + @JvmStatic + fun isVisibleWithAnyReceiver( + what: DeclarationDescriptorWithVisibility, + from: DeclarationDescriptor, + languageVersionSettings: LanguageVersionSettings + ): Boolean { + return isVisibleWithAnyReceiver(what, from, languageVersionSettings.useSpecialRulesForPrivateSealedConstructors) + } + + val LanguageVersionSettings.useSpecialRulesForPrivateSealedConstructors: Boolean + get() = !supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage) || + !supportsFeature(LanguageFeature.UseConsistentRulesForPrivateConstructorsOfSealedClasses) +} diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt index e2113f9c6be..c7e55049efa 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ResolutionParts.kt @@ -11,8 +11,8 @@ import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor import org.jetbrains.kotlin.resolve.calls.components.TypeArgumentsToParametersMapper.TypeArgumentsMapping.NoExplicitArguments -import org.jetbrains.kotlin.resolve.calls.components.candidate.ResolutionCandidate import org.jetbrains.kotlin.resolve.calls.components.candidate.CallableReferenceResolutionCandidate +import org.jetbrains.kotlin.resolve.calls.components.candidate.ResolutionCandidate import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation import org.jetbrains.kotlin.resolve.calls.inference.NewConstraintSystem import org.jetbrains.kotlin.resolve.calls.inference.components.* @@ -43,11 +43,16 @@ internal object CheckVisibility : ResolutionPart() { val receiverValue = dispatchReceiverArgument?.receiver?.receiverValue ?: DescriptorVisibilities.ALWAYS_SUITABLE_RECEIVER val invisibleMember = - DescriptorVisibilities.findInvisibleMember(receiverValue, resolvedCall.candidateDescriptor, containingDescriptor) ?: return + DescriptorVisibilityUtils.findInvisibleMember( + receiverValue, + resolvedCall.candidateDescriptor, + containingDescriptor, + callComponents.languageVersionSettings + ) ?: return if (dispatchReceiverArgument is ExpressionKotlinCallArgument) { val smartCastReceiver = getReceiverValueWithSmartCast(receiverValue, dispatchReceiverArgument.receiver.stableType) - if (DescriptorVisibilities.findInvisibleMember(smartCastReceiver, candidateDescriptor, containingDescriptor) == null) { + if (DescriptorVisibilityUtils.findInvisibleMember(smartCastReceiver, candidateDescriptor, containingDescriptor, callComponents.languageVersionSettings) == null) { addDiagnostic( SmartCastDiagnostic( dispatchReceiverArgument, diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/CallableReferencesCandidateFactory.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/CallableReferencesCandidateFactory.kt index 0867ab8cdff..dd5af269740 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/CallableReferencesCandidateFactory.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/model/CallableReferencesCandidateFactory.kt @@ -340,7 +340,7 @@ class CallableReferencesCandidateFactory( val setter = descriptor.setter setter == null || DescriptorVisibilities.isVisible( dispatchReceiver?.asReceiverValueForVisibilityChecks, setter, - scopeTower.lexicalScope.ownerDescriptor + scopeTower.lexicalScope.ownerDescriptor, false ) } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt index d9067945310..d621eb10237 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.resolve.calls.tower +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.name.Name @@ -48,6 +49,8 @@ interface ImplicitScopeTower { val isNewInferenceEnabled: Boolean + val languageVersionSettings: LanguageVersionSettings + val typeApproximator: TypeApproximator val implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt index 90ed441b361..a8d31c18d08 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt @@ -64,10 +64,11 @@ internal abstract class AbstractScopeTowerLevel( val shouldSkipVisibilityCheck = scopeTower.isNewInferenceEnabled if (!shouldSkipVisibilityCheck) { - DescriptorVisibilities.findInvisibleMember( + DescriptorVisibilityUtils.findInvisibleMember( getReceiverValueWithSmartCast(dispatchReceiver?.receiverValue, dispatchReceiverSmartCastType), descriptor, - scopeTower.lexicalScope.ownerDescriptor + scopeTower.lexicalScope.ownerDescriptor, + scopeTower.languageVersionSettings )?.let { diagnostics.add(VisibilityError(it)) } } } diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index f08b8131a84..9809991fff3 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -243,6 +243,7 @@ enum class LanguageFeature( // 1.8 ProhibitConfusingSyntaxInWhenBranches(KOTLIN_1_8, kind = BUG_FIX), // KT-48385 + UseConsistentRulesForPrivateConstructorsOfSealedClasses(sinceVersion = KOTLIN_1_8, kind = BUG_FIX), // KT-44866 // Temporarily disabled, see KT-27084/KT-22379 SoundSmartcastFromLoopConditionForLoopAssignedVariables(sinceVersion = null, kind = BUG_FIX), diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaDescriptorVisibilities.java b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaDescriptorVisibilities.java index 5dd2fa52a44..bdd4a26c01f 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaDescriptorVisibilities.java +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaDescriptorVisibilities.java @@ -33,7 +33,12 @@ public class JavaDescriptorVisibilities { @NotNull public static final DescriptorVisibility PACKAGE_VISIBILITY = new DelegatedDescriptorVisibility(JavaVisibilities.PackageVisibility.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return areInSamePackage(what, from); } }; @@ -41,7 +46,12 @@ public class JavaDescriptorVisibilities { @NotNull public static final DescriptorVisibility PROTECTED_STATIC_VISIBILITY = new DelegatedDescriptorVisibility(JavaVisibilities.ProtectedStaticVisibility.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return isVisibleForProtectedAndPackage(receiver, what, from); } }; @@ -49,7 +59,12 @@ public class JavaDescriptorVisibilities { @NotNull public static final DescriptorVisibility PROTECTED_AND_PACKAGE = new DelegatedDescriptorVisibility(JavaVisibilities.ProtectedAndPackage.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return isVisibleForProtectedAndPackage(receiver, what, from); } }; @@ -63,7 +78,7 @@ public class JavaDescriptorVisibilities { return true; } - return DescriptorVisibilities.PROTECTED.isVisible(receiver, what, from); + return DescriptorVisibilities.PROTECTED.isVisible(receiver, what, from, false); } private static boolean areInSamePackage(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilities.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilities.java index f782fd9f064..39dcb67eda7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilities.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibilities.java @@ -39,14 +39,20 @@ public class DescriptorVisibilities { } @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { if (DescriptorUtils.isTopLevelDeclaration(what) && hasContainingSourceFile(from)) { return inSameFile(what, from); } if (what instanceof ConstructorDescriptor) { ClassifierDescriptorWithTypeParameters classDescriptor = ((ConstructorDescriptor) what).getContainingDeclaration(); - if (DescriptorUtils.isSealedClass(classDescriptor) + if (useSpecialRulesForPrivateSealedConstructors + && DescriptorUtils.isSealedClass(classDescriptor) && DescriptorUtils.isTopLevelDeclaration(classDescriptor) && from instanceof ConstructorDescriptor && DescriptorUtils.isTopLevelDeclaration(from.getContainingDeclaration()) @@ -99,8 +105,13 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility PRIVATE_TO_THIS = new DelegatedDescriptorVisibility(Visibilities.PrivateToThis.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue thisObject, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - if (PRIVATE.isVisible(thisObject, what, from)) { + public boolean isVisible( + @Nullable ReceiverValue thisObject, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { + if (PRIVATE.isVisible(thisObject, what, from, useSpecialRulesForPrivateSealedConstructors)) { // See Visibility.isVisible contract if (thisObject == ALWAYS_SUITABLE_RECEIVER) return true; if (thisObject == IRRELEVANT_RECEIVER) return false; @@ -121,7 +132,8 @@ public class DescriptorVisibilities { public boolean isVisible( @Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, - @NotNull DeclarationDescriptor from + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors ) { ClassDescriptor givenDescriptorContainingClass = DescriptorUtils.getParentOfType(what, ClassDescriptor.class); ClassDescriptor fromClass = DescriptorUtils.getParentOfType(from, ClassDescriptor.class, false); @@ -148,7 +160,7 @@ public class DescriptorVisibilities { return true; } - return isVisible(receiver, what, fromClass.getContainingDeclaration()); + return isVisible(receiver, what, fromClass.getContainingDeclaration(), useSpecialRulesForPrivateSealedConstructors); } private boolean doesReceiverFitForProtectedVisibility( @@ -179,7 +191,12 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility INTERNAL = new DelegatedDescriptorVisibility(Visibilities.Internal.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { ModuleDescriptor whatModule = DescriptorUtils.getContainingModule(what); ModuleDescriptor fromModule = DescriptorUtils.getContainingModule(from); @@ -196,7 +213,12 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility PUBLIC = new DelegatedDescriptorVisibility(Visibilities.Public.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return true; } }; @@ -204,7 +226,12 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility LOCAL = new DelegatedDescriptorVisibility(Visibilities.Local.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { throw new IllegalStateException("This method shouldn't be invoked for LOCAL visibility"); } }; @@ -212,7 +239,12 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility INHERITED = new DelegatedDescriptorVisibility(Visibilities.Inherited.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { throw new IllegalStateException("Visibility is unknown yet"); //This method shouldn't be invoked for INHERITED visibility } }; @@ -221,7 +253,12 @@ public class DescriptorVisibilities { @NotNull public static final DescriptorVisibility INVISIBLE_FAKE = new DelegatedDescriptorVisibility(Visibilities.InvisibleFake.INSTANCE) { @Override - public boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { + public boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return false; } }; @@ -232,7 +269,8 @@ public class DescriptorVisibilities { public static final DescriptorVisibility UNKNOWN = new DelegatedDescriptorVisibility(Visibilities.Unknown.INSTANCE) { @Override public boolean isVisible( - @Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from + @Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors ) { return false; } @@ -244,23 +282,36 @@ public class DescriptorVisibilities { private DescriptorVisibilities() { } - public static boolean isVisible(@Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - return findInvisibleMember(receiver, what, from) == null; + public static boolean isVisible( + @Nullable ReceiverValue receiver, + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { + return findInvisibleMember(receiver, what, from, useSpecialRulesForPrivateSealedConstructors) == null; } /** * @see DescriptorVisibility.isVisible contract */ - public static boolean isVisibleIgnoringReceiver(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - return findInvisibleMember(ALWAYS_SUITABLE_RECEIVER, what, from) == null; + public static boolean isVisibleIgnoringReceiver( + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { + return findInvisibleMember(ALWAYS_SUITABLE_RECEIVER, what, from, useSpecialRulesForPrivateSealedConstructors) == null; } /** * @see DescriptorVisibility.isVisible contract * @see DescriptorVisibilities.RECEIVER_DOES_NOT_EXIST */ - public static boolean isVisibleWithAnyReceiver(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - return findInvisibleMember(IRRELEVANT_RECEIVER, what, from) == null; + public static boolean isVisibleWithAnyReceiver( + @NotNull DeclarationDescriptorWithVisibility what, + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors + ) { + return findInvisibleMember(IRRELEVANT_RECEIVER, what, from, useSpecialRulesForPrivateSealedConstructors) == null; } // Note that this method returns false if `from` declaration is `init` initializer @@ -277,11 +328,12 @@ public class DescriptorVisibilities { public static DeclarationDescriptorWithVisibility findInvisibleMember( @Nullable ReceiverValue receiver, @NotNull DeclarationDescriptorWithVisibility what, - @NotNull DeclarationDescriptor from + @NotNull DeclarationDescriptor from, + boolean useSpecialRulesForPrivateSealedConstructors ) { DeclarationDescriptorWithVisibility parent = (DeclarationDescriptorWithVisibility) what.getOriginal(); while (parent != null && parent.getVisibility() != LOCAL) { - if (!parent.getVisibility().isVisible(receiver, parent, from)) { + if (!parent.getVisibility().isVisible(receiver, parent, from, useSpecialRulesForPrivateSealedConstructors)) { return parent; } parent = DescriptorUtils.getParentOfType(parent, DeclarationDescriptorWithVisibility.class); @@ -289,7 +341,12 @@ public class DescriptorVisibilities { if (what instanceof TypeAliasConstructorDescriptor) { DeclarationDescriptorWithVisibility invisibleUnderlying = - findInvisibleMember(receiver, ((TypeAliasConstructorDescriptor) what).getUnderlyingConstructorDescriptor(), from); + findInvisibleMember( + receiver, + ((TypeAliasConstructorDescriptor) what).getUnderlyingConstructorDescriptor(), + from, + useSpecialRulesForPrivateSealedConstructors + ); if (invisibleUnderlying != null) return invisibleUnderlying; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibility.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibility.kt index 74cb7743b57..b4497183b96 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibility.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorVisibility.kt @@ -40,7 +40,12 @@ abstract class DescriptorVisibility protected constructor() { * * Also it's important that implementation that take receiver into account do aware about these special values. */ - abstract fun isVisible(receiver: ReceiverValue?, what: DeclarationDescriptorWithVisibility, from: DeclarationDescriptor): Boolean + abstract fun isVisible( + receiver: ReceiverValue?, + what: DeclarationDescriptorWithVisibility, + from: DeclarationDescriptor, + useSpecialRulesForPrivateSealedConstructors: Boolean + ): Boolean /** * True, if it makes sense to check this visibility in imports and not import inaccessible declarations with such visibility. diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java index 601b8e41f9d..14ab093feb7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/OverridingUtil.java @@ -504,9 +504,13 @@ public class OverridingUtil { createAndBindFakeOverrides(current, notOverridden, strategy); } - public static boolean isVisibleForOverride(@NotNull MemberDescriptor overriding, @NotNull MemberDescriptor fromSuper) { + public static boolean isVisibleForOverride( + @NotNull MemberDescriptor overriding, + @NotNull MemberDescriptor fromSuper, + boolean useSpecialRulesForPrivateSealedConstructors + ) { return !DescriptorVisibilities.isPrivate(fromSuper.getVisibility()) && - DescriptorVisibilities.isVisibleIgnoringReceiver(fromSuper, overriding); + DescriptorVisibilities.isVisibleIgnoringReceiver(fromSuper, overriding, useSpecialRulesForPrivateSealedConstructors); } private Collection extractAndBindOverridesForMember( @@ -520,7 +524,7 @@ public class OverridingUtil { for (CallableMemberDescriptor fromSupertype : descriptorsFromSuper) { OverrideCompatibilityInfo.Result result = isOverridableBy(fromSupertype, fromCurrent, current).getResult(); - boolean isVisibleForOverride = isVisibleForOverride(fromCurrent, fromSupertype); + boolean isVisibleForOverride = isVisibleForOverride(fromCurrent, fromSupertype, false); switch (result) { case OVERRIDABLE: @@ -810,7 +814,7 @@ public class OverridingUtil { public Boolean invoke(CallableMemberDescriptor descriptor) { //nested class could capture private member, so check for private visibility added return !DescriptorVisibilities.isPrivate(descriptor.getVisibility()) && - DescriptorVisibilities.isVisibleIgnoringReceiver(descriptor, current); + DescriptorVisibilities.isVisibleIgnoringReceiver(descriptor, current, false); } }); } diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt index 27e2b40dbe0..ef2de012374 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt @@ -956,7 +956,9 @@ class ClassFileToSourceStubConverter(val kaptContext: KaptContextForStubGenerati // We already checked it in convertClass() val declaration = kaptContext.origins[containingClass]?.descriptor as ClassDescriptor val superClass = declaration.getSuperClassOrAny() - val superClassConstructor = superClass.constructors.firstOrNull { it.visibility.isVisible(null, it, declaration) } + val superClassConstructor = superClass.constructors.firstOrNull { + it.visibility.isVisible(null, it, declaration, useSpecialRulesForPrivateSealedConstructors = true) + } val superClassConstructorCall = if (superClassConstructor != null) { val args = mapJList(superClassConstructor.valueParameters) { param -> diff --git a/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt b/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt index 18979d8be66..d1ed00109bc 100644 --- a/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt +++ b/plugins/scripting/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt @@ -11,10 +11,6 @@ import org.jetbrains.kotlin.builtins.isFunctionType import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl -import org.jetbrains.kotlin.scripting.ide_common.idea.codeInsight.ReferenceVariantsHelper -import org.jetbrains.kotlin.scripting.ide_common.idea.util.CallTypeAndReceiver -import org.jetbrains.kotlin.scripting.ide_common.idea.util.IdeDescriptorRenderersScripting -import org.jetbrains.kotlin.scripting.ide_common.idea.util.getResolutionScope import org.jetbrains.kotlin.lexer.KtKeywordToken import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.ClassId @@ -32,8 +28,13 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.annotations.argumentValue import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope.Companion.ALL_NAME_FILTER +import org.jetbrains.kotlin.scripting.ide_common.idea.codeInsight.ReferenceVariantsHelper +import org.jetbrains.kotlin.scripting.ide_common.idea.util.CallTypeAndReceiver +import org.jetbrains.kotlin.scripting.ide_common.idea.util.IdeDescriptorRenderersScripting +import org.jetbrains.kotlin.scripting.ide_common.idea.util.getResolutionScope import org.jetbrains.kotlin.scripting.ide_services.compiler.completion import org.jetbrains.kotlin.scripting.ide_services.compiler.filterOutShadowedDescriptors +import org.jetbrains.kotlin.scripting.ide_services.compiler.impl.KJvmReplCompleter.ResultGetter import org.jetbrains.kotlin.scripting.ide_services.compiler.nameFilter import org.jetbrains.kotlin.scripting.resolve.classId import org.jetbrains.kotlin.types.KotlinType @@ -373,7 +374,7 @@ private class KJvmReplCompleter( if (descriptor is DeclarationDescriptorWithVisibility) { return try { - descriptor.visibility.isVisible(null, descriptor, inDescriptor) + descriptor.visibility.isVisible(null, descriptor, inDescriptor, useSpecialRulesForPrivateSealedConstructors = true) } catch (e: IllegalStateException) { true }