AA: use fully decompiled file when indexing built-ins

analysis/analysis-api-providers/src/org/jetbrains/kotlin/analysis/providers/impl/KotlinStaticDeclarationProvider.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.providers.impl
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.*
 import com.intellij.psi.search.GlobalSearchScope
@@ -14,13 +13,13 @@ import com.intellij.util.indexing.FileContent
 import com.intellij.util.indexing.FileContentImpl
 import com.intellij.util.io.URLUtil
 import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInDecompiler
+import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinDecompiledFileViewProvider
+import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtDecompiledFile
 import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProvider
 import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProviderFactory
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
-import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.stubs.impl.*
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 
 public class KotlinStaticDeclarationIndex {
@@ -111,20 +110,22 @@ public class KotlinStaticDeclarationProviderFactory(
     private val psiManager = PsiManager.getInstance(project)
     private val builtInDecompiler = KotlinBuiltInDecompiler()
 
-    private fun loadBuiltIns() {
+    private fun loadBuiltIns(): Collection<KtDecompiledFile> {
         val classLoader = this::class.java.classLoader
-        StandardClassIds.builtInsPackages.forEach { builtInPackageFqName ->
+        return buildList {
-            val resourcePath = BuiltInSerializerProtocol.getBuiltInsFilePath(builtInPackageFqName)
+            StandardClassIds.builtInsPackages.forEach { builtInPackageFqName ->
-            classLoader.getResource(resourcePath)?.let { resourceUrl ->
+                val resourcePath = BuiltInSerializerProtocol.getBuiltInsFilePath(builtInPackageFqName)
-                // "file:///path/to/stdlib.jar!/builtin/package/.kotlin_builtins
+                classLoader.getResource(resourcePath)?.let { resourceUrl ->
-                //   -> ("path/to/stdlib.jar", "builtin/package/.kotlin_builtins")
+                    // "file:///path/to/stdlib.jar!/builtin/package/.kotlin_builtins
-                URLUtil.splitJarUrl(resourceUrl.path)?.let {
+                    //   -> ("path/to/stdlib.jar", "builtin/package/.kotlin_builtins")
-                    val jarPath = it.first
+                    URLUtil.splitJarUrl(resourceUrl.path)?.let {
-                    val builtInFile = it.second
+                        val jarPath = it.first
-                    val pathToQuery = jarPath + URLUtil.JAR_SEPARATOR + builtInFile
+                        val builtInFile = it.second
-                    jarFileSystem.findFileByPath(pathToQuery)?.let { vf ->
+                        val pathToQuery = jarPath + URLUtil.JAR_SEPARATOR + builtInFile
-                        val fileContent = FileContentImpl.createByFile(vf, project)
+                        jarFileSystem.findFileByPath(pathToQuery)?.let { vf ->
-                        createKtFileStub(fileContent)?.let { ktFileStub -> loadIndexFromFileStub(ktFileStub) }
+                            val fileContent = FileContentImpl.createByFile(vf, project)
+                            createKtFileStub(fileContent)?.let { file -> add(file) }
+                        }
                     }
                 }
             }
@@ -133,36 +134,13 @@ public class KotlinStaticDeclarationProviderFactory(
 
     private fun createKtFileStub(
         fileContent: FileContent,
-    ): KotlinFileStubImpl? {
+    ): KtDecompiledFile? {
-        val ktFileStub = builtInDecompiler.stubBuilder.buildFileStub(fileContent) as? KotlinFileStubImpl ?: return null
+        val fileViewProvider =
-        val fakeFile = object : KtFile(KtClassFileViewProvider(psiManager, fileContent.file), isCompiled = true) {
+            builtInDecompiler.createFileViewProvider(fileContent.file, psiManager, physical = true) as? KotlinDecompiledFileViewProvider
-            override fun getStub() = ktFileStub
+                ?: return null
-
+        return builtInDecompiler.readFile(fileContent.content, fileContent.file)?.let { fileWithMetadata ->
-            override fun isPhysical() = false
+            KtDecompiledFile(fileViewProvider) {
-        }
+                builtInDecompiler.buildDecompiledText(fileWithMetadata)
-        ktFileStub.psi = fakeFile
-        return ktFileStub
-    }
-
-    private class KtClassFileViewProvider(
-        psiManager: PsiManager,
-        virtualFile: VirtualFile,
-    ) : SingleRootFileViewProvider(psiManager, virtualFile, true, KotlinLanguage.INSTANCE)
-
-    private fun loadIndexFromFileStub(
-        fileStubImpl: KotlinFileStubImpl,
-    ) {
-        addToFacadeFileMap(fileStubImpl.psi)
-        fileStubImpl.childrenStubs.forEach { stubElement ->
-            when (stubElement) {
-                is KotlinClassStubImpl ->
-                    addToClassMap(stubElement.psi)
-                is KotlinTypeAliasStubImpl ->
-                    addToTypeAliasMap(stubElement.psi)
-                is KotlinFunctionStubImpl ->
-                    addToFunctionMap(stubElement.psi)
-                is KotlinPropertyStubImpl ->
-                    addToPropertyMap(stubElement.psi)
             }
         }
     }
@@ -239,11 +217,14 @@ public class KotlinStaticDeclarationProviderFactory(
     }
 
     init {
+        val recorder = KtDeclarationRecorder()
+
         // Indexing built-ins
-        loadBuiltIns()
+        loadBuiltIns().forEach {
+            it.accept(recorder)
+        }
 
         // Indexing user source files
-        val recorder = KtDeclarationRecorder()
         files.forEach {
             it.accept(recorder)
         }

analysis/decompiled/decompiler-to-psi/src/org/jetbrains/kotlin/analysis/decompiler/psi/KotlinMetadataDecompiler.kt

@@ -75,7 +75,7 @@ abstract class KotlinMetadataDecompiler<out V : BinaryVersion>(
         }
     }
 
-    private fun buildDecompiledText(file: KotlinMetadataStubBuilder.FileWithMetadata): DecompiledText {
+    fun buildDecompiledText(file: KotlinMetadataStubBuilder.FileWithMetadata): DecompiledText {
         return when (file) {
             is KotlinMetadataStubBuilder.FileWithMetadata.Incompatible -> {
                 createIncompatibleAbiVersionDecompiledText(expectedBinaryVersion(), file.version)