Introduce deprecation of companion objects nested classes

Introdude deprecation as per KT-21515. Warning is reported on type
usage, that soon will became invisible. Quickfix by adding explicit
import is added.

Idea behind implementation is to mark scopes that are deprecated (see
ClassResolutionScopesSupport).

Then, during walk along hierarchy of scopes, look at deprecation status
of the scope that has provided this classifier.
Note that we also have to check if there are *some* non-deprecated
visibility paths (because we can see classifier by two paths, e.g. if
we've added explicit import) -- then this type reference shouldn't be
treated as deprecated.

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -106,6 +106,7 @@ public interface Errors {
     DiagnosticFactory3<KtSimpleNameExpression, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_REFERENCE =
             DiagnosticFactory3.create(ERROR);
     DiagnosticFactory3<PsiElement, DeclarationDescriptor, Visibility, DeclarationDescriptor> INVISIBLE_MEMBER = DiagnosticFactory3.create(ERROR, CALL_ELEMENT);
+    DiagnosticFactory1<KtElement, DeclarationDescriptor> DEPRECATED_ACCESS_BY_SHORT_NAME = DiagnosticFactory1.create(WARNING);
 
     DiagnosticFactory1<PsiElement, ConstructorDescriptor> PROTECTED_CONSTRUCTOR_NOT_IN_SUPER_CALL = DiagnosticFactory1.create(ERROR);
 

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -66,6 +66,7 @@ public class DefaultErrorMessages {
 
         MAP.put(INVISIBLE_REFERENCE, "Cannot access ''{0}'': it is {1} in {2}", NAME, VISIBILITY, NAME_OF_CONTAINING_DECLARATION_OR_FILE);
         MAP.put(INVISIBLE_MEMBER, "Cannot access ''{0}'': it is {1} in {2}", NAME, VISIBILITY, NAME_OF_CONTAINING_DECLARATION_OR_FILE);
+        MAP.put(DEPRECATED_ACCESS_BY_SHORT_NAME, "Access to this type by short name is deprecated, and soon is going to be removed. Please, add explicit qualifier or import", NAME);
 
         MAP.put(PROTECTED_CONSTRUCTOR_NOT_IN_SUPER_CALL, "Protected constructor ''{0}'' from other classes can only be used in super-call", Renderers.SHORT_NAMES_IN_TYPES);
 

compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt

@@ -50,7 +50,7 @@ class SyntheticClassOrObjectDescriptor(
 
     private val thisDescriptor: SyntheticClassOrObjectDescriptor get() = this // code readability
     private val typeConstructor = SyntheticTypeConstructor(c.storageManager)
-    private val resolutionScopesSupport = ClassResolutionScopesSupport(thisDescriptor, c.storageManager, { outerScope })
+    private val resolutionScopesSupport = ClassResolutionScopesSupport(thisDescriptor, c.storageManager, c.languageVersionSettings, { outerScope })
     private val syntheticSupertypes =
         mutableListOf<KotlinType>().apply { c.syntheticResolveExtension.addSyntheticSupertypes(thisDescriptor, this) }
     private val unsubstitutedMemberScope =

compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java

@@ -244,6 +244,8 @@ public interface BindingContext {
     WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice();
     WritableSlice<PsiElement, TypeAliasDescriptor> TYPE_ALIAS = Slices.createSimpleSlice();
 
+    WritableSlice<PsiElement, Boolean> DEPRECATED_SHORT_NAME_ACCESS = Slices.createSimpleSlice();
+
     WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
             CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
             PRIMARY_CONSTRUCTOR_PARAMETER, SCRIPT, TYPE_ALIAS

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt

@@ -33,8 +33,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.resolve.scopes.ImportingScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.*
-import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier
-import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope
+import org.jetbrains.kotlin.resolve.scopes.utils.*
 import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 import org.jetbrains.kotlin.types.expressions.isWithoutValueArguments
@@ -62,6 +61,27 @@ class QualifiedExpressionResolver {
             get() = qualifierParts.flatMap { it.typeArguments?.arguments.orEmpty() }
     }
 
+    fun LexicalScope.findClassifierAndReportDeprecationIfNeeded(
+        name: Name,
+        lookupLocation: KotlinLookupLocation,
+        reportOn: KtExpression,
+        trace: BindingTrace
+    ): ClassifierDescriptor? {
+        val (classifier, isDeprecated) = findFirstClassifierWithDeprecationStatus(name, lookupLocation) ?: return null
+
+        if (isDeprecated) {
+            trace.record(BindingContext.DEPRECATED_SHORT_NAME_ACCESS, reportOn) // For IDE
+
+            // slow-path: we know that closest classifier is imported by the deprecated path, but before reporting
+            // deprecation, we have to recheck if there's some other import path, which isn't deprecated (e.g. explicit import)
+            if (!classifier.canBeResolvedWithoutDeprecation(this, lookupLocation)) {
+                trace.report(Errors.DEPRECATED_ACCESS_BY_SHORT_NAME.on(reportOn, classifier))
+            }
+        }
+
+        return classifier
+    }
+
     fun resolveDescriptorForType(
         userType: KtUserType,
         scope: LexicalScope,
@@ -71,7 +91,13 @@ class QualifiedExpressionResolver {
         val ownerDescriptor = if (!isDebuggerContext) scope.ownerDescriptor else null
         if (userType.qualifier == null) {
             val descriptor = userType.referenceExpression?.let { expression ->
-                val classifier = scope.findClassifier(expression.getReferencedNameAsName(), KotlinLookupLocation(expression))
+                val classifier = scope.findClassifierAndReportDeprecationIfNeeded(
+                    expression.getReferencedNameAsName(),
+                    KotlinLookupLocation(expression),
+                    expression,
+                    trace
+                )
+
                 checkNotEnumEntry(classifier, trace, expression)
                 storeResult(trace, expression, classifier, ownerDescriptor, position = QualifierPosition.TYPE, isQualifier = false)
                 classifier
@@ -143,9 +169,14 @@ class QualifiedExpressionResolver {
         }
 
         if (qualifierPartList.size == 1) {
-            val (name, simpleName) = qualifierPartList.single()
-            val descriptor = scope.findClassifier(name, KotlinLookupLocation(simpleName))
-            storeResult(trace, simpleName, descriptor, ownerDescriptor, position = QualifierPosition.TYPE, isQualifier = true)
+            val (name, simpleNameExpression) = qualifierPartList.single()
+            val descriptor = scope.findClassifierAndReportDeprecationIfNeeded(
+                name,
+                KotlinLookupLocation(simpleNameExpression),
+                simpleNameExpression,
+                trace
+            )
+            storeResult(trace, simpleNameExpression, descriptor, ownerDescriptor, position = QualifierPosition.TYPE, isQualifier = true)
             return TypeQualifierResolutionResult(qualifierPartList, descriptor)
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt

@@ -18,10 +18,7 @@ package org.jetbrains.kotlin.resolve.calls.tower
 
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
@@ -45,11 +42,14 @@ 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.descriptorUtil.hasDynamicExtensionAnnotation
+import org.jetbrains.kotlin.resolve.scopes.HierarchicalScope
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
 import org.jetbrains.kotlin.resolve.scopes.receivers.*
+import org.jetbrains.kotlin.resolve.scopes.utils.canBeResolvedWithoutDeprecation
 import org.jetbrains.kotlin.types.DeferredType
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
@@ -287,15 +287,54 @@ class NewResolutionOldInference(
                                 error.message
                             )
                         )
+
                         is NestedClassViaInstanceReference -> tracing.nestedClassAccessViaInstanceReference(
                             resolvedCall.trace,
                             error.classDescriptor,
                             resolvedCall.explicitReceiverKind
                         )
+
                         is ErrorDescriptorDiagnostic -> {
                             // todo
                             //  return@map null
                         }
+
+                        is ResolvedUsingDeprecatedVisbility -> {
+                            resolvedCall.trace.record(
+                                BindingContext.DEPRECATED_SHORT_NAME_ACCESS,
+                                resolvedCall.call.calleeExpression
+                            )
+
+                            val candidateDescriptor = resolvedCall.candidateDescriptor
+                            val descriptorToLookup: DeclarationDescriptor = when (candidateDescriptor) {
+                                is ClassConstructorDescriptor -> candidateDescriptor.containingDeclaration
+                                is FakeCallableDescriptorForObject -> candidateDescriptor.classDescriptor
+                                else -> error(
+                                    "Unexpected candidate descriptor of resolved call with " +
+                                            "ResolvedUsingDeprecatedVisibility-diagnostic: $candidateDescriptor\n" +
+                                            "Call context: ${resolvedCall.call.callElement.parent?.text}"
+                                )
+                            }
+
+                            // If this descriptor was resolved from HierarchicalScope, then there can be another, non-deprecated path
+                            // in parents of base scope
+                            val sourceScope = error.baseSourceScope
+                            val canBeResolvedWithoutDeprecation = if (sourceScope is HierarchicalScope) {
+                                descriptorToLookup.canBeResolvedWithoutDeprecation(
+                                    sourceScope,
+                                    error.lookupLocation
+                                )
+                            } else {
+                                // Normally, that should be unreachable, but instead of asserting that, we will report diagnostic
+                                false
+                            }
+
+                            if (!canBeResolvedWithoutDeprecation) {
+                                resolvedCall.trace.report(
+                                    Errors.DEPRECATED_ACCESS_BY_SHORT_NAME.on(resolvedCall.call.callElement, resolvedCall.resultingDescriptor)
+                                )
+                            }
+                        }
                     }
                 }
             }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt

@@ -16,9 +16,10 @@
 
 package org.jetbrains.kotlin.resolve.lazy.descriptors
 
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperclassesWithoutAny
 import org.jetbrains.kotlin.resolve.scopes.*
@@ -30,6 +31,7 @@ import java.util.*
 class ClassResolutionScopesSupport(
     private val classDescriptor: ClassDescriptor,
     storageManager: StorageManager,
+    private val languageVersionSettings: LanguageVersionSettings,
     private val getOuterScope: () -> LexicalScope
 ) {
     private fun scopeWithGenerics(parent: LexicalScope): LexicalScopeImpl {
@@ -85,44 +87,50 @@ class ClassResolutionScopesSupport(
         parent: LexicalScope,
         ownerDescriptor: DeclarationDescriptor,
         classDescriptor: ClassDescriptor,
-        withCompanionObject: Boolean = true
+        withCompanionObject: Boolean = true,
+        isDeprecated: Boolean = false
     ): LexicalScope {
+        val companionObjectDescriptor = classDescriptor.companionObjectDescriptor?.takeIf { withCompanionObject }
         val staticScopes = ArrayList<MemberScope>(3)
 
-        // todo filter fake overrides
         staticScopes.add(classDescriptor.staticScope)
-
         staticScopes.add(classDescriptor.unsubstitutedInnerClassesScope)
+        staticScopes.addIfNotNull(companionObjectDescriptor?.getStaticScopeOfCompanionObject(classDescriptor))
 
-        val implicitReceiver: ReceiverParameterDescriptor?
+        val parentForNewScope = companionObjectDescriptor?.packScopesOfCompanionSupertypes(parent, ownerDescriptor) ?: parent
 
-        val parentForNewScope: LexicalScope
-
-        if (withCompanionObject) {
-            staticScopes.addIfNotNull(classDescriptor.companionObjectDescriptor?.unsubstitutedInnerClassesScope)
-            implicitReceiver = classDescriptor.companionObjectDescriptor?.thisAsReceiverParameter
-
-            parentForNewScope = classDescriptor.companionObjectDescriptor?.let {
-                it.getAllSuperclassesWithoutAny().asReversed().fold(parent) { scope, currentClass ->
-                    createInheritanceScope(
-                        parent = scope,
-                        ownerDescriptor = ownerDescriptor,
-                        classDescriptor = currentClass,
-                        withCompanionObject = false
-                    )
-                }
-            } ?: parent
-        } else {
-            implicitReceiver = null
-            parentForNewScope = parent
-        }
-
-        return LexicalChainedScope(
-            parentForNewScope, ownerDescriptor, false,
-            implicitReceiver,
-            LexicalScopeKind.CLASS_INHERITANCE,
-            memberScopes = staticScopes, isStaticScope = true
+        val lexicalChainedScope = LexicalChainedScope(
+            parentForNewScope, ownerDescriptor,
+            isOwnerDescriptorAccessibleByLabel = false,
+            implicitReceiver = companionObjectDescriptor?.thisAsReceiverParameter,
+            kind = LexicalScopeKind.CLASS_INHERITANCE,
+            memberScopes = staticScopes,
+            isStaticScope = true
         )
+
+        return if (isDeprecated) DeprecatedLexicalScope(lexicalChainedScope) else lexicalChainedScope
+    }
+
+    private fun ClassDescriptor.getStaticScopeOfCompanionObject(companionOwner: ClassDescriptor): MemberScope? {
+        return when {
+        // We always see nesteds from our own companion
+            companionOwner == classDescriptor -> unsubstitutedInnerClassesScope
+
+        // We see nesteds from other companions in hierarchy only in legacy mode
+            languageVersionSettings.supportsFeature(LanguageFeature.ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion) -> null
+
+            else -> DeprecatedMemberScope(unsubstitutedInnerClassesScope)
+        }
+    }
+
+    private fun ClassDescriptor.packScopesOfCompanionSupertypes(
+        parent: LexicalScope,
+        ownerDescriptor: DeclarationDescriptor
+    ): LexicalScope? {
+        if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion)) return null
+        return getAllSuperclassesWithoutAny().asReversed().fold(parent) { scope, currentClass ->
+            createInheritanceScope(scope, ownerDescriptor, currentClass, withCompanionObject = false, isDeprecated = true)
+        }
     }
 
     private fun <T : Any> StorageManager.createLazyValue(onRecursion: ((Boolean) -> T), compute: () -> T) =

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -13,6 +13,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.config.LanguageFeature;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase;
@@ -221,7 +222,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
             return null;
         }, null);
 
-        this.resolutionScopesSupport = new ClassResolutionScopesSupport(this, storageManager, this::getOuterScope);
+        this.resolutionScopesSupport = new ClassResolutionScopesSupport(
+                this,
+                storageManager,
+                c.getLanguageVersionSettings(),
+                this::getOuterScope
+        );
 
         this.parameters = c.getStorageManager().createLazyValue(() -> {
             KtClassLikeInfo classInfo = declarationProvider.getOwnerInfo();

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt

@@ -24,9 +24,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.model.DiagnosticReporter
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic
 import org.jetbrains.kotlin.resolve.calls.tower.ResolutionCandidateApplicability.*
-import org.jetbrains.kotlin.resolve.scopes.LexicalScope
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
+import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValueWithSmartCastInfo
 import org.jetbrains.kotlin.types.KotlinType
 
@@ -110,3 +108,5 @@ object HiddenDescriptor : ResolutionDiagnostic(HIDDEN)
 object InvokeConventionCallNoOperatorModifier : ResolutionDiagnostic(CONVENTION_ERROR)
 object InfixCallNoInfixModifier : ResolutionDiagnostic(CONVENTION_ERROR)
 object DeprecatedUnaryPlusAsPlus : ResolutionDiagnostic(CONVENTION_ERROR)
+
+class ResolvedUsingDeprecatedVisbility(val baseSourceScope: ResolutionScope, val lookupLocation: LookupLocation) : ResolutionDiagnostic(RESOLVED)

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.getImmediateSuperclassNotAny
 import org.jetbrains.kotlin.utils.SmartList
 import org.jetbrains.kotlin.utils.addIfNotNull
-import java.util.*
+import kotlin.collections.ArrayList
 
 internal abstract class AbstractScopeTowerLevel(
     protected val scopeTower: ImplicitScopeTower
@@ -201,15 +201,14 @@ internal class QualifierScopeTowerLevel(scopeTower: ImplicitScopeTower, val qual
 
     override fun getObjects(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) = qualifier.staticScope
         .getContributedObjectVariables(name, location).map {
-        createCandidateDescriptor(it, dispatchReceiver = null)
-    }
+            createCandidateDescriptor(it, dispatchReceiver = null)
+        }
 
     override fun getFunctions(name: Name, extensionReceiver: ReceiverValueWithSmartCastInfo?) = qualifier.staticScope
         .getContributedFunctionsAndConstructors(
             name,
             location,
-            scopeTower.syntheticScopes,
-            qualifier.staticScope
+            scopeTower.syntheticScopes
         ).map {
         createCandidateDescriptor(it, dispatchReceiver = null)
     }
@@ -235,20 +234,37 @@ internal open class ScopeBasedTowerLevel protected constructor(
     override fun getObjects(
         name: Name,
         extensionReceiver: ReceiverValueWithSmartCastInfo?
-    ): Collection<CandidateWithBoundDispatchReceiver> = resolutionScope.getContributedObjectVariables(name, location).map {
-        createCandidateDescriptor(it, dispatchReceiver = null)
-    }
+    ): Collection<CandidateWithBoundDispatchReceiver> =
+        resolutionScope.getContributedObjectVariablesIncludeDeprecated(name, location).map { (classifier, isDeprecated) ->
+            createCandidateDescriptor(
+                classifier,
+                dispatchReceiver = null,
+                specialError = if (isDeprecated) ResolvedUsingDeprecatedVisbility(resolutionScope, location) else null
+            )
+        }
 
     override fun getFunctions(
         name: Name,
         extensionReceiver: ReceiverValueWithSmartCastInfo?
-    ): Collection<CandidateWithBoundDispatchReceiver> = resolutionScope.getContributedFunctionsAndConstructors(
-        name,
-        location,
-        scopeTower.syntheticScopes,
-        resolutionScope
-    ).map {
-        createCandidateDescriptor(it, dispatchReceiver = null)
+    ): Collection<CandidateWithBoundDispatchReceiver> {
+        val result: ArrayList<CandidateWithBoundDispatchReceiver> = ArrayList()
+
+        resolutionScope.getContributedFunctionsAndConstructors(name, location, scopeTower.syntheticScopes)
+            .mapTo(result) { createCandidateDescriptor(it, dispatchReceiver = null) }
+
+        // Add constructors of deprecated classifier with an additional diagnostic
+        val descriptorWithDeprecation = resolutionScope.getContributedClassifierIncludeDeprecated(name, location)
+        if (descriptorWithDeprecation != null && descriptorWithDeprecation.isDeprecated) {
+            getConstructorsOfClassifier(descriptorWithDeprecation.descriptor).mapTo(result) {
+                createCandidateDescriptor(
+                    it,
+                    dispatchReceiver = null,
+                    specialError = ResolvedUsingDeprecatedVisbility(resolutionScope, location)
+                )
+            }
+        }
+
+        return result
     }
 
     override fun recordLookup(name: Name) {
@@ -339,32 +355,41 @@ private fun KotlinType?.getInnerConstructors(name: Name, location: LookupLocatio
 private fun ResolutionScope.getContributedFunctionsAndConstructors(
     name: Name,
     location: LookupLocation,
-    syntheticScopes: SyntheticScopes,
-    scope: ResolutionScope
+    syntheticScopes: SyntheticScopes
 ): Collection<FunctionDescriptor> {
     val result = ArrayList<FunctionDescriptor>(getContributedFunctions(name, location))
 
-    val classifier = getContributedClassifier(name, location)
+    getContributedClassifier(name, location)?.let {
+        result.addAll(getConstructorsOfClassifier(it))
+    }
+
+    result.addAll(syntheticScopes.collectSyntheticStaticFunctions(this, name, location))
+    result.addAll(syntheticScopes.collectSyntheticConstructors(this, name, location))
+
+    return result.toList()
+}
+
+private fun getConstructorsOfClassifier(classifier: ClassifierDescriptor?): List<ConstructorDescriptor> {
     val callableConstructors = when (classifier) {
         is TypeAliasDescriptor -> if (classifier.canHaveCallableConstructors) classifier.constructors else emptyList()
         is ClassDescriptor -> if (classifier.canHaveCallableConstructors) classifier.constructors else emptyList()
         else -> emptyList()
     }
 
-    callableConstructors.filterTo(result) { it.dispatchReceiverParameter == null }
-
-    result.addAll(syntheticScopes.collectSyntheticStaticFunctions(scope, name, location))
-    result.addAll(syntheticScopes.collectSyntheticConstructors(scope, name, location))
-
-    return result.toList()
+    return callableConstructors.filter { it.dispatchReceiverParameter == null }
 }
 
-
 private fun ResolutionScope.getContributedObjectVariables(name: Name, location: LookupLocation): Collection<VariableDescriptor> {
     val objectDescriptor = getFakeDescriptorForObject(getContributedClassifier(name, location))
     return listOfNotNull(objectDescriptor)
 }
 
+private fun ResolutionScope.getContributedObjectVariablesIncludeDeprecated(name: Name, location: LookupLocation): Collection<DescriptorWithDeprecation<VariableDescriptor>> {
+    val (classifier, isOwnerDeprecated) = getContributedClassifierIncludeDeprecated(name, location) ?: return emptyList()
+    val objectDescriptor = getFakeDescriptorForObject(classifier) ?: return emptyList()
+    return listOf(DescriptorWithDeprecation(objectDescriptor, isOwnerDeprecated))
+}
+
 fun getFakeDescriptorForObject(classifier: ClassifierDescriptor?): FakeCallableDescriptorForObject? =
     when (classifier) {
         is TypeAliasDescriptor ->

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/DeprecatedScopes.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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.resolve.scopes
+
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
+import org.jetbrains.kotlin.descriptors.DescriptorWithDeprecation
+import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.name.Name
+
+class DeprecatedLexicalScope(private val workerScope: LexicalScope) : LexicalScope by workerScope {
+    override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? = null
+
+    override fun getContributedClassifierIncludeDeprecated(
+        name: Name,
+        location: LookupLocation
+    ): DescriptorWithDeprecation<ClassifierDescriptor>? {
+        return workerScope.getContributedClassifier(name, location)?.let { DescriptorWithDeprecation.createDeprecated(it) }
+    }
+}
+
+class DeprecatedMemberScope(private val workerScope: MemberScope) : MemberScope by workerScope {
+    override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? = null
+
+    override fun getContributedClassifierIncludeDeprecated(
+        name: Name,
+        location: LookupLocation
+    ): DescriptorWithDeprecation<ClassifierDescriptor>? {
+        return workerScope.getContributedClassifier(name, location)?.let { DescriptorWithDeprecation.createDeprecated(it) }
+    }
+}

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt

@@ -16,7 +16,9 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
+import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.DescriptorWithDeprecation
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
@@ -24,6 +26,7 @@ import org.jetbrains.kotlin.resolve.scopes.utils.takeSnapshot
 import org.jetbrains.kotlin.util.collectionUtils.getFirstClassifierDiscriminateHeaders
 import org.jetbrains.kotlin.util.collectionUtils.getFromAllScopes
 import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
 class LexicalChainedScope @JvmOverloads constructor(
     parent: LexicalScope,
@@ -31,6 +34,8 @@ class LexicalChainedScope @JvmOverloads constructor(
     override val isOwnerDescriptorAccessibleByLabel: Boolean,
     override val implicitReceiver: ReceiverParameterDescriptor?,
     override val kind: LexicalScopeKind,
+    // NB. Here can be very special subtypes of MemberScope (e.g., DeprecatedMemberScope).
+    // Please, do not leak them outside of LexicalChainedScope, because other parts of compiler are not ready to work with them
     private val memberScopes: List<MemberScope>,
     @Deprecated("This value is temporary hack for resolve -- don't use it!")
     val isStaticScope: Boolean = false
@@ -43,6 +48,22 @@ class LexicalChainedScope @JvmOverloads constructor(
     override fun getContributedClassifier(name: Name, location: LookupLocation) =
         getFirstClassifierDiscriminateHeaders(memberScopes) { it.getContributedClassifier(name, location) }
 
+    override fun getContributedClassifierIncludeDeprecated(name: Name, location: LookupLocation): DescriptorWithDeprecation<ClassifierDescriptor>? {
+        val (firstClassifier, isFirstDeprecated) = memberScopes.firstNotNullResult {
+            it.getContributedClassifierIncludeDeprecated(name, location)
+        } ?: return null
+
+        if (!isFirstDeprecated) return DescriptorWithDeprecation.createNonDeprecated(firstClassifier)
+
+        // Slow-path: try to find the same classifier, but without deprecation
+        for (scope in memberScopes) {
+            val (descriptor, isDeprecated) = scope.getContributedClassifierIncludeDeprecated(name, location) ?: continue
+            if (descriptor == firstClassifier && !isDeprecated) return DescriptorWithDeprecation.createNonDeprecated(descriptor)
+        }
+
+        return DescriptorWithDeprecation.createDeprecated(firstClassifier)
+    }
+
     override fun getContributedVariables(name: Name, location: LookupLocation) =
         getFromAllScopes(memberScopes) { it.getContributedVariables(name, location) }
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalWritableScope.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 class LexicalWritableScope(
     parent: LexicalScope,
@@ -74,6 +75,18 @@ class LexicalWritableScope(
         override fun getContributedClassifier(name: Name, location: LookupLocation) =
             variableOrClassDescriptorByName(name, descriptorLimit) as? ClassifierDescriptor
 
+        // NB. This is important to have this explicit override, otherwise calls will be delegated to `this`-delegate,
+        // which will use default implementation from `ResolutionScope`, which will call `getContributedClassifier` on
+        // the `LexicalWritableScope` instead of calling it on this snapshot
+        override fun getContributedClassifierIncludeDeprecated(
+            name: Name,
+            location: LookupLocation
+        ): DescriptorWithDeprecation<ClassifierDescriptor>? {
+            return variableOrClassDescriptorByName(name, descriptorLimit)
+                ?.safeAs<ClassifierDescriptor>()
+                ?.let { DescriptorWithDeprecation.createNonDeprecated(it) }
+        }
+
         override fun getContributedVariables(name: Name, location: LookupLocation) =
             listOfNotNull(variableOrClassDescriptorByName(name, descriptorLimit) as? VariableDescriptor)
 

compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt

@@ -81,6 +81,22 @@ fun LexicalScope.findLocalVariable(name: Name): VariableDescriptor? {
 fun HierarchicalScope.findClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? =
     findFirstFromMeAndParent { it.getContributedClassifier(name, location) }
 
+fun DeclarationDescriptor.canBeResolvedWithoutDeprecation(
+    scopeForResolution: HierarchicalScope,
+    location: LookupLocation
+): Boolean {
+    for (scope in scopeForResolution.parentsWithSelf) {
+        val (descriptorFromCurrentScope, isDeprecated) = scope.getContributedClassifierIncludeDeprecated(name, location) ?: continue
+        if (descriptorFromCurrentScope == this && !isDeprecated) return true
+    }
+
+    return false
+}
+
+fun HierarchicalScope.findFirstClassifierWithDeprecationStatus(name: Name, location: LookupLocation): DescriptorWithDeprecation<ClassifierDescriptor>? {
+    return findFirstFromMeAndParent { it.getContributedClassifierIncludeDeprecated(name, location) }
+}
+
 fun HierarchicalScope.findPackage(name: Name): PackageViewDescriptor? = findFirstFromImportingScopes { it.getContributedPackage(name) }
 
 fun HierarchicalScope.collectVariables(name: Name, location: LookupLocation): Collection<VariableDescriptor> =

compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers.kt

@@ -8,7 +8,7 @@ public class C {
 
     open class <!CYCLIC_SCOPES_WITH_COMPANION!>Base<!> ()
 
-    class Foo : Data()
+    class Foo : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>Data<!>()
 
     companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : DerivedAbstract()
 }

compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers.kt

@@ -7,11 +7,11 @@ object WithFunctionInBase {
 
     public class C {
         // error-scope
-        val data: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
+        val data: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
 
         open class <!CYCLIC_SCOPES_WITH_COMPANION!>Base<!>() {
             // error-scope
-            fun foo(): <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
+            fun foo(): <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
         }
 
         companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : DerivedAbstract()
@@ -29,11 +29,11 @@ object WithPropertyInBase {
 
         open class <!CYCLIC_SCOPES_WITH_COMPANION!>Base<!>() {
             // error-scope
-            val foo: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
+            val foo: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Int<!> = 42
         }
 
         // error-scope
-        val data: <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
+        val data: <!DEPRECATED_ACCESS_BY_SHORT_NAME, DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>Data<!> = Data()
 
         companion <!CYCLIC_SCOPES_WITH_COMPANION!>object<!> : DerivedAbstract()
     }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt

@@ -14,7 +14,7 @@ class A {
 
     // Does not work, could be Outer<String>.Inner<Int>
     // TODO: Should work?
-    fun foo(x: <!OUTER_CLASS_ARGUMENTS_REQUIRED!>Inner<!><Int>) {
+    fun foo(x: <!DEPRECATED_ACCESS_BY_SHORT_NAME, OUTER_CLASS_ARGUMENTS_REQUIRED!>Inner<!><Int>) {
         // Inner<Char>() call use companion as implicit receiver
         val y: Outer<String>.Inner<Char> = Inner<Char>()
     }

compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+open class Base {
+    companion object {
+        annotation class Foo
+    }
+}
+
+class Derived : Base() {
+
+    @<!DEPRECATED_ACCESS_BY_SHORT_NAME!>Foo<!>
+    fun foo() = 42
+}

compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.txt

@@ -0,0 +1,30 @@
+package
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final annotation class Foo : kotlin.Annotation {
+            public constructor Foo()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public final class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    @Base.Companion.Foo public final fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt

@@ -0,0 +1,74 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+import A.Base.Companion.FromABaseCompanion
+import B.Base.Companion.FromBBaseCompanion
+import C.Base.Companion.FromCBaseCompanion
+import D.Base.Companion.FromDBaseCompanion
+
+// ===== Case 1: LHS is a class
+//
+object A {
+    open class Base {
+        companion object {
+            class FromABaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = FromABaseCompanion::foo
+    }
+}
+
+// ===== Case 2: LHS is a class with companion object, function comes from class
+
+object B {
+    open class Base {
+        companion object {
+            class FromBBaseCompanion {
+                fun foo() = 42
+
+                companion object {}
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = FromBBaseCompanion::foo
+    }
+}
+
+// ==== Case 3: LHS is a class with companion object, function comes from companion
+
+object C {
+    open class Base {
+        companion object {
+            class FromCBaseCompanion {
+                companion object {
+                    fun foo() = 42
+                }
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = FromCBaseCompanion::<!UNRESOLVED_REFERENCE!>foo<!>
+    }
+}
+
+// ==== Case 4: LHS is an object
+
+object D {
+    open class Base {
+        companion object {
+            object FromDBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = FromDBaseCompanion::foo
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.txt

@@ -0,0 +1,163 @@
+package
+
+public object A {
+    private constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromABaseCompanion {
+                public constructor FromABaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : A.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<A.Base.Companion.FromABaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object B {
+    private constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBBaseCompanion {
+                public constructor FromBBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : B.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<B.Base.Companion.FromBBaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object C {
+    private constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCBaseCompanion {
+                public constructor FromCBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public final fun foo(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : C.Base {
+        public constructor Derived()
+        public final val a: [ERROR : Type for FromCBaseCompanion::foo]
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object D {
+    private constructor D()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public object FromDBaseCompanion {
+                private constructor FromDBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : D.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction0<kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt

@@ -0,0 +1,69 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// ===== Case 1: LHS is a class
+//
+object A {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = A.Base.Companion.FromBaseCompanion::foo
+    }
+}
+
+// ===== Case 2: LHS is a class with companion object, function comes from class
+
+object B {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+
+                companion object {}
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = B.Base.Companion.FromBaseCompanion::foo
+    }
+}
+
+// ==== Case 3: LHS is a class with companion object, function comes from companion
+
+object C {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                companion object {
+                    fun foo() = 42
+                }
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = C.Base.Companion.FromBaseCompanion::<!UNRESOLVED_REFERENCE!>foo<!>
+    }
+}
+
+// ==== Case 4: LHS is an object
+
+object D {
+    open class Base {
+        companion object {
+            object FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = D.Base.Companion.FromBaseCompanion::foo
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.txt

@@ -0,0 +1,163 @@
+package
+
+public object A {
+    private constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : A.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<A.Base.Companion.FromBaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object B {
+    private constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : B.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<B.Base.Companion.FromBaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object C {
+    private constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public final fun foo(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : C.Base {
+        public constructor Derived()
+        public final val a: [ERROR : Type for C.Base.Companion.FromBaseCompanion::foo]
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object D {
+    private constructor D()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public object FromBaseCompanion {
+                private constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : D.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction0<kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt

@@ -0,0 +1,142 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// class is to prevent accidental short-name import
+class O {
+    open class Alpha {
+        open fun foo() = 42
+
+        class FromAlpha {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionAlpha {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class Beta : Alpha() {
+        override fun foo() = 42
+
+        class FromBeta {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionBeta {
+                fun foo() = 42
+            }
+        }
+    }
+
+
+    open class A {
+        open fun foo() = 42
+
+        class FromA {
+            fun foo() = 42
+        }
+
+        companion object : Beta() {
+            class FromCompanionA {
+                fun foo() = 42
+            }
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open fun foo() = 42
+
+        class FromFarAway {
+            fun foo() = 42
+        }
+
+    }
+
+    open class Gamma {
+        open fun foo() = 42
+
+        class FromGamma {
+            fun foo() = 42
+        }
+
+        companion object : FarAway() {
+            class FromCompanionGamma {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class B : A() {
+        override fun foo() = 42
+
+        class FromB {
+            fun foo() = 42
+        }
+
+        companion object : Gamma() {
+            override fun foo() = 42
+
+            class FromCompanionB {
+                fun foo() = 42
+            }
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open fun foo() = 42
+    class FromDelta {
+        fun foo() = 42
+    }
+}
+
+class C : O.B() {
+    override fun foo() = 42
+
+    companion object : Delta() {
+        class FromCompanionC {
+            fun foo() = 42
+        }
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = FromA::foo
+    val d = FromB::foo
+
+    // VISIBLE: Classifiers from our own companion
+    val n = FromCompanionC::foo
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.txt

@@ -0,0 +1,239 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : Type for A::foo]
+    public final val b: [ERROR : Type for A::foo]
+    public final val c: kotlin.reflect.KFunction1<O.A.FromA, kotlin.Int>
+    public final val d: kotlin.reflect.KFunction1<O.B.FromB, kotlin.Int>
+    public final val e: [ERROR : Type for FromCompanionA::foo]
+    public final val f: [ERROR : Type for FromCompanionB::foo]
+    public final val g: [ERROR : Type for Alpha::foo]
+    public final val h: [ERROR : Type for Beta::foo]
+    public final val i: [ERROR : Type for Gamma::foo]
+    public final val k: [ERROR : Type for FromAlpha::foo]
+    public final val l: [ERROR : Type for FromBeta::foo]
+    public final val m: [ERROR : Type for FromGamma::foo]
+    public final val n: kotlin.reflect.KFunction1<C.Companion.FromCompanionC, kotlin.Int>
+    public final val o: [ERROR : Type for FromCompanionAlpha::foo]
+    public final val p: [ERROR : Type for FromCompanionBeta::foo]
+    public final val q: [ERROR : Type for FromCompanionGamma::foo]
+    public final val r: [ERROR : Type for FromDelta::foo]
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class O {
+    public constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt

@@ -0,0 +1,142 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// class is to prevent accidental short-name import
+class O {
+    open class Alpha {
+        open fun foo() = 42
+
+        class FromAlpha {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionAlpha {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class Beta : Alpha() {
+        override fun foo() = 42
+
+        class FromBeta {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionBeta {
+                fun foo() = 42
+            }
+        }
+    }
+
+
+    open class A {
+        open fun foo() = 42
+
+        class FromA {
+            fun foo() = 42
+        }
+
+        companion object : Beta() {
+            class FromCompanionA {
+                fun foo() = 42
+            }
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open fun foo() = 42
+
+        class FromFarAway {
+            fun foo() = 42
+        }
+
+    }
+
+    open class Gamma {
+        open fun foo() = 42
+
+        class FromGamma {
+            fun foo() = 42
+        }
+
+        companion object : FarAway() {
+            class FromCompanionGamma {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class B : A() {
+        override fun foo() = 42
+
+        class FromB {
+            fun foo() = 42
+        }
+
+        companion object : Gamma() {
+            override fun foo() = 42
+
+            class FromCompanionB {
+                fun foo() = 42
+            }
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open fun foo() = 42
+    class FromDelta {
+        fun foo() = 42
+    }
+}
+
+class C : O.B() {
+    override fun foo() = 42
+
+    companion object : Delta() {
+        class FromCompanionC {
+            fun foo() = 42
+        }
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = FromA::foo
+    val d = FromB::foo
+
+    // VISIBLE: Classifiers from our own companion
+    val n = FromCompanionC::foo
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = <!UNRESOLVED_REFERENCE!>A<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val b = <!UNRESOLVED_REFERENCE!>A<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionA<!>::foo
+    val f = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionB<!>::foo
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromAlpha<!>::foo
+    val l = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBeta<!>::foo
+    val m = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromGamma<!>::foo
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::<!DEBUG_INFO_MISSING_UNRESOLVED!>foo<!>
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromDelta<!>::foo
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.txt

@@ -0,0 +1,239 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : Type for A::foo]
+    public final val b: [ERROR : Type for A::foo]
+    public final val c: kotlin.reflect.KFunction1<O.A.FromA, kotlin.Int>
+    public final val d: kotlin.reflect.KFunction1<O.B.FromB, kotlin.Int>
+    public final val e: kotlin.reflect.KFunction1<O.A.Companion.FromCompanionA, kotlin.Int>
+    public final val f: kotlin.reflect.KFunction1<O.B.Companion.FromCompanionB, kotlin.Int>
+    public final val g: [ERROR : Type for Alpha::foo]
+    public final val h: [ERROR : Type for Beta::foo]
+    public final val i: [ERROR : Type for Gamma::foo]
+    public final val k: kotlin.reflect.KFunction1<O.Alpha.FromAlpha, kotlin.Int>
+    public final val l: kotlin.reflect.KFunction1<O.Beta.FromBeta, kotlin.Int>
+    public final val m: kotlin.reflect.KFunction1<O.Gamma.FromGamma, kotlin.Int>
+    public final val n: kotlin.reflect.KFunction1<C.Companion.FromCompanionC, kotlin.Int>
+    public final val o: [ERROR : Type for FromCompanionAlpha::foo]
+    public final val p: [ERROR : Type for FromCompanionBeta::foo]
+    public final val q: [ERROR : Type for FromCompanionGamma::foo]
+    public final val r: kotlin.reflect.KFunction1<Delta.FromDelta, kotlin.Int>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class O {
+    public constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt

@@ -0,0 +1,69 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// ===== Case 1: LHS is a class
+//
+object A {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBaseCompanion<!>::foo
+    }
+}
+
+// ===== Case 2: LHS is a class with companion object, function comes from class
+
+object B {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+
+                companion object {}
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBaseCompanion<!>::foo
+    }
+}
+
+// ==== Case 3: LHS is a class with companion object, function comes from companion
+
+object C {
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                companion object {
+                    fun foo() = 42
+                }
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBaseCompanion<!>::<!UNRESOLVED_REFERENCE!>foo<!>
+    }
+}
+
+// ==== Case 4: LHS is an object
+
+object D {
+    open class Base {
+        companion object {
+            object FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    class Derived : Base() {
+        val a = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBaseCompanion<!>::foo
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.txt

@@ -0,0 +1,163 @@
+package
+
+public object A {
+    private constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : A.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<A.Base.Companion.FromBaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object B {
+    private constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : B.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction1<B.Base.Companion.FromBaseCompanion, kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object C {
+    private constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromBaseCompanion {
+                public constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+                public companion object Companion {
+                    private constructor Companion()
+                    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                    public final fun foo(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+                }
+            }
+        }
+    }
+
+    public final class Derived : C.Base {
+        public constructor Derived()
+        public final val a: [ERROR : Type for FromBaseCompanion::foo]
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object D {
+    private constructor D()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class Base {
+        public constructor Base()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public object FromBaseCompanion {
+                private constructor FromBaseCompanion()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+    }
+
+    public final class Derived : D.Base {
+        public constructor Derived()
+        public final val a: kotlin.reflect.KFunction0<kotlin.Int>
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt

@@ -0,0 +1,142 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// class is to prevent accidental short-name import
+class O {
+    open class Alpha {
+        open fun foo() = 42
+
+        class FromAlpha {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionAlpha {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class Beta : Alpha() {
+        override fun foo() = 42
+
+        class FromBeta {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionBeta {
+                fun foo() = 42
+            }
+        }
+    }
+
+
+    open class A {
+        open fun foo() = 42
+
+        class FromA {
+            fun foo() = 42
+        }
+
+        companion object : Beta() {
+            class FromCompanionA {
+                fun foo() = 42
+            }
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open fun foo() = 42
+
+        class FromFarAway {
+            fun foo() = 42
+        }
+
+    }
+
+    open class Gamma {
+        open fun foo() = 42
+
+        class FromGamma {
+            fun foo() = 42
+        }
+
+        companion object : FarAway() {
+            class FromCompanionGamma {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class B : A() {
+        override fun foo() = 42
+
+        class FromB {
+            fun foo() = 42
+        }
+
+        companion object : Gamma() {
+            override fun foo() = 42
+
+            class FromCompanionB {
+                fun foo() = 42
+            }
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open fun foo() = 42
+    class FromDelta {
+        fun foo() = 42
+    }
+}
+
+class C : O.B() {
+    override fun foo() = 42
+
+    companion object : Delta() {
+        class FromCompanionC {
+            fun foo() = 42
+        }
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = O.A.FromA::foo
+    val d = O.B.FromB::foo
+
+    // VISIBLE: Classifiers from our own companion
+    val n = C.Companion.FromCompanionC::foo
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = O.A::foo
+    val b = O.A::foo
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = O.A.Companion.FromCompanionA::foo
+    val f = O.B.Companion.FromCompanionB::foo
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = O.Alpha::foo
+    val h = O.Beta::foo
+    val i = O.Gamma::foo
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = O.Alpha.FromAlpha::foo
+    val l = O.Beta.FromBeta::foo
+    val m = O.Gamma.FromGamma::foo
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = O.Alpha.Companion.FromCompanionAlpha::foo
+    val p = O.Beta.Companion.FromCompanionBeta::foo
+    val q = O.Gamma.Companion.FromCompanionGamma::foo
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = Delta.FromDelta::foo
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.txt

@@ -0,0 +1,239 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: kotlin.reflect.KFunction1<O.A, kotlin.Int>
+    public final val b: kotlin.reflect.KFunction1<O.A, kotlin.Int>
+    public final val c: kotlin.reflect.KFunction1<O.A.FromA, kotlin.Int>
+    public final val d: kotlin.reflect.KFunction1<O.B.FromB, kotlin.Int>
+    public final val e: kotlin.reflect.KFunction1<O.A.Companion.FromCompanionA, kotlin.Int>
+    public final val f: kotlin.reflect.KFunction1<O.B.Companion.FromCompanionB, kotlin.Int>
+    public final val g: kotlin.reflect.KFunction1<O.Alpha, kotlin.Int>
+    public final val h: kotlin.reflect.KFunction1<O.Beta, kotlin.Int>
+    public final val i: kotlin.reflect.KFunction1<O.Gamma, kotlin.Int>
+    public final val k: kotlin.reflect.KFunction1<O.Alpha.FromAlpha, kotlin.Int>
+    public final val l: kotlin.reflect.KFunction1<O.Beta.FromBeta, kotlin.Int>
+    public final val m: kotlin.reflect.KFunction1<O.Gamma.FromGamma, kotlin.Int>
+    public final val n: kotlin.reflect.KFunction1<C.Companion.FromCompanionC, kotlin.Int>
+    public final val o: kotlin.reflect.KFunction1<O.Alpha.Companion.FromCompanionAlpha, kotlin.Int>
+    public final val p: kotlin.reflect.KFunction1<O.Beta.Companion.FromCompanionBeta, kotlin.Int>
+    public final val q: kotlin.reflect.KFunction1<O.Gamma.Companion.FromCompanionGamma, kotlin.Int>
+    public final val r: kotlin.reflect.KFunction1<Delta.FromDelta, kotlin.Int>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class O {
+    public constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt

@@ -0,0 +1,142 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// class is to prevent accidental short-name import
+class O {
+    open class Alpha {
+        open fun foo() = 42
+
+        class FromAlpha {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionAlpha {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class Beta : Alpha() {
+        override fun foo() = 42
+
+        class FromBeta {
+            fun foo() = 42
+        }
+
+        companion object {
+            class FromCompanionBeta {
+                fun foo() = 42
+            }
+        }
+    }
+
+
+    open class A {
+        open fun foo() = 42
+
+        class FromA {
+            fun foo() = 42
+        }
+
+        companion object : Beta() {
+            class FromCompanionA {
+                fun foo() = 42
+            }
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open fun foo() = 42
+
+        class FromFarAway {
+            fun foo() = 42
+        }
+
+    }
+
+    open class Gamma {
+        open fun foo() = 42
+
+        class FromGamma {
+            fun foo() = 42
+        }
+
+        companion object : FarAway() {
+            class FromCompanionGamma {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class B : A() {
+        override fun foo() = 42
+
+        class FromB {
+            fun foo() = 42
+        }
+
+        companion object : Gamma() {
+            override fun foo() = 42
+
+            class FromCompanionB {
+                fun foo() = 42
+            }
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open fun foo() = 42
+    class FromDelta {
+        fun foo() = 42
+    }
+}
+
+class C : O.B() {
+    override fun foo() = 42
+
+    companion object : Delta() {
+        class FromCompanionC {
+            fun foo() = 42
+        }
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = O.A.FromA::foo
+    val d = O.B.FromB::foo
+
+    // VISIBLE: Classifiers from our own companion
+    val n = FromCompanionC::foo
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = O.A::foo
+    val b = O.A::foo
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = O.A.Companion.FromCompanionA::foo
+    val f = O.B.Companion.FromCompanionB::foo
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = O.Alpha::foo
+    val h = O.Beta::foo
+    val i = O.Gamma::foo
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = O.Alpha.FromAlpha::foo
+    val l = O.Beta.FromBeta::foo
+    val m = O.Gamma.FromGamma::foo
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = O.Alpha.Companion.FromCompanionAlpha::foo
+    val p = O.Beta.Companion.FromCompanionBeta::foo
+    val q = O.Gamma.Companion.FromCompanionGamma::foo
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = Delta.FromDelta::foo
+}

compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.txt

@@ -0,0 +1,239 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: kotlin.reflect.KFunction1<O.A, kotlin.Int>
+    public final val b: kotlin.reflect.KFunction1<O.A, kotlin.Int>
+    public final val c: kotlin.reflect.KFunction1<O.A.FromA, kotlin.Int>
+    public final val d: kotlin.reflect.KFunction1<O.B.FromB, kotlin.Int>
+    public final val e: kotlin.reflect.KFunction1<O.A.Companion.FromCompanionA, kotlin.Int>
+    public final val f: kotlin.reflect.KFunction1<O.B.Companion.FromCompanionB, kotlin.Int>
+    public final val g: kotlin.reflect.KFunction1<O.Alpha, kotlin.Int>
+    public final val h: kotlin.reflect.KFunction1<O.Beta, kotlin.Int>
+    public final val i: kotlin.reflect.KFunction1<O.Gamma, kotlin.Int>
+    public final val k: kotlin.reflect.KFunction1<O.Alpha.FromAlpha, kotlin.Int>
+    public final val l: kotlin.reflect.KFunction1<O.Beta.FromBeta, kotlin.Int>
+    public final val m: kotlin.reflect.KFunction1<O.Gamma.FromGamma, kotlin.Int>
+    public final val n: kotlin.reflect.KFunction1<C.Companion.FromCompanionC, kotlin.Int>
+    public final val o: kotlin.reflect.KFunction1<O.Alpha.Companion.FromCompanionAlpha, kotlin.Int>
+    public final val p: kotlin.reflect.KFunction1<O.Beta.Companion.FromCompanionBeta, kotlin.Int>
+    public final val q: kotlin.reflect.KFunction1<O.Gamma.Companion.FromCompanionGamma, kotlin.Int>
+    public final val r: kotlin.reflect.KFunction1<Delta.FromDelta, kotlin.Int>
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class O {
+    public constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public final fun foo(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public final fun foo(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt

@@ -0,0 +1,99 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c: FromA? = null
+    val d: FromB? = null
+
+    // VISIBLE: Classifiers from our own companion
+    val n: FromCompanionC? = null
+
+    // INVISIBLE: direct superclasses themselves.
+    val a: <!UNRESOLVED_REFERENCE!>A<!>? = null
+    val b: <!UNRESOLVED_REFERENCE!>B<!>? = null
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e: <!UNRESOLVED_REFERENCE!>FromCompanionA<!>? = null
+    val f: <!UNRESOLVED_REFERENCE!>FromCompanionB<!>? = null
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g: <!UNRESOLVED_REFERENCE!>Alpha<!>? = null
+    val h: <!UNRESOLVED_REFERENCE!>Beta<!>? = null
+    val i: <!UNRESOLVED_REFERENCE!>Gamma<!>? = null
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k: <!UNRESOLVED_REFERENCE!>FromAlpha<!>? = null
+    val l: <!UNRESOLVED_REFERENCE!>FromBeta<!>? = null
+    val m: <!UNRESOLVED_REFERENCE!>FromGamma<!>? = null
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o: <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>? = null
+    val p: <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>? = null
+    val q: <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>? = null
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r: <!UNRESOLVED_REFERENCE!>FromDelta<!>? = null
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : A]?
+    public final val b: [ERROR : B]?
+    public final val c: O.A.FromA? = null
+    public final val d: O.B.FromB? = null
+    public final val e: [ERROR : FromCompanionA]?
+    public final val f: [ERROR : FromCompanionB]?
+    public final val g: [ERROR : Alpha]?
+    public final val h: [ERROR : Beta]?
+    public final val i: [ERROR : Gamma]?
+    public final val k: [ERROR : FromAlpha]?
+    public final val l: [ERROR : FromBeta]?
+    public final val m: [ERROR : FromGamma]?
+    public final val n: C.Companion.FromCompanionC? = null
+    public final val o: [ERROR : FromCompanionAlpha]?
+    public final val p: [ERROR : FromCompanionBeta]?
+    public final val q: [ERROR : FromCompanionGamma]?
+    public final val r: [ERROR : FromDelta]?
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt

@@ -0,0 +1,98 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c: FromA? = null
+    val d: FromB? = null
+
+    // VISIBLE: Classifiers from our own companion
+    val n: FromCompanionC? = null
+
+    // INVISIBLE: direct superclasses themselves.
+    val a: <!UNRESOLVED_REFERENCE!>A<!>? = null
+    val b: <!UNRESOLVED_REFERENCE!>B<!>? = null
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionA<!>? = null
+    val f: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionB<!>? = null
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g: <!UNRESOLVED_REFERENCE!>Alpha<!>? = null
+    val h: <!UNRESOLVED_REFERENCE!>Beta<!>? = null
+    val i: <!UNRESOLVED_REFERENCE!>Gamma<!>? = null
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromAlpha<!>? = null
+    val l: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBeta<!>? = null
+    val m: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromGamma<!>? = null
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o: <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>? = null
+    val p: <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>? = null
+    val q: <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>? = null
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromDelta<!>? = null
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : A]?
+    public final val b: [ERROR : B]?
+    public final val c: O.A.FromA? = null
+    public final val d: O.B.FromB? = null
+    public final val e: O.A.Companion.FromCompanionA? = null
+    public final val f: O.B.Companion.FromCompanionB? = null
+    public final val g: [ERROR : Alpha]?
+    public final val h: [ERROR : Beta]?
+    public final val i: [ERROR : Gamma]?
+    public final val k: O.Alpha.FromAlpha? = null
+    public final val l: O.Beta.FromBeta? = null
+    public final val m: O.Gamma.FromGamma? = null
+    public final val n: C.Companion.FromCompanionC? = null
+    public final val o: [ERROR : FromCompanionAlpha]?
+    public final val p: [ERROR : FromCompanionBeta]?
+    public final val q: [ERROR : FromCompanionGamma]?
+    public final val r: Delta.FromDelta? = null
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt

@@ -0,0 +1,99 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c: O.A.FromA? = null
+    val d: O.B.FromB? = null
+
+    // VISIBLE: Classifiers from our own companion
+    val n: C.Companion.FromCompanionC? = null
+
+    // INVISIBLE: direct superclasses themselves.
+    val a: O.A? = null
+    val b: O.B? = null
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e: O.A.Companion.FromCompanionA? = null
+    val f: O.B.Companion.FromCompanionB? = null
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g: O.Alpha? = null
+    val h: O.Beta? = null
+    val i: O.Gamma? = null
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k: O.Alpha.FromAlpha? = null
+    val l: O.Beta.FromBeta? = null
+    val m: O.Gamma.FromGamma? = null
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o: O.Alpha.Companion.FromCompanionAlpha? = null
+    val p: O.Beta.Companion.FromCompanionBeta? = null
+    val q: O.Gamma.Companion.FromCompanionGamma? = null
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r: Delta.FromDelta? = null
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: O.A? = null
+    public final val b: O.B? = null
+    public final val c: O.A.FromA? = null
+    public final val d: O.B.FromB? = null
+    public final val e: O.A.Companion.FromCompanionA? = null
+    public final val f: O.B.Companion.FromCompanionB? = null
+    public final val g: O.Alpha? = null
+    public final val h: O.Beta? = null
+    public final val i: O.Gamma? = null
+    public final val k: O.Alpha.FromAlpha? = null
+    public final val l: O.Beta.FromBeta? = null
+    public final val m: O.Gamma.FromGamma? = null
+    public final val n: C.Companion.FromCompanionC? = null
+    public final val o: O.Alpha.Companion.FromCompanionAlpha? = null
+    public final val p: O.Beta.Companion.FromCompanionBeta? = null
+    public final val q: O.Gamma.Companion.FromCompanionGamma? = null
+    public final val r: Delta.FromDelta? = null
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt

@@ -0,0 +1,98 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c: O.A.FromA? = null
+    val d: O.B.FromB? = null
+
+    // VISIBLE: Classifiers from our own companion
+    val n: C.Companion.FromCompanionC? = null
+
+    // INVISIBLE: direct superclasses themselves.
+    val a: O.A? = null
+    val b: O.B? = null
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e: O.A.Companion.FromCompanionA? = null
+    val f: O.B.Companion.FromCompanionB? = null
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g: O.Alpha? = null
+    val h: O.Beta? = null
+    val i: O.Gamma? = null
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k: O.Alpha.FromAlpha? = null
+    val l: O.Beta.FromBeta? = null
+    val m: O.Gamma.FromGamma? = null
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o: O.Alpha.Companion.FromCompanionAlpha? = null
+    val p: O.Beta.Companion.FromCompanionBeta? = null
+    val q: O.Gamma.Companion.FromCompanionGamma? = null
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r: Delta.FromDelta? = null
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: O.A? = null
+    public final val b: O.B? = null
+    public final val c: O.A.FromA? = null
+    public final val d: O.B.FromB? = null
+    public final val e: O.A.Companion.FromCompanionA? = null
+    public final val f: O.B.Companion.FromCompanionB? = null
+    public final val g: O.Alpha? = null
+    public final val h: O.Beta? = null
+    public final val i: O.Gamma? = null
+    public final val k: O.Alpha.FromAlpha? = null
+    public final val l: O.Beta.FromBeta? = null
+    public final val m: O.Gamma.FromGamma? = null
+    public final val n: C.Companion.FromCompanionC? = null
+    public final val o: O.Alpha.Companion.FromCompanionAlpha? = null
+    public final val p: O.Beta.Companion.FromCompanionBeta? = null
+    public final val q: O.Gamma.Companion.FromCompanionGamma? = null
+    public final val r: Delta.FromDelta? = null
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt

@@ -0,0 +1,17 @@
+open class A {
+    class FromA {
+        fun foo() = 42
+    }
+}
+
+class B : A() {
+    companion object : A() { }
+
+    // we're seeing FromA here by two paths: one is deprecated (via companion object), and another one is not,
+    // so we shouldn't see deprecation warning
+    val a: FromA? = null
+
+    val b = FromA::foo
+
+    val c = FromA()
+}

compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.txt

@@ -0,0 +1,33 @@
+package
+
+public open class A {
+    public constructor A()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromA {
+        public constructor FromA()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun foo(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public final class B : A {
+    public constructor B()
+    public final val a: A.FromA? = null
+    public final val b: kotlin.reflect.KFunction1<A.FromA, kotlin.Int>
+    public final val c: A.FromA
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : A {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a open class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        open class FromAlpha
+
+        companion object {
+            open class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        open class FromBeta
+
+        companion object {
+            open class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        open class FromA
+
+        companion object : Beta() {
+            open class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open class FromFarAway
+
+    }
+
+    open class Gamma {
+        open class FromGamma
+        companion object : FarAway() {
+            open class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        open class FromB
+
+        companion object : Gamma() {
+            open class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open class FromDelta
+}
+
+open class C : O.B() {
+    companion object : Delta() {
+        open class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    open class c : FromA()
+    open class d : FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    open class n : FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    open class a : <!UNRESOLVED_REFERENCE!>A<!>()
+    open class b : <!UNRESOLVED_REFERENCE!>B<!>()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    open class e : <!UNRESOLVED_REFERENCE!>FromCompanionA<!>()
+    open class f : <!UNRESOLVED_REFERENCE!>FromCompanionB<!>()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    open class g : <!UNRESOLVED_REFERENCE!>Alpha<!>()
+    open class h : <!UNRESOLVED_REFERENCE!>Beta<!>()
+    open class i : <!UNRESOLVED_REFERENCE!>Gamma<!>()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    open class k : <!UNRESOLVED_REFERENCE!>FromAlpha<!>()
+    open class l : <!UNRESOLVED_REFERENCE!>FromBeta<!>()
+    open class m : <!UNRESOLVED_REFERENCE!>FromGamma<!>()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    open class o : <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
+    open class p : <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
+    open class q : <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    open class r : <!UNRESOLVED_REFERENCE!>FromDelta<!>()
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.txt

@@ -0,0 +1,316 @@
+package
+
+public open class C : O.B {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class a {
+        public constructor a()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class b {
+        public constructor b()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class c : O.A.FromA {
+        public constructor c()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class d : O.B.FromB {
+        public constructor d()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class e {
+        public constructor e()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class f {
+        public constructor f()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class g {
+        public constructor g()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class h {
+        public constructor h()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class i {
+        public constructor i()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class k {
+        public constructor k()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class l {
+        public constructor l()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class m {
+        public constructor m()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class n : C.Companion.FromCompanionC {
+        public constructor n()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class o {
+        public constructor o()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class p {
+        public constructor p()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class q {
+        public constructor q()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class r {
+        public constructor r()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a open class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        open class FromAlpha
+
+        companion object {
+            open class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        open class FromBeta
+
+        companion object {
+            open class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        open class FromA
+
+        companion object : Beta() {
+            open class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open class FromFarAway
+
+    }
+
+    open class Gamma {
+        open class FromGamma
+        companion object : FarAway() {
+            open class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        open class FromB
+
+        companion object : Gamma() {
+            open class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open class FromDelta
+}
+
+open class C : O.B() {
+    companion object : Delta() {
+        open class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    open class c : FromA()
+    open class d : FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    open class n : FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    open class a : <!UNRESOLVED_REFERENCE!>A<!>()
+    open class b : <!UNRESOLVED_REFERENCE!>B<!>()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    open class e : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionA<!>()
+    open class f : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionB<!>()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    open class g : <!UNRESOLVED_REFERENCE!>Alpha<!>()
+    open class h : <!UNRESOLVED_REFERENCE!>Beta<!>()
+    open class i : <!UNRESOLVED_REFERENCE!>Gamma<!>()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    open class k : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromAlpha<!>()
+    open class l : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBeta<!>()
+    open class m : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromGamma<!>()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    open class o : <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
+    open class p : <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
+    open class q : <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    open class r : <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromDelta<!>()
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.txt

@@ -0,0 +1,316 @@
+package
+
+public open class C : O.B {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class a {
+        public constructor a()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class b {
+        public constructor b()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class c : O.A.FromA {
+        public constructor c()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class d : O.B.FromB {
+        public constructor d()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class e : O.A.Companion.FromCompanionA {
+        public constructor e()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class f : O.B.Companion.FromCompanionB {
+        public constructor f()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class g {
+        public constructor g()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class h {
+        public constructor h()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class i {
+        public constructor i()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class k : O.Alpha.FromAlpha {
+        public constructor k()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class l : O.Beta.FromBeta {
+        public constructor l()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class m : O.Gamma.FromGamma {
+        public constructor m()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class n : C.Companion.FromCompanionC {
+        public constructor n()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class o {
+        public constructor o()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class p {
+        public constructor p()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class q {
+        public constructor q()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class r : Delta.FromDelta {
+        public constructor r()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a open class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        open class FromAlpha
+
+        companion object {
+            open class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        open class FromBeta
+
+        companion object {
+            open class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        open class FromA
+
+        companion object : Beta() {
+            open class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open class FromFarAway
+
+    }
+
+    open class Gamma {
+        open class FromGamma
+        companion object : FarAway() {
+            open class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        open class FromB
+
+        companion object : Gamma() {
+            open class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open class FromDelta
+}
+
+open class C : O.B() {
+    companion object : Delta() {
+        open class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    open class c : O.A.FromA()
+    open class d : O.B.FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    open class n : C.Companion.FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    open class a : O.A()
+    open class b : O.B()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    open class e : O.A.Companion.FromCompanionA()
+    open class f : O.B.Companion.FromCompanionB()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    open class g : O.Alpha()
+    open class h : O.Beta()
+    open class i : O.Gamma()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    open class k : O.Alpha.FromAlpha()
+    open class l : O.Beta.FromBeta()
+    open class m : O.Gamma.FromGamma()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    open class o : O.Alpha.Companion.FromCompanionAlpha()
+    open class p : O.Beta.Companion.FromCompanionBeta()
+    open class q : O.Gamma.Companion.FromCompanionGamma()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    open class r : Delta.FromDelta()
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.txt

@@ -0,0 +1,316 @@
+package
+
+public open class C : O.B {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class a : O.A {
+        public constructor a()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class b : O.B {
+        public constructor b()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class c : O.A.FromA {
+        public constructor c()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class d : O.B.FromB {
+        public constructor d()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class e : O.A.Companion.FromCompanionA {
+        public constructor e()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class f : O.B.Companion.FromCompanionB {
+        public constructor f()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class g : O.Alpha {
+        public constructor g()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class h : O.Beta {
+        public constructor h()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class i : O.Gamma {
+        public constructor i()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class k : O.Alpha.FromAlpha {
+        public constructor k()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class l : O.Beta.FromBeta {
+        public constructor l()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class m : O.Gamma.FromGamma {
+        public constructor m()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class n : C.Companion.FromCompanionC {
+        public constructor n()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class o : O.Alpha.Companion.FromCompanionAlpha {
+        public constructor o()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class p : O.Beta.Companion.FromCompanionBeta {
+        public constructor p()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class q : O.Gamma.Companion.FromCompanionGamma {
+        public constructor q()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class r : Delta.FromDelta {
+        public constructor r()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a open class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        open class FromAlpha
+
+        companion object {
+            open class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        open class FromBeta
+
+        companion object {
+            open class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        open class FromA
+
+        companion object : Beta() {
+            open class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        open class FromFarAway
+
+    }
+
+    open class Gamma {
+        open class FromGamma
+        companion object : FarAway() {
+            open class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        open class FromB
+
+        companion object : Gamma() {
+            open class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    open class FromDelta
+}
+
+open class C : O.B() {
+    companion object : Delta() {
+        open class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    open class c : O.A.FromA()
+    open class d : O.B.FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    open class n : C.Companion.FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    open class a : O.A()
+    open class b : O.B()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    open class e : O.A.Companion.FromCompanionA()
+    open class f : O.B.Companion.FromCompanionB()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    open class g : O.Alpha()
+    open class h : O.Beta()
+    open class i : O.Gamma()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    open class k : O.Alpha.FromAlpha()
+    open class l : O.Beta.FromBeta()
+    open class m : O.Gamma.FromGamma()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    open class o : O.Alpha.Companion.FromCompanionAlpha()
+    open class p : O.Beta.Companion.FromCompanionBeta()
+    open class q : O.Gamma.Companion.FromCompanionGamma()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    open class r : Delta.FromDelta()
+}

compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.txt

@@ -0,0 +1,316 @@
+package
+
+public open class C : O.B {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class a : O.A {
+        public constructor a()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class b : O.B {
+        public constructor b()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class c : O.A.FromA {
+        public constructor c()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class d : O.B.FromB {
+        public constructor d()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class e : O.A.Companion.FromCompanionA {
+        public constructor e()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class f : O.B.Companion.FromCompanionB {
+        public constructor f()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class g : O.Alpha {
+        public constructor g()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class h : O.Beta {
+        public constructor h()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class i : O.Gamma {
+        public constructor i()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class k : O.Alpha.FromAlpha {
+        public constructor k()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class l : O.Beta.FromBeta {
+        public constructor l()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class m : O.Gamma.FromGamma {
+        public constructor m()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class n : C.Companion.FromCompanionC {
+        public constructor n()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class o : O.Alpha.Companion.FromCompanionAlpha {
+        public constructor o()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class p : O.Beta.Companion.FromCompanionBeta {
+        public constructor p()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class q : O.Gamma.Companion.FromCompanionGamma {
+        public constructor q()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public open class r : Delta.FromDelta {
+        public constructor r()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public open class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public open class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public open class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = FromA()
+    val d = FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    val n = FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = <!UNRESOLVED_REFERENCE!>A<!>()
+    val b = <!UNRESOLVED_REFERENCE!>B<!>()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = <!UNRESOLVED_REFERENCE!>FromCompanionA<!>()
+    val f = <!UNRESOLVED_REFERENCE!>FromCompanionB<!>()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>()
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>()
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = <!UNRESOLVED_REFERENCE!>FromAlpha<!>()
+    val l = <!UNRESOLVED_REFERENCE!>FromBeta<!>()
+    val m = <!UNRESOLVED_REFERENCE!>FromGamma<!>()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = <!UNRESOLVED_REFERENCE!>FromDelta<!>()
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : Type for A()]
+    public final val b: [ERROR : Type for B()]
+    public final val c: O.A.FromA
+    public final val d: O.B.FromB
+    public final val e: [ERROR : Type for FromCompanionA()]
+    public final val f: [ERROR : Type for FromCompanionB()]
+    public final val g: [ERROR : Type for Alpha()]
+    public final val h: [ERROR : Type for Beta()]
+    public final val i: [ERROR : Type for Gamma()]
+    public final val k: [ERROR : Type for FromAlpha()]
+    public final val l: [ERROR : Type for FromBeta()]
+    public final val m: [ERROR : Type for FromGamma()]
+    public final val n: C.Companion.FromCompanionC
+    public final val o: [ERROR : Type for FromCompanionAlpha()]
+    public final val p: [ERROR : Type for FromCompanionBeta()]
+    public final val q: [ERROR : Type for FromCompanionGamma()]
+    public final val r: [ERROR : Type for FromDelta()]
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt

@@ -0,0 +1,99 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = FromA()
+    val d = FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    val n = FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = <!UNRESOLVED_REFERENCE!>A<!>()
+    val b = <!UNRESOLVED_REFERENCE!>B<!>()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionA()<!>
+    val f = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromCompanionB()<!>
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = <!UNRESOLVED_REFERENCE!>Alpha<!>()
+    val h = <!UNRESOLVED_REFERENCE!>Beta<!>()
+    val i = <!UNRESOLVED_REFERENCE!>Gamma<!>()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromAlpha()<!>
+    val l = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromBeta()<!>
+    val m = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromGamma()<!>
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
+    val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
+    val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = <!DEPRECATED_ACCESS_BY_SHORT_NAME!>FromDelta()<!>
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: [ERROR : Type for A()]
+    public final val b: [ERROR : Type for B()]
+    public final val c: O.A.FromA
+    public final val d: O.B.FromB
+    public final val e: O.A.Companion.FromCompanionA
+    public final val f: O.B.Companion.FromCompanionB
+    public final val g: [ERROR : Type for Alpha()]
+    public final val h: [ERROR : Type for Beta()]
+    public final val i: [ERROR : Type for Gamma()]
+    public final val k: O.Alpha.FromAlpha
+    public final val l: O.Beta.FromBeta
+    public final val m: O.Gamma.FromGamma
+    public final val n: C.Companion.FromCompanionC
+    public final val o: [ERROR : Type for FromCompanionAlpha()]
+    public final val p: [ERROR : Type for FromCompanionBeta()]
+    public final val q: [ERROR : Type for FromCompanionGamma()]
+    public final val r: Delta.FromDelta
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = O.A.FromA()
+    val d = O.B.FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    val n = C.Companion.FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = O.A()
+    val b = O.B()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = O.A.Companion.FromCompanionA()
+    val f = O.B.Companion.FromCompanionB()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = O.Alpha()
+    val h = O.Beta()
+    val i = O.Gamma()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = O.Alpha.FromAlpha()
+    val l = O.Beta.FromBeta()
+    val m = O.Gamma.FromGamma()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = O.Alpha.Companion.FromCompanionAlpha()
+    val p = O.Beta.Companion.FromCompanionBeta()
+    val q = O.Gamma.Companion.FromCompanionGamma()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = Delta.FromDelta()
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: O.A
+    public final val b: O.B
+    public final val c: O.A.FromA
+    public final val d: O.B.FromB
+    public final val e: O.A.Companion.FromCompanionA
+    public final val f: O.B.Companion.FromCompanionB
+    public final val g: O.Alpha
+    public final val h: O.Beta
+    public final val i: O.Gamma
+    public final val k: O.Alpha.FromAlpha
+    public final val l: O.Beta.FromBeta
+    public final val m: O.Gamma.FromGamma
+    public final val n: C.Companion.FromCompanionC
+    public final val o: O.Alpha.Companion.FromCompanionAlpha
+    public final val p: O.Beta.Companion.FromCompanionBeta
+    public final val q: O.Gamma.Companion.FromCompanionGamma
+    public final val r: Delta.FromDelta
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt

@@ -0,0 +1,100 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+// See KT-21515 for a class diagram and details
+
+// Object is to prevent accidental short-name import
+object O {
+    open class Alpha {
+        class FromAlpha
+
+        companion object {
+            class FromCompanionAlpha
+        }
+    }
+
+    open class Beta : Alpha() {
+        class FromBeta
+
+        companion object {
+            class FromCompanionBeta
+        }
+    }
+
+
+    open class A {
+        class FromA
+
+        companion object : Beta() {
+            class FromCompanionA
+        }
+    }
+
+//////////////////////////
+
+    open class FarAway {
+        class FromFarAway
+
+    }
+
+    open class Gamma {
+        class FromGamma
+        companion object : FarAway() {
+            class FromCompanionGamma
+        }
+    }
+
+    open class B : A() {
+        class FromB
+
+        companion object : Gamma() {
+            class FromCompanionB
+        }
+    }
+}
+
+///////////////////////////////
+
+
+open class Delta {
+    class FromDelta
+}
+
+class C : O.B() {
+    companion object : Delta() {
+        class FromCompanionC
+    }
+
+    // VISIBLE: Classifiers from direct superclasses
+    val c = O.A.FromA()
+    val d = O.B.FromB()
+
+    // VISIBLE: Classifiers from our own companion
+    val n = C.Companion.FromCompanionC()
+
+    // INVISIBLE: direct superclasses themselves.
+    val a = O.A()
+    val b = O.B()
+
+    // DEPRECATED: Classifiers from companions of direct superclasses
+    val e = O.A.Companion.FromCompanionA()
+    val f = O.B.Companion.FromCompanionB()
+
+    // INVISIBLE: "cousin" supertypes themselves
+    val g = O.Alpha()
+    val h = O.Beta()
+    val i = O.Gamma()
+
+    // DEPRECATED: classifiers from "cousin" superclasses
+    val k = O.Alpha.FromAlpha()
+    val l = O.Beta.FromBeta()
+    val m = O.Gamma.FromGamma()
+
+    // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
+    val o = O.Alpha.Companion.FromCompanionAlpha()
+    val p = O.Beta.Companion.FromCompanionBeta()
+    val q = O.Gamma.Companion.FromCompanionGamma()
+
+    // DEPRECATED: Classifiers from supertypes of our own companion
+    val r = Delta.FromDelta()
+}

compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.txt

@@ -0,0 +1,214 @@
+package
+
+public final class C : O.B {
+    public constructor C()
+    public final val a: O.A
+    public final val b: O.B
+    public final val c: O.A.FromA
+    public final val d: O.B.FromB
+    public final val e: O.A.Companion.FromCompanionA
+    public final val f: O.B.Companion.FromCompanionB
+    public final val g: O.Alpha
+    public final val h: O.Beta
+    public final val i: O.Gamma
+    public final val k: O.Alpha.FromAlpha
+    public final val l: O.Beta.FromBeta
+    public final val m: O.Gamma.FromGamma
+    public final val n: C.Companion.FromCompanionC
+    public final val o: O.Alpha.Companion.FromCompanionAlpha
+    public final val p: O.Beta.Companion.FromCompanionBeta
+    public final val q: O.Gamma.Companion.FromCompanionGamma
+    public final val r: Delta.FromDelta
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public companion object Companion : Delta {
+        private constructor Companion()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromCompanionC {
+            public constructor FromCompanionC()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}
+
+public open class Delta {
+    public constructor Delta()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public final class FromDelta {
+        public constructor FromDelta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+public object O {
+    private constructor O()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+    public open class A {
+        public constructor A()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Beta {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionA {
+                public constructor FromCompanionA()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromA {
+            public constructor FromA()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Alpha {
+        public constructor Alpha()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionAlpha {
+                public constructor FromCompanionAlpha()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromAlpha {
+            public constructor FromAlpha()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class B : O.A {
+        public constructor B()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.Gamma {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionB {
+                public constructor FromCompanionB()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromB {
+            public constructor FromB()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Beta : O.Alpha {
+        public constructor Beta()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionBeta {
+                public constructor FromCompanionBeta()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromBeta {
+            public constructor FromBeta()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class FarAway {
+        public constructor FarAway()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final class FromFarAway {
+            public constructor FromFarAway()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    public open class Gamma {
+        public constructor Gamma()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public companion object Companion : O.FarAway {
+            private constructor Companion()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+            public final class FromCompanionGamma {
+                public constructor FromCompanionGamma()
+                public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+                public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+                public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+            }
+        }
+
+        public final class FromGamma {
+            public constructor FromGamma()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+}

compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 interface A {
     companion object {
         fun foo() {}
@@ -31,7 +33,7 @@ class C: B(), A {
         B.Companion.bar()
         C.<!UNRESOLVED_REFERENCE!>bar<!>()
 
-        B_()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B_()<!>
         B.<!UNRESOLVED_REFERENCE!>B_<!>()
         B.Companion.B_()
         C.<!UNRESOLVED_REFERENCE!>B_<!>()

compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 // FILE: 1.kt
 interface A {
     companion object {
@@ -41,7 +43,7 @@ class D: C() {
         C.<!UNRESOLVED_REFERENCE!>bar<!>()
         D.<!UNRESOLVED_REFERENCE!>bar<!>()
 
-        B_()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B_()<!>
         B.<!UNRESOLVED_REFERENCE!>B_<!>()
         B.Companion.B_()
         C.<!UNRESOLVED_REFERENCE!>B_<!>()

compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 open class A {
     inner class B {
         fun foo() {}
@@ -28,7 +30,7 @@ class E: A() {
         B().<!UNRESOLVED_REFERENCE!>bar<!>()
 
         D()
-        C()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>C()<!>
     }
 
     object Z {
@@ -37,7 +39,7 @@ class E: A() {
             <!RESOLUTION_TO_CLASSIFIER!>B<!>().<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>bar<!>()
 
             <!RESOLUTION_TO_CLASSIFIER!>D<!>()
-            C()
+            <!DEPRECATED_ACCESS_BY_SHORT_NAME!>C()<!>
         }
     }
 }

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 open class A {
     companion object {
         class B
@@ -5,33 +7,33 @@ open class A {
 }
 
 class C: A() {
-    val b: B = null!!
+    val b: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B<!> = null!!
 
     init {
-        B()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B()<!>
     }
 
     object O {
-        val b: B = null!!
+        val b: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B<!> = null!!
 
         init {
-            B()
+            <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B()<!>
         }
     }
 
     class K {
-        val b: B = null!!
+        val b: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B<!> = null!!
 
         init {
-            B()
+            <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B()<!>
         }
     }
 
     inner class I {
-        val b: B = null!!
+        val b: <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B<!> = null!!
 
         init {
-            B()
+            <!DEPRECATED_ACCESS_BY_SHORT_NAME!>B()<!>
         }
     }
 }

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 open class A {
     class X {
         fun A_X() {}
@@ -26,7 +28,7 @@ open class A {
 class Simple: A() {
     init {
         Y().A_Y()
-        Z().A_C_Z()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>Z()<!>.A_C_Z()
     }
 }
 

compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 // FILE: 1.kt
 open class A {
     class Y {
@@ -40,6 +42,6 @@ class Y: C() {
     init {
         Y().A_Y()
 
-        Z().A_C_Z()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>Z()<!>.A_C_Z()
     }
 }

compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt

@@ -1,3 +1,5 @@
+// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
+
 class X {
     fun T_X() {}
 }
@@ -30,7 +32,7 @@ class B: A() {
         X().A_X()
         X().<!UNRESOLVED_REFERENCE!>T_X<!>()
 
-        Y().A_C_Y()
-        Y().<!UNRESOLVED_REFERENCE!>T_Y<!>()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>Y()<!>.A_C_Y()
+        <!DEPRECATED_ACCESS_BY_SHORT_NAME!>Y()<!>.<!UNRESOLVED_REFERENCE!>T_Y<!>()
     }
 }

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -15232,6 +15232,141 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/upperBoundViolated.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("compiler/testData/diagnostics/tests/objects/kt21515")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Kt21515 extends AbstractDiagnosticsTest {
+                public void testAllFilesPresentInKt21515() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                }
+
+                @TestMetadata("annotationConstructor.kt")
+                public void testAnnotationConstructor() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferenceComplexCasesWithImportsOld.kt")
+                public void testCallableReferenceComplexCasesWithImportsOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesComplexCasesWithQualificationOld.kt")
+                public void testCallableReferencesComplexCasesWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesNew.kt")
+                public void testCallableReferencesNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesOld.kt")
+                public void testCallableReferencesOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesOldComplexCases.kt")
+                public void testCallableReferencesOldComplexCases() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesWithQualificationNew.kt")
+                public void testCallableReferencesWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesWithQualificationOld.kt")
+                public void testCallableReferencesWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectNew.kt")
+                public void testClassifierFromCompanionObjectNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectOld.kt")
+                public void testClassifierFromCompanionObjectOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectWithQualificationNew.kt")
+                public void testClassifierFromCompanionObjectWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectWithQualificationOld.kt")
+                public void testClassifierFromCompanionObjectWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierIsVisibleByTwoPaths.kt")
+                public void testClassifierIsVisibleByTwoPaths() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedNew.kt")
+                public void testInheritedFromDeprecatedNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedOld.kt")
+                public void testInheritedFromDeprecatedOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedWithQualificationNew.kt")
+                public void testInheritedFromDeprecatedWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedWithQualificationOld.kt")
+                public void testInheritedFromDeprecatedWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorNew.kt")
+                public void testUseDeprecatedConstructorNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorOld.kt")
+                public void testUseDeprecatedConstructorOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorWithQualificationNew.kt")
+                public void testUseDeprecatedConstructorWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorWithQualificationOld.kt")
+                public void testUseDeprecatedConstructorWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/operatorRem")

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -15232,6 +15232,141 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/upperBoundViolated.kt");
                 doTest(fileName);
             }
+
+            @TestMetadata("compiler/testData/diagnostics/tests/objects/kt21515")
+            @TestDataPath("$PROJECT_ROOT")
+            @RunWith(JUnit3RunnerWithInners.class)
+            public static class Kt21515 extends AbstractDiagnosticsUsingJavacTest {
+                public void testAllFilesPresentInKt21515() throws Exception {
+                    KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true);
+                }
+
+                @TestMetadata("annotationConstructor.kt")
+                public void testAnnotationConstructor() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferenceComplexCasesWithImportsOld.kt")
+                public void testCallableReferenceComplexCasesWithImportsOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesComplexCasesWithQualificationOld.kt")
+                public void testCallableReferencesComplexCasesWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesNew.kt")
+                public void testCallableReferencesNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesOld.kt")
+                public void testCallableReferencesOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesOldComplexCases.kt")
+                public void testCallableReferencesOldComplexCases() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesWithQualificationNew.kt")
+                public void testCallableReferencesWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("callableReferencesWithQualificationOld.kt")
+                public void testCallableReferencesWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectNew.kt")
+                public void testClassifierFromCompanionObjectNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectOld.kt")
+                public void testClassifierFromCompanionObjectOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectWithQualificationNew.kt")
+                public void testClassifierFromCompanionObjectWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierFromCompanionObjectWithQualificationOld.kt")
+                public void testClassifierFromCompanionObjectWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("classifierIsVisibleByTwoPaths.kt")
+                public void testClassifierIsVisibleByTwoPaths() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedNew.kt")
+                public void testInheritedFromDeprecatedNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedOld.kt")
+                public void testInheritedFromDeprecatedOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedWithQualificationNew.kt")
+                public void testInheritedFromDeprecatedWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("inheritedFromDeprecatedWithQualificationOld.kt")
+                public void testInheritedFromDeprecatedWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorNew.kt")
+                public void testUseDeprecatedConstructorNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorOld.kt")
+                public void testUseDeprecatedConstructorOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorWithQualificationNew.kt")
+                public void testUseDeprecatedConstructorWithQualificationNew() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt");
+                    doTest(fileName);
+                }
+
+                @TestMetadata("useDeprecatedConstructorWithQualificationOld.kt")
+                public void testUseDeprecatedConstructorWithQualificationOld() throws Exception {
+                    String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt");
+                    doTest(fileName);
+                }
+            }
         }
 
         @TestMetadata("compiler/testData/diagnostics/tests/operatorRem")

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -66,6 +66,7 @@ enum class LanguageFeature(
     NestedClassesInAnnotations(KOTLIN_1_3),
     JvmStaticInInterface(KOTLIN_1_3),
     InlineClasses(KOTLIN_1_3),
+    ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion(KOTLIN_1_3),
 
     StrictJavaNullabilityAssertions(sinceVersion = null, defaultState = State.DISABLED),
     ProperIeee754Comparisons(sinceVersion = null, defaultState = State.DISABLED),

core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorWithDeprecation.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2000-2018 JetBrains s.r.o. 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
+
+data class DescriptorWithDeprecation<out T : DeclarationDescriptor>(val descriptor: T, val isDeprecated: Boolean) {
+    companion object {
+        fun <T : DeclarationDescriptor> createNonDeprecated(descriptor: T): DescriptorWithDeprecation<T> =
+            DescriptorWithDeprecation(descriptor, false)
+
+        fun <T : DeclarationDescriptor> createDeprecated(descriptor: T): DescriptorWithDeprecation<T> =
+            DescriptorWithDeprecation(descriptor, true)
+    }
+}
+

core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ResolutionScope.kt

@@ -16,17 +16,29 @@
 
 package org.jetbrains.kotlin.resolve.scopes
 
-import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.name.Name
 
 interface ResolutionScope {
-
+    /**
+     * Returns only non-deprecated classifiers.
+     *
+     * See [getContributedClassifierIncludeDeprecated] to get all classifiers.
+     */
     fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor?
 
+    /**
+     * Returns contributed classifier, but discriminates deprecated
+     *
+     * This method can return some classifier where [getContributedClassifier] haven't returned none,
+     * but it should never return different one, even if it is deprecated.
+     * Note that implementors are encouraged to provide non-deprecated classifier if it doesn't contradict
+     * contract above.
+     */
+    fun getContributedClassifierIncludeDeprecated(name: Name, location: LookupLocation): DescriptorWithDeprecation<ClassifierDescriptor>? =
+        getContributedClassifier(name, location)?.let { DescriptorWithDeprecation.createNonDeprecated(it) }
+
     fun getContributedVariables(name: Name, location: LookupLocation): Collection<VariableDescriptor>
 
     fun getContributedFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor>

core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java

@@ -181,6 +181,14 @@ public class ErrorUtils {
             return createErrorClass(name.asString());
         }
 
+        @Nullable
+        @Override
+        public DescriptorWithDeprecation<ClassifierDescriptor> getContributedClassifierIncludeDeprecated(
+                @NotNull Name name, @NotNull LookupLocation location
+        ) {
+            return null;
+        }
+
         @NotNull
         @Override
         // TODO: Convert to Kotlin or add @JvmWildcard to MemberScope declarations
@@ -259,6 +267,14 @@ public class ErrorUtils {
             throw new IllegalStateException(debugMessage+", required name: " + name);
         }
 
+        @Nullable
+        @Override
+        public DescriptorWithDeprecation<ClassifierDescriptor> getContributedClassifierIncludeDeprecated(
+                @NotNull Name name, @NotNull LookupLocation location
+        ) {
+            throw new IllegalStateException(debugMessage + ", required name: " + name);
+        }
+
         @NotNull
         @Override
         @SuppressWarnings({"unchecked"}) // KT-9898 Impossible implement kotlin interface from java

idea/idea-core/src/org/jetbrains/kotlin/idea/core/ShortenReferences.kt

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
-import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier
+import org.jetbrains.kotlin.resolve.scopes.utils.findFirstClassifierWithDeprecationStatus
 import org.jetbrains.kotlin.resolve.scopes.utils.findPackage
 import org.jetbrains.kotlin.resolve.source.getPsi
 import java.lang.IllegalStateException
@@ -369,12 +369,20 @@ class ShortenReferences(val options: (KtElement) -> Options = { Options.DEFAULT
 
             val scope = element.getResolutionScope(bindingContext, resolutionFacade)
             val name = target.name
-            val targetByName = if (target is ClassifierDescriptor)
-                scope.findClassifier(name, NoLookupLocation.FROM_IDE)
-            else
-                scope.findPackage(name)
 
-            val canShortenNow = targetByName?.asString() == target.asString()
+            val targetByName: DeclarationDescriptor?
+            val isDeprecated: Boolean
+
+            if (target is ClassifierDescriptor) {
+                val classifierWithDeprecation = scope.findFirstClassifierWithDeprecationStatus(name, NoLookupLocation.FROM_IDE)
+                targetByName = classifierWithDeprecation?.descriptor
+                isDeprecated = classifierWithDeprecation?.isDeprecated ?: false
+            } else {
+                targetByName = scope.findPackage(name)
+                isDeprecated = false
+            }
+
+            val canShortenNow = targetByName?.asString() == target.asString() && !isDeprecated
             return if (canShortenNow) AnalyzeQualifiedElementResult.ShortenNow else AnalyzeQualifiedElementResult.ImportDescriptors(
                 listOfNotNull(target)
             )
@@ -461,6 +469,9 @@ class ShortenReferences(val options: (KtElement) -> Options = { Options.DEFAULT
                             resolvedCallWhenShort is VariableAsFunctionResolvedCall? &&
                                     resolvedCallsMatch(resolvedCall, resolvedCallWhenShort)))
 
+            // Don't shorten references if it will result to call to deprecated classifier by short name
+            val isShortenedReferenceResolvesToDeprecated = newContext[BindingContext.DEPRECATED_SHORT_NAME_ACCESS, newCallee] == true
+            if (isShortenedReferenceResolvesToDeprecated) return AnalyzeQualifiedElementResult.Skip
 
             // If before and after shorten call can be resolved unambiguously, then preform comparing of such calls,
             // if it matches, then we can preform shortening

idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt

@@ -128,6 +128,7 @@ class KotlinImportOptimizer : ImportOptimizer {
 
                     is ClassDescriptor ->
                         scope.findClassifier(target.name, NoLookupLocation.FROM_IDE) == target
+                            && bindingContext[BindingContext.DEPRECATED_SHORT_NAME_ACCESS, place] != true
 
                     else -> false
                 }

idea/src/org/jetbrains/kotlin/idea/quickfix/AddExplicitImportForDeprecatedVisibilityFix.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.idea.quickfix
+
+import com.intellij.codeInsight.intention.IntentionAction
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.idea.caches.resolve.resolveImportReference
+import org.jetbrains.kotlin.idea.imports.importableFqName
+import org.jetbrains.kotlin.idea.util.ImportInsertHelper
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+
+internal class AddExplicitImportForDeprecatedVisibilityFix(expression: KtElement, private val targetFqName: FqName) : KotlinQuickFixAction<KtElement>(expression) {
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val targetDescriptor = file.resolveImportReference(targetFqName).singleOrNull() ?: return
+        ImportInsertHelper.getInstance(project).importDescriptor(file, targetDescriptor)
+    }
+
+    override fun getFamilyName(): String = text
+
+    override fun getText(): String = "Add explicit import"
+
+    object Factory : KotlinSingleIntentionActionFactory() {
+        override fun createAction(diagnostic: Diagnostic): IntentionAction? {
+            if (diagnostic.factory != Errors.DEPRECATED_ACCESS_BY_SHORT_NAME) return null
+            val castedDiagnostic = Errors.DEPRECATED_ACCESS_BY_SHORT_NAME.cast(diagnostic)
+
+            val soonToBeDeprecatedType = castedDiagnostic.psiElement
+            val importableFqNameOfTargetDescriptor = castedDiagnostic.a.importableFqName ?: return null
+
+            return AddExplicitImportForDeprecatedVisibilityFix(soonToBeDeprecatedType, importableFqNameOfTargetDescriptor)
+        }
+    }
+}

idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt

@@ -144,6 +144,7 @@ class QuickFixRegistrar : QuickFixContributor {
 
         UNRESOLVED_REFERENCE.registerFactory(ImportFix)
         UNRESOLVED_REFERENCE.registerFactory(ImportConstructorReferenceFix)
+        DEPRECATED_ACCESS_BY_SHORT_NAME.registerFactory(AddExplicitImportForDeprecatedVisibilityFix.Factory)
 
         TOO_MANY_ARGUMENTS.registerFactory(ImportForMismatchingArgumentsFix)
         NO_VALUE_FOR_PARAMETER.registerFactory(ImportForMismatchingArgumentsFix)

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.quickfix.replaceWith
 
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.analysis.analyzeInContext
 import org.jetbrains.kotlin.idea.caches.resolve.resolveImportReference
@@ -75,8 +76,10 @@ object ReplaceWithAnnotationAnalyzer {
         val module = resolutionFacade.moduleDescriptor
         val explicitImportsScope = buildExplicitImportsScope(annotation, resolutionFacade, module)
         val defaultImportsScopes = buildDefaultImportsScopes(resolutionFacade, module)
+
+        val languageVersionSettings = resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
         val scope = getResolutionScope(symbolDescriptor, symbolDescriptor,
-                                       listOf(explicitImportsScope) + defaultImportsScopes) ?: return null
+                                       listOf(explicitImportsScope) + defaultImportsScopes, languageVersionSettings) ?: return null
 
         val expressionTypingServices = resolutionFacade.getFrontendService(module, ExpressionTypingServices::class.java)
 
@@ -104,7 +107,12 @@ object ReplaceWithAnnotationAnalyzer {
 
         val explicitImportsScope = buildExplicitImportsScope(annotation, resolutionFacade, module)
         val defaultImportScopes = buildDefaultImportsScopes(resolutionFacade, module)
-        val scope = getResolutionScope(symbolDescriptor, symbolDescriptor, listOf(explicitImportsScope) + defaultImportScopes) ?: return null
+        val scope = getResolutionScope(
+                symbolDescriptor,
+                symbolDescriptor,
+                listOf(explicitImportsScope) + defaultImportScopes,
+                resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
+        ) ?: return null
 
         val typeResolver = resolutionFacade.getFrontendService(TypeResolver::class.java)
         val bindingTrace = BindingTraceContext()
@@ -155,11 +163,16 @@ object ReplaceWithAnnotationAnalyzer {
                 .map(FqNameUnsafe::toSafe)
     }
 
-    private fun getResolutionScope(descriptor: DeclarationDescriptor, ownerDescriptor: DeclarationDescriptor, additionalScopes: Collection<ImportingScope>): LexicalScope? {
+    private fun getResolutionScope(
+            descriptor: DeclarationDescriptor,
+            ownerDescriptor: DeclarationDescriptor,
+            additionalScopes: Collection<ImportingScope>,
+            languageVersionSettings: LanguageVersionSettings
+    ): LexicalScope? {
         return when (descriptor) {
             is PackageFragmentDescriptor -> {
                 val moduleDescriptor = descriptor.containingDeclaration
-                getResolutionScope(moduleDescriptor.getPackage(descriptor.fqName), ownerDescriptor, additionalScopes)
+                getResolutionScope(moduleDescriptor.getPackage(descriptor.fqName), ownerDescriptor, additionalScopes, languageVersionSettings)
             }
 
             is PackageViewDescriptor -> {
@@ -169,12 +182,12 @@ object ReplaceWithAnnotationAnalyzer {
             }
 
             is ClassDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
-                ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, { outerScope }).scopeForMemberDeclarationResolution()
+                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
+                ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, languageVersionSettings, { outerScope }).scopeForMemberDeclarationResolution()
             }
 
             is TypeAliasDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
+                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
                 LexicalScopeImpl(outerScope, descriptor, false, null, LexicalScopeKind.TYPE_ALIAS_HEADER, LocalRedeclarationChecker.DO_NOTHING) {
                     for (typeParameter in descriptor.declaredTypeParameters) {
                         addClassifierDescriptor(typeParameter)
@@ -183,12 +196,12 @@ object ReplaceWithAnnotationAnalyzer {
             }
 
             is FunctionDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
+                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
                 FunctionDescriptorUtil.getFunctionInnerScope(outerScope, descriptor, LocalRedeclarationChecker.DO_NOTHING)
             }
 
             is PropertyDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
+                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
                 val propertyHeader = ScopeUtils.makeScopeForPropertyHeader(outerScope, descriptor)
                 LexicalScopeImpl(propertyHeader, descriptor, false, descriptor.extensionReceiverParameter, LexicalScopeKind.PROPERTY_ACCESSOR_BODY)
             }

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt

@@ -0,0 +1,29 @@
+package foo
+
+import foo.CallableReferenceOnClass.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnClass.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnClass {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : CallableReferenceOnClass.Base() {
+    companion object : CallableReferenceOnClass.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt.after

@@ -0,0 +1,29 @@
+package foo
+
+import foo.CallableReferenceOnClass.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnClass.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnClass {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : CallableReferenceOnClass.Base() {
+    companion object : CallableReferenceOnClass.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt

@@ -0,0 +1,35 @@
+package foo
+
+import foo.CallableReferenceOnClassWithCompanion.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnClassWithCompanion.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnClassWithCompanion {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+
+                // We need it to cover another code-path
+                companion object
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+
+            // We need it to cover another code-path
+            companion object
+        }
+    }
+}
+
+class Derived : CallableReferenceOnClassWithCompanion.Base() {
+    companion object : CallableReferenceOnClassWithCompanion.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt.after

@@ -0,0 +1,35 @@
+package foo
+
+import foo.CallableReferenceOnClassWithCompanion.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnClassWithCompanion.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnClassWithCompanion {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+
+                // We need it to cover another code-path
+                companion object
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+
+            // We need it to cover another code-path
+            companion object
+        }
+    }
+}
+
+class Derived : CallableReferenceOnClassWithCompanion.Base() {
+    companion object : CallableReferenceOnClassWithCompanion.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt

@@ -0,0 +1,29 @@
+package foo
+
+import foo.CallableReferenceOnObject.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnObject.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnObject {
+
+    open class Base {
+        companion object {
+            object FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        object FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : CallableReferenceOnObject.Base() {
+    companion object : CallableReferenceOnObject.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt.after

@@ -0,0 +1,29 @@
+package foo
+
+import foo.CallableReferenceOnObject.Base.Companion.FromBaseCompanion
+import foo.CallableReferenceOnObject.CompanionSupertype.FromCompanionSupertype
+
+object CallableReferenceOnObject {
+
+    open class Base {
+        companion object {
+            object FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        object FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : CallableReferenceOnObject.Base() {
+    companion object : CallableReferenceOnObject.CompanionSupertype() { }
+
+    // Callable references
+    val c = FromBaseCompanion::foo
+    val d = FromCompanionSupertype::foo
+}

idea/testData/editor/optimizeImports/common/kt21515/constructor.kt

@@ -0,0 +1,30 @@
+package foo
+
+import foo.Constructors.Base.Companion.FromBaseCompanion
+import foo.Constructors.CompanionSupertype.FromCompanionSupertype
+
+object Constructors {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : Constructors.Base() {
+    companion object : Constructors.CompanionSupertype() {
+    }
+
+    // Constructors
+    val e = FromBaseCompanion()
+    val f = FromCompanionSupertype()
+}

idea/testData/editor/optimizeImports/common/kt21515/constructor.kt.after

@@ -0,0 +1,30 @@
+package foo
+
+import foo.Constructors.Base.Companion.FromBaseCompanion
+import foo.Constructors.CompanionSupertype.FromCompanionSupertype
+
+object Constructors {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : Constructors.Base() {
+    companion object : Constructors.CompanionSupertype() {
+    }
+
+    // Constructors
+    val e = FromBaseCompanion()
+    val f = FromCompanionSupertype()
+}

idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt

@@ -0,0 +1,30 @@
+package foo
+
+import foo.TypeReference.Base.Companion.FromBaseCompanion
+import foo.TypeReference.CompanionSupertype.FromCompanionSupertype
+
+object TypeReference {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : TypeReference.Base() {
+    companion object : TypeReference.CompanionSupertype() {
+    }
+
+    // Type references
+    val a: FromBaseCompanion? = null
+    val b: FromCompanionSupertype? = null
+}

idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt.after

@@ -0,0 +1,30 @@
+package foo
+
+import foo.TypeReference.Base.Companion.FromBaseCompanion
+import foo.TypeReference.CompanionSupertype.FromCompanionSupertype
+
+object TypeReference {
+
+    open class Base {
+        companion object {
+            class FromBaseCompanion {
+                fun foo() = 42
+            }
+        }
+    }
+
+    open class CompanionSupertype {
+        class FromCompanionSupertype {
+            fun foo() = 42
+        }
+    }
+}
+
+class Derived : TypeReference.Base() {
+    companion object : TypeReference.CompanionSupertype() {
+    }
+
+    // Type references
+    val a: FromBaseCompanion? = null
+    val b: FromCompanionSupertype? = null
+}

idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt

@@ -0,0 +1,16 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion::foo
+}

idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt.after

@@ -0,0 +1,16 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = Companion.FromBarCompanion::foo
+}

idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt

@@ -0,0 +1,14 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion
+    }
+}
+
+class Foo : Bar() {
+    val a: <caret>FromBarCompanion? = null
+}

idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt.after

@@ -0,0 +1,14 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion
+    }
+}
+
+class Foo : Bar() {
+    val a: Companion.FromBarCompanion? = null
+}

idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt

@@ -0,0 +1,14 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion()
+}

idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt.after

@@ -0,0 +1,14 @@
+// "Import" "true"
+// LANGUAGE_VERSION: 1.3
+
+package foo
+
+open class Bar {
+    companion object {
+        class FromBarCompanion
+    }
+}
+
+class Foo : Bar() {
+    val a = Companion.FromBarCompanion()
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt

@@ -0,0 +1,13 @@
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt.after

@@ -0,0 +1,15 @@
+import Bar.Companion.FromBarCompanion
+
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt

@@ -0,0 +1,16 @@
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+
+            // We need it to cover another code-path
+            companion object { }
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt.after

@@ -0,0 +1,18 @@
+import Bar.Companion.FromBarCompanion
+
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        class FromBarCompanion {
+            fun foo() = 42
+
+            // We need it to cover another code-path
+            companion object { }
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt

@@ -0,0 +1,13 @@
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        object FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt.after

@@ -0,0 +1,15 @@
+import Bar.Companion.FromBarCompanion
+
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        object FromBarCompanion {
+            fun foo() = 42
+        }
+    }
+}
+
+class Foo : Bar() {
+    val a = FromBarCompanion::foo
+}

idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt

@@ -0,0 +1,11 @@
+// "Add explicit import" "true"
+
+open class Bar {
+    companion object {
+        class FromBarCompanion
+    }
+}
+
+class Foo : Bar() {
+    val a = <caret>FromBarCompanion()
+}