From 7d7256536cdfbefe514f255b762f09edf82cfef3 Mon Sep 17 00:00:00 2001 From: Roman Golyshev Date: Tue, 21 Nov 2023 15:16:37 +0100 Subject: [PATCH] KT-63627 [AA] Properly handle object declarations when traversing scopes in `KtFirReferenceShortener` `KtClass` denotes only classes, interfaces and enums. To handle object declarations, we now use `KtClassOrObject` PSI type ^KT-63627 Fixed --- .../fir/components/KtFirReferenceShortener.kt | 21 ++++++++--- ...ModuleReferenceShortenerTestGenerated.java | 36 +++++++++++++++++++ ...ModuleReferenceShortenerTestGenerated.java | 36 +++++++++++++++++++ ...jectHaveConflictingNestedClasses_inside.kt | 14 ++++++++ ...ectHaveConflictingNestedClasses_inside.txt | 14 ++++++++ ...nflictingNestedClasses_inside_companion.kt | 14 ++++++++ ...flictingNestedClasses_inside_companion.txt | 14 ++++++++ ...tingNestedClasses_inside_namedCompanion.kt | 14 ++++++++ ...ingNestedClasses_inside_namedCompanion.txt | 14 ++++++++ ...ectHaveConflictingNestedClasses_outside.kt | 14 ++++++++ ...ctHaveConflictingNestedClasses_outside.txt | 14 ++++++++ ...flictingNestedClasses_outside_companion.kt | 14 ++++++++ ...lictingNestedClasses_outside_companion.txt | 14 ++++++++ ...ingNestedClasses_outside_namedCompanion.kt | 14 ++++++++ ...ngNestedClasses_outside_namedCompanion.txt | 14 ++++++++ 15 files changed, 256 insertions(+), 5 deletions(-) create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.txt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.txt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.txt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.txt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.txt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt create mode 100644 analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.txt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt index 7736da70de9..5f61fd9661a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.AllCandidatesResolver import org.jetbrains.kotlin.analysis.low.level.api.fir.util.ContextCollector +import org.jetbrains.kotlin.analysis.utils.printer.parentOfType import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* @@ -66,6 +67,7 @@ import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment +import java.util.Arrays internal class KtFirReferenceShortener( override val analysisSession: KtFirAnalysisSession, @@ -652,7 +654,7 @@ private class ElementsToShortenCollector( * * This function determines the distance based on [ClassId]. */ - private fun FirScope.isScopeForClassCloserThanAnotherScopeForClass(another: FirScope, from: KtClass): Boolean { + private fun FirScope.isScopeForClassCloserThanAnotherScopeForClass(another: FirScope, from: KtClassOrObject): Boolean { // Make sure both are scopes for classes if (!isScopeForClass() || !another.isScopeForClass()) return false @@ -673,12 +675,12 @@ private class ElementsToShortenCollector( * Travels all containing classes of [innerClass] and finds the one matching ClassId with one of [candidates]. Returns the matching * ClassId. If it does not have a matching ClassId, it returns null. */ - private fun findMostInnerClassMatchingId(innerClass: KtClass, candidates: Set): ClassId? { - var classInNestedClass: KtClass? = innerClass + private fun findMostInnerClassMatchingId(innerClass: KtClassOrObject, candidates: Set): ClassId? { + var classInNestedClass: KtClassOrObject? = innerClass while (classInNestedClass != null) { val containingClassId = classInNestedClass.getClassId() if (containingClassId in candidates) return containingClassId - classInNestedClass = classInNestedClass.containingClass() + classInNestedClass = classInNestedClass.findClassOrObjectParent() } return null } @@ -745,7 +747,7 @@ private class ElementsToShortenCollector( */ private fun List.hasScopeCloserThan(base: FirScope, from: KtElement) = any { scope -> if (scope.isScopeForClass() && base.isScopeForClass()) { - val classContainingFrom = from.containingClass() ?: return@any false + val classContainingFrom = from.findClassOrObjectParent() ?: return@any false return@any scope.isScopeForClassCloserThanAnotherScopeForClass(base, classContainingFrom) } base.isWiderThan(scope) @@ -1494,3 +1496,12 @@ private fun KtElement.getQualifier(): KtElement? = when (this) { is KtThisExpression -> labelQualifier else -> error("Unexpected ${this::class}") } + +/** + * N.B. We don't use [containingClassOrObject] because it works only for [KtDeclaration]s, + * and also check only the immediate (direct) parent. + * + * For this function, we want to find the parent [KtClassOrObject] declaration no matter + * how far it is from the element. + */ +private fun KtElement.findClassOrObjectParent(): KtClassOrObject? = parentOfType() diff --git a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java index 13a682f7e59..da48a834753 100644 --- a/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java +++ b/analysis/analysis-api-fir/tests-gen/org/jetbrains/kotlin/analysis/api/fir/test/cases/generated/cases/references/FirIdeNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java @@ -625,6 +625,42 @@ public class FirIdeNormalAnalysisSourceModuleReferenceShortenerTestGenerated ext KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside_companion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside_companion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside_namedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside_companion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside_companion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside_namedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt"); + } + @Test @TestMetadata("nestedClassFromSupertypes1.kt") public void testNestedClassFromSupertypes1() throws Exception { diff --git a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java index b59f7faa8df..cf52bb1bb92 100644 --- a/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java +++ b/analysis/analysis-api-standalone/tests-gen/org/jetbrains/kotlin/analysis/api/standalone/fir/test/cases/generated/cases/references/FirStandaloneNormalAnalysisSourceModuleReferenceShortenerTestGenerated.java @@ -625,6 +625,42 @@ public class FirStandaloneNormalAnalysisSourceModuleReferenceShortenerTestGenera KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside_companion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside_companion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_inside_namedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside_companion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside_companion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt"); + } + + @Test + @TestMetadata("classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt") + public void testClassAndObjectHaveConflictingNestedClasses_outside_namedCompanion() throws Exception { + runTest("analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt"); + } + @Test @TestMetadata("nestedClassFromSupertypes1.kt") public void testNestedClassFromSupertypes1() throws Exception { diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt new file mode 100644 index 00000000000..249b6175a52 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + object NestedObject { + class Nested + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NestedObject.Nested, + ) {} + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.txt new file mode 100644 index 00000000000..aeb34bf6d74 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NestedObject.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass +[type] test.OuterClass.NestedObject.Nested +with SHORTEN_AND_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.NestedObject.Nested +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.NestedObject.Nested diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt new file mode 100644 index 00000000000..8f5815ae564 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + companion object { + class Nested + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.Companion.Nested, + ) {} + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.txt new file mode 100644 index 00000000000..5b9e9a4dc48 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_companion.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.Companion.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass +[type] test.OuterClass.Companion.Nested +with SHORTEN_AND_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.Companion.Nested +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.Companion.Nested diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt new file mode 100644 index 00000000000..ee6c3bfa893 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + companion object NamedCompanion { + class Nested + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NamedCompanion.Nested, + ) {} + } +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.txt new file mode 100644 index 00000000000..cfb2ebd1f5a --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_inside_namedCompanion.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NamedCompanion.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass +[type] test.OuterClass.NamedCompanion.Nested +with SHORTEN_AND_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.NamedCompanion.Nested +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass +[type] test.OuterClass.NamedCompanion.Nested diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt new file mode 100644 index 00000000000..104184cad80 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + object NestedObject { + class Nested + } + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NestedObject.Nested, + ) {} +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.txt new file mode 100644 index 00000000000..d974c6f26fb --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NestedObject.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass.Nested +[type] test.OuterClass.NestedObject +with SHORTEN_AND_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.NestedObject +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.NestedObject diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt new file mode 100644 index 00000000000..eadabfab53c --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + companion object { + class Nested + } + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.Companion.Nested, + ) {} +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.txt new file mode 100644 index 00000000000..e59134ec26f --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_companion.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.Companion.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass.Nested +[type] test.OuterClass.Companion +with SHORTEN_AND_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.Companion +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.Companion diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt new file mode 100644 index 00000000000..744028b2d6c --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.kt @@ -0,0 +1,14 @@ +package test + +class OuterClass { + class Nested + + companion object NamedCompanion { + class Nested + } + + fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NamedCompanion.Nested, + ) {} +} \ No newline at end of file diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.txt new file mode 100644 index 00000000000..dbe73b62007 --- /dev/null +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortener/nestedClasses/classAndObjectHaveConflictingNestedClasses_outside_namedCompanion.txt @@ -0,0 +1,14 @@ +Before shortening: fun usage( + first: test.OuterClass.Nested, + second: test.OuterClass.NamedCompanion.Nested, + ) {} +with DO_NOT_SHORTEN: +with SHORTEN_IF_ALREADY_IMPORTED: +[type] test.OuterClass.Nested +[type] test.OuterClass.NamedCompanion +with SHORTEN_AND_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.NamedCompanion +with SHORTEN_AND_STAR_IMPORT: +[type] test.OuterClass.Nested +[type] test.OuterClass.NamedCompanion