From 5557ea690dfb5cb86da1de706ad6aa9342098c3a Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Thu, 24 Aug 2023 14:30:06 +0200 Subject: [PATCH] [AA] add generated tests for scripts ^KT-61431 --- .../scriptFileWithImportStatement.kts | 10 +- .../scriptFileWithImportStatement.txt | 6 +- .../scriptFileWithoutImportStatements.kts | 6 +- .../scriptFileWithoutImportStatements.txt | 3 + ...alysisApiTestConfiguratorServiceFactory.kt | 5 + .../tests/analysis/api/analysisApi.kt | 147 +++++++++--------- .../analysis/api/dsl/AnalysisApiTestGroup.kt | 18 ++- 7 files changed, 109 insertions(+), 86 deletions(-) diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.kts b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.kts index 605cfdf171a..95752b2cead 100644 --- a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.kts +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.kts @@ -1,11 +1,9 @@ -// FILE: main.kts -import a.b.c.dependency.Foo - -fun foo(): a.b.c.dependency.Foo = t - -// FILE: dependency.kt package a.b.c.dependency +import a.b.c.dependency.Foo.Nested + class Foo { class Nested } + +fun foo(): a.b.c.dependency.Foo.Nested = t diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.txt index 2071aaddb50..c13cfb9d372 100644 --- a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.txt +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithImportStatement.txt @@ -1,7 +1,7 @@ with DO_NOT_SHORTEN: with SHORTEN_IF_ALREADY_IMPORTED: -[type] a.b.c.dependency.Foo +[type] a.b.c.dependency.Foo.Nested with SHORTEN_AND_IMPORT: -[type] a.b.c.dependency.Foo +[type] a.b.c.dependency.Foo.Nested with SHORTEN_AND_STAR_IMPORT: -[type] a.b.c.dependency.Foo +[type] a.b.c.dependency.Foo.Nested diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.kts b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.kts index d45ab497727..bf90101d48c 100644 --- a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.kts +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.kts @@ -1,9 +1,7 @@ -// FILE: main.kts -fun foo(): a.b.c.dependency.Foo = t - -// FILE: dependency.kt package a.b.c.dependency class Foo { class Nested } + +fun foo(): a.b.c.dependency.Foo.Nested = t diff --git a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.txt b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.txt index 99fd1d5116c..c00c69495d5 100644 --- a/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.txt +++ b/analysis/analysis-api/testData/components/referenceShortener/referenceShortenerWholeFile/scriptFileWithoutImportStatements.txt @@ -1,4 +1,7 @@ with DO_NOT_SHORTEN: with SHORTEN_IF_ALREADY_IMPORTED: +[type] a.b.c.dependency.Foo with SHORTEN_AND_IMPORT: +[type] a.b.c.dependency.Foo.Nested with SHORTEN_AND_STAR_IMPORT: +[type] a.b.c.dependency.Foo.Nested diff --git a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/test/configurators/AnalysisApiTestConfiguratorServiceFactory.kt b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/test/configurators/AnalysisApiTestConfiguratorServiceFactory.kt index 717e2f09326..c2259e5a8cc 100644 --- a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/test/configurators/AnalysisApiTestConfiguratorServiceFactory.kt +++ b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/test/configurators/AnalysisApiTestConfiguratorServiceFactory.kt @@ -28,6 +28,11 @@ data class AnalysisApiTestConfiguratorFactoryData( val analysisApiMode: AnalysisApiMode, ) +fun AnalysisApiTestConfiguratorFactoryData.defaultExtension(): String = when (this.moduleKind) { + TestModuleKind.ScriptSource -> "kts" + else -> "kt" +} + enum class AnalysisSessionMode(val suffix: String) { Normal("Normal"), diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt index eb82e2d874c..ae9f40ed272 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt @@ -82,7 +82,7 @@ internal fun AnalysisApiTestGroup.generateAnalysisApiTests() { } } - group(filter = testModuleKindIs(TestModuleKind.Source)) { + group(filter = testModuleKindIs(TestModuleKind.Source, TestModuleKind.ScriptSource)) { generateAnalysisApiComponentsTests() generateAnalysisApiNonComponentsTests() generateResolveExtensionsTests() @@ -97,7 +97,7 @@ private fun AnalysisApiTestGroup.generateResolveExtensionsTests() { testModuleKindIs(TestModuleKind.Source) ) { test(AbstractReferenceResolveWithResolveExtensionTest::class) { - model("referenceResolve") + model(it, "referenceResolve") } } } @@ -105,23 +105,23 @@ private fun AnalysisApiTestGroup.generateResolveExtensionsTests() { private fun AnalysisApiTestGroup.generateAnalysisApiNonComponentsTests() { group("symbols", filter = analysisSessionModeIs(AnalysisSessionMode.Normal)) { test(AbstractSymbolByPsiTest::class) { - model("symbolByPsi") + model(it, "symbolByPsi") } test(AbstractSymbolByJavaPsiTest::class, filter = frontendIs(FrontendKind.Fir)) { - model("symbolByJavaPsi") + model(it, "symbolByJavaPsi") } test(AbstractSingleSymbolByPsiTest::class) { - model("singleSymbolByPsi") + model(it, "singleSymbolByPsi") } test(AbstractSymbolRestoreFromDifferentModuleTest::class) { - model("symbolRestoreFromDifferentModule") + model(it, "symbolRestoreFromDifferentModule") } test(AbstractMultiModuleSymbolByPsiTest::class) { - model("multiModuleSymbolByPsi") + model(it, "multiModuleSymbolByPsi") } test( @@ -129,63 +129,63 @@ private fun AnalysisApiTestGroup.generateAnalysisApiNonComponentsTests() { ) { when (it.analysisApiMode) { AnalysisApiMode.Ide -> - model("symbolByFqName") + model(it, "symbolByFqName") AnalysisApiMode.Standalone -> - model("symbolByFqName", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) + model(it, "symbolByFqName", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) } } test(AbstractSymbolByReferenceTest::class) { when (it.analysisApiMode) { AnalysisApiMode.Ide -> - model("symbolByReference") + model(it, "symbolByReference") AnalysisApiMode.Standalone -> - model("symbolByReference", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) + model(it, "symbolByReference", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) } } } group("types", filter = analysisSessionModeIs(AnalysisSessionMode.Normal)) { test(AbstractTypeByDeclarationReturnTypeTest::class) { - model("byDeclarationReturnType") + model(it, "byDeclarationReturnType") } } group("annotations") { test(AbstractAnalysisApiAnnotationsOnTypesTest::class) { - model("annotationsOnTypes") + model(it, "annotationsOnTypes") } test(AbstractAnalysisApiAnnotationsOnDeclarationsTest::class) { - model("annotationsOnDeclaration") + model(it, "annotationsOnDeclaration") } test(AbstractAnalysisApiSpecificAnnotationOnDeclarationTest::class) { - model("specificAnnotations") + model(it, "specificAnnotations") } test( AbstractAnalysisApiAnnotationsOnFilesTest::class, filter = analysisSessionModeIs(AnalysisSessionMode.Normal), ) { - model("annotationsOnFiles") + model(it, "annotationsOnFiles") } test(AbstractAnalysisApiAnnotationsOnDeclarationsWithMetaTest::class) { - model("metaAnnotations") + model(it, "metaAnnotations") } } group("substitutors", filter = frontendIs(FrontendKind.Fir)) { test(AbstractAnalysisApiSubstitutorsTest::class) { - model("typeSubstitution") + model(it, "typeSubstitution") } } group("standalone", filter = analysisApiModeIs(AnalysisApiMode.Standalone)) { test(AbstractPsiDeclarationProviderTest::class) { - model("singleModule") + model(it, "singleModule") } } } @@ -196,16 +196,16 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { test(AbstractResolveCallTest::class) { when (it.analysisApiMode) { AnalysisApiMode.Ide -> - model("resolveCall") + model(it, "resolveCall") AnalysisApiMode.Standalone -> - model("resolveCall", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) + model(it, "resolveCall", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) } } test( AbstractResolveCandidatesTest::class ) { - model("resolveCandidates") + model(it, "resolveCandidates") } } @@ -213,16 +213,17 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { test(AbstractMultiModuleResolveCallTest::class, filter = frontendIs(FrontendKind.Fir)) { when (it.analysisApiMode) { AnalysisApiMode.Ide -> - model("resolveCall") + model(it, "resolveCall") AnalysisApiMode.Standalone -> - model("resolveCall") + model(it, "resolveCall") } } } component( "compilerFacility", - filter = frontendIs(FrontendKind.Fir) + filter = testModuleKindIs(TestModuleKind.Source) + and frontendIs(FrontendKind.Fir) and analysisSessionModeIs(AnalysisSessionMode.Normal) and analysisApiModeIs(AnalysisApiMode.Ide) ) { @@ -233,57 +234,61 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { component("compileTimeConstantProvider") { test(AbstractCompileTimeConstantEvaluatorTest::class) { - model("evaluate") + model(it, "evaluate") } } component("expressionInfoProvider") { test(AbstractWhenMissingCasesTest::class) { - model("whenMissingCases") + model(it, "whenMissingCases") } test(AbstractReturnTargetSymbolTest::class) { - model("returnExpressionTargetSymbol") + model(it, "returnExpressionTargetSymbol") } test(AbstractIsUsedAsExpressionTest::class) { - model("isUsedAsExpression") + model(it, "isUsedAsExpression") } } component("referenceShortener", filter = frontendIs(FrontendKind.Fir) and analysisSessionModeIs(AnalysisSessionMode.Normal)) { test(AbstractReferenceShortenerTest::class) { - model("referenceShortener", pattern = TestGeneratorUtil.KT_OR_KTS) + model(it, "referenceShortener") } + test(AbstractReferenceShortenerForWholeFileTest::class) { - model("referenceShortenerWholeFile", pattern = TestGeneratorUtil.KT_OR_KTS) + model(it, "referenceShortenerWholeFile") } } component("expressionTypeProvider") { test(AbstractExpectedExpressionTypeTest::class) { - model("expectedExpressionType") + model(it, "expectedExpressionType") } test( AbstractHLExpressionTypeTest::class ) { - model("expressionType") + model(it, "expressionType") } test( AbstractDeclarationReturnTypeTest::class ) { - model("declarationReturnType") + model(it, "declarationReturnType") } } component("diagnosticsProvider", filter = analysisSessionModeIs(AnalysisSessionMode.Normal)) { test(AbstractCollectDiagnosticsTest::class) { - model("diagnostics") + model(it, "diagnostics") } - test(AbstractCodeFragmentCollectDiagnosticsTest::class, filter = frontendIs(FrontendKind.Fir)) { + test( + AbstractCodeFragmentCollectDiagnosticsTest::class, + filter = testModuleKindIs(TestModuleKind.Source) and frontendIs(FrontendKind.Fir), + ) { model("codeFragmentDiagnostics", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) } } @@ -291,15 +296,15 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { // for K1, symbols do not have a proper equality implementation, so the tests are failing component("containingDeclarationProvider", filter = frontendIs(FrontendKind.Fir)) { test(AbstractContainingDeclarationProviderByPsiTest::class) { - model("containingDeclarationByPsi") + model(it, "containingDeclarationByPsi") } test(AbstractContainingDeclarationProviderByMemberScopeTest::class) { - model("containingDeclarationFromMemberScope") + model(it, "containingDeclarationFromMemberScope") } test(AbstractContainingDeclarationProviderByDelegatedMemberScopeTest::class) { - model("containingDeclarationByDelegatedMemberScope") + model(it, "containingDeclarationByDelegatedMemberScope") } } @@ -308,109 +313,109 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { AbstractAnalysisApiImportOptimizerTest::class, filter = analysisSessionModeIs(AnalysisSessionMode.Normal), ) { - model("analyseImports", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) + model(it, "analyseImports") } } component("multiplatformInfoProvider") { test(AbstractExpectForActualTest::class) { - model("expectForActual") + model(it, "expectForActual") } } component("psiTypeProvider") { test(AbstractAnalysisApiPsiTypeProviderTest::class) { - model("psiType/forDeclaration") + model(it, "psiType/forDeclaration") } test(AbstractAnalysisApiExpressionPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) { - model("psiType/forExpression") + model(it, "psiType/forExpression") } } component("resolveExtensionInfoProvider", filter = frontendIs(FrontendKind.Fir)) { test(AbstractResolveExtensionInfoProviderTest::class) { - model("extensionScopeWithPsi") + model(it, "extensionScopeWithPsi") } } component("smartCastProvider") { test(AbstractHLSmartCastInfoTest::class) { - model("smartCastInfo") + model(it, "smartCastInfo") } } component("symbolDeclarationOverridesProvider") { test(AbstractOverriddenDeclarationProviderTest::class) { - model("overriddenSymbols") + model(it, "overriddenSymbols") } test(AbstractIsSubclassOfTest::class) { - model("isSubclassOf") + model(it, "isSubclassOf") } } component("symbolDeclarationRenderer") { test(AbstractRendererTest::class) { - model("renderDeclaration") + model(it, "renderDeclaration") } } component("symbolInfoProvider") { test(AbstractAnnotationApplicableTargetsTest::class) { - model("annotationApplicableTargets") + model(it, "annotationApplicableTargets") } } component("typeCreator") { test(AbstractTypeParameterTypeTest::class) { - model("typeParameter") + model(it, "typeParameter") } test(AbstractBuildClassTypeTest::class, filter = analysisSessionModeIs(AnalysisSessionMode.Normal)/*no non-file context element*/) { - model("classType") + model(it, "classType") } } component("typeInfoProvider") { test(AbstractFunctionClassKindTest::class) { - model("functionClassKind") + model(it, "functionClassKind") } test(AbstractAnalysisApiGetSuperTypesTest::class, filter = frontendIs(FrontendKind.Fir)) { - model("superTypes") + model(it, "superTypes") } test(AbstractIsDenotableTest::class) { - model("isDenotable", excludedPattern = ".*\\.descriptors\\.kt$") + model(it, "isDenotable", excludedPattern = ".*\\.descriptors\\.kt$") } } component("typeProvider") { group(filter = analysisSessionModeIs(AnalysisSessionMode.Normal)) { test(AbstractHasCommonSubtypeTest::class) { - model("haveCommonSubtype") + model(it, "haveCommonSubtype") } } test(AbstractTypeReferenceTest::class) { - model("typeReference") + model(it, "typeReference") } } component("signatureSubstitution") { group(filter = analysisSessionModeIs(AnalysisSessionMode.Normal) and frontendIs(FrontendKind.Fir)) { test(AbstractAnalysisApiSymbolAsSignatureTest::class) { - model("symbolAsSignature") + model(it, "symbolAsSignature") } test(AbstractAnalysisApiSymbolSubstitutionTest::class) { - model("symbolSubstitution") + model(it, "symbolSubstitution") } test(AbstractAnalysisApiSignatureSubstitutionTest::class) { - model("signatureSubstitution") + model(it, "signatureSubstitution") } test(AbstractAnalysisApiSignatureContractsTest::class) { - model("signatureContracts") + model(it, "signatureContracts") } } } @@ -418,7 +423,7 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { component("substitutorFactory") { group(filter = analysisSessionModeIs(AnalysisSessionMode.Normal) and frontendIs(FrontendKind.Fir)) { test(AbstractSubstitutorBuilderTest::class) { - model("substitutorBuilder") + model(it, "substitutorBuilder") } } } @@ -426,22 +431,22 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { component("referenceResolveProvider") { test(AbstractIsImplicitCompanionReferenceTest::class) { - model("isImplicitReferenceToCompanion") + model(it, "isImplicitReferenceToCompanion") } } component("scopeProvider") { group(filter = frontendIs(FrontendKind.Fir)) { test(AbstractTypeScopeTest::class) { - model("typeScope") + model(it, "typeScope") } test(AbstractScopeContextForPositionTest::class) { - model("scopeContextForPosition") + model(it, "scopeContextForPosition") } test(AbstractFileImportingScopeContextTest::class) { - model("importingScopeContext") + model(it, "importingScopeContext") } } @@ -450,7 +455,7 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { AbstractSubstitutionOverridesUnwrappingTest::class, filter = frontendIs(FrontendKind.Fir), ) { - model("substitutionOverridesUnwrapping") + model(it, "substitutionOverridesUnwrapping") } test( @@ -459,25 +464,25 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() { ) { when (it.analysisApiMode) { AnalysisApiMode.Ide -> - model("memberScopeByFqName") + model(it, "memberScopeByFqName") AnalysisApiMode.Standalone -> - model("memberScopeByFqName", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) + model(it, "memberScopeByFqName", excludeDirsRecursively = listOf("withTestCompilerPluginEnabled")) } } test(AbstractFileScopeTest::class) { - model("fileScopeTest", extension = "kt") + model(it, "fileScopeTest") } test(AbstractDelegateMemberScopeTest::class) { - model("delegatedMemberScope") + model(it, "delegatedMemberScope") } test( AbstractDeclaredMemberScopeTest::class, filter = frontendIs(FrontendKind.Fir), ) { - model("declaredMemberScope") + model(it, "declaredMemberScope") } } } diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt index 667189b870a..5a73451697f 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/AnalysisApiTestGroup.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * 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. */ @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiMode import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfiguratorFactoryData +import org.jetbrains.kotlin.analysis.test.framework.test.configurators.defaultExtension import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.getDefaultSuiteTestClassName @@ -30,7 +31,6 @@ internal class AnalysisApiTestGroup( generator.suite.init() } - fun test( testClass: KClass<*>, filter: TestFilter = { true }, @@ -53,6 +53,20 @@ internal class AnalysisApiTestGroup( } } +internal fun TestGroup.TestClass.model( + data: AnalysisApiTestConfiguratorFactoryData, + relativeRootPath: String, + excludeDirsRecursively: List = listOf(), + excludedPattern: String? = null, +) { + model( + relativeRootPath = relativeRootPath, + extension = data.defaultExtension(), + excludeDirsRecursively = excludeDirsRecursively, + excludedPattern = excludedPattern, + ) +} + private fun TestGroup.analysisApiTestClass( data: AnalysisApiTestConfiguratorFactoryData, testClass: KClass<*>,