From d570b863cec83883435c58e4e994b285e139213e Mon Sep 17 00:00:00 2001 From: Dmitry Savvinov Date: Thu, 14 Dec 2017 18:59:32 +0300 Subject: [PATCH] Introduce deprecation of companion objects nested classes Introdude deprecation as per KT-21515. Warning is reported on type usage, that soon will became invisible. Quickfix by adding explicit import is added. Idea behind implementation is to mark scopes that are deprecated (see ClassResolutionScopesSupport). Then, during walk along hierarchy of scopes, look at deprecation status of the scope that has provided this classifier. Note that we also have to check if there are *some* non-deprecated visibility paths (because we can see classifier by two paths, e.g. if we've added explicit import) -- then this type reference shouldn't be treated as deprecated. --- .../jetbrains/kotlin/diagnostics/Errors.java | 1 + .../rendering/DefaultErrorMessages.java | 1 + .../SyntheticClassOrObjectDescriptor.kt | 2 +- .../kotlin/resolve/BindingContext.java | 2 + .../resolve/QualifiedExpressionResolver.kt | 43 ++- .../calls/tower/NewResolutionOldInference.kt | 47 ++- .../ClassResolutionScopesSupport.kt | 70 ++-- .../lazy/descriptors/LazyClassDescriptor.java | 8 +- .../resolve/calls/tower/ImplicitScopeTower.kt | 6 +- .../kotlin/resolve/calls/tower/TowerLevels.kt | 75 +++-- .../kotlin/resolve/scopes/DeprecatedScopes.kt | 33 ++ .../resolve/scopes/LexicalChainedScope.kt | 21 ++ .../resolve/scopes/LexicalWritableScope.kt | 13 + .../kotlin/resolve/scopes/utils/ScopeUtils.kt | 16 + .../withCompanion/noMembers.kt | 2 +- .../withCompanion/withMembers.kt | 8 +- .../implicitArguments/fromCompanionObject.kt | 2 +- .../objects/kt21515/annotationConstructor.kt | 13 + .../objects/kt21515/annotationConstructor.txt | 30 ++ ...ableReferenceComplexCasesWithImportsOld.kt | 74 ++++ ...bleReferenceComplexCasesWithImportsOld.txt | 163 +++++++++ ...erencesComplexCasesWithQualificationOld.kt | 69 ++++ ...rencesComplexCasesWithQualificationOld.txt | 163 +++++++++ .../objects/kt21515/callableReferencesNew.kt | 142 ++++++++ .../objects/kt21515/callableReferencesNew.txt | 239 +++++++++++++ .../objects/kt21515/callableReferencesOld.kt | 142 ++++++++ .../objects/kt21515/callableReferencesOld.txt | 239 +++++++++++++ .../callableReferencesOldComplexCases.kt | 69 ++++ .../callableReferencesOldComplexCases.txt | 163 +++++++++ .../callableReferencesWithQualificationNew.kt | 142 ++++++++ ...callableReferencesWithQualificationNew.txt | 239 +++++++++++++ .../callableReferencesWithQualificationOld.kt | 142 ++++++++ ...callableReferencesWithQualificationOld.txt | 239 +++++++++++++ .../classifierFromCompanionObjectNew.kt | 99 ++++++ .../classifierFromCompanionObjectNew.txt | 214 ++++++++++++ .../classifierFromCompanionObjectOld.kt | 98 ++++++ .../classifierFromCompanionObjectOld.txt | 214 ++++++++++++ ...FromCompanionObjectWithQualificationNew.kt | 99 ++++++ ...romCompanionObjectWithQualificationNew.txt | 214 ++++++++++++ ...FromCompanionObjectWithQualificationOld.kt | 98 ++++++ ...romCompanionObjectWithQualificationOld.txt | 214 ++++++++++++ .../kt21515/classifierIsVisibleByTwoPaths.kt | 17 + .../kt21515/classifierIsVisibleByTwoPaths.txt | 33 ++ .../kt21515/inheritedFromDeprecatedNew.kt | 100 ++++++ .../kt21515/inheritedFromDeprecatedNew.txt | 316 ++++++++++++++++++ .../kt21515/inheritedFromDeprecatedOld.kt | 100 ++++++ .../kt21515/inheritedFromDeprecatedOld.txt | 316 ++++++++++++++++++ ...ritedFromDeprecatedWithQualificationNew.kt | 100 ++++++ ...itedFromDeprecatedWithQualificationNew.txt | 316 ++++++++++++++++++ ...ritedFromDeprecatedWithQualificationOld.kt | 100 ++++++ ...itedFromDeprecatedWithQualificationOld.txt | 316 ++++++++++++++++++ .../kt21515/useDeprecatedConstructorNew.kt | 100 ++++++ .../kt21515/useDeprecatedConstructorNew.txt | 214 ++++++++++++ .../kt21515/useDeprecatedConstructorOld.kt | 99 ++++++ .../kt21515/useDeprecatedConstructorOld.txt | 214 ++++++++++++ ...precatedConstructorWithQualificationNew.kt | 100 ++++++ ...recatedConstructorWithQualificationNew.txt | 214 ++++++++++++ ...precatedConstructorWithQualificationOld.kt | 100 ++++++ ...recatedConstructorWithQualificationOld.txt | 214 ++++++++++++ .../scopes/inheritance/companionObject.kt | 4 +- .../inheritance/companionObjectAfterJava.kt | 4 +- .../tests/scopes/inheritance/innerClasses.kt | 6 +- .../inheritance/nestedCompanionClass.kt | 18 +- .../nestedCompanionClassVsNested.kt | 4 +- .../nestedCompanionClassVsNestedJava.kt | 4 +- .../inheritance/nestedVsToplevelClass.kt | 6 +- .../checkers/DiagnosticsTestGenerated.java | 135 ++++++++ .../DiagnosticsUsingJavacTestGenerated.java | 135 ++++++++ .../kotlin/config/LanguageVersionSettings.kt | 1 + .../descriptors/DescriptorWithDeprecation.kt | 17 + .../kotlin/resolve/scopes/ResolutionScope.kt | 22 +- .../jetbrains/kotlin/types/ErrorUtils.java | 16 + .../kotlin/idea/core/ShortenReferences.kt | 23 +- .../idea/imports/KotlinImportOptimizer.kt | 1 + ...xplicitImportForDeprecatedVisibilityFix.kt | 52 +++ .../kotlin/idea/quickfix/QuickFixRegistrar.kt | 1 + .../ReplaceWithAnnotationAnalyzer.kt | 31 +- .../kt21515/callableReferenceOnClass.kt | 29 ++ .../kt21515/callableReferenceOnClass.kt.after | 29 ++ .../callableReferenceOnClassWithCompanion.kt | 35 ++ ...ableReferenceOnClassWithCompanion.kt.after | 35 ++ .../kt21515/callableReferenceOnObject.kt | 29 ++ .../callableReferenceOnObject.kt.after | 29 ++ .../common/kt21515/constructor.kt | 30 ++ .../common/kt21515/constructor.kt.after | 30 ++ .../common/kt21515/typeReference.kt | 30 ++ .../common/kt21515/typeReference.kt.after | 30 ++ .../callableReferenceFromDeprecated.kt | 16 + .../callableReferenceFromDeprecated.kt.after | 16 + ...erFromCompanionObjectDeprecationEnabled.kt | 14 + ...CompanionObjectDeprecationEnabled.kt.after | 14 + .../kt21515/constructorFromDeprecated.kt | 14 + .../constructorFromDeprecated.kt.after | 14 + .../kt21515/callableReferenceOnClass.kt | 13 + .../kt21515/callableReferenceOnClass.kt.after | 15 + .../callableReferenceOnClassWithCompanion.kt | 16 + ...ableReferenceOnClassWithCompanion.kt.after | 18 + .../kt21515/callableReferenceOnObject.kt | 13 + .../callableReferenceOnObject.kt.after | 15 + .../importDirective/kt21515/constructor.kt | 11 + .../kt21515/constructor.kt.after | 13 + .../importDirective/kt21515/typeReference.kt | 11 + .../kt21515/typeReference.kt.after | 13 + .../kt21515/callableReferenceOnClass.kt | 11 + .../kt21515/callableReferenceOnClass.kt.after | 11 + .../callableReferenceOnClassWithCompanion.kt | 14 + ...ableReferenceOnClassWithCompanion.kt.after | 14 + .../kt21515/callableReferenceOnObject.kt | 11 + .../callableReferenceOnObject.kt.after | 11 + .../shortenRefs/kt21515/constructor.kt | 9 + .../shortenRefs/kt21515/constructor.kt.after | 9 + .../shortenRefs/kt21515/typeReference.kt | 9 + .../kt21515/typeReference.kt.after | 9 + .../JsOptimizeImportsTestGenerated.java | 39 +++ .../JvmOptimizeImportsTestGenerated.java | 39 +++ .../idea/quickfix/QuickFixTestGenerated.java | 66 ++++ .../shortenRefs/ShortenRefsTestGenerated.java | 39 +++ 117 files changed, 8027 insertions(+), 113 deletions(-) create mode 100644 compiler/resolution/src/org/jetbrains/kotlin/resolve/scopes/DeprecatedScopes.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.txt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt create mode 100644 compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.txt create mode 100644 core/descriptors/src/org/jetbrains/kotlin/descriptors/DescriptorWithDeprecation.kt create mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/AddExplicitImportForDeprecatedVisibilityFix.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClass.kt.after create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnClassWithCompanion.kt.after create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/callableReferenceOnObject.kt.after create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/constructor.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/constructor.kt.after create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt create mode 100644 idea/testData/editor/optimizeImports/common/kt21515/typeReference.kt.after create mode 100644 idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt create mode 100644 idea/testData/quickfix/autoImports/kt21515/callableReferenceFromDeprecated.kt.after create mode 100644 idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt create mode 100644 idea/testData/quickfix/autoImports/kt21515/classifierFromCompanionObjectDeprecationEnabled.kt.after create mode 100644 idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt create mode 100644 idea/testData/quickfix/autoImports/kt21515/constructorFromDeprecated.kt.after create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClass.kt.after create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnClassWithCompanion.kt.after create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/callableReferenceOnObject.kt.after create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/constructor.kt.after create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt create mode 100644 idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515/typeReference.kt.after create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnClass.kt.after create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnClassWithCompanion.kt.after create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt create mode 100644 idea/testData/shortenRefs/kt21515/callableReferenceOnObject.kt.after create mode 100644 idea/testData/shortenRefs/kt21515/constructor.kt create mode 100644 idea/testData/shortenRefs/kt21515/constructor.kt.after create mode 100644 idea/testData/shortenRefs/kt21515/typeReference.kt create mode 100644 idea/testData/shortenRefs/kt21515/typeReference.kt.after 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)