[FE 1.0] Resolve private constructors of sealed classes same as for regular classes

^KT-44866
^KT-49729

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
+
+    val languageVersionSettings: LanguageVersionSettings
+        get() = resolveSession.languageVersionSettings
 }

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(

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()
+                return lexicalScope.getImplicitReceiversHierarchy().any {
-                    .any { DescriptorVisibilities.isVisible(it.value, targetDescriptor, useSiteDescriptor) }
+                    isVisible(it.value, targetDescriptor, useSiteDescriptor, analysisContext.languageVersionSettings)
+                }
             }
         }
 

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)
         }

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<ClassDescriptor> {
         val scopeOwner = c.scope.ownerDescriptor
         val inaccessibleJavaClasses = LinkedHashSet<ClassDescriptor>()
-        findInaccessibleJavaClassesRec(type, scopeOwner, inaccessibleJavaClasses)
+        findInaccessibleJavaClassesRec(type, scopeOwner, inaccessibleJavaClasses, c.languageVersionSettings)
         return inaccessibleJavaClasses
     }
 
     private fun findInaccessibleJavaClassesRec(
             type: KotlinType,
             scopeOwner: DeclarationDescriptor,
-            inaccessibleClasses: MutableCollection<ClassDescriptor>
+            inaccessibleClasses: MutableCollection<ClassDescriptor>,
+            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)
         }
     }
 

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))
         }
     }

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")

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(

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 <D : CallableMemberDescriptor> Collection<D>.choseOnlyVisibleOrAll() =
+    private fun <D : CallableMemberDescriptor> Collection<D>.choseOnlyVisibleOrAll(): Collection<D> =
-        filter { isVisible(it, packageFragmentForVisibilityCheck, position = QualifierPosition.IMPORT) }.takeIf { it.isNotEmpty() } ?: this
+        filter { isVisible(it, packageFragmentForVisibilityCheck, position = QualifierPosition.IMPORT, languageVersionSettings) }
+            .takeIf { it.isNotEmpty() }
+            ?: this
 }

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()"

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 {

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(
+        val invisibleMember = DescriptorVisibilityUtils.findInvisibleMember(
-            getReceiverValueWithSmartCast(receiverArgument, smartCastType), candidateDescriptor, scope.ownerDescriptor
+            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 {

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))
         }
     }

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,

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

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 }
             }
 

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? {

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.*
-import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
-import org.jetbrains.kotlin.resolve.calls.util.createValueParametersForInvokeInFunctionType
 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(

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 {

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)
+}

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,

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
                     )
                 }
 

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

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)) }
             }
         }

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),

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) {

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) {
+        public boolean isVisible(
-            if (PRIVATE.isVisible(thisObject, what, from)) {
+                @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) {
+    public static boolean isVisible(
-        return findInvisibleMember(receiver, what, from) == null;
+            @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) {
+    public static boolean isVisibleIgnoringReceiver(
-        return findInvisibleMember(ALWAYS_SUITABLE_RECEIVER, what, from) == null;
+            @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) {
+    public static boolean isVisibleWithAnyReceiver(
-        return findInvisibleMember(IRRELEVANT_RECEIVER, what, from) == null;
+            @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;
         }
 

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.

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<CallableMemberDescriptor> 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);
             }
         });
     }

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 ->

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
                 }