diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 80276a153d5..592c1253eac 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -106,6 +106,7 @@ public interface Errors { DiagnosticFactory3 INVISIBLE_REFERENCE = DiagnosticFactory3.create(ERROR); DiagnosticFactory3 INVISIBLE_MEMBER = DiagnosticFactory3.create(ERROR, CALL_ELEMENT); + DiagnosticFactory1 DEPRECATED_ACCESS_BY_SHORT_NAME = DiagnosticFactory1.create(WARNING); DiagnosticFactory1 PROTECTED_CONSTRUCTOR_NOT_IN_SUPER_CALL = DiagnosticFactory1.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 123f8ab8c8d..69d1ea72ba3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt index bc65efcc523..2abbd279b19 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt +++ b/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().apply { c.syntheticResolveExtension.addSyntheticSupertypes(thisDescriptor, this) } private val unsubstitutedMemberScope = diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java index 17448a60cf1..9031b90f05a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java @@ -244,6 +244,8 @@ public interface BindingContext { WritableSlice PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice(); WritableSlice TYPE_ALIAS = Slices.createSimpleSlice(); + WritableSlice 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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt index 49381f51d5c..4d0aada0300 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt +++ b/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) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt index 0409d211494..756fd31e056 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/NewResolutionOldInference.kt @@ -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) + ) + } + } } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt index bd15cdff870..7605258d74d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt +++ b/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(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 StorageManager.createLazyValue(onRecursion: ((Boolean) -> T), compute: () -> T) = diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 8aa04bcb953..64e8b235d9d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/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(); diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt index 73f91f870cf..b72fbabaf84 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/ImplicitScopeTower.kt @@ -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) \ No newline at end of file diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt index 7638912c155..af02b3de633 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt +++ b/compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt @@ -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 = resolutionScope.getContributedObjectVariables(name, location).map { - createCandidateDescriptor(it, dispatchReceiver = null) - } + ): Collection = + 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 = resolutionScope.getContributedFunctionsAndConstructors( - name, - location, - scopeTower.syntheticScopes, - resolutionScope - ).map { - createCandidateDescriptor(it, dispatchReceiver = null) + ): Collection { + val result: ArrayList = 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 { val result = ArrayList(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 { 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 { val objectDescriptor = getFakeDescriptorForObject(getContributedClassifier(name, location)) return listOfNotNull(objectDescriptor) } +private fun ResolutionScope.getContributedObjectVariablesIncludeDeprecated(name: Name, location: LookupLocation): Collection> { + 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 -> diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/DeprecatedScopes.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/DeprecatedScopes.kt new file mode 100644 index 00000000000..de5c1da5a09 --- /dev/null +++ b/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? { + 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? { + return workerScope.getContributedClassifier(name, location)?.let { DescriptorWithDeprecation.createDeprecated(it) } + } +} \ No newline at end of file diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt index c0d3702406e..1d56325c13e 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalChainedScope.kt +++ b/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, @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? { + 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) } diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalWritableScope.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalWritableScope.kt index cea0ab2a0f8..7142206f572 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/LexicalWritableScope.kt +++ b/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? { + return variableOrClassDescriptorByName(name, descriptorLimit) + ?.safeAs() + ?.let { DescriptorWithDeprecation.createNonDeprecated(it) } + } + override fun getContributedVariables(name: Name, location: LookupLocation) = listOfNotNull(variableOrClassDescriptorByName(name, descriptorLimit) as? VariableDescriptor) diff --git a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt b/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt index c671013af99..ded44def4e5 100644 --- a/compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt +++ b/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? { + return findFirstFromMeAndParent { it.getContributedClassifierIncludeDeprecated(name, location) } +} + fun HierarchicalScope.findPackage(name: Name): PackageViewDescriptor? = findFirstFromImportingScopes { it.getContributedPackage(name) } fun HierarchicalScope.collectVariables(name: Name, location: LookupLocation): Collection = diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers.kt index 638d0e388e3..14792344c85 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers.kt @@ -8,7 +8,7 @@ public class C { open class Base () - class Foo : Data() + class Foo : Data() companion object : DerivedAbstract() } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers.kt index 3922425564d..8de24cb9cf3 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers.kt @@ -7,11 +7,11 @@ object WithFunctionInBase { public class C { // error-scope - val data: Data = Data() + val data: Data = Data() open class Base() { // error-scope - fun foo(): Int = 42 + fun foo(): Int = 42 } companion object : DerivedAbstract() @@ -29,11 +29,11 @@ object WithPropertyInBase { open class Base() { // error-scope - val foo: Int = 42 + val foo: Int = 42 } // error-scope - val data: Data = Data() + val data: Data = Data() companion object : DerivedAbstract() } diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt index e55283f2f3a..21cd7627e58 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject.kt @@ -14,7 +14,7 @@ class A { // Does not work, could be Outer.Inner // TODO: Should work? - fun foo(x: Inner) { + fun foo(x: Inner) { // Inner() call use companion as implicit receiver val y: Outer.Inner = Inner() } diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt b/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt new file mode 100644 index 00000000000..8129714dda7 --- /dev/null +++ b/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() { + + @Foo + fun foo() = 42 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.txt b/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.txt new file mode 100644 index 00000000000..0a3ac141b6d --- /dev/null +++ b/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 +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt new file mode 100644 index 00000000000..c5a2f2f5a1e --- /dev/null +++ b/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::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 + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.txt new file mode 100644 index 00000000000..db1001558a8 --- /dev/null +++ b/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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt new file mode 100644 index 00000000000..c1a0de8e9d1 --- /dev/null +++ b/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::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 + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.txt new file mode 100644 index 00000000000..b649effc5c6 --- /dev/null +++ b/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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt new file mode 100644 index 00000000000..d062660d407 --- /dev/null +++ b/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 = A::foo + val b = A::foo + + // DEPRECATED: Classifiers from companions of direct superclasses + val e = FromCompanionA::foo + val f = FromCompanionB::foo + + // INVISIBLE: "cousin" supertypes themselves + val g = Alpha::foo + val h = Beta::foo + val i = Gamma::foo + + // DEPRECATED: classifiers from "cousin" superclasses + val k = FromAlpha::foo + val l = FromBeta::foo + val m = FromGamma::foo + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o = FromCompanionAlpha::foo + val p = FromCompanionBeta::foo + val q = FromCompanionGamma::foo + + // DEPRECATED: Classifiers from supertypes of our own companion + val r = FromDelta::foo +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.txt new file mode 100644 index 00000000000..0e7b838c140 --- /dev/null +++ b/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 + public final val d: kotlin.reflect.KFunction1 + 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 + 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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt new file mode 100644 index 00000000000..70899a07f0e --- /dev/null +++ b/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 = A::foo + val b = A::foo + + // DEPRECATED: Classifiers from companions of direct superclasses + val e = FromCompanionA::foo + val f = FromCompanionB::foo + + // INVISIBLE: "cousin" supertypes themselves + val g = Alpha::foo + val h = Beta::foo + val i = Gamma::foo + + // DEPRECATED: classifiers from "cousin" superclasses + val k = FromAlpha::foo + val l = FromBeta::foo + val m = FromGamma::foo + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o = FromCompanionAlpha::foo + val p = FromCompanionBeta::foo + val q = FromCompanionGamma::foo + + // DEPRECATED: Classifiers from supertypes of our own companion + val r = FromDelta::foo +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.txt new file mode 100644 index 00000000000..a669e74aa6b --- /dev/null +++ b/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 + public final val d: kotlin.reflect.KFunction1 + public final val e: kotlin.reflect.KFunction1 + public final val f: kotlin.reflect.KFunction1 + 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 + public final val l: kotlin.reflect.KFunction1 + public final val m: kotlin.reflect.KFunction1 + public final val n: kotlin.reflect.KFunction1 + 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 + 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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt new file mode 100644 index 00000000000..a774f4f746e --- /dev/null +++ b/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 = 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 = 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 = FromBaseCompanion::foo + } +} + +// ==== Case 4: LHS is an object + +object D { + open class Base { + companion object { + object FromBaseCompanion { + fun foo() = 42 + } + } + } + + class Derived : Base() { + val a = FromBaseCompanion::foo + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.txt new file mode 100644 index 00000000000..81cac01202c --- /dev/null +++ b/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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.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 + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt new file mode 100644 index 00000000000..4a72ff41864 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.txt new file mode 100644 index 00000000000..dacdadd5f95 --- /dev/null +++ b/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 + public final val b: kotlin.reflect.KFunction1 + public final val c: kotlin.reflect.KFunction1 + public final val d: kotlin.reflect.KFunction1 + public final val e: kotlin.reflect.KFunction1 + public final val f: kotlin.reflect.KFunction1 + public final val g: kotlin.reflect.KFunction1 + public final val h: kotlin.reflect.KFunction1 + public final val i: kotlin.reflect.KFunction1 + public final val k: kotlin.reflect.KFunction1 + public final val l: kotlin.reflect.KFunction1 + public final val m: kotlin.reflect.KFunction1 + public final val n: kotlin.reflect.KFunction1 + public final val o: kotlin.reflect.KFunction1 + public final val p: kotlin.reflect.KFunction1 + public final val q: kotlin.reflect.KFunction1 + public final val r: kotlin.reflect.KFunction1 + 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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt new file mode 100644 index 00000000000..365ce45f7b7 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.txt new file mode 100644 index 00000000000..dacdadd5f95 --- /dev/null +++ b/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 + public final val b: kotlin.reflect.KFunction1 + public final val c: kotlin.reflect.KFunction1 + public final val d: kotlin.reflect.KFunction1 + public final val e: kotlin.reflect.KFunction1 + public final val f: kotlin.reflect.KFunction1 + public final val g: kotlin.reflect.KFunction1 + public final val h: kotlin.reflect.KFunction1 + public final val i: kotlin.reflect.KFunction1 + public final val k: kotlin.reflect.KFunction1 + public final val l: kotlin.reflect.KFunction1 + public final val m: kotlin.reflect.KFunction1 + public final val n: kotlin.reflect.KFunction1 + public final val o: kotlin.reflect.KFunction1 + public final val p: kotlin.reflect.KFunction1 + public final val q: kotlin.reflect.KFunction1 + public final val r: kotlin.reflect.KFunction1 + 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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt new file mode 100644 index 00000000000..0a8b4409562 --- /dev/null +++ b/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: A? = null + val b: B? = null + + // DEPRECATED: Classifiers from companions of direct superclasses + val e: FromCompanionA? = null + val f: FromCompanionB? = null + + // INVISIBLE: "cousin" supertypes themselves + val g: Alpha? = null + val h: Beta? = null + val i: Gamma? = null + + // DEPRECATED: classifiers from "cousin" superclasses + val k: FromAlpha? = null + val l: FromBeta? = null + val m: FromGamma? = null + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o: FromCompanionAlpha? = null + val p: FromCompanionBeta? = null + val q: FromCompanionGamma? = null + + // DEPRECATED: Classifiers from supertypes of our own companion + val r: FromDelta? = null +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.txt new file mode 100644 index 00000000000..2a65af87583 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt new file mode 100644 index 00000000000..0f7da9de805 --- /dev/null +++ b/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: A? = null + val b: B? = null + + // DEPRECATED: Classifiers from companions of direct superclasses + val e: FromCompanionA? = null + val f: FromCompanionB? = null + + // INVISIBLE: "cousin" supertypes themselves + val g: Alpha? = null + val h: Beta? = null + val i: Gamma? = null + + // DEPRECATED: classifiers from "cousin" superclasses + val k: FromAlpha? = null + val l: FromBeta? = null + val m: FromGamma? = null + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o: FromCompanionAlpha? = null + val p: FromCompanionBeta? = null + val q: FromCompanionGamma? = null + + // DEPRECATED: Classifiers from supertypes of our own companion + val r: FromDelta? = null +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.txt new file mode 100644 index 00000000000..25cf5aab348 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt new file mode 100644 index 00000000000..cee85fc989c --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.txt new file mode 100644 index 00000000000..2221901880d --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt new file mode 100644 index 00000000000..6a65b624428 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.txt new file mode 100644 index 00000000000..2221901880d --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt new file mode 100644 index 00000000000..bdc9c72d601 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.txt b/compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.txt new file mode 100644 index 00000000000..2c1d2b34c7d --- /dev/null +++ b/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 + 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 + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt new file mode 100644 index 00000000000..273f7d2faf4 --- /dev/null +++ b/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 : A() + open class b : B() + + // DEPRECATED: Classifiers from companions of direct superclasses + open class e : FromCompanionA() + open class f : FromCompanionB() + + // INVISIBLE: "cousin" supertypes themselves + open class g : Alpha() + open class h : Beta() + open class i : Gamma() + + // DEPRECATED: classifiers from "cousin" superclasses + open class k : FromAlpha() + open class l : FromBeta() + open class m : FromGamma() + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + open class o : FromCompanionAlpha() + open class p : FromCompanionBeta() + open class q : FromCompanionGamma() + + // DEPRECATED: Classifiers from supertypes of our own companion + open class r : FromDelta() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.txt new file mode 100644 index 00000000000..a5886fb3eb1 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt new file mode 100644 index 00000000000..f7113d0e739 --- /dev/null +++ b/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 : A() + open class b : B() + + // DEPRECATED: Classifiers from companions of direct superclasses + open class e : FromCompanionA() + open class f : FromCompanionB() + + // INVISIBLE: "cousin" supertypes themselves + open class g : Alpha() + open class h : Beta() + open class i : Gamma() + + // DEPRECATED: classifiers from "cousin" superclasses + open class k : FromAlpha() + open class l : FromBeta() + open class m : FromGamma() + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + open class o : FromCompanionAlpha() + open class p : FromCompanionBeta() + open class q : FromCompanionGamma() + + // DEPRECATED: Classifiers from supertypes of our own companion + open class r : FromDelta() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.txt new file mode 100644 index 00000000000..acf97d3392d --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt new file mode 100644 index 00000000000..f1abf117b2d --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.txt new file mode 100644 index 00000000000..4a810403218 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt new file mode 100644 index 00000000000..ea97e72b0c0 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.txt new file mode 100644 index 00000000000..4a810403218 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt new file mode 100644 index 00000000000..62c8d5d5f0b --- /dev/null +++ b/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 = A() + val b = B() + + // DEPRECATED: Classifiers from companions of direct superclasses + val e = FromCompanionA() + val f = FromCompanionB() + + // INVISIBLE: "cousin" supertypes themselves + val g = Alpha() + val h = Beta() + val i = Gamma() + + // DEPRECATED: classifiers from "cousin" superclasses + val k = FromAlpha() + val l = FromBeta() + val m = FromGamma() + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o = FromCompanionAlpha() + val p = FromCompanionBeta() + val q = FromCompanionGamma() + + // DEPRECATED: Classifiers from supertypes of our own companion + val r = FromDelta() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.txt new file mode 100644 index 00000000000..23e30e8a3dd --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt new file mode 100644 index 00000000000..47eace1ee00 --- /dev/null +++ b/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 = A() + val b = B() + + // DEPRECATED: Classifiers from companions of direct superclasses + val e = FromCompanionA() + val f = FromCompanionB() + + // INVISIBLE: "cousin" supertypes themselves + val g = Alpha() + val h = Beta() + val i = Gamma() + + // DEPRECATED: classifiers from "cousin" superclasses + val k = FromAlpha() + val l = FromBeta() + val m = FromGamma() + + // INVISIBLE: We don't see classifiers from companions of "cousin" superclasses + val o = FromCompanionAlpha() + val p = FromCompanionBeta() + val q = FromCompanionGamma() + + // DEPRECATED: Classifiers from supertypes of our own companion + val r = FromDelta() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.txt new file mode 100644 index 00000000000..9b990c7cc5e --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt new file mode 100644 index 00000000000..2a1da9d91d3 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.txt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.txt new file mode 100644 index 00000000000..5972d71dfe9 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt new file mode 100644 index 00000000000..ab80273e1c2 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.txt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.txt new file mode 100644 index 00000000000..5972d71dfe9 --- /dev/null +++ b/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 + } + } +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt index 76543d06ac4..efd791f306f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt +++ b/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.bar() - B_() + B_() B.B_() B.Companion.B_() C.B_() diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt index 49fa3245a60..e298d612d22 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt +++ 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.bar() D.bar() - B_() + B_() B.B_() B.Companion.B_() C.B_() diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt index 85559597aa2..fe6efb2684a 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt +++ 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().bar() D() - C() + C() } object Z { @@ -37,7 +39,7 @@ class E: A() { B().bar() D() - C() + C() } } } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt index 70ba5ba8899..f2bd8f0c5d0 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt +++ b/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: B = null!! init { - B() + B() } object O { - val b: B = null!! + val b: B = null!! init { - B() + B() } } class K { - val b: B = null!! + val b: B = null!! init { - B() + B() } } inner class I { - val b: B = null!! + val b: B = null!! init { - B() + B() } } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt index 1cd65322253..4824f34ff71 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt +++ 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() + Z().A_C_Z() } } diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt index 6a7f0386506..d682b0f9f4a 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt +++ b/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() + Z().A_C_Z() } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt index 9ebeaeecf23..81ae00acaa4 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt +++ b/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().T_X() - Y().A_C_Y() - Y().T_Y() + Y().A_C_Y() + Y().T_Y() } } \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 7eaa70c99cd..604cffe10f9 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/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") diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index a692add89a1..97d8f8d5aea 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/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") diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 401e1b1bb97..63aaa2cdb1a 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/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), diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorWithDeprecation.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorWithDeprecation.kt new file mode 100644 index 00000000000..f6ad5e8b3f1 --- /dev/null +++ b/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(val descriptor: T, val isDeprecated: Boolean) { + companion object { + fun createNonDeprecated(descriptor: T): DescriptorWithDeprecation = + DescriptorWithDeprecation(descriptor, false) + + fun createDeprecated(descriptor: T): DescriptorWithDeprecation = + DescriptorWithDeprecation(descriptor, true) + } +} + diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ResolutionScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ResolutionScope.kt index 0a772b52259..79d05c92629 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/ResolutionScope.kt +++ b/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? = + getContributedClassifier(name, location)?.let { DescriptorWithDeprecation.createNonDeprecated(it) } + fun getContributedVariables(name: Name, location: LookupLocation): Collection fun getContributedFunctions(name: Name, location: LookupLocation): Collection diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java index ae2bd983b6a..40143f4b9c7 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/ErrorUtils.java @@ -181,6 +181,14 @@ public class ErrorUtils { return createErrorClass(name.asString()); } + @Nullable + @Override + public DescriptorWithDeprecation 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 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 diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ShortenReferences.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ShortenReferences.kt index 8ef60d58a48..b37a6ee83ae 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/ShortenReferences.kt +++ b/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 diff --git a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt index 557019b8f01..77229f85abc 100644 --- a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt +++ b/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 } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddExplicitImportForDeprecatedVisibilityFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddExplicitImportForDeprecatedVisibilityFix.kt new file mode 100644 index 00000000000..49cd19f3eab --- /dev/null +++ b/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(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) + } + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt index 5c6b24cb154..674dfbecee2 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt +++ b/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) diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt index e7860044195..a3d21285b10 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt +++ b/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): LexicalScope? { + private fun getResolutionScope( + descriptor: DeclarationDescriptor, + ownerDescriptor: DeclarationDescriptor, + additionalScopes: Collection, + 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) } diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt new file mode 100644 index 00000000000..a880c0948b2 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt.after b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt.after new file mode 100644 index 00000000000..a880c0948b2 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt new file mode 100644 index 00000000000..a2926337bbb --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt.after b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt.after new file mode 100644 index 00000000000..a2926337bbb --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt new file mode 100644 index 00000000000..e15edc670fa --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt.after b/idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt.after new file mode 100644 index 00000000000..e15edc670fa --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/constructor.kt b/idea/testData/editor/optimizeImports/common/kt21515/constructor.kt new file mode 100644 index 00000000000..b9f4bc0a640 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/constructor.kt.after b/idea/testData/editor/optimizeImports/common/kt21515/constructor.kt.after new file mode 100644 index 00000000000..b9f4bc0a640 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt b/idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt new file mode 100644 index 00000000000..8d3c693284a --- /dev/null +++ b/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 +} diff --git a/idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt.after b/idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt.after new file mode 100644 index 00000000000..8d3c693284a --- /dev/null +++ b/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 +} diff --git a/idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt b/idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt new file mode 100644 index 00000000000..0aa7efd58fa --- /dev/null +++ b/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 = FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt.after b/idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt.after new file mode 100644 index 00000000000..70da6996e37 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt b/idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt new file mode 100644 index 00000000000..5f77c1f79e0 --- /dev/null +++ b/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: FromBarCompanion? = null +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt.after b/idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt.after new file mode 100644 index 00000000000..31db73b694b --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt b/idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt new file mode 100644 index 00000000000..25445377fea --- /dev/null +++ b/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 = FromBarCompanion() +} \ No newline at end of file diff --git a/idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt.after b/idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt.after new file mode 100644 index 00000000000..54195742a4b --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt new file mode 100644 index 00000000000..bf8ad05db3e --- /dev/null +++ b/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 = FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt.after b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt.after new file mode 100644 index 00000000000..867de9080d8 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt new file mode 100644 index 00000000000..e06b7da2432 --- /dev/null +++ b/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 = FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt.after b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt.after new file mode 100644 index 00000000000..6f7a868eda9 --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt new file mode 100644 index 00000000000..a7825dd31a7 --- /dev/null +++ b/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 = FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt.after b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt.after new file mode 100644 index 00000000000..1674b89653e --- /dev/null +++ b/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 +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt new file mode 100644 index 00000000000..42b226ed906 --- /dev/null +++ b/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 = FromBarCompanion() +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt.after b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt.after new file mode 100644 index 00000000000..6524d4a32db --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt.after @@ -0,0 +1,13 @@ +import Bar.Companion.FromBarCompanion + +// "Add explicit import" "true" + +open class Bar { + companion object { + class FromBarCompanion + } +} + +class Foo : Bar() { + val a = FromBarCompanion() +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt new file mode 100644 index 00000000000..fd206326ab3 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt @@ -0,0 +1,11 @@ +// "Add explicit import" "true" + +open class Bar { + companion object { + class FromBarCompanion + } +} + +class Foo : Bar() { + val a: FromBarCompanion? = null +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt.after b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt.after new file mode 100644 index 00000000000..5f81af8815c --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt.after @@ -0,0 +1,13 @@ +import Bar.Companion.FromBarCompanion + +// "Add explicit import" "true" + +open class Bar { + companion object { + class FromBarCompanion + } +} + +class Foo : Bar() { + val a: FromBarCompanion? = null +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt b/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt new file mode 100644 index 00000000000..c324cb0d118 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt @@ -0,0 +1,11 @@ +open class Bar { + companion object { + class FromBarCompanion { + fun foo() = 42 + } + } +} + +class Foo : Bar() { + val a = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt.after b/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt.after new file mode 100644 index 00000000000..d051ac8f4a0 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt.after @@ -0,0 +1,11 @@ +open class Bar { + companion object { + class FromBarCompanion { + fun foo() = 42 + } + } +} + +class Foo : Bar() { + val a = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt b/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt new file mode 100644 index 00000000000..33e5d84d2c4 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt @@ -0,0 +1,14 @@ +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 = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt.after b/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt.after new file mode 100644 index 00000000000..560d7908b57 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt.after @@ -0,0 +1,14 @@ +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 = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt b/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt new file mode 100644 index 00000000000..6c8cba1eb20 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt @@ -0,0 +1,11 @@ +open class Bar { + companion object { + object FromBarCompanion { + fun foo() = 42 + } + } +} + +class Foo : Bar() { + val a = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt.after b/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt.after new file mode 100644 index 00000000000..3bf1c517f4d --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt.after @@ -0,0 +1,11 @@ +open class Bar { + companion object { + object FromBarCompanion { + fun foo() = 42 + } + } +} + +class Foo : Bar() { + val a = Companion.FromBarCompanion::foo +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/constructor.kt b/idea/testData/shortenRefs/kt21515/constructor.kt new file mode 100644 index 00000000000..592e20565ac --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/constructor.kt @@ -0,0 +1,9 @@ + open class Bar { + companion object { + class FromBarCompanion + } + } + +class Foo : Bar() { + val a = Companion.FromBarCompanion() +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/constructor.kt.after b/idea/testData/shortenRefs/kt21515/constructor.kt.after new file mode 100644 index 00000000000..69e142ce837 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/constructor.kt.after @@ -0,0 +1,9 @@ + open class Bar { + companion object { + class FromBarCompanion + } + } + +class Foo : Bar() { + val a = Companion.FromBarCompanion() +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/typeReference.kt b/idea/testData/shortenRefs/kt21515/typeReference.kt new file mode 100644 index 00000000000..1fe4eb7f89a --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/typeReference.kt @@ -0,0 +1,9 @@ +open class Bar { + companion object { + class FromBarCompanion + } +} + +class Foo : Bar() { + val a: Companion.FromBarCompanion? = null +} \ No newline at end of file diff --git a/idea/testData/shortenRefs/kt21515/typeReference.kt.after b/idea/testData/shortenRefs/kt21515/typeReference.kt.after new file mode 100644 index 00000000000..a9b78692b61 --- /dev/null +++ b/idea/testData/shortenRefs/kt21515/typeReference.kt.after @@ -0,0 +1,9 @@ +open class Bar { + companion object { + class FromBarCompanion + } +} + +class Foo : Bar() { + val a: Companion.FromBarCompanion? = null +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java index 94590ed63f1..366cc827896 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java @@ -185,5 +185,44 @@ public class JsOptimizeImportsTestGenerated extends AbstractJsOptimizeImportsTes String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/TypeAliasUsage.kt"); doTest(fileName); } + + @TestMetadata("idea/testData/editor/optimizeImports/common/kt21515") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt21515 extends AbstractJsOptimizeImportsTest { + public void testAllFilesPresentInKt21515() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferenceOnClass.kt") + public void testCallableReferenceOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnClassWithCompanion.kt") + public void testCallableReferenceOnClassWithCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnObject.kt") + public void testCallableReferenceOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeReference.kt") + public void testTypeReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt"); + doTest(fileName); + } + } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java index bf1a0037fc1..62b59ab2f83 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java @@ -386,5 +386,44 @@ public class JvmOptimizeImportsTestGenerated extends AbstractJvmOptimizeImportsT String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/TypeAliasUsage.kt"); doTest(fileName); } + + @TestMetadata("idea/testData/editor/optimizeImports/common/kt21515") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt21515 extends AbstractJvmOptimizeImportsTest { + public void testAllFilesPresentInKt21515() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferenceOnClass.kt") + public void testCallableReferenceOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnClassWithCompanion.kt") + public void testCallableReferenceOnClassWithCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnObject.kt") + public void testCallableReferenceOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeReference.kt") + public void testTypeReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt"); + doTest(fileName); + } + } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java index b67841adaa2..7fa450f1549 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java @@ -1337,6 +1337,33 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/unresolvedReferenceInCall.kt"); doTest(fileName); } + + @TestMetadata("idea/testData/quickfix/autoImports/kt21515") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt21515 extends AbstractQuickFixTest { + public void testAllFilesPresentInKt21515() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/autoImports/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferenceFromDeprecated.kt") + public void testCallableReferenceFromDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt"); + doTest(fileName); + } + + @TestMetadata("classifierFromCompanionObjectDeprecationEnabled.kt") + public void testClassifierFromCompanionObjectDeprecationEnabled() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt"); + doTest(fileName); + } + + @TestMetadata("constructorFromDeprecated.kt") + public void testConstructorFromDeprecated() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt"); + doTest(fileName); + } + } } @TestMetadata("idea/testData/quickfix/canBeParameter") @@ -2331,6 +2358,45 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/traitWithQualifier.kt"); doTest(fileName); } + + @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt21515 extends AbstractQuickFixTest { + public void testAllFilesPresentInKt21515() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferenceOnClass.kt") + public void testCallableReferenceOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnClassWithCompanion.kt") + public void testCallableReferenceOnClassWithCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnObject.kt") + public void testCallableReferenceOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeReference.kt") + public void testTypeReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt"); + doTest(fileName); + } + } } @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/referenceExpression") diff --git a/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java index 28e40b40a75..fdb085c52e4 100644 --- a/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java @@ -334,6 +334,45 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } } + @TestMetadata("idea/testData/shortenRefs/kt21515") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Kt21515 extends AbstractShortenRefsTest { + public void testAllFilesPresentInKt21515() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/shortenRefs/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("callableReferenceOnClass.kt") + public void testCallableReferenceOnClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnClassWithCompanion.kt") + public void testCallableReferenceOnClassWithCompanion() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt"); + doTest(fileName); + } + + @TestMetadata("callableReferenceOnObject.kt") + public void testCallableReferenceOnObject() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt"); + doTest(fileName); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/shortenRefs/kt21515/constructor.kt"); + doTest(fileName); + } + + @TestMetadata("typeReference.kt") + public void testTypeReference() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/shortenRefs/kt21515/typeReference.kt"); + doTest(fileName); + } + } + @TestMetadata("idea/testData/shortenRefs/this") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class)