From caddbda01b745049a25e08d63dddd69fd07a6258 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Tue, 25 Jan 2022 16:46:43 +0100 Subject: [PATCH] Analysis API FIR: introduce library resolve tests --- analysis/analysis-api-fir/build.gradle.kts | 4 + ...rySourceReferenceResolveTestGenerated.java | 1284 +++++++++++++++++ ...rSourceReferenceResolveTestGenerated.java} | 2 +- ...raryFrontendApiTestConfiguratorService.kt} | 19 +- ...ibraryModuleRegistrarPreAnalysisHandler.kt | 46 + ...ourceFrontendApiTestConfiguratorService.kt | 39 + ...SourceModuleRegistrarPreAnalysisHandler.kt | 82 ++ .../barebone/test/AbstractFrontendApiTest.kt | 8 +- .../impl/barebone/test/SkipTestException.kt | 8 + .../impl/barebone/test/TestKtSourceModule.kt | 13 + .../base/test/AbstractReferenceResolveTest.kt | 9 +- .../libraries/CompiledLibraryProvider.kt | 34 + .../test/utils/libraries}/CompilerExecutor.kt | 16 +- .../LibraryEnvironmentConfigurator.kt | 19 + .../test/utils/libraries/TestLibraryUtils.kt | 32 + .../utils/libraries/TestModuleCompiler.kt | 57 + .../AbstractSymbolLightClassesTestBase.kt | 2 +- ...ibraryModuleRegistrarPreAnalysisHandler.kt | 79 - ...braryFrontendApiTestConfiguratorService.kt | 39 + .../tests/analysis/api/analysisApi.kt | 3 + .../dsl/FrontendConfiguratorTestGenerator.kt | 13 +- .../generators/tests/analysis/api/dsl/dsl.kt | 104 +- 22 files changed, 1784 insertions(+), 128 deletions(-) create mode 100644 analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirLibrarySourceReferenceResolveTestGenerated.java rename analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/{FirReferenceResolveTestGenerated.java => FirSourceReferenceResolveTestGenerated.java} (99%) rename analysis/{symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesrFrontendApiTestConfiguratorService.kt => analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryFrontendApiTestConfiguratorService.kt} (78%) create mode 100644 analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryModuleRegistrarPreAnalysisHandler.kt create mode 100644 analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceFrontendApiTestConfiguratorService.kt create mode 100644 analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceModuleRegistrarPreAnalysisHandler.kt create mode 100644 analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/SkipTestException.kt create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompiledLibraryProvider.kt rename analysis/{symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service => analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries}/CompilerExecutor.kt (82%) create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/LibraryEnvironmentConfigurator.kt create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestLibraryUtils.kt create mode 100644 analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestModuleCompiler.kt delete mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/LibraryModuleRegistrarPreAnalysisHandler.kt create mode 100644 analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesForLibraryFrontendApiTestConfiguratorService.kt diff --git a/analysis/analysis-api-fir/build.gradle.kts b/analysis/analysis-api-fir/build.gradle.kts index 0976a6d64b8..88d570aa4d7 100644 --- a/analysis/analysis-api-fir/build.gradle.kts +++ b/analysis/analysis-api-fir/build.gradle.kts @@ -29,7 +29,11 @@ dependencies { testApi(projectTests(":compiler:tests-common-new")) testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests")) testApi(projectTests(":analysis:analysis-api-impl-base")) + testApi(projectTests(":analysis:decompiled:decompiler-to-file-stubs")) + testApi(project(":analysis:decompiled:decompiler-to-file-stubs")) + testApi(project(":analysis:decompiled:decompiler-to-psi")) testApi(project(":kotlin-test:kotlin-test-junit")) + testApi(toolsJar()) testApiJUnit5() testApi(project(":analysis:symbol-light-classes")) diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirLibrarySourceReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirLibrarySourceReferenceResolveTestGenerated.java new file mode 100644 index 00000000000..a5c094faccd --- /dev/null +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirLibrarySourceReferenceResolveTestGenerated.java @@ -0,0 +1,1284 @@ +/* + * Copyright 2010-2021 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.analysis.api.fir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService; +import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.source.LibrarySourceFrontendApiTestConfiguratorService; +import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest; +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 GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("analysis/analysis-api/testData/referenceResolve") +@TestDataPath("$PROJECT_ROOT") +public class FirLibrarySourceReferenceResolveTestGenerated extends AbstractReferenceResolveTest { + @NotNull + @Override + public FrontendApiTestConfiguratorService getConfigurator() { + return LibrarySourceFrontendApiTestConfiguratorService.INSTANCE; + } + + @Test + public void testAllFilesPresentInReferenceResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("AnnotationForClass.kt") + public void testAnnotationForClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationForClass.kt"); + } + + @Test + @TestMetadata("AnnotationInsideFunction.kt") + public void testAnnotationInsideFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationInsideFunction.kt"); + } + + @Test + @TestMetadata("AnnotationOnFile.kt") + public void testAnnotationOnFile() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationOnFile.kt"); + } + + @Test + @TestMetadata("AnnotationOnFileWithImport.kt") + public void testAnnotationOnFileWithImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationOnFileWithImport.kt"); + } + + @Test + @TestMetadata("AnnotationParameter.kt") + public void testAnnotationParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationParameter.kt"); + } + + @Test + @TestMetadata("AnnotationTypeParameter.kt") + public void testAnnotationTypeParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/AnnotationTypeParameter.kt"); + } + + @Test + @TestMetadata("ClassInTypeConstraint.kt") + public void testClassInTypeConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassInTypeConstraint.kt"); + } + + @Test + @TestMetadata("ClassNameBeforeDot.kt") + public void testClassNameBeforeDot() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassNameBeforeDot.kt"); + } + + @Test + @TestMetadata("ClassObjectClassLiteralReference.kt") + public void testClassObjectClassLiteralReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassObjectClassLiteralReference.kt"); + } + + @Test + @TestMetadata("ClassObjectClassLiteralReferenceWithField.kt") + public void testClassObjectClassLiteralReferenceWithField() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassObjectClassLiteralReferenceWithField.kt"); + } + + @Test + @TestMetadata("ClassQualifierForNestedClassConstructorCall.kt") + public void testClassQualifierForNestedClassConstructorCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassQualifierForNestedClassConstructorCall.kt"); + } + + @Test + @TestMetadata("ClassReferenceInImport.kt") + public void testClassReferenceInImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ClassReferenceInImport.kt"); + } + + @Test + @TestMetadata("CollectionLiteralLeft.kt") + public void testCollectionLiteralLeft() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/CollectionLiteralLeft.kt"); + } + + @Test + @TestMetadata("CollectionLiteralRight.kt") + public void testCollectionLiteralRight() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/CollectionLiteralRight.kt"); + } + + @Test + @TestMetadata("CoroutineSuspensionPoint.kt") + public void testCoroutineSuspensionPoint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/CoroutineSuspensionPoint.kt"); + } + + @Test + @TestMetadata("CtrlClickResolve.kt") + public void testCtrlClickResolve() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/CtrlClickResolve.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsExtensionReceiverForFunction.kt") + public void testDefaultObjectAsExtensionReceiverForFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsExtensionReceiverForFunction.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsExtensionReceiverForProperty.kt") + public void testDefaultObjectAsExtensionReceiverForProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsExtensionReceiverForProperty.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt") + public void testDefaultObjectAsReceiverForExtensionFunctionOnSuperType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsReceiverForExtensionFunctionOnSuperType.kt"); + } + + @Test + @TestMetadata("DefaultObjectAsReceiverForMemberPropertyInSuperType.kt") + public void testDefaultObjectAsReceiverForMemberPropertyInSuperType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectAsReceiverForMemberPropertyInSuperType.kt"); + } + + @Test + @TestMetadata("DefaultObjectInShortReferenceFormCall.kt") + public void testDefaultObjectInShortReferenceFormCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DefaultObjectInShortReferenceFormCall.kt"); + } + + @Test + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/Deprecated.kt"); + } + + @Test + @TestMetadata("DeprecatedHidden.kt") + public void testDeprecatedHidden() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/DeprecatedHidden.kt"); + } + + @Test + @TestMetadata("EnumValues.kt") + public void testEnumValues() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/EnumValues.kt"); + } + + @Test + @TestMetadata("ExternalCompanionObject.kt") + public void testExternalCompanionObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ExternalCompanionObject.kt"); + } + + @Test + @TestMetadata("FakeJavaLang1.kt") + public void testFakeJavaLang1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/FakeJavaLang1.kt"); + } + + @Test + @TestMetadata("FakeJavaLang2.kt") + public void testFakeJavaLang2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/FakeJavaLang2.kt"); + } + + @Test + @TestMetadata("FakeJavaLang3.kt") + public void testFakeJavaLang3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/FakeJavaLang3.kt"); + } + + @Test + @TestMetadata("FakeJavaLang4.kt") + public void testFakeJavaLang4() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/FakeJavaLang4.kt"); + } + + @Test + @TestMetadata("functionCall.kt") + public void testFunctionCall() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/functionCall.kt"); + } + + @Test + @TestMetadata("GenericFunctionParameter.kt") + public void testGenericFunctionParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/GenericFunctionParameter.kt"); + } + + @Test + @TestMetadata("GenericTypeInFunctionParameter.kt") + public void testGenericTypeInFunctionParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/GenericTypeInFunctionParameter.kt"); + } + + @Test + @TestMetadata("implicitExtensionInvoke.kt") + public void testImplicitExtensionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitExtensionInvoke.kt"); + } + + @Test + @TestMetadata("implicitFunctionInvoke.kt") + public void testImplicitFunctionInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitFunctionInvoke.kt"); + } + + @Test + @TestMetadata("implicitFunctionalInterfaceInvoke.kt") + public void testImplicitFunctionalInterfaceInvoke() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/implicitFunctionalInterfaceInvoke.kt"); + } + + @Test + @TestMetadata("ImportFromRootScope.kt") + public void testImportFromRootScope() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ImportFromRootScope.kt"); + } + + @Test + @TestMetadata("InClassParameter.kt") + public void testInClassParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InClassParameter.kt"); + } + + @Test + @TestMetadata("InClassParameterField.kt") + public void testInClassParameterField() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InClassParameterField.kt"); + } + + @Test + @TestMetadata("InEnumEntry.kt") + public void testInEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InEnumEntry.kt"); + } + + @Test + @TestMetadata("InFunctionParameterType.kt") + public void testInFunctionParameterType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InFunctionParameterType.kt"); + } + + @Test + @TestMetadata("InMethodParameter.kt") + public void testInMethodParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InMethodParameter.kt"); + } + + @Test + @TestMetadata("InMethodVarargParameter.kt") + public void testInMethodVarargParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InMethodVarargParameter.kt"); + } + + @Test + @TestMetadata("InObjectClassObject.kt") + public void testInObjectClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InObjectClassObject.kt"); + } + + @Test + @TestMetadata("InSecondClassObject.kt") + public void testInSecondClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InSecondClassObject.kt"); + } + + @Test + @TestMetadata("InVaragReferenceInFunctionBody.kt") + public void testInVaragReferenceInFunctionBody() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InVaragReferenceInFunctionBody.kt"); + } + + @Test + @TestMetadata("InVaragReferenceInNamedParameter.kt") + public void testInVaragReferenceInNamedParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InVaragReferenceInNamedParameter.kt"); + } + + @Test + @TestMetadata("InvisibleMember.kt") + public void testInvisibleMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/InvisibleMember.kt"); + } + + @Test + @TestMetadata("JavaAnnotationParameter.kt") + public void testJavaAnnotationParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaAnnotationParameter.kt"); + } + + @Test + @TestMetadata("JavaConstructorNotNullParameter.kt") + public void testJavaConstructorNotNullParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaConstructorNotNullParameter.kt"); + } + + @Test + @TestMetadata("JavaEnumEntry.kt") + public void testJavaEnumEntry() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaEnumEntry.kt"); + } + + @Test + @TestMetadata("JavaEnumValueOf.kt") + public void testJavaEnumValueOf() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaEnumValueOf.kt"); + } + + @Test + @TestMetadata("JavaReference.kt") + public void testJavaReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/JavaReference.kt"); + } + + @Test + @TestMetadata("KotlinPropertyAssignment.kt") + public void testKotlinPropertyAssignment() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/KotlinPropertyAssignment.kt"); + } + + @Test + @TestMetadata("KotlinPropertyWithGetterAndSetterAssignment.kt") + public void testKotlinPropertyWithGetterAndSetterAssignment() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/KotlinPropertyWithGetterAndSetterAssignment.kt"); + } + + @Test + @TestMetadata("MultiDeclarationExtension.kt") + public void testMultiDeclarationExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/MultiDeclarationExtension.kt"); + } + + @Test + @TestMetadata("MultiDeclarationMember.kt") + public void testMultiDeclarationMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/MultiDeclarationMember.kt"); + } + + @Test + @TestMetadata("NamedClassObject.kt") + public void testNamedClassObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/NamedClassObject.kt"); + } + + @Test + @TestMetadata("PackageReference.kt") + public void testPackageReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PackageReference.kt"); + } + + @Test + @TestMetadata("PackageReferenceInImport.kt") + public void testPackageReferenceInImport() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PackageReferenceInImport.kt"); + } + + @Test + @TestMetadata("parameterByName.kt") + public void testParameterByName() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/parameterByName.kt"); + } + + @Test + @TestMetadata("PropertyPlaceInClassObjectInObject.kt") + public void testPropertyPlaceInClassObjectInObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/PropertyPlaceInClassObjectInObject.kt"); + } + + @Test + @TestMetadata("ReferenceInClassWhereConstraint.kt") + public void testReferenceInClassWhereConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceInClassWhereConstraint.kt"); + } + + @Test + @TestMetadata("ReferenceInFunWhereConstraint.kt") + public void testReferenceInFunWhereConstraint() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceInFunWhereConstraint.kt"); + } + + @Test + @TestMetadata("ReferenceToSam.kt") + public void testReferenceToSam() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ReferenceToSam.kt"); + } + + @Test + @TestMetadata("ResolveClass.kt") + public void testResolveClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolveClass.kt"); + } + + @Test + @TestMetadata("ResolveClassNameInCallExpression.kt") + public void testResolveClassNameInCallExpression() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolveClassNameInCallExpression.kt"); + } + + @Test + @TestMetadata("ResolvePackageInProperty.kt") + public void testResolvePackageInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheEndInProperty.kt") + public void testResolvePackageInTheEndInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheEndInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheMiddleInProperty.kt") + public void testResolvePackageInTheMiddleInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheMiddleInProperty.kt"); + } + + @Test + @TestMetadata("ResolvePackageInTheTypeNameInProperty.kt") + public void testResolvePackageInTheTypeNameInProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ResolvePackageInTheTypeNameInProperty.kt"); + } + + @Test + @TestMetadata("RetentionValue.kt") + public void testRetentionValue() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/RetentionValue.kt"); + } + + @Test + @TestMetadata("SamAdapter.kt") + public void testSamAdapter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamAdapter.kt"); + } + + @Test + @TestMetadata("SamConstructor.kt") + public void testSamConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamConstructor.kt"); + } + + @Test + @TestMetadata("SamConstructorTypeArguments.kt") + public void testSamConstructorTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SamConstructorTypeArguments.kt"); + } + + @Test + @TestMetadata("SeveralOverrides.kt") + public void testSeveralOverrides() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SeveralOverrides.kt"); + } + + @Test + @TestMetadata("superWithLabel_caretAtLabel.kt") + public void testSuperWithLabel_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/superWithLabel_caretAtLabel.kt"); + } + + @Test + @TestMetadata("superWithLabel_caretAtSuper.kt") + public void testSuperWithLabel_caretAtSuper() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/superWithLabel_caretAtSuper.kt"); + } + + @Test + @TestMetadata("SyntheticProperty.kt") + public void testSyntheticProperty() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/SyntheticProperty.kt"); + } + + @Test + @TestMetadata("thisWithLabelToFunction_caretAtLabel.kt") + public void testThisWithLabelToFunction_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToFunction_caretAtLabel.kt"); + } + + @Test + @TestMetadata("thisWithLabelToFunction_caretAtThis.kt") + public void testThisWithLabelToFunction_caretAtThis() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToFunction_caretAtThis.kt"); + } + + @Test + @TestMetadata("thisWithLabelToProperty_caretAtLabel.kt") + public void testThisWithLabelToProperty_caretAtLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToProperty_caretAtLabel.kt"); + } + + @Test + @TestMetadata("thisWithLabelToProperty_caretAtThis.kt") + public void testThisWithLabelToProperty_caretAtThis() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/thisWithLabelToProperty_caretAtThis.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassConstructor.kt") + public void testTopLevelClassVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelClassVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassConstructor2.kt") + public void testTopLevelClassVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelClassVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsLocalClassQualifier.kt") + public void testTopLevelClassVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelClassVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassConstructor.kt") + public void testTopLevelCompanionObjectVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassConstructor2.kt") + public void testTopLevelCompanionObjectVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelCompanionObjectVsLocalClassQualifier.kt") + public void testTopLevelCompanionObjectVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelCompanionObjectVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor.kt") + public void testTopLevelObjectVsLocalClassConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor2.kt") + public void testTopLevelObjectVsLocalClassConstructor2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor2.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassConstructor3.kt") + public void testTopLevelObjectVsLocalClassConstructor3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassConstructor3.kt"); + } + + @Test + @TestMetadata("TopLevelObjectVsLocalClassQualifier.kt") + public void testTopLevelObjectVsLocalClassQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TopLevelObjectVsLocalClassQualifier.kt"); + } + + @Test + @TestMetadata("TypeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAlias.kt"); + } + + @Test + @TestMetadata("TypeAliasAsSupertypeConstructor.kt") + public void testTypeAliasAsSupertypeConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAliasAsSupertypeConstructor.kt"); + } + + @Test + @TestMetadata("TypeAliasRHS.kt") + public void testTypeAliasRHS() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeAliasRHS.kt"); + } + + @Test + @TestMetadata("TypeArgumentBeforeDot.kt") + public void testTypeArgumentBeforeDot() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot.kt"); + } + + @Test + @TestMetadata("TypeArgumentBeforeDot2.kt") + public void testTypeArgumentBeforeDot2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentBeforeDot2.kt"); + } + + @Test + @TestMetadata("TypeArgumentUnresolvedClass.kt") + public void testTypeArgumentUnresolvedClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentUnresolvedClass.kt"); + } + + @Test + @TestMetadata("TypeArgumentUnresolvedConstructor.kt") + public void testTypeArgumentUnresolvedConstructor() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentUnresolvedConstructor.kt"); + } + + @Test + @TestMetadata("TypeArgumentWrongNumber.kt") + public void testTypeArgumentWrongNumber() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/TypeArgumentWrongNumber.kt"); + } + + @Test + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/ValueParameter.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments.kt") + public void testWrongNumberOfTypeArguments() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/WrongNumberOfTypeArguments.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments2.kt") + public void testWrongNumberOfTypeArguments2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/WrongNumberOfTypeArguments2.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments3.kt") + public void testWrongNumberOfTypeArguments3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/WrongNumberOfTypeArguments3.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArguments4.kt") + public void testWrongNumberOfTypeArguments4() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/WrongNumberOfTypeArguments4.kt"); + } + + @Test + @TestMetadata("WrongNumberOfTypeArgumentsInSupertype.kt") + public void testWrongNumberOfTypeArgumentsInSupertype() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/WrongNumberOfTypeArgumentsInSupertype.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/arrayAccess") + @TestDataPath("$PROJECT_ROOT") + public class ArrayAccess { + @Test + public void testAllFilesPresentInArrayAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("get.kt") + public void testGet() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/get.kt"); + } + + @Test + @TestMetadata("getFunction.kt") + public void testGetFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/getFunction.kt"); + } + + @Test + @TestMetadata("getOperator.kt") + public void testGetOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/getOperator.kt"); + } + + @Test + @TestMetadata("set.kt") + public void testSet() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/set.kt"); + } + + @Test + @TestMetadata("setFunction.kt") + public void testSetFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/setFunction.kt"); + } + + @Test + @TestMetadata("setOperator.kt") + public void testSetOperator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/arrayAccess/setOperator.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorDelegatingReference { + @Test + public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("toPrimary.kt") + public void testToPrimary() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference/toPrimary.kt"); + } + + @Test + @TestMetadata("toSecondary.kt") + public void testToSecondary() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/constructorDelegatingReference/toSecondary.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedPropertyAccessors { + @Test + public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("unresolved.kt") + public void testUnresolved() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/unresolved.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("getExtension.kt") + public void testGetExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getExtension.kt"); + } + + @Test + @TestMetadata("getMember.kt") + public void testGetMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getMember.kt"); + } + + @Test + @TestMetadata("getMultipleDeclarations.kt") + public void testGetMultipleDeclarations() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getMultipleDeclarations.kt"); + } + + @Test + @TestMetadata("getOneFakeOverride.kt") + public void testGetOneFakeOverride() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inSource/getOneFakeOverride.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InStandardLibrary { + @Test + public void testAllFilesPresentInInStandardLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lazy.kt") + public void testLazy() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary/lazy.kt"); + } + + @Test + @TestMetadata("notNull.kt") + public void testNotNull() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/delegatedPropertyAccessors/inStandardLibrary/notNull.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn") + @TestDataPath("$PROJECT_ROOT") + public class ForLoopIn { + @Test + public void testAllFilesPresentInForLoopIn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("unresolvedIterator.kt") + public void testUnresolvedIterator() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/unresolvedIterator.kt"); + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns") + @TestDataPath("$PROJECT_ROOT") + public class InBuiltIns { + @Test + public void testAllFilesPresentInInBuiltIns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns/extension.kt"); + } + + @Test + @TestMetadata("member.kt") + public void testMember() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inBuiltIns/member.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary") + @TestDataPath("$PROJECT_ROOT") + public class InLibrary { + @Test + public void testAllFilesPresentInInLibrary() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inLibrary/extension.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource") + @TestDataPath("$PROJECT_ROOT") + public class InSource { + @Test + @TestMetadata("allExtensions.kt") + public void testAllExtensions() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/allExtensions.kt"); + } + + @Test + public void testAllFilesPresentInInSource() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("allMembers.kt") + public void testAllMembers() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/allMembers.kt"); + } + + @Test + @TestMetadata("nextMissing.kt") + public void testNextMissing() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/forLoopIn/inSource/nextMissing.kt"); + } + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/inImport") + @TestDataPath("$PROJECT_ROOT") + public class InImport { + @Test + public void testAllFilesPresentInInImport() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/inImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("javaClass.kt") + public void testJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaClass.kt"); + } + + @Test + @TestMetadata("javaPackageFirstQualifier.kt") + public void testJavaPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("javaPackageSecondQualifier.kt") + public void testJavaPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/javaPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinClass.kt") + public void testKotlinClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinClass.kt"); + } + + @Test + @TestMetadata("kotlinPackageFirstQualifier.kt") + public void testKotlinPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageSecondQualifier.kt") + public void testKotlinPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinTopLevelFunction.kt") + public void testKotlinTopLevelFunction() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/kotlinTopLevelFunction.kt"); + } + + @Test + @TestMetadata("staticMethodFromJavaClass.kt") + public void testStaticMethodFromJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/staticMethodFromJavaClass.kt"); + } + + @Test + @TestMetadata("staticMethodFromJavaClassJavaClass.kt") + public void testStaticMethodFromJavaClassJavaClass() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/inImport/staticMethodFromJavaClassJavaClass.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("lambdaAndParens.kt") + public void testLambdaAndParens() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaAndParens.kt"); + } + + @Test + @TestMetadata("lambdaAndParensIncorrectVararg.kt") + public void testLambdaAndParensIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaAndParensIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoPar.kt") + public void testLambdaNoPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoPar.kt"); + } + + @Test + @TestMetadata("lambdaNoParIncorrectVararg.kt") + public void testLambdaNoParIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoParLabel.kt") + public void testLambdaNoParLabel() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParLabel.kt"); + } + + @Test + @TestMetadata("lambdaNoParLabelIncorrectVararg.kt") + public void testLambdaNoParLabelIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParLabelIncorrectVararg.kt"); + } + + @Test + @TestMetadata("lambdaNoParRCurly.kt") + public void testLambdaNoParRCurly() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParRCurly.kt"); + } + + @Test + @TestMetadata("lambdaNoParRCurlyIncorrectVararg.kt") + public void testLambdaNoParRCurlyIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/lambdaNoParRCurlyIncorrectVararg.kt"); + } + + @Test + @TestMetadata("noParams.kt") + public void testNoParams() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/noParams.kt"); + } + + @Test + @TestMetadata("noParamsRPar.kt") + public void testNoParamsRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/noParamsRPar.kt"); + } + + @Test + @TestMetadata("nonemptyLambdaRPar.kt") + public void testNonemptyLambdaRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/nonemptyLambdaRPar.kt"); + } + + @Test + @TestMetadata("nonemptyLambdaRParIncorrectVararg.kt") + public void testNonemptyLambdaRParIncorrectVararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/nonemptyLambdaRParIncorrectVararg.kt"); + } + + @Test + @TestMetadata("oneParam.kt") + public void testOneParam() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/oneParam.kt"); + } + + @Test + @TestMetadata("oneParamRPar.kt") + public void testOneParamRPar() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/invoke/oneParamRPar.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/nestedTypes") + @TestDataPath("$PROJECT_ROOT") + public class NestedTypes { + @Test + public void testAllFilesPresentInNestedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("ResolveCompanionInCompanionType.kt") + public void testResolveCompanionInCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveCompanionInCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveEndOfPackageInType.kt") + public void testResolveEndOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveEndOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveMiddleOfPackageInType.kt") + public void testResolveMiddleOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveMiddleOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveNamedCompanionInCompanionType.kt") + public void testResolveNamedCompanionInCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveNamedCompanionInCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveStartOfPackageInType.kt") + public void testResolveStartOfPackageInType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveStartOfPackageInType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheEndOfType.kt") + public void testResolveTypeInTheEndOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheEndOfType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfCompanionType.kt") + public void testResolveTypeInTheMiddleOfCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfFunctionalType.kt") + public void testResolveTypeInTheMiddleOfFunctionalType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfFunctionalType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfNullableType.kt") + public void testResolveTypeInTheMiddleOfNullableType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfNullableType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheMiddleOfType.kt") + public void testResolveTypeInTheMiddleOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheMiddleOfType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheStartOfCompanionType.kt") + public void testResolveTypeInTheStartOfCompanionType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheStartOfCompanionType.kt"); + } + + @Test + @TestMetadata("ResolveTypeInTheStartOfType.kt") + public void testResolveTypeInTheStartOfType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/nestedTypes/ResolveTypeInTheStartOfType.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/packageReference") + @TestDataPath("$PROJECT_ROOT") + public class PackageReference { + @Test + public void testAllFilesPresentInPackageReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/packageReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("javaPackageFirstQualifier.kt") + public void testJavaPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/javaPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("javaPackageSecondQualifier.kt") + public void testJavaPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/javaPackageSecondQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageFirstQualifier.kt") + public void testKotlinPackageFirstQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/kotlinPackageFirstQualifier.kt"); + } + + @Test + @TestMetadata("kotlinPackageSecondQualifier.kt") + public void testKotlinPackageSecondQualifier() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/packageReference/kotlinPackageSecondQualifier.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/qualifiedAccess") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedAccess { + @Test + public void testAllFilesPresentInQualifiedAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/qualifiedAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("callableReference1.kt") + public void testCallableReference1() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference1.kt"); + } + + @Test + @TestMetadata("callableReference2.kt") + public void testCallableReference2() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference2.kt"); + } + + @Test + @TestMetadata("callableReference3.kt") + public void testCallableReference3() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/callableReference3.kt"); + } + + @Test + @TestMetadata("nullSafeCallExpression.kt") + public void testNullSafeCallExpression() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/nullSafeCallExpression.kt"); + } + + @Test + @TestMetadata("ResolveFirstPackageOfFullyQualifiedReference.kt") + public void testResolveFirstPackageOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveFirstPackageOfFullyQualifiedReference.kt"); + } + + @Test + @TestMetadata("ResolveFullyQualifiedCompanionObject.kt") + public void testResolveFullyQualifiedCompanionObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveFullyQualifiedCompanionObject.kt"); + } + + @Test + @TestMetadata("ResolveOuterClassOfFullyQualifiedReference.kt") + public void testResolveOuterClassOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolveOuterClassOfFullyQualifiedReference.kt"); + } + + @Test + @TestMetadata("ResolvePackageOfFullyQualifiedReference.kt") + public void testResolvePackageOfFullyQualifiedReference() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/qualifiedAccess/ResolvePackageOfFullyQualifiedReference.kt"); + } + } + + @Nested + @TestMetadata("analysis/analysis-api/testData/referenceResolve/typeParameter") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameter { + @Test + public void testAllFilesPresentInTypeParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve/typeParameter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + } + + @Test + @TestMetadata("multipleBounds.kt") + public void testMultipleBounds() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/multipleBounds.kt"); + } + + @Test + @TestMetadata("reified_argumentInFunctionalType.kt") + public void testReified_argumentInFunctionalType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_argumentInFunctionalType.kt"); + } + + @Test + @TestMetadata("reified_extensionReceiver.kt") + public void testReified_extensionReceiver() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_extensionReceiver.kt"); + } + + @Test + @TestMetadata("reified_returnType.kt") + public void testReified_returnType() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_returnType.kt"); + } + + @Test + @TestMetadata("reified_valueParameter.kt") + public void testReified_valueParameter() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_valueParameter.kt"); + } + + @Test + @TestMetadata("reified_valueParameter_vararg.kt") + public void testReified_valueParameter_vararg() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/reified_valueParameter_vararg.kt"); + } + + @Test + @TestMetadata("TypeParameterInAnonymousObject.kt") + public void testTypeParameterInAnonymousObject() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/TypeParameterInAnonymousObject.kt"); + } + + @Test + @TestMetadata("TypeParameterInFunctionLiteral.kt") + public void testTypeParameterInFunctionLiteral() throws Exception { + runTest("analysis/analysis-api/testData/referenceResolve/typeParameter/TypeParameterInFunctionLiteral.kt"); + } + } +} diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirReferenceResolveTestGenerated.java b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirSourceReferenceResolveTestGenerated.java similarity index 99% rename from analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirReferenceResolveTestGenerated.java rename to analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirSourceReferenceResolveTestGenerated.java index c1c0b5aec29..c051b81f6ea 100644 --- a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirReferenceResolveTestGenerated.java +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirSourceReferenceResolveTestGenerated.java @@ -22,7 +22,7 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("analysis/analysis-api/testData/referenceResolve") @TestDataPath("$PROJECT_ROOT") -public class FirReferenceResolveTestGenerated extends AbstractReferenceResolveTest { +public class FirSourceReferenceResolveTestGenerated extends AbstractReferenceResolveTest { @NotNull @Override public FrontendApiTestConfiguratorService getConfigurator() { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesrFrontendApiTestConfiguratorService.kt b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryFrontendApiTestConfiguratorService.kt similarity index 78% rename from analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesrFrontendApiTestConfiguratorService.kt rename to analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryFrontendApiTestConfiguratorService.kt index 0fbe20191b9..dc8862676e9 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesrFrontendApiTestConfiguratorService.kt +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryFrontendApiTestConfiguratorService.kt @@ -3,7 +3,7 @@ * 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.service +package org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary import com.intellij.ide.highlighter.JavaClassFileType import com.intellij.mock.MockApplication @@ -15,7 +15,7 @@ import com.intellij.psi.FileTypeFileViewProviders import com.intellij.psi.compiled.ClassFileDecompilers import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService -import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.LibraryEnvironmentConfigurator import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInDecompiler import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinClassFileDecompiler import org.jetbrains.kotlin.analysis.decompiler.stub.file.ClsKotlinBinaryClassCache @@ -24,13 +24,15 @@ import org.jetbrains.kotlin.analysis.decompiler.stub.files.DummyFileAttributeSer import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder -object SymbolLightClassesForLibraryFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService { +object LibraryFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService { + override val allowDependedAnalysisSession: Boolean get() = false + override fun TestConfigurationBuilder.configureTest(disposable: Disposable) { + useConfigurators(::LibraryEnvironmentConfigurator) usePreAnalysisHandlers(::LibraryModuleRegistrarPreAnalysisHandler) } override fun registerProjectServices(project: MockProject) { - project.registerService(ClsJavaStubByVirtualFileCache::class.java) } @@ -39,14 +41,17 @@ object SymbolLightClassesForLibraryFrontendApiTestConfiguratorService : Frontend if (application.getServiceIfCreated(ClsKotlinBinaryClassCache::class.java) != null) return application.registerService(ClsKotlinBinaryClassCache::class.java) application.registerService(FileAttributeService::class.java, DummyFileAttributeService) + FileTypeFileViewProviders.INSTANCE.addExplicitExtension( JavaClassFileType.INSTANCE, ClassFileViewProviderFactory() ) + @Suppress("DEPRECATION") - ClassFileDecompilers.getInstance().EP_NAME.point.registerExtension(KotlinClassFileDecompiler(), LoadingOrder.FIRST) - @Suppress("DEPRECATION") - ClassFileDecompilers.getInstance().EP_NAME.point.registerExtension(KotlinBuiltInDecompiler(), LoadingOrder.FIRST) + ClassFileDecompilers.getInstance().EP_NAME.point.apply { + registerExtension(KotlinClassFileDecompiler(), LoadingOrder.FIRST) + registerExtension(KotlinBuiltInDecompiler(), LoadingOrder.FIRST) + } } override fun doOutOfBlockModification(file: KtFile) { diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryModuleRegistrarPreAnalysisHandler.kt b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryModuleRegistrarPreAnalysisHandler.kt new file mode 100644 index 00000000000..f3e216633e3 --- /dev/null +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryModuleRegistrarPreAnalysisHandler.kt @@ -0,0 +1,46 @@ +/* + * 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.analysis.api.fir.utils.libraries.binary + +import com.intellij.mock.MockProject +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiManager +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.TestKtLibraryModule +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.TestLibraryUtils +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.compiledLibraryProvider +import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.PreAnalysisHandler +import org.jetbrains.kotlin.test.services.TestModuleStructure +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider + + +class LibraryModuleRegistrarPreAnalysisHandler( + testServices: TestServices +) : PreAnalysisHandler(testServices) { + private val moduleInfoProvider = testServices.projectModuleProvider + + override fun preprocessModuleStructure(moduleStructure: TestModuleStructure) { + val testModule = moduleStructure.modules.single() + val project = testServices.compilerConfigurationProvider.getProject(testModule) + val decompiledKtFiles = getDecompiledVirtualFilesFromLibrary(testModule, project) + + moduleInfoProvider.registerModuleInfo(testModule, TestKtLibraryModule(project, testModule, decompiledKtFiles, testServices)) + (project as MockProject).registerTestServices(testModule, decompiledKtFiles, testServices) + } + + private fun getDecompiledVirtualFilesFromLibrary(module: TestModule, project: Project): List { + val library = testServices.compiledLibraryProvider.getCompiledLibrary(module).jar + + val virtualFiles = TestLibraryUtils.getAllVirtualFilesFromJar(library) + return virtualFiles.mapNotNull { virtualFile -> + PsiManager.getInstance(project).findFile(virtualFile) as? KtClsFile + } + } +} diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceFrontendApiTestConfiguratorService.kt b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceFrontendApiTestConfiguratorService.kt new file mode 100644 index 00000000000..c0f4d0f94ba --- /dev/null +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceFrontendApiTestConfiguratorService.kt @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2021 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.analysis.api.fir.utils.libraries.source + +import com.intellij.mock.MockApplication +import com.intellij.mock.MockProject +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.CompiledLibraryProvider +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.LibraryEnvironmentConfigurator +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.services.ServiceRegistrationData + +object LibrarySourceFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService { + override val allowDependedAnalysisSession: Boolean get() = false + + override fun TestConfigurationBuilder.configureTest(disposable: Disposable) { + useConfigurators(::LibraryEnvironmentConfigurator) + usePreAnalysisHandlers(::LibrarySourceModuleRegistrarPreAnalysisHandler) + useAdditionalServices(ServiceRegistrationData(CompiledLibraryProvider::class, ::CompiledLibraryProvider)) + } + + override fun registerProjectServices(project: MockProject) { + } + + + override fun registerApplicationServices(application: MockApplication) { + FirFrontendApiTestConfiguratorService.registerApplicationServices(application) + } + + override fun doOutOfBlockModification(file: KtFile) { + FirFrontendApiTestConfiguratorService.doOutOfBlockModification(file) + } +} diff --git a/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceModuleRegistrarPreAnalysisHandler.kt b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceModuleRegistrarPreAnalysisHandler.kt new file mode 100644 index 00000000000..fd8e7fba57c --- /dev/null +++ b/analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceModuleRegistrarPreAnalysisHandler.kt @@ -0,0 +1,82 @@ +/* + * 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.analysis.api.fir.utils.libraries.source + +import com.intellij.mock.MockProject +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiManager +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.TestKtLibrarySourceModule +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.TestLibraryUtils +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.compiledLibraryProvider +import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices +import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule +import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule +import org.jetbrains.kotlin.analysis.project.structure.KtModule +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices +import org.jetbrains.kotlin.test.frontend.fir.getAnalyzerServices +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.PreAnalysisHandler +import org.jetbrains.kotlin.test.services.TestModuleStructure +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider +import java.nio.file.Path + + +class LibrarySourceModuleRegistrarPreAnalysisHandler( + testServices: TestServices +) : PreAnalysisHandler(testServices) { + private val moduleInfoProvider = testServices.projectModuleProvider + + override fun preprocessModuleStructure(moduleStructure: TestModuleStructure) { + val testModule = moduleStructure.modules.single() + val project = testServices.compilerConfigurationProvider.getProject(testModule) + val (libraryJar, librarySourcesJar) = testServices.compiledLibraryProvider.getCompiledLibrary(testModule) + + val libraryKtModule = KtTestLibraryModule(project, testModule, libraryJar) + + val librarySourceKtFiles = TestLibraryUtils + .getAllVirtualFilesFromJar(librarySourcesJar) + .mapNotNull { PsiManager.getInstance(project).findFile(it) as? KtFile } + + val sourcesKtModule = TestKtLibrarySourceModule( + project, + testModule, + librarySourceKtFiles.toSet(), + testServices, + libraryKtModule + ) + libraryKtModule.librarySources = sourcesKtModule + + moduleInfoProvider.registerModuleInfo(testModule, sourcesKtModule) + (project as MockProject).registerTestServices(testModule, librarySourceKtFiles, testServices) + } +} + +private class KtTestLibraryModule( + override val project: Project, + private val testModule: TestModule, + private val jar: Path +) : KtLibraryModule { + override val directRegularDependencies: List get() = emptyList() + override val directRefinementDependencies: List get() = emptyList() + override val directFriendDependencies: List get() = emptyList() + + override val contentScope: GlobalSearchScope by lazy { + GlobalSearchScope.filesScope(project, TestLibraryUtils.getAllVirtualFilesFromJar(jar)) + } + + override fun getBinaryRoots(): Collection = listOf(jar) + override val libraryName: String get() = testModule.name + + override lateinit var librarySources: KtLibrarySourceModule + + override val platform: TargetPlatform get() = testModule.targetPlatform + override val analyzerServices: PlatformDependentAnalyzerServices get() = testModule.targetPlatform.getAnalyzerServices() +} \ No newline at end of file diff --git a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt index 5be321c33e7..da5831f97af 100644 --- a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt +++ b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt @@ -158,7 +158,12 @@ abstract class AbstractFrontendApiTest : TestWithDisposable() { testConfiguration.directives, ) val singleModule = moduleStructure.modules.single() - val project = testServices.compilerConfigurationProvider.getProject(singleModule) + val project = try { + testServices.compilerConfigurationProvider.getProject(singleModule) + } catch (_: SkipTestException) { + return + } + val moduleInfoProvider = testServices.projectModuleProvider with(project as MockProject) { configurator.registerProjectServices(this) @@ -183,6 +188,7 @@ abstract class AbstractFrontendApiTest : TestWithDisposable() { val ktFiles = when (moduleInfo) { is TestKtSourceModule -> moduleInfo.testFilesToKtFiles.filterKeys { testFile -> !testFile.isAdditional }.values.toList() is TestKtLibraryModule -> moduleInfo.ktFiles.toList() + is TestKtLibrarySourceModule -> moduleInfo.ktFiles.toList() else -> error("Unexpected $moduleInfo") } diff --git a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/SkipTestException.kt b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/SkipTestException.kt new file mode 100644 index 00000000000..a53c8f6a9ac --- /dev/null +++ b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/SkipTestException.kt @@ -0,0 +1,8 @@ +/* + * 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.analysis.api.impl.barebone.test + +abstract class SkipTestException : RuntimeException() \ No newline at end of file diff --git a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtSourceModule.kt b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtSourceModule.kt index d3a1baeb741..1c2516b83db 100644 --- a/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtSourceModule.kt +++ b/analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtSourceModule.kt @@ -119,6 +119,19 @@ class TestKtLibraryModule( GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile }) } +class TestKtLibrarySourceModule( + project: Project, + testModule: TestModule, + ktFilesFromSourceJar: Set, + testServices: TestServices, + override val binaryLibrary: KtLibraryModule, +) : TestKtModule(project, testModule, ktFilesFromSourceJar, testServices), KtLibrarySourceModule { + override val ktModule: KtModule get() = this + override val contentScope: GlobalSearchScope get() = GlobalSearchScope.filesScope(project, ktFiles.map { it.virtualFile }) + + override val libraryName: String get() = testModule.name +} + private class LibraryByRoots( private val roots: List, private val module: KtModule, diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/AbstractReferenceResolveTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/AbstractReferenceResolveTest.kt index eb5e3b63c52..14446ad785e 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/AbstractReferenceResolveTest.kt +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/AbstractReferenceResolveTest.kt @@ -11,12 +11,10 @@ import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions import org.jetbrains.kotlin.analysis.api.components.RendererModifier -import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol -import org.jetbrains.kotlin.analysis.api.symbols.markers.KtPossibleMemberSymbol import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind import org.jetbrains.kotlin.idea.references.KtReference import org.jetbrains.kotlin.name.FqName @@ -53,7 +51,7 @@ abstract class AbstractReferenceResolveTest : AbstractHLApiSingleModuleTest() { PsiTreeUtil.findElementOfClassAtOffset(mainKtFile, caretPosition, KtDeclaration::class.java, false) ?: mainKtFile ) { val symbols = ktReferences.flatMap { it.resolveToSymbols() } - checkReferenceResultForValidity(module, testServices, symbols) + checkReferenceResultForValidity(ktReferences, module, testServices, symbols) renderResolvedTo(symbols) } @@ -69,6 +67,7 @@ abstract class AbstractReferenceResolveTest : AbstractHLApiSingleModuleTest() { mainKtFile.findReferenceAt(caretPosition)?.unwrapMultiReferences().orEmpty().filterIsInstance() private fun KtAnalysisSession.checkReferenceResultForValidity( + references: List, module: TestModule, testServices: TestServices, resolvedTo: List @@ -78,7 +77,9 @@ abstract class AbstractReferenceResolveTest : AbstractHLApiSingleModuleTest() { "Reference should be unresolved, but was resolved to ${renderResolvedTo(resolvedTo)}" } } else { - testServices.assertions.assertTrue(resolvedTo.isNotEmpty()) { "Unresolved reference" } + if (resolvedTo.isEmpty()) { + testServices.assertions.fail { "Unresolved reference ${references.first().element.text}" } + } } } diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompiledLibraryProvider.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompiledLibraryProvider.kt new file mode 100644 index 00000000000..73f9c781ad5 --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompiledLibraryProvider.kt @@ -0,0 +1,34 @@ +/* + * 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.analysis.api.impl.base.test.utils.libraries + +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestService +import org.jetbrains.kotlin.test.services.TestServices +import java.nio.file.Path + +class CompiledLibraryProvider(private val testServices: TestServices) : TestService { + private val libraries = mutableMapOf() + + fun compileToLibrary(module: TestModule): CompiledLibrary { + if (module.name in libraries) { + error("Library for module ${module.name} is already compiled") + } + val libraryJar = TestModuleCompiler.compileTestModuleToLibrary(module, testServices) + val librarySourcesJar = TestModuleCompiler.compileTestModuleToLibrarySources(module, testServices) + return CompiledLibrary(libraryJar, librarySourcesJar).also { libraries[module.name] = it } + } + + fun getCompiledLibrary(module: TestModule): CompiledLibrary = + libraries.getValue(module.name) +} + +val TestServices.compiledLibraryProvider: CompiledLibraryProvider by TestServices.testServiceAccessor() + +data class CompiledLibrary( + val jar: Path, + val sourcesJar: Path, +) \ No newline at end of file diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/CompilerExecutor.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompilerExecutor.kt similarity index 82% rename from analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/CompilerExecutor.kt rename to analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompilerExecutor.kt index 3bae8570aa8..28638589d09 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/CompilerExecutor.kt +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/CompilerExecutor.kt @@ -1,10 +1,11 @@ /* - * 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. */ -package org.jetbrains.kotlin.light.classes.symbol.decompiled.service +package org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.SkipTestException import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives @@ -17,7 +18,7 @@ import kotlin.io.path.exists import kotlin.io.path.notExists object CompilerExecutor { - fun compileLibrary(sourcesPath: Path, options: List, compilationErrorExpected: Boolean): Path? { + fun compileLibrary(sourcesPath: Path, options: List, compilationErrorExpected: Boolean): Path { val library = sourcesPath / "library.jar" val sourceFiles = sourcesPath.toFile().walkBottomUp() val commands = buildList { @@ -37,7 +38,10 @@ object CompilerExecutor { if (library.exists() && compilationErrorExpected) { error("Compilation error expected but, code was compiled successfully") } - return library.takeIf(Path::exists) + if (library.notExists()) { + throw LibraryWasNotCompiledDueToExpectedCompilationError() + } + return library } fun parseCompilerOptionsFromTestdata(module: TestModule): List = buildList { @@ -56,4 +60,6 @@ object CompilerExecutor { val COMPILER_ARGUMENTS by stringDirective("List of additional compiler arguments") val COMPILATION_ERRORS by directive("Is compilation errors expected in the file") } -} \ No newline at end of file +} + +class LibraryWasNotCompiledDueToExpectedCompilationError : SkipTestException() \ No newline at end of file diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/LibraryEnvironmentConfigurator.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/LibraryEnvironmentConfigurator.kt new file mode 100644 index 00000000000..0e26a615dbb --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/LibraryEnvironmentConfigurator.kt @@ -0,0 +1,19 @@ +/* + * 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.analysis.api.impl.base.test.utils.libraries + +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.EnvironmentConfigurator +import org.jetbrains.kotlin.test.services.TestServices + +class LibraryEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { + override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) { + val library = testServices.compiledLibraryProvider.compileToLibrary(module).jar + configuration.addJvmClasspathRoot(library.toFile()) + } +} \ No newline at end of file diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestLibraryUtils.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestLibraryUtils.kt new file mode 100644 index 00000000000..c2264e5cd0e --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestLibraryUtils.kt @@ -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.analysis.api.impl.base.test.utils.libraries + +import com.intellij.openapi.vfs.VfsUtilCore +import com.intellij.openapi.vfs.VirtualFile +import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem +import java.nio.file.Path +import kotlin.io.path.absolutePathString + +object TestLibraryUtils { + fun getAllVirtualFilesFromJar(jar: Path): Collection { + val jarFileSystem = CoreJarFileSystem() + val root = jarFileSystem.refreshAndFindFileByPath(jar.absolutePathString() + "!/")!! + + val files = mutableSetOf() + VfsUtilCore.iterateChildrenRecursively( + root, + /*filter=*/{ true }, + /*iterator=*/{ virtualFile -> + if (!virtualFile.isDirectory) { + files.add(virtualFile) + } + true + } + ) + return files + } +} \ No newline at end of file diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestModuleCompiler.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestModuleCompiler.kt new file mode 100644 index 00000000000..169f9d4b438 --- /dev/null +++ b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/utils/libraries/TestModuleCompiler.kt @@ -0,0 +1,57 @@ +/* + * 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.analysis.api.impl.base.test.utils.libraries + +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.sourceFileProvider +import org.jetbrains.kotlin.test.util.KtTestUtil +import java.io.ByteArrayInputStream +import java.nio.file.Path +import java.util.jar.Attributes +import java.util.jar.JarEntry +import java.util.jar.JarOutputStream +import java.util.jar.Manifest +import kotlin.io.path.createFile +import kotlin.io.path.div +import kotlin.io.path.outputStream +import kotlin.io.path.writeText + + +internal object TestModuleCompiler { + fun compileTestModuleToLibrary(module: TestModule, testServices: TestServices): Path { + val tmpDir = KtTestUtil.tmpDir("testSourcesToCompile").toPath() + for (testFile in module.files) { + val text = testServices.sourceFileProvider.getContentOfSourceFile(testFile) + val tmpSourceFile = (tmpDir / testFile.name).createFile() + tmpSourceFile.writeText(text) + } + return CompilerExecutor.compileLibrary( + tmpDir, + CompilerExecutor.parseCompilerOptionsFromTestdata(module), + compilationErrorExpected = CompilerExecutor.Directives.COMPILATION_ERRORS in module.directives + ) + } + + fun compileTestModuleToLibrarySources(module: TestModule, testServices: TestServices): Path { + val tmpDir = KtTestUtil.tmpDir("testSourcesToCompile").toPath() + val librarySourcesPath = tmpDir / "library-sources.jar" + val manifest = Manifest().apply { mainAttributes[Attributes.Name.MANIFEST_VERSION] = "1.0" } + JarOutputStream(librarySourcesPath.outputStream(), manifest).use { jarOutputStream -> + for (testFile in module.files) { + val text = testServices.sourceFileProvider.getContentOfSourceFile(testFile) + addFileToJar(testFile.name, text, jarOutputStream) + } + } + return librarySourcesPath + } + + private fun addFileToJar(path: String, text: String, jarOutputStream: JarOutputStream) { + jarOutputStream.putNextEntry(JarEntry(path)) + ByteArrayInputStream(text.toByteArray()).copyTo(jarOutputStream) + jarOutputStream.closeEntry() + } +} \ No newline at end of file diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt index 9a1aad16f26..b13cc3a1375 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt @@ -10,9 +10,9 @@ import com.intellij.psi.PsiClass import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.CompilerExecutor import org.jetbrains.kotlin.asJava.finder.JavaElementFinder import org.jetbrains.kotlin.light.classes.symbol.base.service.NullabilityAnnotationSourceProvider -import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.CompilerExecutor import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/LibraryModuleRegistrarPreAnalysisHandler.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/LibraryModuleRegistrarPreAnalysisHandler.kt deleted file mode 100644 index 4640fc13c01..00000000000 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/LibraryModuleRegistrarPreAnalysisHandler.kt +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright 2010-2021 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.service - -import com.intellij.mock.MockProject -import com.intellij.openapi.project.Project -import com.intellij.openapi.vfs.VfsUtilCore -import com.intellij.openapi.vfs.VirtualFile -import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem -import com.intellij.psi.PsiManager -import org.jetbrains.kotlin.analysis.api.impl.barebone.test.TestKtLibraryModule -import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider -import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile -import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices -import org.jetbrains.kotlin.test.model.TestModule -import org.jetbrains.kotlin.test.services.* -import org.jetbrains.kotlin.test.util.KtTestUtil -import java.nio.file.Path -import kotlin.io.path.absolutePathString -import kotlin.io.path.createFile -import kotlin.io.path.div -import kotlin.io.path.writeText - - -class LibraryModuleRegistrarPreAnalysisHandler( - testServices: TestServices -) : PreAnalysisHandler(testServices) { - private val moduleInfoProvider = testServices.projectModuleProvider - - override fun preprocessModuleStructure(moduleStructure: TestModuleStructure) { - val testModule = moduleStructure.modules.single() - val project = testServices.compilerConfigurationProvider.getProject(testModule) - val decompiledKtFiles = getDecompiledVirtualFilesFromLibrary(testModule, project) - - moduleInfoProvider.registerModuleInfo(testModule, TestKtLibraryModule(project, testModule, decompiledKtFiles, testServices)) - (project as MockProject).registerTestServices(testModule, decompiledKtFiles, testServices) - } - - private fun getDecompiledVirtualFilesFromLibrary(module: TestModule, project: Project): List { - val tmpDir = KtTestUtil.tmpDir("testSourcesToCompile").toPath() - for (testFile in module.files) { - val text = testServices.sourceFileProvider.getContentOfSourceFile(testFile) - val tmpSourceFile = (tmpDir / testFile.name).createFile() - tmpSourceFile.writeText(text) - } - val library = CompilerExecutor.compileLibrary( - tmpDir, - CompilerExecutor.parseCompilerOptionsFromTestdata(module), - compilationErrorExpected = CompilerExecutor.Directives.COMPILATION_ERRORS in module.directives - ) ?: return emptyList() - - val virtualFiles = getAllVirtualFilesFromLibrary(library) - return virtualFiles.mapNotNull { virtualFile -> - PsiManager.getInstance(project).findFile(virtualFile) as? KtClsFile - } - } - - - private fun getAllVirtualFilesFromLibrary(library: Path): Collection { - val jarFileSystem = CoreJarFileSystem() - val root = jarFileSystem.refreshAndFindFileByPath(library.absolutePathString() + "!/")!! - - val files = mutableSetOf() - VfsUtilCore.iterateChildrenRecursively( - root, - /*filter=*/{ true }, - /*iterator=*/{ virtualFile -> - if (!virtualFile.isDirectory) { - files.add(virtualFile) - } - true - } - ) - return files - } -} diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesForLibraryFrontendApiTestConfiguratorService.kt b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesForLibraryFrontendApiTestConfiguratorService.kt new file mode 100644 index 00000000000..4f7aefd6bc9 --- /dev/null +++ b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesForLibraryFrontendApiTestConfiguratorService.kt @@ -0,0 +1,39 @@ +/* + * 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.service + +import com.intellij.mock.MockApplication +import com.intellij.mock.MockProject +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary.LibraryFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.base.test.utils.libraries.CompiledLibraryProvider +import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.services.ServiceRegistrationData + +internal object SymbolLightClassesForLibraryFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService { + override fun TestConfigurationBuilder.configureTest(disposable: Disposable) { + with(LibraryFrontendApiTestConfiguratorService) { + configureTest(disposable) + } + useAdditionalServices(ServiceRegistrationData(CompiledLibraryProvider::class, ::CompiledLibraryProvider)) + } + + override fun registerProjectServices(project: MockProject) { + LibraryFrontendApiTestConfiguratorService.registerProjectServices(project) + project.registerService(ClsJavaStubByVirtualFileCache::class.java) + } + + override fun registerApplicationServices(application: MockApplication) { + LibraryFrontendApiTestConfiguratorService.registerApplicationServices(application) + } + + override fun doOutOfBlockModification(file: KtFile) { + LibraryFrontendApiTestConfiguratorService.doOutOfBlockModification(file) + } +} \ No newline at end of file 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 979370d8645..5607ff9d18f 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 @@ -37,6 +37,8 @@ import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolBy import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByPsiTest import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByReferenceTest import org.jetbrains.kotlin.generators.TestGroupSuite +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.* +import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.TestModuleKind import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.component import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.group import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.test @@ -50,6 +52,7 @@ fun TestGroupSuite.generateAnalysisApiTests() { private fun TestGroupSuite.generateAnalysisApiNonComponentsTests() { test( AbstractReferenceResolveTest::class, + testModuleKinds = TestModuleKind.SOURCES_AND_LIBRARIES_SOURCES, addFe10 = false, ) { model("referenceResolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt index 6f0cf9d5aa2..0fb5c144b96 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt @@ -6,8 +6,6 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl import org.jetbrains.annotations.NotNull -import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService -import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService import org.jetbrains.kotlin.generators.MethodGenerator import org.jetbrains.kotlin.generators.model.MethodModel @@ -25,7 +23,7 @@ object FrontendConfiguratorTestGenerator : MethodGenerator) : MethodModel { override val kind: MethodModel.Kind get() = FrontendConfiguratorTestModelKind override val name: String get() = "getConfigurator" override val dataString: String? get() = null @@ -46,12 +44,7 @@ class FrontendConfiguratorTestModel(val frontendConfiguratorType: FrontendConfig return buildList { add(NotNull::class.java) add(FrontendApiTestConfiguratorService::class.java) - add(frontendConfiguratorType.configuratorClass.java) + add(frontendConfiguratorClass.java) } } - - enum class FrontendConfiguratorType(val configuratorClass: KClass) { - FIR(FirFrontendApiTestConfiguratorService::class), - FE10(KtFe10FrontendApiTestConfiguratorService::class); - } } \ No newline at end of file diff --git a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt index 5186e97ac32..db981d3f6ea 100644 --- a/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt +++ b/generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/dsl.kt @@ -5,16 +5,39 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl +import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10FrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary.LibraryFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.source.LibrarySourceFrontendApiTestConfiguratorService +import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.TestGroupSuite import org.jetbrains.kotlin.generators.getDefaultSuiteTestClassName +import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly import kotlin.reflect.KClass internal class FirAndFe10TestGroup( val suite: TestGroupSuite, - val directory: String? + val directory: String?, + val testModuleKinds: List, ) +internal sealed class TestModuleKind(val componentName: String) { + object SOURCE : TestModuleKind("source") + object LIBRARY : TestModuleKind("library") + object LIBRARY_SOURCE : TestModuleKind("librarySource") + + companion object { + val SOURCES_ONLY = listOf(SOURCE) + val SOURCES_AND_LIBRARIES_SOURCES = listOf(SOURCE, LIBRARY_SOURCE) + } +} + +internal enum class Frontend(val prefix: String) { + FIR("Fir"), + FE10("Fe10"), +} + internal fun FirAndFe10TestGroup.test( baseClass: KClass<*>, generateFe10: Boolean = true, @@ -22,14 +45,14 @@ internal fun FirAndFe10TestGroup.test( ) { analysisApiTest( "analysis/analysis-api-fir/tests", - FrontendConfiguratorTestModel.FrontendConfiguratorType.FIR, + Frontend.FIR, baseClass, init ) if (generateFe10) { analysisApiTest( "analysis/analysis-api-fe10/tests", - FrontendConfiguratorTestModel.FrontendConfiguratorType.FE10, + Frontend.FE10, baseClass, init ) @@ -40,54 +63,95 @@ internal fun FirAndFe10TestGroup.test( internal fun TestGroupSuite.test( baseClass: KClass<*>, addFe10: Boolean = true, + testModuleKinds: List = TestModuleKind.SOURCES_ONLY, init: TestGroup.TestClass.() -> Unit, ) { - FirAndFe10TestGroup(this, directory = null).test(baseClass, addFe10, init) + FirAndFe10TestGroup(this, directory = null, testModuleKinds).test(baseClass, addFe10, init) } internal fun TestGroupSuite.group( directory: String, + testModuleKinds: List = TestModuleKind.SOURCES_ONLY, init: FirAndFe10TestGroup.() -> Unit, ) { - FirAndFe10TestGroup(this, directory).init() + FirAndFe10TestGroup(this, directory, testModuleKinds).init() } internal fun TestGroupSuite.component( directory: String, + moduleKinds: List = TestModuleKind.SOURCES_ONLY, init: FirAndFe10TestGroup.() -> Unit, ) { - group("components/$directory", init) + group("components/$directory", moduleKinds, init) } private fun FirAndFe10TestGroup.analysisApiTest( testRoot: String, - frontendConfiguratorType: FrontendConfiguratorTestModel.FrontendConfiguratorType, + frontend: Frontend, testClass: KClass<*>, init: TestGroup.TestClass.() -> Unit, ) { with(suite) { val fullTestPath = "analysis/analysis-api/testData" + directory?.let { "/$it" }.orEmpty() testGroup(testRoot, fullTestPath) { - val prefix = when (frontendConfiguratorType) { - FrontendConfiguratorTestModel.FrontendConfiguratorType.FIR -> "Fir" - FrontendConfiguratorTestModel.FrontendConfiguratorType.FE10 -> "Fe10" - } - val fullPackage = getPackageName(prefix, testClass) - - testClass( - testClass, - suiteTestClassName = fullPackage + prefix + getDefaultSuiteTestClassName(testClass.java.simpleName), - useJunit4 = false - ) { - method(FrontendConfiguratorTestModel(frontendConfiguratorType)) - init() + if (testModuleKinds.size == 1) { + analysisApiTestClass(frontend, moduleKind = TestModuleKind.SOURCE, testClass, prefixNeeded = false, init) + } else { + testModuleKinds.forEach { component -> + analysisApiTestClass(frontend, component, testClass, prefixNeeded = true, init) + } } } } } +private fun TestGroup.analysisApiTestClass( + frontend: Frontend, + moduleKind: TestModuleKind, + testClass: KClass<*>, + prefixNeeded: Boolean, + init: TestGroup.TestClass.() -> Unit +) { + val fullPackage = getPackageName(frontend.prefix, testClass) + + val suiteTestClassName = fullPackage + + frontend.prefix + + moduleKind.componentName.capitalizeAsciiOnly().takeIf { prefixNeeded }.orEmpty() + + getDefaultSuiteTestClassName(testClass.java.simpleName) + + getDefaultSuiteTestClassName(testClass.java.simpleName) + + val configurator = createConfigurator(frontend, moduleKind) + + testClass( + testClass, + suiteTestClassName = suiteTestClassName, + useJunit4 = false + ) { + method(FrontendConfiguratorTestModel(configurator)) + init() + } +} + +private fun createConfigurator( + frontend: Frontend, + moduleKind: TestModuleKind +): KClass = when (frontend) { + Frontend.FIR -> when (moduleKind) { + TestModuleKind.SOURCE -> FirFrontendApiTestConfiguratorService::class + TestModuleKind.LIBRARY -> LibraryFrontendApiTestConfiguratorService::class + TestModuleKind.LIBRARY_SOURCE -> LibrarySourceFrontendApiTestConfiguratorService::class + } + Frontend.FE10 -> when (moduleKind) { + TestModuleKind.SOURCE -> KtFe10FrontendApiTestConfiguratorService::class + TestModuleKind.LIBRARY -> TODO("TestModuleKind.LIBRARY is unsupported for fe10") + TestModuleKind.LIBRARY_SOURCE -> TODO("TestModuleKind.LIBRARY_SOURCE is unsupported for fe10") + } +} + + private fun getPackageName(prefix: String, testClass: KClass<*>): String { val basePrefix = "org.jetbrains.kotlin.analysis.api.${prefix.lowercase()}" val packagePrefix = testClass.java.name