From 7273610d4189e3835be87e25141319e94714ba16 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Wed, 22 Feb 2023 13:34:53 +0100 Subject: [PATCH] [SLC] introduce AbstractSymbolLightClassesParentingTestByPsi ^KT-56613 --- .../AbstractSymbolLightClassesByPsiTest.kt | 10 +- ...actSymbolLightClassesParentingTestByPsi.kt | 28 ++ .../base/service/symbolLightClassTestUtils.kt | 12 +- ...ightClassesParentingByPsiForLibraryTest.kt | 16 + ...ParentingByPsiForLibraryTestGenerated.java | 448 ++++++++++++++++++ ...LightClassesParentingByPsiForSourceTest.kt | 16 + ...sParentingByPsiForSourceTestGenerated.java | 448 ++++++++++++++++++ .../tests/analysis/api/lightClasses.kt | 8 + 8 files changed, 976 insertions(+), 10 deletions(-) create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTestByPsi.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesParentingByPsiForLibraryTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesParentingByPsiForSourceTest.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesByPsiTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesByPsiTest.kt index 0769539469b..3c593830651 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesByPsiTest.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesByPsiTest.kt @@ -6,14 +6,11 @@ package org.jetbrains.kotlin.light.classes.symbol.base import com.intellij.openapi.project.Project -import com.intellij.psi.PsiClass -import com.intellij.psi.SyntaxTraverser import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator import org.jetbrains.kotlin.asJava.LightClassTestCommon import org.jetbrains.kotlin.asJava.renderClass -import org.jetbrains.kotlin.asJava.toLightElements +import org.jetbrains.kotlin.light.classes.symbol.base.service.getLightClassesFromFile import org.jetbrains.kotlin.light.classes.symbol.base.service.withExtendedTypeRenderer -import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.model.TestModule import java.nio.file.Path @@ -30,9 +27,4 @@ abstract class AbstractSymbolLightClassesByPsiTest( lightClasses.sortedBy { it.name }.joinToString("\n\n") { it.renderClass() } } } - - private fun getLightClassesFromFile(ktFile: KtFile): List { - val ktClasses = SyntaxTraverser.psiTraverser(ktFile).filter(KtClassOrObject::class.java).toList() - return ktClasses.plus(ktFile).flatMap { it.toLightElements() }.filterIsInstance() - } } diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTestByPsi.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTestByPsi.kt new file mode 100644 index 00000000000..c3c74a1bf7f --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesParentingTestByPsi.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2023 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.asJava.LightClassTestCommon +import org.jetbrains.kotlin.light.classes.symbol.base.service.getLightClassesFromFile +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions + +abstract class AbstractSymbolLightClassesParentingTestByPsi( + configurator: AnalysisApiTestConfigurator, + currentExtension: String, + stopIfCompilationErrorDirectivePresent: Boolean, +) : AbstractSymbolLightClassesParentingTestBase(configurator, currentExtension, stopIfCompilationErrorDirectivePresent) { + override fun doTestByFileStructure(ktFiles: List, module: TestModule, testServices: TestServices) { + for (ktFile in ktFiles) { + for (psiClass in getLightClassesFromFile(ktFile)) { + psiClass.accept(createLightElementsVisitor(testServices.assertions)) + } + } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/service/symbolLightClassTestUtils.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/service/symbolLightClassTestUtils.kt index b89e41118e2..587cca895ac 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/service/symbolLightClassTestUtils.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/service/symbolLightClassTestUtils.kt @@ -5,7 +5,12 @@ package org.jetbrains.kotlin.light.classes.symbol.base.service +import com.intellij.psi.PsiClass +import com.intellij.psi.SyntaxTraverser import org.jetbrains.kotlin.asJava.PsiClassRenderer +import org.jetbrains.kotlin.asJava.toLightElements +import org.jetbrains.kotlin.psi.KtClassOrObject +import org.jetbrains.kotlin.psi.KtFile import java.nio.file.Path internal inline fun withExtendedTypeRenderer(testDataFile: Path, action: () -> R): R { @@ -16,4 +21,9 @@ internal inline fun withExtendedTypeRenderer(testDataFile: Path, action: () } finally { PsiClassRenderer.extendedTypeRenderer = extendedTypeRendererOld } -} \ No newline at end of file +} + +internal fun getLightClassesFromFile(ktFile: KtFile): List { + val ktClasses = SyntaxTraverser.psiTraverser(ktFile).filter(KtClassOrObject::class.java).toList() + return ktClasses.plus(ktFile).flatMap { it.toLightElements() }.filterIsInstance() +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesParentingByPsiForLibraryTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesParentingByPsiForLibraryTest.kt new file mode 100644 index 00000000000..febb7cd8f61 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesParentingByPsiForLibraryTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.AbstractSymbolLightClassesParentingTestByPsi +import org.jetbrains.kotlin.light.classes.symbol.decompiled.test.configurators.AnalysisApiSymbolLightClassesDecompiledTestConfigurator + +abstract class AbstractSymbolLightClassesParentingByPsiForLibraryTest : + AbstractSymbolLightClassesParentingTestByPsi( + AnalysisApiSymbolLightClassesDecompiledTestConfigurator, + EXTENSIONS.LIB_JAVA, + stopIfCompilationErrorDirectivePresent = true + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java new file mode 100644 index 00000000000..8378b23dced --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java @@ -0,0 +1,448 @@ +/* + * Copyright 2010-2023 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("compiler/testData/asJava/lightClasses/lightClassByPsi") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesParentingByPsiForLibraryTestGenerated extends AbstractSymbolLightClassesParentingByPsiForLibraryTest { + @Test + public void testAllFilesPresentInLightClassByPsi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("annotationWithSetParamPropertyModifier.kt") + public void testAnnotationWithSetParamPropertyModifier() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.kt"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotations.kt"); + } + + @Test + @TestMetadata("AnnotationsOnEnumEntry.kt") + public void testAnnotationsOnEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsOnEnumEntry.kt"); + } + + @Test + @TestMetadata("AnnotationsWithUnresolvedAnnotations.kt") + public void testAnnotationsWithUnresolvedAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsWithUnresolvedAnnotations.kt"); + } + + @Test + @TestMetadata("classModifiers.kt") + public void testClassModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.kt"); + } + + @Test + @TestMetadata("companionDuplication.kt") + public void testCompanionDuplication() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/companionDuplication.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.kt"); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dataClasses.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAll.kt") + public void testDefaultMethodInKotlinWithSettingAll() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAll.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAllCompatibility.kt") + public void testDefaultMethodInKotlinWithSettingAllCompatibility() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAllCompatibility.kt"); + } + + @Test + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/DelegatedProperty.kt"); + } + + @Test + @TestMetadata("delegatesWithAnnotations.kt") + public void testDelegatesWithAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegatingToInterfaces.kt") + public void testDelegatingToInterfaces() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatingToInterfaces.kt"); + } + + @Test + @TestMetadata("dollarsInNameLocal.kt") + public void testDollarsInNameLocal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dollarsInNameLocal.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/enums.kt"); + } + + @Test + @TestMetadata("exposedAnonymousType.kt") + public void testExposedAnonymousType() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt"); + } + + @Test + @TestMetadata("fieldModifiers.kt") + public void testFieldModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/generics.kt"); + } + + @Test + @TestMetadata("implementingKotlinCollections.kt") + public void testImplementingKotlinCollections() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/implementingKotlinCollections.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/importAliases.kt"); + } + + @Test + @TestMetadata("inferringAnonymousObjectTypes.kt") + public void testInferringAnonymousObjectTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inferringAnonymousObjectTypes.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inheritance.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineClasses.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineOnly.kt"); + } + + @Test + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineReified.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmName.kt"); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmOverloads.kt"); + } + + @Test + @TestMetadata("jvmRecord.kt") + public void testJvmRecord() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmRecord.kt"); + } + + @Test + @TestMetadata("jvmStaticOnPropertySetter.kt") + public void testJvmStaticOnPropertySetter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmStaticOnPropertySetter.kt"); + } + + @Test + @TestMetadata("jvmSynthetic.kt") + public void testJvmSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSynthetic.kt"); + } + + @Test + @TestMetadata("jvmSyntheticForAccessors.kt") + public void testJvmSyntheticForAccessors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSyntheticForAccessors.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("LateinitProperties.kt") + public void testLateinitProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/lateinitProperty.kt"); + } + + @Test + @TestMetadata("localClassDerived.kt") + public void testLocalClassDerived() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/localClassDerived.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/objects.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/simpleFunctions.kt"); + } + + @Test + @TestMetadata("strangeIdentifiers.kt") + public void testStrangeIdentifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/strangeIdentifiers.kt"); + } + + @Test + @TestMetadata("targetAnnotation.kt") + public void testTargetAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/targetAnnotation.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("typeAliases.kt") + public void testTypeAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.kt"); + } + + @Test + @TestMetadata("typealiasInAnnotation.kt") + public void testTypealiasInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInAnnotation.kt"); + } + + @Test + @TestMetadata("typealiasInTypeArguments.kt") + public void testTypealiasInTypeArguments() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInTypeArguments.kt"); + } + + @Test + @TestMetadata("unresolvedWithAliasedImport.kt") + public void testUnresolvedWithAliasedImport() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/coroutines.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/importAliases.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/inlineOnly.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmName.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/lateinitProperty.kt"); + } + + @Test + @TestMetadata("multifileFacade.kt") + public void testMultifileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacade.kt"); + } + + @Test + @TestMetadata("multifileFacadeJvmName.kt") + public void testMultifileFacadeJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacadeJvmName.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/simpleFunctions.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/wildcardOptimization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts") + @TestDataPath("$PROJECT_ROOT") + public class Scripts { + @Test + public void testAllFilesPresentInScripts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("FunsPropsAndFields.kts") + public void testFunsPropsAndFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/FunsPropsAndFields.kts"); + } + + @Test + @TestMetadata("HelloWorld.kts") + public void testHelloWorld() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/HelloWorld.kts"); + } + + @Test + @TestMetadata("InnerClasses.kts") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/InnerClasses.kts"); + } + } +} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesParentingByPsiForSourceTest.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesParentingByPsiForSourceTest.kt new file mode 100644 index 00000000000..8710d453116 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesParentingByPsiForSourceTest.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2023 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.AbstractSymbolLightClassesParentingTestByPsi + +abstract class AbstractSymbolLightClassesParentingByPsiForSourceTest : + AbstractSymbolLightClassesParentingTestByPsi( + AnalysisApiFirSourceTestConfigurator(analyseInDependentSession = false), + EXTENSIONS.FIR_JAVA, + stopIfCompilationErrorDirectivePresent = false + ) diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java new file mode 100644 index 00000000000..e3c74c4ca3a --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java @@ -0,0 +1,448 @@ +/* + * Copyright 2010-2023 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("compiler/testData/asJava/lightClasses/lightClassByPsi") +@TestDataPath("$PROJECT_ROOT") +public class SymbolLightClassesParentingByPsiForSourceTestGenerated extends AbstractSymbolLightClassesParentingByPsiForSourceTest { + @Test + public void testAllFilesPresentInLightClassByPsi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("annotationWithSetParamPropertyModifier.kt") + public void testAnnotationWithSetParamPropertyModifier() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotationWithSetParamPropertyModifier.kt"); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/annotations.kt"); + } + + @Test + @TestMetadata("AnnotationsOnEnumEntry.kt") + public void testAnnotationsOnEnumEntry() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsOnEnumEntry.kt"); + } + + @Test + @TestMetadata("AnnotationsWithUnresolvedAnnotations.kt") + public void testAnnotationsWithUnresolvedAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/AnnotationsWithUnresolvedAnnotations.kt"); + } + + @Test + @TestMetadata("classModifiers.kt") + public void testClassModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/classModifiers.kt"); + } + + @Test + @TestMetadata("companionDuplication.kt") + public void testCompanionDuplication() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/companionDuplication.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/constructors.kt"); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/coroutines.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dataClasses.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAll.kt") + public void testDefaultMethodInKotlinWithSettingAll() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAll.kt"); + } + + @Test + @TestMetadata("defaultMethodInKotlinWithSettingAllCompatibility.kt") + public void testDefaultMethodInKotlinWithSettingAllCompatibility() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/defaultMethodInKotlinWithSettingAllCompatibility.kt"); + } + + @Test + @TestMetadata("DelegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/DelegatedProperty.kt"); + } + + @Test + @TestMetadata("delegatesWithAnnotations.kt") + public void testDelegatesWithAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatesWithAnnotations.kt"); + } + + @Test + @TestMetadata("delegatingToInterfaces.kt") + public void testDelegatingToInterfaces() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/delegatingToInterfaces.kt"); + } + + @Test + @TestMetadata("dollarsInNameLocal.kt") + public void testDollarsInNameLocal() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/dollarsInNameLocal.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/enums.kt"); + } + + @Test + @TestMetadata("exposedAnonymousType.kt") + public void testExposedAnonymousType() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt"); + } + + @Test + @TestMetadata("fieldModifiers.kt") + public void testFieldModifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/generics.kt"); + } + + @Test + @TestMetadata("implementingKotlinCollections.kt") + public void testImplementingKotlinCollections() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/implementingKotlinCollections.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/importAliases.kt"); + } + + @Test + @TestMetadata("inferringAnonymousObjectTypes.kt") + public void testInferringAnonymousObjectTypes() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inferringAnonymousObjectTypes.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inheritance.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineClasses.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineOnly.kt"); + } + + @Test + @TestMetadata("inlineReified.kt") + public void testInlineReified() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/inlineReified.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmName.kt"); + } + + @Test + @TestMetadata("jvmOverloads.kt") + public void testJvmOverloads() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmOverloads.kt"); + } + + @Test + @TestMetadata("jvmRecord.kt") + public void testJvmRecord() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmRecord.kt"); + } + + @Test + @TestMetadata("jvmStaticOnPropertySetter.kt") + public void testJvmStaticOnPropertySetter() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmStaticOnPropertySetter.kt"); + } + + @Test + @TestMetadata("jvmSynthetic.kt") + public void testJvmSynthetic() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSynthetic.kt"); + } + + @Test + @TestMetadata("jvmSyntheticForAccessors.kt") + public void testJvmSyntheticForAccessors() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmSyntheticForAccessors.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("LateinitProperties.kt") + public void testLateinitProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/LateinitProperties.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/lateinitProperty.kt"); + } + + @Test + @TestMetadata("localClassDerived.kt") + public void testLocalClassDerived() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/localClassDerived.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/objects.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/simpleFunctions.kt"); + } + + @Test + @TestMetadata("strangeIdentifiers.kt") + public void testStrangeIdentifiers() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/strangeIdentifiers.kt"); + } + + @Test + @TestMetadata("targetAnnotation.kt") + public void testTargetAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/targetAnnotation.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("typeAliases.kt") + public void testTypeAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAliases.kt"); + } + + @Test + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typeAnnotations.kt"); + } + + @Test + @TestMetadata("typealiasInAnnotation.kt") + public void testTypealiasInAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInAnnotation.kt"); + } + + @Test + @TestMetadata("typealiasInTypeArguments.kt") + public void testTypealiasInTypeArguments() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/typealiasInTypeArguments.kt"); + } + + @Test + @TestMetadata("unresolvedWithAliasedImport.kt") + public void testUnresolvedWithAliasedImport() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/wildcardOptimization.kt"); + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/facades") + @TestDataPath("$PROJECT_ROOT") + public class Facades { + @Test + public void testAllFilesPresentInFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("coroutines.kt") + public void testCoroutines() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/coroutines.kt"); + } + + @Test + @TestMetadata("importAliases.kt") + public void testImportAliases() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/importAliases.kt"); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/inlineOnly.kt"); + } + + @Test + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmField.kt"); + } + + @Test + @TestMetadata("jvmName.kt") + public void testJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmName.kt"); + } + + @Test + @TestMetadata("jvmWildcardAnnotations.kt") + public void testJvmWildcardAnnotations() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/jvmWildcardAnnotations.kt"); + } + + @Test + @TestMetadata("lateinitProperty.kt") + public void testLateinitProperty() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/lateinitProperty.kt"); + } + + @Test + @TestMetadata("multifileFacade.kt") + public void testMultifileFacade() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacade.kt"); + } + + @Test + @TestMetadata("multifileFacadeJvmName.kt") + public void testMultifileFacadeJvmName() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/multifileFacadeJvmName.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.kt"); + } + + @Test + @TestMetadata("simpleFunctions.kt") + public void testSimpleFunctions() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/simpleFunctions.kt"); + } + + @Test + @TestMetadata("throwsAnnotation.kt") + public void testThrowsAnnotation() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/throwsAnnotation.kt"); + } + + @Test + @TestMetadata("valueClassInSignature.kt") + public void testValueClassInSignature() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/valueClassInSignature.kt"); + } + + @Test + @TestMetadata("wildcardOptimization.kt") + public void testWildcardOptimization() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/facades/wildcardOptimization.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts") + @TestDataPath("$PROJECT_ROOT") + public class Scripts { + @Test + public void testAllFilesPresentInScripts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + } + + @Test + @TestMetadata("FunsPropsAndFields.kts") + public void testFunsPropsAndFields() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/FunsPropsAndFields.kts"); + } + + @Test + @TestMetadata("HelloWorld.kts") + public void testHelloWorld() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/HelloWorld.kts"); + } + + @Test + @TestMetadata("InnerClasses.kts") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/scripts/InnerClasses.kts"); + } + } +} 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 643cdc24d50..bbb90a190fa 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 @@ -56,6 +56,14 @@ internal fun TestGroupSuite.generateSymbolLightClassesTests() { testClass { model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) } + + testClass { + model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) + } + + testClass { + model("asJava/lightClasses/lightClassByPsi", pattern = TestGeneratorUtil.KT_OR_KTS) + } } }