diff --git a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt index 32b2daceb5f..14b0b09a720 100644 --- a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt +++ b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt @@ -58,9 +58,11 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() { protected abstract fun doTestByModuleStructure(moduleStructure: TestModuleStructure, testServices: TestServices) - protected fun AssertionsService.assertEqualsToTestDataFileSibling(actual: String, extension: String = ".txt") { - val testPrefix = configurator.testPrefix - + protected fun AssertionsService.assertEqualsToTestDataFileSibling( + actual: String, + extension: String = ".txt", + testPrefix: String? = configurator.testPrefix, + ) { val expectedFile = getTestDataFileSiblingPath(extension, testPrefix = testPrefix) assertEqualsToFile(expectedFile, actual) diff --git a/analysis/symbol-light-classes/testData/structure/Annotations.inh.txt b/analysis/symbol-light-classes/testData/structure/Annotations.inh.txt new file mode 100644 index 00000000000..235f1b289c6 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Annotations.inh.txt @@ -0,0 +1,5 @@ +one.MyAnnotationClass|java.lang.annotation.Annotation|false| -> true +one.MyAnnotationClass|java.lang.annotation.Annotation|true| -> true +one.MyAnnotationClass|java.lang.Object|false| -> true +one.MyAnnotationClass|java.lang.Object|true| -> true +one.MyAnnotationClass|java.util.Collection|true| -> false diff --git a/analysis/symbol-light-classes/testData/structure/Annotations.kt b/analysis/symbol-light-classes/testData/structure/Annotations.kt new file mode 100644 index 00000000000..577a09e5ccb --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Annotations.kt @@ -0,0 +1,3 @@ +package one + +annotation class MyAnnotationClass \ No newline at end of file diff --git a/analysis/symbol-light-classes/testData/structure/Annotations.lib.txt b/analysis/symbol-light-classes/testData/structure/Annotations.lib.txt new file mode 100644 index 00000000000..c954d9946a2 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Annotations.lib.txt @@ -0,0 +1,19 @@ +KtClass: + line: 6 + name: MyAnnotationClass + qualifier: one.MyAnnotationClass + light: KtLightClassForDecompiledDeclaration + name: MyAnnotationClass + qualifier: one.MyAnnotationClass + superTypes: [ + PsiType:Annotation + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + ClsClassImpl: Annotation (java.lang.annotation.Annotation) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ClsClassImpl: Annotation (java.lang.annotation.Annotation) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Annotations.txt b/analysis/symbol-light-classes/testData/structure/Annotations.txt new file mode 100644 index 00000000000..6bb81dffbe7 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Annotations.txt @@ -0,0 +1,19 @@ +KtClass: + line: 3 + name: MyAnnotationClass + qualifier: one.MyAnnotationClass + light: SymbolLightClassForAnnotationClass + name: MyAnnotationClass + qualifier: one.MyAnnotationClass + superTypes: [ + PsiType:Annotation + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + ClsClassImpl: Annotation (java.lang.annotation.Annotation) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ClsClassImpl: Annotation (java.lang.annotation.Annotation) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Classes.inh.txt b/analysis/symbol-light-classes/testData/structure/Classes.inh.txt new file mode 100644 index 00000000000..df8397d5b37 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Classes.inh.txt @@ -0,0 +1,12 @@ +cba.ChildOfOpen|cba.OpenClassFromAbstractClass|false| -> true +cba.ChildOfOpen|cba.OpenClassFromAbstractClass|true| -> true +cba.ChildOfOpen|java.lang.Object|false| -> false +cba.ChildOfOpen|java.lang.Object|true| -> true +cba.ChildOfOpen|cba.AbstractClass|false| -> false +cba.ChildOfOpen|cba.AbstractClass|true| -> true +cba.OpenClassFromAbstractClass|cba.AbstractClass|false| -> true +cba.OpenClassFromAbstractClass|cba.AbstractClass|true| -> true +cba.OpenClassFromAbstractClass|cba.OpenClassFromAbstractClass|false| -> false +cba.OpenClassFromAbstractClass|cba.OpenClassFromAbstractClass|true| -> false +cba.OpenClassFromAbstractClass|cba.FinalClass|false| -> false +cba.OpenClassFromAbstractClass|cba.FinalClass|true| -> false \ No newline at end of file diff --git a/analysis/symbol-light-classes/testData/structure/Classes.kt b/analysis/symbol-light-classes/testData/structure/Classes.kt new file mode 100644 index 00000000000..e8b1c75e841 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Classes.kt @@ -0,0 +1,9 @@ +package cba + +class FinalClass + +abstract class AbstractClass + +open class OpenClassFromAbstractClass : AbstractClass() + +class ChildOfOpen : OpenClassFromAbstractClass() diff --git a/analysis/symbol-light-classes/testData/structure/Classes.lib.txt b/analysis/symbol-light-classes/testData/structure/Classes.lib.txt new file mode 100644 index 00000000000..f70e5eeea2f --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Classes.lib.txt @@ -0,0 +1,68 @@ +FinalClass.class: + KtClass: + line: 6 + name: FinalClass + qualifier: cba.FinalClass + light: KtLightClassForDecompiledDeclaration + name: FinalClass + qualifier: cba.FinalClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +AbstractClass.class: + KtClass: + line: 6 + name: AbstractClass + qualifier: cba.AbstractClass + light: KtLightClassForDecompiledDeclaration + name: AbstractClass + qualifier: cba.AbstractClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +ChildOfOpen.class: + KtClass: + line: 6 + name: ChildOfOpen + qualifier: cba.ChildOfOpen + light: KtLightClassForDecompiledDeclaration + name: ChildOfOpen + qualifier: cba.ChildOfOpen + superTypes: [ + PsiType:OpenClassFromAbstractClass + ] + superClass: KtLightClassForDecompiledDeclaration: OpenClassFromAbstractClass (cba.OpenClassFromAbstractClass) + interfaces: [] + supers: [ + KtLightClassForDecompiledDeclaration: OpenClassFromAbstractClass (cba.OpenClassFromAbstractClass) + ] + +OpenClassFromAbstractClass.class: + KtClass: + line: 6 + name: OpenClassFromAbstractClass + qualifier: cba.OpenClassFromAbstractClass + light: KtLightClassForDecompiledDeclaration + name: OpenClassFromAbstractClass + qualifier: cba.OpenClassFromAbstractClass + superTypes: [ + PsiType:AbstractClass + ] + superClass: KtLightClassForDecompiledDeclaration: AbstractClass (cba.AbstractClass) + interfaces: [] + supers: [ + KtLightClassForDecompiledDeclaration: AbstractClass (cba.AbstractClass) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Classes.txt b/analysis/symbol-light-classes/testData/structure/Classes.txt new file mode 100644 index 00000000000..f180dec585a --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Classes.txt @@ -0,0 +1,64 @@ +KtClass: + line: 3 + name: FinalClass + qualifier: cba.FinalClass + light: SymbolLightClassForClassOrObject + name: FinalClass + qualifier: cba.FinalClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 5 + name: AbstractClass + qualifier: cba.AbstractClass + light: SymbolLightClassForClassOrObject + name: AbstractClass + qualifier: cba.AbstractClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 7 + name: OpenClassFromAbstractClass + qualifier: cba.OpenClassFromAbstractClass + light: SymbolLightClassForClassOrObject + name: OpenClassFromAbstractClass + qualifier: cba.OpenClassFromAbstractClass + superTypes: [ + PsiType:AbstractClass + ] + superClass: SymbolLightClassForClassOrObject: AbstractClass (cba.AbstractClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: AbstractClass (cba.AbstractClass) + ] + +KtClass: + line: 9 + name: ChildOfOpen + qualifier: cba.ChildOfOpen + light: SymbolLightClassForClassOrObject + name: ChildOfOpen + qualifier: cba.ChildOfOpen + superTypes: [ + PsiType:OpenClassFromAbstractClass + ] + superClass: SymbolLightClassForClassOrObject: OpenClassFromAbstractClass (cba.OpenClassFromAbstractClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: OpenClassFromAbstractClass (cba.OpenClassFromAbstractClass) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/EnumEntries.inh.txt b/analysis/symbol-light-classes/testData/structure/EnumEntries.inh.txt new file mode 100644 index 00000000000..7f7cd80b422 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/EnumEntries.inh.txt @@ -0,0 +1,14 @@ +one.two.EnumEntries|java.lang.Object|false| -> false +one.two.EnumEntries|java.lang.Object|true| -> true +one.two.EnumEntries|java.lang.Enum|false| -> true +one.two.EnumEntries|java.lang.Enum|true| -> true +one.two.EnumEntries.SecondEntryWithBody|java.lang.Enum|false| -> false +one.two.EnumEntries.SecondEntryWithBody|java.lang.Enum|true| -> true +one.two.EnumEntries.SecondEntryWithBody|one.two.EnumEntries|false| -> true +one.two.EnumEntries.SecondEntryWithBody|one.two.EnumEntries|true| -> true +one.two.EnumEntries.SecondEntryWithBody|java.lang.Object|false| -> false +one.two.EnumEntries.SecondEntryWithBody|java.lang.Object|true| -> true +one.two.EnumEntries.SecondEntryWithBody|one.two.BaseInterface|false| -> false +one.two.EnumEntries.SecondEntryWithBody|one.two.BaseInterface|true| -> false +one.two.EnumClassWithInterface.NewSecondEntryWithBody|one.two.BaseInterface|false| -> false +one.two.EnumClassWithInterface.NewSecondEntryWithBody|one.two.BaseInterface|true| -> true diff --git a/analysis/symbol-light-classes/testData/structure/EnumEntries.kt b/analysis/symbol-light-classes/testData/structure/EnumEntries.kt new file mode 100644 index 00000000000..5eef2f06281 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/EnumEntries.kt @@ -0,0 +1,21 @@ +package one.two + +interface BaseInterface + +enum class EnumEntries { + FirstEntry, + SecondEntryWithBody { + fun foo() { + + } + } +} + +enum class EnumClassWithInterface : BaseInterface { + NewFirstEntry, + NewSecondEntryWithBody { + fun foo() { + + } + } +} diff --git a/analysis/symbol-light-classes/testData/structure/EnumEntries.lib.txt b/analysis/symbol-light-classes/testData/structure/EnumEntries.lib.txt new file mode 100644 index 00000000000..e54dac24082 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/EnumEntries.lib.txt @@ -0,0 +1,79 @@ +BaseInterface.class: + KtClass: + line: 6 + name: BaseInterface + qualifier: one.two.BaseInterface + light: KtLightClassForDecompiledDeclaration + name: BaseInterface + qualifier: one.two.BaseInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +EnumClassWithInterface.class: + KtEnumEntry: + line: 7 + name: NewFirstEntry + qualifier: one.two.EnumClassWithInterface.NewFirstEntry + light: null + + KtEnumEntry: + line: 9 + name: NewSecondEntryWithBody + qualifier: one.two.EnumClassWithInterface.NewSecondEntryWithBody + light: null + + KtClass: + line: 6 + name: EnumClassWithInterface + qualifier: one.two.EnumClassWithInterface + light: KtLightClassForDecompiledDeclaration + name: EnumClassWithInterface + qualifier: one.two.EnumClassWithInterface + superTypes: [ + PsiType:Enum + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Enum (java.lang.Enum) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface (one.two.BaseInterface) + ] + supers: [ + ClsClassImpl: Enum (java.lang.Enum) + KtLightClassForDecompiledDeclaration: BaseInterface (one.two.BaseInterface) + ] + +EnumEntries.class: + KtEnumEntry: + line: 7 + name: FirstEntry + qualifier: one.two.EnumEntries.FirstEntry + light: null + + KtEnumEntry: + line: 9 + name: SecondEntryWithBody + qualifier: one.two.EnumEntries.SecondEntryWithBody + light: null + + KtClass: + line: 6 + name: EnumEntries + qualifier: one.two.EnumEntries + light: KtLightClassForDecompiledDeclaration + name: EnumEntries + qualifier: one.two.EnumEntries + superTypes: [ + PsiType:Enum + ] + superClass: ClsClassImpl: Enum (java.lang.Enum) + interfaces: [] + supers: [ + ClsClassImpl: Enum (java.lang.Enum) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/EnumEntries.txt b/analysis/symbol-light-classes/testData/structure/EnumEntries.txt new file mode 100644 index 00000000000..948cf513669 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/EnumEntries.txt @@ -0,0 +1,96 @@ +KtClass: + line: 3 + name: BaseInterface + qualifier: one.two.BaseInterface + light: SymbolLightClassForInterface + name: BaseInterface + qualifier: one.two.BaseInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtEnumEntry: + line: 6 + name: FirstEntry + qualifier: one.two.EnumEntries.FirstEntry + light: null + +KtEnumEntry: + line: 7 + name: SecondEntryWithBody + qualifier: one.two.EnumEntries.SecondEntryWithBody + light: SymbolLightClassForEnumEntry + name: SecondEntryWithBody + qualifier: one.two.EnumEntries.SecondEntryWithBody + superTypes: [ + PsiType:EnumEntries + ] + superClass: SymbolLightClassForClassOrObject: EnumEntries (one.two.EnumEntries) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: EnumEntries (one.two.EnumEntries) + ] + +KtClass: + line: 5 + name: EnumEntries + qualifier: one.two.EnumEntries + light: SymbolLightClassForClassOrObject + name: EnumEntries + qualifier: one.two.EnumEntries + superTypes: [ + PsiType:Enum + ] + superClass: ClsClassImpl: Enum (java.lang.Enum) + interfaces: [] + supers: [ + ClsClassImpl: Enum (java.lang.Enum) + ] + +KtEnumEntry: + line: 15 + name: NewFirstEntry + qualifier: one.two.EnumClassWithInterface.NewFirstEntry + light: null + +KtEnumEntry: + line: 16 + name: NewSecondEntryWithBody + qualifier: one.two.EnumClassWithInterface.NewSecondEntryWithBody + light: SymbolLightClassForEnumEntry + name: NewSecondEntryWithBody + qualifier: one.two.EnumClassWithInterface.NewSecondEntryWithBody + superTypes: [ + PsiType:EnumClassWithInterface + ] + superClass: SymbolLightClassForClassOrObject: EnumClassWithInterface (one.two.EnumClassWithInterface) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: EnumClassWithInterface (one.two.EnumClassWithInterface) + ] + +KtClass: + line: 14 + name: EnumClassWithInterface + qualifier: one.two.EnumClassWithInterface + light: SymbolLightClassForClassOrObject + name: EnumClassWithInterface + qualifier: one.two.EnumClassWithInterface + superTypes: [ + PsiType:Enum + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Enum (java.lang.Enum) + interfaces: [ + SymbolLightClassForInterface: BaseInterface (one.two.BaseInterface) + ] + supers: [ + ClsClassImpl: Enum (java.lang.Enum) + SymbolLightClassForInterface: BaseInterface (one.two.BaseInterface) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.kt b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.kt new file mode 100644 index 00000000000..e9f0e54b31d --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.kt @@ -0,0 +1,27 @@ +package my + +interface BaseInterface1 + +interface BaseInterface2 + +interface ComplexInterface : BaseInterface1, BaseInterface2 + +open class OpenBaseClass + +class FinalClassWithBaseInterface : BaseInterface1 + +class FinalClassWithSeveralBaseInterfaces : BaseInterface1, BaseInterface2 + +class FinalClassWithComplexInterface : ComplexInterface + +class FinalClassWithComplexInterfaceAndBaseInterface : ComplexInterface, BaseInterface1 + +abstract class AbstractClassWithBaseInterface : BaseInterface2 + +abstract class AbstractClassWithComplexInterface : ComplexInterface + +abstract class AbstractClassTransitiveBaseInterface : AbstractClassWithBaseInterface(), BaseInterface1 + +open class OpenComplexClass : ComplexInterface, AbstractClassTransitiveBaseInterface() + +class OnlyTransitiveInterface : OpenComplexClass() diff --git a/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.lib.txt b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.lib.txt new file mode 100644 index 00000000000..ddece986b70 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.lib.txt @@ -0,0 +1,265 @@ +OpenBaseClass.class: + KtClass: + line: 6 + name: OpenBaseClass + qualifier: my.OpenBaseClass + light: KtLightClassForDecompiledDeclaration + name: OpenBaseClass + qualifier: my.OpenBaseClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +FinalClassWithBaseInterface.class: + KtClass: + line: 6 + name: FinalClassWithBaseInterface + qualifier: my.FinalClassWithBaseInterface + light: KtLightClassForDecompiledDeclaration + name: FinalClassWithBaseInterface + qualifier: my.FinalClassWithBaseInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface1 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + +AbstractClassWithBaseInterface.class: + KtClass: + line: 6 + name: AbstractClassWithBaseInterface + qualifier: my.AbstractClassWithBaseInterface + light: KtLightClassForDecompiledDeclaration + name: AbstractClassWithBaseInterface + qualifier: my.AbstractClassWithBaseInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + +BaseInterface1.class: + KtClass: + line: 6 + name: BaseInterface1 + qualifier: my.BaseInterface1 + light: KtLightClassForDecompiledDeclaration + name: BaseInterface1 + qualifier: my.BaseInterface1 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +BaseInterface2.class: + KtClass: + line: 6 + name: BaseInterface2 + qualifier: my.BaseInterface2 + light: KtLightClassForDecompiledDeclaration + name: BaseInterface2 + qualifier: my.BaseInterface2 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +FinalClassWithSeveralBaseInterfaces.class: + KtClass: + line: 6 + name: FinalClassWithSeveralBaseInterfaces + qualifier: my.FinalClassWithSeveralBaseInterfaces + light: KtLightClassForDecompiledDeclaration + name: FinalClassWithSeveralBaseInterfaces + qualifier: my.FinalClassWithSeveralBaseInterfaces + superTypes: [ + PsiType:Object + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + +OnlyTransitiveInterface.class: + KtClass: + line: 6 + name: OnlyTransitiveInterface + qualifier: my.OnlyTransitiveInterface + light: KtLightClassForDecompiledDeclaration + name: OnlyTransitiveInterface + qualifier: my.OnlyTransitiveInterface + superTypes: [ + PsiType:OpenComplexClass + ] + superClass: KtLightClassForDecompiledDeclaration: OpenComplexClass (my.OpenComplexClass) + interfaces: [] + supers: [ + KtLightClassForDecompiledDeclaration: OpenComplexClass (my.OpenComplexClass) + ] + +AbstractClassWithComplexInterface.class: + KtClass: + line: 6 + name: AbstractClassWithComplexInterface + qualifier: my.AbstractClassWithComplexInterface + light: KtLightClassForDecompiledDeclaration + name: AbstractClassWithComplexInterface + qualifier: my.AbstractClassWithComplexInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + +FinalClassWithComplexInterfaceAndBaseInterface.class: + KtClass: + line: 6 + name: FinalClassWithComplexInterfaceAndBaseInterface + qualifier: my.FinalClassWithComplexInterfaceAndBaseInterface + light: KtLightClassForDecompiledDeclaration + name: FinalClassWithComplexInterfaceAndBaseInterface + qualifier: my.FinalClassWithComplexInterfaceAndBaseInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + PsiType:BaseInterface1 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + +FinalClassWithComplexInterface.class: + KtClass: + line: 6 + name: FinalClassWithComplexInterface + qualifier: my.FinalClassWithComplexInterface + light: KtLightClassForDecompiledDeclaration + name: FinalClassWithComplexInterface + qualifier: my.FinalClassWithComplexInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + +AbstractClassTransitiveBaseInterface.class: + KtClass: + line: 6 + name: AbstractClassTransitiveBaseInterface + qualifier: my.AbstractClassTransitiveBaseInterface + light: KtLightClassForDecompiledDeclaration + name: AbstractClassTransitiveBaseInterface + qualifier: my.AbstractClassTransitiveBaseInterface + superTypes: [ + PsiType:AbstractClassWithBaseInterface + PsiType:BaseInterface1 + ] + superClass: KtLightClassForDecompiledDeclaration: AbstractClassWithBaseInterface (my.AbstractClassWithBaseInterface) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + KtLightClassForDecompiledDeclaration: AbstractClassWithBaseInterface (my.AbstractClassWithBaseInterface) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + ] + +ComplexInterface.class: + KtClass: + line: 6 + name: ComplexInterface + qualifier: my.ComplexInterface + light: KtLightClassForDecompiledDeclaration + name: ComplexInterface + qualifier: my.ComplexInterface + superTypes: [ + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface1 (my.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (my.BaseInterface2) + ] + +OpenComplexClass.class: + KtClass: + line: 6 + name: OpenComplexClass + qualifier: my.OpenComplexClass + light: KtLightClassForDecompiledDeclaration + name: OpenComplexClass + qualifier: my.OpenComplexClass + superTypes: [ + PsiType:AbstractClassTransitiveBaseInterface + PsiType:ComplexInterface + ] + superClass: KtLightClassForDecompiledDeclaration: AbstractClassTransitiveBaseInterface (my.AbstractClassTransitiveBaseInterface) + interfaces: [ + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + supers: [ + KtLightClassForDecompiledDeclaration: AbstractClassTransitiveBaseInterface (my.AbstractClassTransitiveBaseInterface) + KtLightClassForDecompiledDeclaration: ComplexInterface (my.ComplexInterface) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.txt b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.txt new file mode 100644 index 00000000000..0a5f5fa2ac5 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.txt @@ -0,0 +1,252 @@ +KtClass: + line: 3 + name: BaseInterface1 + qualifier: my.BaseInterface1 + light: SymbolLightClassForInterface + name: BaseInterface1 + qualifier: my.BaseInterface1 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 5 + name: BaseInterface2 + qualifier: my.BaseInterface2 + light: SymbolLightClassForInterface + name: BaseInterface2 + qualifier: my.BaseInterface2 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 7 + name: ComplexInterface + qualifier: my.ComplexInterface + light: SymbolLightClassForInterface + name: ComplexInterface + qualifier: my.ComplexInterface + superTypes: [ + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + +KtClass: + line: 9 + name: OpenBaseClass + qualifier: my.OpenBaseClass + light: SymbolLightClassForClassOrObject + name: OpenBaseClass + qualifier: my.OpenBaseClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 11 + name: FinalClassWithBaseInterface + qualifier: my.FinalClassWithBaseInterface + light: SymbolLightClassForClassOrObject + name: FinalClassWithBaseInterface + qualifier: my.FinalClassWithBaseInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface1 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + +KtClass: + line: 13 + name: FinalClassWithSeveralBaseInterfaces + qualifier: my.FinalClassWithSeveralBaseInterfaces + light: SymbolLightClassForClassOrObject + name: FinalClassWithSeveralBaseInterfaces + qualifier: my.FinalClassWithSeveralBaseInterfaces + superTypes: [ + PsiType:Object + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + +KtClass: + line: 15 + name: FinalClassWithComplexInterface + qualifier: my.FinalClassWithComplexInterface + light: SymbolLightClassForClassOrObject + name: FinalClassWithComplexInterface + qualifier: my.FinalClassWithComplexInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + +KtClass: + line: 17 + name: FinalClassWithComplexInterfaceAndBaseInterface + qualifier: my.FinalClassWithComplexInterfaceAndBaseInterface + light: SymbolLightClassForClassOrObject + name: FinalClassWithComplexInterfaceAndBaseInterface + qualifier: my.FinalClassWithComplexInterfaceAndBaseInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + PsiType:BaseInterface1 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + +KtClass: + line: 19 + name: AbstractClassWithBaseInterface + qualifier: my.AbstractClassWithBaseInterface + light: SymbolLightClassForClassOrObject + name: AbstractClassWithBaseInterface + qualifier: my.AbstractClassWithBaseInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface2 (my.BaseInterface2) + ] + +KtClass: + line: 21 + name: AbstractClassWithComplexInterface + qualifier: my.AbstractClassWithComplexInterface + light: SymbolLightClassForClassOrObject + name: AbstractClassWithComplexInterface + qualifier: my.AbstractClassWithComplexInterface + superTypes: [ + PsiType:Object + PsiType:ComplexInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + +KtClass: + line: 23 + name: AbstractClassTransitiveBaseInterface + qualifier: my.AbstractClassTransitiveBaseInterface + light: SymbolLightClassForClassOrObject + name: AbstractClassTransitiveBaseInterface + qualifier: my.AbstractClassTransitiveBaseInterface + superTypes: [ + PsiType:AbstractClassWithBaseInterface + PsiType:BaseInterface1 + ] + superClass: SymbolLightClassForClassOrObject: AbstractClassWithBaseInterface (my.AbstractClassWithBaseInterface) + interfaces: [ + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + supers: [ + SymbolLightClassForClassOrObject: AbstractClassWithBaseInterface (my.AbstractClassWithBaseInterface) + SymbolLightClassForInterface: BaseInterface1 (my.BaseInterface1) + ] + +KtClass: + line: 25 + name: OpenComplexClass + qualifier: my.OpenComplexClass + light: SymbolLightClassForClassOrObject + name: OpenComplexClass + qualifier: my.OpenComplexClass + superTypes: [ + PsiType:AbstractClassTransitiveBaseInterface + PsiType:ComplexInterface + ] + superClass: SymbolLightClassForClassOrObject: AbstractClassTransitiveBaseInterface (my.AbstractClassTransitiveBaseInterface) + interfaces: [ + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + supers: [ + SymbolLightClassForClassOrObject: AbstractClassTransitiveBaseInterface (my.AbstractClassTransitiveBaseInterface) + SymbolLightClassForInterface: ComplexInterface (my.ComplexInterface) + ] + +KtClass: + line: 27 + name: OnlyTransitiveInterface + qualifier: my.OnlyTransitiveInterface + light: SymbolLightClassForClassOrObject + name: OnlyTransitiveInterface + qualifier: my.OnlyTransitiveInterface + superTypes: [ + PsiType:OpenComplexClass + ] + superClass: SymbolLightClassForClassOrObject: OpenComplexClass (my.OpenComplexClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: OpenComplexClass (my.OpenComplexClass) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Interfaces.kt b/analysis/symbol-light-classes/testData/structure/Interfaces.kt new file mode 100644 index 00000000000..51be4e0585e --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Interfaces.kt @@ -0,0 +1,10 @@ +package abc + +interface SingleInterface + +interface BaseInterface1 +interface BaseInterface2 + +interface InterfaceWithBase : BaseInterface1, BaseInterface2 + +interface InterfaceWithTransitive : InterfaceWithBase diff --git a/analysis/symbol-light-classes/testData/structure/Interfaces.lib.txt b/analysis/symbol-light-classes/testData/structure/Interfaces.lib.txt new file mode 100644 index 00000000000..501b78d9923 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Interfaces.lib.txt @@ -0,0 +1,94 @@ +SingleInterface.class: + KtClass: + line: 6 + name: SingleInterface + qualifier: abc.SingleInterface + light: KtLightClassForDecompiledDeclaration + name: SingleInterface + qualifier: abc.SingleInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +BaseInterface2.class: + KtClass: + line: 6 + name: BaseInterface2 + qualifier: abc.BaseInterface2 + light: KtLightClassForDecompiledDeclaration + name: BaseInterface2 + qualifier: abc.BaseInterface2 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +InterfaceWithTransitive.class: + KtClass: + line: 6 + name: InterfaceWithTransitive + qualifier: abc.InterfaceWithTransitive + light: KtLightClassForDecompiledDeclaration + name: InterfaceWithTransitive + qualifier: abc.InterfaceWithTransitive + superTypes: [ + PsiType:InterfaceWithBase + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: InterfaceWithBase (abc.InterfaceWithBase) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: InterfaceWithBase (abc.InterfaceWithBase) + ] + +InterfaceWithBase.class: + KtClass: + line: 6 + name: InterfaceWithBase + qualifier: abc.InterfaceWithBase + light: KtLightClassForDecompiledDeclaration + name: InterfaceWithBase + qualifier: abc.InterfaceWithBase + superTypes: [ + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface1 (abc.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (abc.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface1 (abc.BaseInterface1) + KtLightClassForDecompiledDeclaration: BaseInterface2 (abc.BaseInterface2) + ] + +BaseInterface1.class: + KtClass: + line: 6 + name: BaseInterface1 + qualifier: abc.BaseInterface1 + light: KtLightClassForDecompiledDeclaration + name: BaseInterface1 + qualifier: abc.BaseInterface1 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Interfaces.txt b/analysis/symbol-light-classes/testData/structure/Interfaces.txt new file mode 100644 index 00000000000..8b57add5cc6 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Interfaces.txt @@ -0,0 +1,89 @@ +KtClass: + line: 3 + name: SingleInterface + qualifier: abc.SingleInterface + light: SymbolLightClassForInterface + name: SingleInterface + qualifier: abc.SingleInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 5 + name: BaseInterface1 + qualifier: abc.BaseInterface1 + light: SymbolLightClassForInterface + name: BaseInterface1 + qualifier: abc.BaseInterface1 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 6 + name: BaseInterface2 + qualifier: abc.BaseInterface2 + light: SymbolLightClassForInterface + name: BaseInterface2 + qualifier: abc.BaseInterface2 + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 8 + name: InterfaceWithBase + qualifier: abc.InterfaceWithBase + light: SymbolLightClassForInterface + name: InterfaceWithBase + qualifier: abc.InterfaceWithBase + superTypes: [ + PsiType:BaseInterface1 + PsiType:BaseInterface2 + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface1 (abc.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (abc.BaseInterface2) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface1 (abc.BaseInterface1) + SymbolLightClassForInterface: BaseInterface2 (abc.BaseInterface2) + ] + +KtClass: + line: 10 + name: InterfaceWithTransitive + qualifier: abc.InterfaceWithTransitive + light: SymbolLightClassForInterface + name: InterfaceWithTransitive + qualifier: abc.InterfaceWithTransitive + superTypes: [ + PsiType:InterfaceWithBase + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: InterfaceWithBase (abc.InterfaceWithBase) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: InterfaceWithBase (abc.InterfaceWithBase) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Objects.inh.txt b/analysis/symbol-light-classes/testData/structure/Objects.inh.txt new file mode 100644 index 00000000000..eb676df9b91 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Objects.inh.txt @@ -0,0 +1,22 @@ +two.Object|java.lang.Object|false| -> true +two.Object|java.lang.Object|true| -> true +two.Object|two.BaseInterface|false| -> false +two.Object|two.BaseInterface|true| -> false +two.ObjectWithInterface|two.BaseInterface|false| -> true +two.ObjectWithInterface|two.BaseInterface|true| -> true +two.ObjectWithInterface|java.lang.Object|false| -> true +two.ObjectWithInterface|java.lang.Object|true| -> true +two.ObjectWithClassAndInterface|java.lang.Object|false| -> false +two.ObjectWithClassAndInterface|java.lang.Object|true| -> true +two.ObjectWithClassAndInterface|two.NonBaseClass|false| -> true +two.ObjectWithClassAndInterface|two.NonBaseClass|true| -> true +two.ObjectWithClassAndInterface|two.NonBaseInterface|false| -> true +two.ObjectWithClassAndInterface|two.NonBaseInterface|true| -> true +two.ObjectWithClassAndJavaInterface|java.lang.Object|false| -> false +two.ObjectWithClassAndJavaInterface|java.lang.Object|true| -> true +two.ObjectWithClassAndJavaInterface|two.NonBaseClass|false| -> true +two.ObjectWithClassAndJavaInterface|two.NonBaseClass|true| -> true +two.ObjectWithClassAndJavaInterface|two.NonBaseInterface|false| -> false +two.ObjectWithClassAndJavaInterface|two.NonBaseInterface|true| -> false +two.ObjectWithClassAndJavaInterface|java.lang.Runnable|false| -> true +two.ObjectWithClassAndJavaInterface|java.lang.Runnable|true| -> true diff --git a/analysis/symbol-light-classes/testData/structure/Objects.kt b/analysis/symbol-light-classes/testData/structure/Objects.kt new file mode 100644 index 00000000000..6cca486d9fd --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Objects.kt @@ -0,0 +1,30 @@ +package two + +import java.lang.Runnable + +interface BaseInterface +interface NonBaseInterface : BaseInterface +interface AnotherInterface + +abstract class BaseClass +abstract class NonBaseClass : BaseClass() + +object Object + +object ObjectWithInterface : BaseInterface + +object ObjectWithNonBaseInterface : NonBaseInterface + +object ObjectWithClass : BaseClass() + +object ObjectWithClassAndInterface : NonBaseClass(), NonBaseInterface +object ObjectWithClassAndJavaInterface : NonBaseClass(), Runnable { + override fun run() {} +} + +val a = object : BaseClass() {} +val b = object : NonBaseClass() {} +val c = object : BaseInterface {} +val d = object : NonBaseInterface {} +val e: NonBaseInterface = object : BaseClass(), NonBaseInterface, AnotherInterface {} +val f: AnotherInterface = object : BaseInterface, AnotherInterface {} \ No newline at end of file diff --git a/analysis/symbol-light-classes/testData/structure/Objects.lib.txt b/analysis/symbol-light-classes/testData/structure/Objects.lib.txt new file mode 100644 index 00000000000..3082bfad629 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Objects.lib.txt @@ -0,0 +1,207 @@ +ObjectWithClassAndInterface.class: + KtObjectDeclaration: + line: 6 + name: ObjectWithClassAndInterface + qualifier: two.ObjectWithClassAndInterface + light: KtLightClassForDecompiledDeclaration + name: ObjectWithClassAndInterface + qualifier: two.ObjectWithClassAndInterface + superTypes: [ + PsiType:NonBaseClass + PsiType:NonBaseInterface + ] + superClass: KtLightClassForDecompiledDeclaration: NonBaseClass (two.NonBaseClass) + interfaces: [ + KtLightClassForDecompiledDeclaration: NonBaseInterface (two.NonBaseInterface) + ] + supers: [ + KtLightClassForDecompiledDeclaration: NonBaseClass (two.NonBaseClass) + KtLightClassForDecompiledDeclaration: NonBaseInterface (two.NonBaseInterface) + ] + +BaseInterface.class: + KtClass: + line: 6 + name: BaseInterface + qualifier: two.BaseInterface + light: KtLightClassForDecompiledDeclaration + name: BaseInterface + qualifier: two.BaseInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +NonBaseClass.class: + KtClass: + line: 6 + name: NonBaseClass + qualifier: two.NonBaseClass + light: KtLightClassForDecompiledDeclaration + name: NonBaseClass + qualifier: two.NonBaseClass + superTypes: [ + PsiType:BaseClass + ] + superClass: KtLightClassForDecompiledDeclaration: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + KtLightClassForDecompiledDeclaration: BaseClass (two.BaseClass) + ] + +Object.class: + KtObjectDeclaration: + line: 6 + name: Object + qualifier: two.Object + light: KtLightClassForDecompiledDeclaration + name: Object + qualifier: two.Object + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +BaseClass.class: + KtClass: + line: 6 + name: BaseClass + qualifier: two.BaseClass + light: KtLightClassForDecompiledDeclaration + name: BaseClass + qualifier: two.BaseClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +ObjectWithClass.class: + KtObjectDeclaration: + line: 6 + name: ObjectWithClass + qualifier: two.ObjectWithClass + light: KtLightClassForDecompiledDeclaration + name: ObjectWithClass + qualifier: two.ObjectWithClass + superTypes: [ + PsiType:BaseClass + ] + superClass: KtLightClassForDecompiledDeclaration: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + KtLightClassForDecompiledDeclaration: BaseClass (two.BaseClass) + ] + +ObjectWithInterface.class: + KtObjectDeclaration: + line: 6 + name: ObjectWithInterface + qualifier: two.ObjectWithInterface + light: KtLightClassForDecompiledDeclaration + name: ObjectWithInterface + qualifier: two.ObjectWithInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface (two.BaseInterface) + ] + +ObjectWithClassAndJavaInterface.class: + KtObjectDeclaration: + line: 6 + name: ObjectWithClassAndJavaInterface + qualifier: two.ObjectWithClassAndJavaInterface + light: KtLightClassForDecompiledDeclaration + name: ObjectWithClassAndJavaInterface + qualifier: two.ObjectWithClassAndJavaInterface + superTypes: [ + PsiType:NonBaseClass + PsiType:Runnable + ] + superClass: KtLightClassForDecompiledDeclaration: NonBaseClass (two.NonBaseClass) + interfaces: [ + ClsClassImpl: Runnable (java.lang.Runnable) + ] + supers: [ + KtLightClassForDecompiledDeclaration: NonBaseClass (two.NonBaseClass) + ClsClassImpl: Runnable (java.lang.Runnable) + ] + +ObjectsKt.class: +NonBaseInterface.class: + KtClass: + line: 6 + name: NonBaseInterface + qualifier: two.NonBaseInterface + light: KtLightClassForDecompiledDeclaration + name: NonBaseInterface + qualifier: two.NonBaseInterface + superTypes: [ + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: BaseInterface (two.BaseInterface) + ] + +AnotherInterface.class: + KtClass: + line: 6 + name: AnotherInterface + qualifier: two.AnotherInterface + light: KtLightClassForDecompiledDeclaration + name: AnotherInterface + qualifier: two.AnotherInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +ObjectWithNonBaseInterface.class: + KtObjectDeclaration: + line: 6 + name: ObjectWithNonBaseInterface + qualifier: two.ObjectWithNonBaseInterface + light: KtLightClassForDecompiledDeclaration + name: ObjectWithNonBaseInterface + qualifier: two.ObjectWithNonBaseInterface + superTypes: [ + PsiType:Object + PsiType:NonBaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + KtLightClassForDecompiledDeclaration: NonBaseInterface (two.NonBaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + KtLightClassForDecompiledDeclaration: NonBaseInterface (two.NonBaseInterface) + ] + diff --git a/analysis/symbol-light-classes/testData/structure/Objects.txt b/analysis/symbol-light-classes/testData/structure/Objects.txt new file mode 100644 index 00000000000..fd94914abb6 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structure/Objects.txt @@ -0,0 +1,303 @@ +KtClass: + line: 5 + name: BaseInterface + qualifier: two.BaseInterface + light: SymbolLightClassForInterface + name: BaseInterface + qualifier: two.BaseInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 6 + name: NonBaseInterface + qualifier: two.NonBaseInterface + light: SymbolLightClassForInterface + name: NonBaseInterface + qualifier: two.NonBaseInterface + superTypes: [ + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + +KtClass: + line: 7 + name: AnotherInterface + qualifier: two.AnotherInterface + light: SymbolLightClassForInterface + name: AnotherInterface + qualifier: two.AnotherInterface + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 9 + name: BaseClass + qualifier: two.BaseClass + light: SymbolLightClassForClassOrObject + name: BaseClass + qualifier: two.BaseClass + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtClass: + line: 10 + name: NonBaseClass + qualifier: two.NonBaseClass + light: SymbolLightClassForClassOrObject + name: NonBaseClass + qualifier: two.NonBaseClass + superTypes: [ + PsiType:BaseClass + ] + superClass: SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + ] + +KtObjectDeclaration: + line: 12 + name: Object + qualifier: two.Object + light: SymbolLightClassForClassOrObject + name: Object + qualifier: two.Object + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] + +KtObjectDeclaration: + line: 14 + name: ObjectWithInterface + qualifier: two.ObjectWithInterface + light: SymbolLightClassForClassOrObject + name: ObjectWithInterface + qualifier: two.ObjectWithInterface + superTypes: [ + PsiType:Object + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + +KtObjectDeclaration: + line: 16 + name: ObjectWithNonBaseInterface + qualifier: two.ObjectWithNonBaseInterface + light: SymbolLightClassForClassOrObject + name: ObjectWithNonBaseInterface + qualifier: two.ObjectWithNonBaseInterface + superTypes: [ + PsiType:Object + PsiType:NonBaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + +KtObjectDeclaration: + line: 18 + name: ObjectWithClass + qualifier: two.ObjectWithClass + light: SymbolLightClassForClassOrObject + name: ObjectWithClass + qualifier: two.ObjectWithClass + superTypes: [ + PsiType:BaseClass + ] + superClass: SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + ] + +KtObjectDeclaration: + line: 20 + name: ObjectWithClassAndInterface + qualifier: two.ObjectWithClassAndInterface + light: SymbolLightClassForClassOrObject + name: ObjectWithClassAndInterface + qualifier: two.ObjectWithClassAndInterface + superTypes: [ + PsiType:NonBaseClass + PsiType:NonBaseInterface + ] + superClass: SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + interfaces: [ + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + supers: [ + SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + +KtObjectDeclaration: + line: 21 + name: ObjectWithClassAndJavaInterface + qualifier: two.ObjectWithClassAndJavaInterface + light: SymbolLightClassForClassOrObject + name: ObjectWithClassAndJavaInterface + qualifier: two.ObjectWithClassAndJavaInterface + superTypes: [ + PsiType:NonBaseClass + PsiType:Runnable + ] + superClass: SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + interfaces: [ + ClsClassImpl: Runnable (java.lang.Runnable) + ] + supers: [ + SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + ClsClassImpl: Runnable (java.lang.Runnable) + ] + +KtObjectDeclaration: + line: 25 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:BaseClass + ] + superClass: SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + ] + +KtObjectDeclaration: + line: 26 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:NonBaseClass + ] + superClass: SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: NonBaseClass (two.NonBaseClass) + ] + +KtObjectDeclaration: + line: 27 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:Object + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + +KtObjectDeclaration: + line: 28 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:Object + PsiType:NonBaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: NonBaseInterface (two.NonBaseInterface) + ] + +KtObjectDeclaration: + line: 29 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:BaseClass + ] + superClass: SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + interfaces: [] + supers: [ + SymbolLightClassForClassOrObject: BaseClass (two.BaseClass) + ] + +KtObjectDeclaration: + line: 30 + name: null + qualifier: null + light: SymbolLightClassForAnonymousObject + name: null + qualifier: null + superTypes: [ + PsiType:Object + PsiType:BaseInterface + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [ + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + supers: [ + ClsClassImpl: Object (java.lang.Object) + SymbolLightClassForInterface: BaseInterface (two.BaseInterface) + ] + diff --git a/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.inh.txt b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.inh.txt new file mode 100644 index 00000000000..36619de6524 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.inh.txt @@ -0,0 +1,2 @@ +one.two.MyInterface.DefaultImpls|java.lang.Object|false| -> false +one.two.MyInterface.DefaultImpls|java.lang.Object|true| -> false diff --git a/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.kt b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.kt new file mode 100644 index 00000000000..21752a17f4c --- /dev/null +++ b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.kt @@ -0,0 +1,9 @@ +// FQ_NAME: one.two.MyInterface.DefaultImpls + +package one.two + +interface MyInterface { + fun functionWithDefaultImplementation() { + + } +} diff --git a/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.lib.txt b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.lib.txt new file mode 100644 index 00000000000..17a74181f5e --- /dev/null +++ b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.lib.txt @@ -0,0 +1,11 @@ +KtLightClassForDecompiledDeclaration + name: DefaultImpls + qualifier: one.two.MyInterface.DefaultImpls + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] diff --git a/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.txt b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.txt new file mode 100644 index 00000000000..3df1abe84f3 --- /dev/null +++ b/analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.txt @@ -0,0 +1,11 @@ +SymbolLightClassForInterfaceDefaultImpls + name: DefaultImpls + qualifier: one.two.MyInterface.DefaultImpls + superTypes: [ + PsiType:Object + ] + superClass: ClsClassImpl: Object (java.lang.Object) + interfaces: [] + supers: [ + ClsClassImpl: Object (java.lang.Object) + ] diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureByFqNameTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureByFqNameTest.kt new file mode 100644 index 00000000000..184ad7b1864 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureByFqNameTest.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.base + +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator +import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint +import org.jetbrains.kotlin.asJava.LightClassTestCommon +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer +import org.jetbrains.kotlin.test.directives.model.singleValue +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions + +abstract class AbstractSymbolLightClassesStructureByFqNameTest( + configurator: AnalysisApiTestConfigurator, + testPrefix: String, + stopIfCompilationErrorDirectivePresent: Boolean, +) : AbstractSymbolLightClassesStructureTest(configurator, testPrefix, stopIfCompilationErrorDirectivePresent) { + override fun configureTest(builder: TestConfigurationBuilder) { + super.configureTest(builder) + builder.useDirectives(Directives) + } + + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + val result = prettyPrint { + val fqName = module.directives.singleValue(Directives.FQ_NAME) + val psiClass = findLightClass(fqName, ktFiles.first().project) + psiClass?.let { handleClass(it) } ?: append(LightClassTestCommon.NOT_GENERATED_DIRECTIVE) + } + + testServices.assertions.assertEqualsToTestDataFileSibling(result, testPrefix = testPrefix) + + doTestInheritors(ktFiles, testServices) + } + + private object Directives : SimpleDirectivesContainer() { + val FQ_NAME by stringDirective(description = "Light class to render") + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt new file mode 100644 index 00000000000..f74e5b2d61b --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesStructureTest.kt @@ -0,0 +1,166 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.base + +import com.intellij.openapi.project.Project +import com.intellij.psi.JavaPsiFacade +import com.intellij.psi.PsiClass +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator +import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter +import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint +import org.jetbrains.kotlin.asJava.toLightClass +import org.jetbrains.kotlin.psi.KtClassOrObject +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType +import org.jetbrains.kotlin.psi.psiUtil.startOffset +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import java.nio.file.Path +import kotlin.io.path.forEachLine +import kotlin.io.path.notExists + +private const val INHERITORS_EXTENSION = "inh.txt" + +abstract class AbstractSymbolLightClassesStructureTest( + configurator: AnalysisApiTestConfigurator, + protected val testPrefix: String, + override val stopIfCompilationErrorDirectivePresent: Boolean, +) : AbstractSymbolLightClassesTestBase(configurator) { + override val currentExtension: String get() = throw UnsupportedOperationException() + + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + val result = prettyPrint { + for (ktFile in ktFiles) { + if (ktFiles.size > 1) { + appendLine("${ktFile.name}:") + withIndent { + handleFile(ktFile) + } + } else { + handleFile(ktFile) + } + } + } + + testServices.assertions.assertEqualsToTestDataFileSibling(result, testPrefix = testPrefix) + + doTestInheritors(ktFiles, testServices) + } + + protected fun doTestInheritors(ktFiles: List, testServices: TestServices) { + val testData = getTestDataFileSiblingPath(extension = INHERITORS_EXTENSION, testPrefix = testPrefix) + if (testData.notExists()) return + val project = ktFiles.first().project + + val queries = parseInheritorsFile(testData) + val result = buildString { + for (query in queries) { + append(query.fqNameToCheck) + append('|') + append(query.baseFqName) + append('|') + append(query.deep.toString()) + append("| -> ") + appendLine(query.isInheritor(project).toString()) + } + } + + testServices.assertions.assertEqualsToTestDataFileSibling( + actual = result, + testPrefix = testPrefix, + extension = INHERITORS_EXTENSION, + ) + } + + private fun InheritorStructure.isInheritor(project: Project): Boolean { + val lightClass = findLightClass(fqNameToCheck, project) ?: error("Can't find light class by '$fqNameToCheck' qualifier") + val baseClass = JavaPsiFacade.getInstance(project).findClass(baseFqName, GlobalSearchScope.allScope(project)) + ?: error("Can't find class by '$baseFqName' qualifier") + + return lightClass.isInheritor(/* baseClass = */ baseClass, /* checkDeep = */ deep) + } + + private fun parseInheritorsFile(path: Path): Collection = buildList { + path.forEachLine { line: String -> + if (line.isBlank()) return@forEachLine + + val arguments = line.split('|') + val fqNameToCheck = arguments.getOrNull(0) ?: wrongInheritorStructure(line) + val baseFqName = arguments.getOrNull(1) ?: wrongInheritorStructure(line) + val deep = arguments.getOrNull(2)?.toBoolean() ?: wrongInheritorStructure(line) + add(InheritorStructure(fqNameToCheck = fqNameToCheck, baseFqName = baseFqName, deep = deep)) + } + }.toSet() + + private fun wrongInheritorStructure(line: String): Nothing = error("Can't parse '$line' line correctly") + + private fun PrettyPrinter.handleFile(ktFile: KtFile) { + val text = ktFile.text + ktFile.forEachDescendantOfType { classOrObject -> + handleClassDeclaration(classOrObject, text) + appendLine() + } + } + + private fun PrettyPrinter.handleClassDeclaration(declaration: KtClassOrObject, fileText: String) { + appendLine("${declaration::class.simpleName}:") + withIndent { + val lineNumber = fileText.subSequence(0, declaration.startOffset).count { it == '\n' } + 1 + appendLine("line: $lineNumber") + appendLine("name: ${declaration.name}") + appendLine("qualifier: ${declaration.fqName}") + append("light: ") + val lightClass = declaration.toLightClass() + if (lightClass != null) { + handleClass(lightClass) + } else { + appendLine("null") + } + } + } + + protected fun PrettyPrinter.handleClass(psiClass: PsiClass) { + appendLine(psiClass::class.simpleName) + withIndent { + appendLine("name: ${psiClass.name}") + appendLine("qualifier: ${psiClass.qualifiedName}") + appendCollection("superTypes", psiClass.superTypes.asList()) { it.toString() } + appendLine("superClass: ${psiClass.superClass?.render()}") + appendCollection("interfaces", psiClass.interfaces.asList()) { it.render() } + appendCollection("supers", psiClass.supers.asList()) { it.render() } + } + } + + private fun PsiClass.render(): String = "${this::class.simpleName}: $name ($qualifiedName)" + + private inline fun PrettyPrinter.appendCollection( + name: String, + collection: Collection, + crossinline renderer: (T) -> CharSequence, + ) { + append("$name: ") + if (collection.isEmpty()) { + appendLine("[]") + return + } + + withIndentInSquareBrackets { + printCollection(collection, separator = "\n") { + append(renderer(it)) + } + } + + appendLine() + } + + override fun getRenderResult(ktFile: KtFile, testDataFile: Path, module: TestModule, project: Project): String { + throw UnsupportedOperationException() + } +} + +private data class InheritorStructure(val fqNameToCheck: String, val baseFqName: String, val deep: Boolean) \ No newline at end of file diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureByFqNameForLibraryTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureByFqNameForLibraryTest.kt new file mode 100644 index 00000000000..fdcbcdaedf0 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureByFqNameForLibraryTest.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.decompiled + +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesStructureByFqNameTest +import org.jetbrains.kotlin.light.classes.symbol.decompiled.test.configurators.AnalysisApiSymbolLightClassesDecompiledTestConfigurator + +abstract class AbstractSymbolLightClassesStructureByFqNameForLibraryTest : AbstractSymbolLightClassesStructureByFqNameTest( + configurator = AnalysisApiSymbolLightClassesDecompiledTestConfigurator, + testPrefix = "lib", + stopIfCompilationErrorDirectivePresent = true, +) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureForLibraryTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureForLibraryTest.kt new file mode 100644 index 00000000000..55e39361252 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesStructureForLibraryTest.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.decompiled + +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesStructureTest +import org.jetbrains.kotlin.light.classes.symbol.decompiled.test.configurators.AnalysisApiSymbolLightClassesDecompiledTestConfigurator + +abstract class AbstractSymbolLightClassesStructureForLibraryTest : AbstractSymbolLightClassesStructureTest( + configurator = AnalysisApiSymbolLightClassesDecompiledTestConfigurator, + testPrefix = "lib", + stopIfCompilationErrorDirectivePresent = true, +) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureByFqNameForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureByFqNameForLibraryTestGenerated.java new file mode 100644 index 00000000000..aa3a3782ea5 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureByFqNameForLibraryTestGenerated.java @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.decompiled; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/symbol-light-classes/testData/structureByFqName") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesStructureByFqNameForLibraryTestGenerated extends AbstractSymbolLightClassesStructureByFqNameForLibraryTest { + @Test + public void testAllFilesPresentInStructureByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/symbol-light-classes/testData/structureByFqName"), Pattern.compile("^(.+)\\.(kt)$"), null, true); + } + + @Test + @TestMetadata("DefaultImpls.kt") + public void testDefaultImpls() throws Exception { + runTest("analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.kt"); + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureForLibraryTestGenerated.java new file mode 100644 index 00000000000..93dd29bd76e --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesStructureForLibraryTestGenerated.java @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.decompiled; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/symbol-light-classes/testData/structure") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesStructureForLibraryTestGenerated extends AbstractSymbolLightClassesStructureForLibraryTest { + @Test + public void testAllFilesPresentInStructure() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/symbol-light-classes/testData/structure"), Pattern.compile("^(.+)\\.(kt)$"), null, true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Annotations.kt"); + } + + @Test + @TestMetadata("Classes.kt") + public void testClasses() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Classes.kt"); + } + + @Test + @TestMetadata("EnumEntries.kt") + public void testEnumEntries() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/EnumEntries.kt"); + } + + @Test + @TestMetadata("InterfaceAndClasses.kt") + public void testInterfaceAndClasses() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.kt"); + } + + @Test + @TestMetadata("Interfaces.kt") + public void testInterfaces() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Interfaces.kt"); + } + + @Test + @TestMetadata("Objects.kt") + public void testObjects() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Objects.kt"); + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureByFqNameForSourceTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureByFqNameForSourceTest.kt new file mode 100644 index 00000000000..e24dd05384b --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureByFqNameForSourceTest.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.source + +import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesStructureByFqNameTest + +abstract class AbstractSymbolLightClassesStructureByFqNameForSourceTest : AbstractSymbolLightClassesStructureByFqNameTest( + configurator = AnalysisApiFirSourceTestConfigurator(analyseInDependentSession = false), + testPrefix = "fir", + stopIfCompilationErrorDirectivePresent = false, +) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureForSourceTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureForSourceTest.kt new file mode 100644 index 00000000000..58f551c87de --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesStructureForSourceTest.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.source + +import org.jetbrains.kotlin.analysis.low.level.api.fir.test.configurators.AnalysisApiFirSourceTestConfigurator +import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesStructureTest + +abstract class AbstractSymbolLightClassesStructureForSourceTest : AbstractSymbolLightClassesStructureTest( + configurator = AnalysisApiFirSourceTestConfigurator(analyseInDependentSession = false), + testPrefix = "fir", + stopIfCompilationErrorDirectivePresent = false, +) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureByFqNameForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureByFqNameForSourceTestGenerated.java new file mode 100644 index 00000000000..2bfc6eeee39 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureByFqNameForSourceTestGenerated.java @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.source; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/symbol-light-classes/testData/structureByFqName") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesStructureByFqNameForSourceTestGenerated extends AbstractSymbolLightClassesStructureByFqNameForSourceTest { + @Test + public void testAllFilesPresentInStructureByFqName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/symbol-light-classes/testData/structureByFqName"), Pattern.compile("^(.+)\\.(kt)$"), null, true); + } + + @Test + @TestMetadata("DefaultImpls.kt") + public void testDefaultImpls() throws Exception { + runTest("analysis/symbol-light-classes/testData/structureByFqName/DefaultImpls.kt"); + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureForSourceTestGenerated.java new file mode 100644 index 00000000000..a3716e31439 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesStructureForSourceTestGenerated.java @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.light.classes.symbol.source; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.analysis.api.GenerateAnalysisApiTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/symbol-light-classes/testData/structure") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesStructureForSourceTestGenerated extends AbstractSymbolLightClassesStructureForSourceTest { + @Test + public void testAllFilesPresentInStructure() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/symbol-light-classes/testData/structure"), Pattern.compile("^(.+)\\.(kt)$"), null, true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Annotations.kt"); + } + + @Test + @TestMetadata("Classes.kt") + public void testClasses() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Classes.kt"); + } + + @Test + @TestMetadata("EnumEntries.kt") + public void testEnumEntries() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/EnumEntries.kt"); + } + + @Test + @TestMetadata("InterfaceAndClasses.kt") + public void testInterfaceAndClasses() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/InterfaceAndClasses.kt"); + } + + @Test + @TestMetadata("Interfaces.kt") + public void testInterfaces() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Interfaces.kt"); + } + + @Test + @TestMetadata("Objects.kt") + public void testObjects() throws Exception { + runTest("analysis/symbol-light-classes/testData/structure/Objects.kt"); + } +} diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt index 010ded06d67..f8fa91e69fa 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/lightClasses.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -7,14 +7,8 @@ package org.jetbrains.kotlin.generators.tests.analysis.api import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil -import org.jetbrains.kotlin.light.classes.symbol.decompiled.AbstractSymbolLightClassesParentingForLibraryTest -import org.jetbrains.kotlin.light.classes.symbol.decompiled.AbstractSymbolLightClassesFacadeForLibraryTest -import org.jetbrains.kotlin.light.classes.symbol.decompiled.AbstractSymbolLightClassesForLibraryTest -import org.jetbrains.kotlin.light.classes.symbol.decompiled.AbstractSymbolLightClassesLoadingForLibraryTest -import org.jetbrains.kotlin.light.classes.symbol.source.AbstractSymbolLightClassesParentingForSourceTest -import org.jetbrains.kotlin.light.classes.symbol.source.AbstractSymbolLightClassesFacadeForSourceTest -import org.jetbrains.kotlin.light.classes.symbol.source.AbstractSymbolLightClassesForSourceTest -import org.jetbrains.kotlin.light.classes.symbol.source.AbstractSymbolLightClassesLoadingForSourceTest +import org.jetbrains.kotlin.light.classes.symbol.decompiled.* +import org.jetbrains.kotlin.light.classes.symbol.source.* internal fun TestGroupSuite.generateSymbolLightClassesTests() { testGroup( @@ -73,4 +67,29 @@ internal fun TestGroupSuite.generateSymbolLightClassesTests() { } } } -} \ No newline at end of file + + testGroup( + "analysis/symbol-light-classes/tests", + "analysis/symbol-light-classes/testData", + ) { + run { + testClass { + model("structure", pattern = TestGeneratorUtil.KT) + } + + testClass { + model("structure", pattern = TestGeneratorUtil.KT) + } + } + + run { + testClass { + model("structureByFqName", pattern = TestGeneratorUtil.KT) + } + + testClass { + model("structureByFqName", pattern = TestGeneratorUtil.KT) + } + } + } +}