[analysis api, test] rework test infrastructure, add multimodule tests

2022-03-24 22:34:31 +01:00
parent 1e5cf80278
commit 4bd7fed1ea
79 changed files with 1786 additions and 510 deletions
@@ -20,6 +20,9 @@ dependencies {
    testApi(projectTests(":compiler:tests-common-new"))
    testApi(projectTests(":analysis:analysis-api-impl-barebone"))
    testApi(project(":analysis:symbol-light-classes"))
+    testApi(projectTests(":analysis:decompiled:decompiler-to-file-stubs"))
+    testApi(project(":analysis:decompiled:decompiler-to-file-stubs"))
+    testApi(project(":analysis:decompiled:decompiler-to-psi"))
    testApi(projectTests(":analysis:analysis-test-framework"))
    testImplementation(project(":kotlin-reflect"))
    testImplementation(toolsJar())
@@ -5,10 +5,13 @@

 package org.jetbrains.kotlin.analysis.api.impl.base.util

+import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VfsUtilCore
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiManager
 import com.intellij.util.io.URLUtil.JAR_SEPARATOR
 import java.nio.file.Path

@@ -32,6 +35,19 @@ object LibraryUtils {
            ?.let { getAllVirtualFilesFromRoot(it, includeRoot) } ?: emptySet()
    }

+    fun getAllPsiFilesFromTheJar(
+        jar: Path,
+        project: Project,
+        jarFileSystem: CoreJarFileSystem = CoreJarFileSystem(),
+        includeRoot: Boolean = true,
+    ): List<PsiFile> {
+        val virtualFiles = getAllVirtualFilesFromJar(jar, jarFileSystem, includeRoot)
+        return virtualFiles
+            .mapNotNull { virtualFile ->
+                PsiManager.getInstance(project).findFile(virtualFile)
+            }
+    }
+
    /**
     * Get all [VirtualFile]s inside the given [dir] (of [Path])
     *
@@ -0,0 +1,29 @@
+/*
+ * 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.components.importOptimizer
+
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+
+abstract class AbstractAnalysisApiImportOptimizerTest : AbstractAnalysisApiBasedSingleModuleTest(){
+    override fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices) {
+        val mainKtFile = ktFiles.singleOrNull() ?: ktFiles.first { it.name == "main.kt" }
+        val unusedImports = analyseForTest(mainKtFile) { analyseImports(mainKtFile).unusedImports }
+
+        val unusedImportPaths = unusedImports
+            .map { it.importPath ?: error("Import $it should have an import path, instead was ${it.text}") }
+            .sortedBy { it.toString() } // for stable results
+
+        val actualUnusedImports = buildString {
+            unusedImportPaths.forEach(::appendLine)
+        }
+
+        testServices.assertions.assertEqualsToTestDataFileSibling(actualUnusedImports, extension = ".imports")
+    }
+}
@@ -0,0 +1,31 @@
+/*
+ * 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.components.psiTypeProvider
+
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+
+abstract class AbstractAnalysisApiExpressionPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
+    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+        val declarationAtCaret = testServices.expressionMarkerProvider.getSelectedElement(ktFile) as KtExpression
+        val actual = analyse(ktFile) {
+            val returnType = declarationAtCaret.getKtType()
+                ?: error("Not a typable expression ${declarationAtCaret::class} ${declarationAtCaret.text}")
+            val psiType = returnType.asPsiType(declarationAtCaret)
+            buildString {
+                appendLine("KtType: ${returnType.render()}")
+                appendLine("PsiType: $psiType")
+            }
+        }
+        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
+    }
+}
@@ -0,0 +1,98 @@
+/*
+ * 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.components.psiTypeProvider
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiElementVisitor
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
+import org.jetbrains.kotlin.asJava.classes.KtLightClass
+import org.jetbrains.kotlin.asJava.elements.KtLightElement
+import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+
+abstract class AbstractAnalysisApiPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
+    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+        val declaration = testServices.expressionMarkerProvider.getElementOfTypAtCaret<KtDeclaration>(ktFile)
+        val containingClass =
+            getContainingKtLightClass(declaration, ktFile)
+        val psiContext = containingClass.findLightDeclarationContext(declaration)
+            ?: error("Can't find psi context for $declaration")
+        val actual = buildString {
+            executeOnPooledThreadInReadAction {
+                analyse(declaration) {
+                    val ktType = declaration.getReturnKtType()
+                    appendLine("KtType: ${ktType.render()}")
+                    appendLine("PsiType: ${ktType.asPsiType(psiContext)}")
+                }
+            }
+        }
+        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
+    }
+
+    private fun getContainingKtLightClass(
+        declaration: KtDeclaration,
+        ktFile: KtFile,
+    ): KtLightClass {
+        val project = ktFile.project
+        return createLightClassByContainingClass(declaration, project)
+            ?: getFacadeLightClass(ktFile, project)
+            ?: error("Can't get or create containing KtLightClass for $declaration")
+
+    }
+
+    private fun getFacadeLightClass(
+        ktFile: KtFile,
+        project: Project,
+    ): KtLightClass? {
+        val mainKtFileFqName = ktFile.packageFqName.child(Name.identifier(ktFile.name))
+        return project.getService(SymbolLightClassFacadeCache::class.java)
+            .getOrCreateSymbolLightFacade(listOf(ktFile), mainKtFileFqName)
+    }
+
+    private fun createLightClassByContainingClass(
+        declaration: KtDeclaration,
+        project: Project
+    ): KtLightClass? {
+        val containingClass = declaration.parents.firstIsInstanceOrNull<KtClassOrObject>() ?: return null
+        return project.getService(KotlinAsJavaSupport::class.java).getLightClass(containingClass)
+    }
+
+    private fun KtLightClass.findLightDeclarationContext(ktDeclaration: KtDeclaration): KtLightElement<*, *>? {
+        val selfOrParents = listOf(ktDeclaration) + ktDeclaration.parents.filterIsInstance<KtDeclaration>()
+        var result: KtLightElement<*, *>? = null
+        val visitor = object : PsiElementVisitor() {
+            override fun visitElement(element: PsiElement) {
+                if (element !is KtLightElement<*, *>) return
+                // NB: intentionally visit members first so that `self` can be found first if matched
+                if (element is PsiClass) {
+                    element.fields.forEach { it.accept(this) }
+                    element.methods.forEach { it.accept(this) }
+                    element.innerClasses.forEach { it.accept(this) }
+                }
+                if (result == null && element.kotlinOrigin in selfOrParents) {
+                    result = element
+                    return
+                }
+            }
+        }
+        accept(visitor)
+        return result
+    }
+
+}
@@ -0,0 +1,47 @@
+/*
+ * 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.components.typeProvider
+
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.assertions
+
+abstract class AbstractAnalysisApiGetSuperTypesTest : AbstractAnalysisApiSingleFileTest(){
+    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
+        val expression = testServices.expressionMarkerProvider.getSelectedElement(ktFile)
+
+        val actual = executeOnPooledThreadInReadAction {
+            analyse(expression) {
+                val expectedType = expression.getExpectedType() ?: error("expect to get type of expression '${expression.text}'")
+                val directSuperTypes = expectedType.getDirectSuperTypes()
+                val approximatedDirectSuperTypes = expectedType.getDirectSuperTypes(shouldApproximate = true)
+                val allSuperTypes = expectedType.getAllSuperTypes()
+                val approximatedAllSuperTypes = expectedType.getAllSuperTypes(shouldApproximate = true)
+
+                buildString {
+                    fun List<KtType>.print(name: String) {
+                        appendLine(name)
+                        for (type in this) {
+                            appendLine(type.render(KtTypeRendererOptions.DEFAULT))
+                        }
+                        appendLine()
+                    }
+                    directSuperTypes.print("[direct super types]")
+                    approximatedDirectSuperTypes.print("[approximated direct super types]")
+                    allSuperTypes.print("[all super types]")
+                    approximatedAllSuperTypes.print("[approximated all super types]")
+                }
+            }
+        }
+        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
+    }
+}
@@ -0,0 +1,51 @@
+/*
+ * 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.configurators
+
+import com.intellij.mock.MockApplication
+import com.intellij.mock.MockProject
+import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
+import org.jetbrains.kotlin.analysis.project.structure.KtModuleScopeProvider
+import org.jetbrains.kotlin.analysis.project.structure.KtModuleScopeProviderImpl
+import org.jetbrains.kotlin.analysis.providers.KotlinAnnotationsResolverFactory
+import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProviderFactory
+import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
+import org.jetbrains.kotlin.analysis.providers.KotlinPackageProviderFactory
+import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticAnnotationsResolverFactory
+import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticDeclarationProviderFactory
+import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticModificationTrackerFactory
+import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticPackageProviderFactory
+import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestServiceRegistrar
+import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.services.TestServices
+
+object AnalysisApiBaseTestServiceRegistrar: AnalysisApiTestServiceRegistrar()  {
+    override fun registerProjectExtensionPoints(project: MockProject, testServices: TestServices) {
+    }
+
+    override fun registerProjectServices(project: MockProject, testServices: TestServices) {
+        val allKtFiles = testServices.ktModuleProvider.getAllModules().flatMap { it.files.filterIsInstance<KtFile>() }
+
+        project.apply {
+            registerService(KotlinModificationTrackerFactory::class.java, KotlinStaticModificationTrackerFactory::class.java)
+
+            registerService(KtModuleScopeProvider::class.java, KtModuleScopeProviderImpl())
+            registerService(KotlinModificationTrackerFactory::class.java, KotlinStaticModificationTrackerFactory::class.java)
+            registerService(KotlinAnnotationsResolverFactory::class.java, KotlinStaticAnnotationsResolverFactory(allKtFiles))
+            registerService(KotlinDeclarationProviderFactory::class.java, KotlinStaticDeclarationProviderFactory(allKtFiles))
+            registerService(KotlinPackageProviderFactory::class.java, KotlinStaticPackageProviderFactory(allKtFiles))
+        }
+    }
+
+    override fun registerApplicationServices(application: MockApplication, testServices: TestServices) {
+        application.apply {
+            registerService(KotlinReferenceProvidersService::class.java, HLApiReferenceProviderService::class.java)
+        }
+
+    }
+}
@@ -0,0 +1,48 @@
+/*
+ * 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.configurators
+
+import com.intellij.ide.highlighter.JavaClassFileType
+import com.intellij.mock.MockApplication
+import com.intellij.mock.MockProject
+import com.intellij.openapi.extensions.LoadingOrder
+import com.intellij.psi.ClassFileViewProviderFactory
+import com.intellij.psi.FileTypeFileViewProviders
+import com.intellij.psi.compiled.ClassFileDecompilers
+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
+import org.jetbrains.kotlin.analysis.decompiler.stub.file.FileAttributeService
+import org.jetbrains.kotlin.analysis.decompiler.stub.files.DummyFileAttributeService
+import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestServiceRegistrar
+import org.jetbrains.kotlin.test.TestInfrastructureInternals
+import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.analysis.test.framework.services.disposableProvider
+
+
+object AnalysisApiLibraryBaseTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
+    override fun registerProjectExtensionPoints(project: MockProject, testServices: TestServices) {
+    }
+
+    override fun registerProjectServices(project: MockProject, testServices: TestServices) {
+    }
+
+    @OptIn(TestInfrastructureInternals::class)
+    override fun registerApplicationServices(application: MockApplication, testServices: TestServices) {
+        application.apply {
+            registerService(ClsKotlinBinaryClassCache::class.java)
+            registerService(FileAttributeService::class.java, DummyFileAttributeService)
+        }
+
+        FileTypeFileViewProviders.INSTANCE.addExplicitExtension(JavaClassFileType.INSTANCE, ClassFileViewProviderFactory())
+
+        ClassFileDecompilers.getInstance().EP_NAME.point.apply {
+            registerExtension(KotlinClassFileDecompiler(), LoadingOrder.FIRST, testServices.disposableProvider.getApplicationDisposable())
+            registerExtension(KotlinBuiltInDecompiler(), LoadingOrder.FIRST, testServices.disposableProvider.getApplicationDisposable())
+        }
+
+    }
+}