[LL FIR] provide fallback symbol provider for callables from multifile class part

Regular `functionCache`/`propertyCache` doesn't work because for
such cases `declarationProvider` doesn't return the requested
declaration as it is not indexed.

This change is already covered by tests from b7e9906,
but the fix for `KotlinStandaloneDeclarationProviderFactory` is required
to simulate how real indices work as they work on top of stubs for
compiled classes

^KT-68484 Fixed

Author: dimonchik0036

analysis/analysis-api-standalone/analysis-api-standalone-base/src/org/jetbrains/kotlin/analysis/api/standalone/base/declarations/KotlinStandaloneDeclarationProvider.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2025 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.
  */
 
@@ -26,20 +26,16 @@ import com.intellij.util.io.StringRef
 import com.intellij.util.io.UnsyncByteArrayOutputStream
 import org.jetbrains.kotlin.analysis.api.KaImplementationDetail
 import org.jetbrains.kotlin.analysis.api.impl.base.symbols.pointers.SmartPointerIncompatiblePsiFile
+import org.jetbrains.kotlin.analysis.api.platform.declarations.*
+import org.jetbrains.kotlin.analysis.api.platform.mergeSpecificProviders
+import org.jetbrains.kotlin.analysis.api.projectStructure.KaModule
 import org.jetbrains.kotlin.analysis.decompiler.konan.K2KotlinNativeMetadataDecompiler
 import org.jetbrains.kotlin.analysis.decompiler.konan.KlibMetaFileType
 import org.jetbrains.kotlin.analysis.decompiler.psi.BuiltinsVirtualFileProvider
 import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInDecompiler
 import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInFileType
 import org.jetbrains.kotlin.analysis.decompiler.stub.file.ClsKotlinBinaryClassCache
 import org.jetbrains.kotlin.analysis.decompiler.stub.file.KotlinClsStubBuilder
-import org.jetbrains.kotlin.analysis.api.projectStructure.KaModule
-import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProvider
-import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProviderFactory
-import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinDeclarationProviderMerger
-import org.jetbrains.kotlin.analysis.api.platform.declarations.createDeclarationProvider
-import org.jetbrains.kotlin.analysis.api.platform.declarations.KotlinCompositeDeclarationProvider
-import org.jetbrains.kotlin.analysis.api.platform.mergeSpecificProviders
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.*
@@ -394,10 +390,29 @@ class KotlinStandaloneDeclarationProviderFactory(
             binaryRoots
                 .map { collectStubsFromBinaryRoot(it, binaryClassCache) }
                 .forEach { processCollectedBinaryStubs(it, isSharedStubs = false) }
+
+            for (file in sourceKtFiles) {
+                if (!file.isCompiled) continue
+
+                // Special handling for builtins is required as normally they are indexed by [loadBuiltIns],
+                // so [buildStubByVirtualFile] skips them explicitly, but actually stubs for them exist
+                val stub = buildStubByVirtualFile(file.virtualFile, binaryClassCache, preserveBuiltins = skipBuiltins)
+
+                // Only files for which stub exists should be indexed, so some synthetic classes should be ignored.
+                // This behavior is closer to real indices.
+                if (stub != null) {
+                    stub.psi = file
+                    processMultifileClassStub(stub)
+
+                    file.accept(recorder)
+                }
+            }
         }
 
         sourceKtFiles.forEach { file ->
-            file.accept(recorder)
+            if (!shouldBuildStubsForBinaryLibraries || !file.isCompiled) {
+                file.accept(recorder)
+            }
         }
     }
 
@@ -424,18 +439,20 @@ class KotlinStandaloneDeclarationProviderFactory(
         }
     }
 
-    private fun processStub(ktFileStub: KotlinFileStubImpl) {
+    private fun processMultifileClassStub(ktFileStub: KotlinFileStubImpl) {
         val ktFile: KtFile = ktFileStub.psi
-        addToFacadeFileMap(ktFile)
-
-        val partNames = ktFileStub.facadePartSimpleNames
-        if (partNames != null) {
-            val packageFqName = ktFileStub.getPackageFqName()
-            for (partName in partNames) {
-                val multiFileClassPartFqName: FqName = packageFqName.child(Name.identifier(partName))
-                index.multiFileClassPartMap.computeIfAbsent(multiFileClassPartFqName) { mutableSetOf() }.add(ktFile)
-            }
+
+        val partNames = ktFileStub.facadePartSimpleNames ?: return
+        val packageFqName = ktFileStub.getPackageFqName()
+        for (partName in partNames) {
+            val multiFileClassPartFqName: FqName = packageFqName.child(Name.identifier(partName))
+            index.multiFileClassPartMap.computeIfAbsent(multiFileClassPartFqName) { mutableSetOf() }.add(ktFile)
         }
+    }
+
+    private fun processStub(ktFileStub: KotlinFileStubImpl) {
+        addToFacadeFileMap(ktFileStub.psi)
+        processMultifileClassStub(ktFileStub)
 
         // top-level functions and properties, built-in classes
         ktFileStub.childrenStubs.forEach(::indexStub)
@@ -449,23 +466,27 @@ class KotlinStandaloneDeclarationProviderFactory(
             VfsUtilCore.visitChildrenRecursively(binaryRoot, object : VirtualFileVisitor<Void>() {
                 override fun visitFile(file: VirtualFile): Boolean {
                     if (!file.isDirectory) {
-                        val stub = buildStubByVirtualFile(file, binaryClassCache) ?: return true
+                        val stub = buildStubByVirtualFile(file, binaryClassCache, preserveBuiltins = false) ?: return true
                         put(file, stub)
                     }
                     return true
                 }
             })
         }
 
-    private fun buildStubByVirtualFile(file: VirtualFile, binaryClassCache: ClsKotlinBinaryClassCache): KotlinFileStubImpl? {
+    private fun buildStubByVirtualFile(
+        file: VirtualFile,
+        binaryClassCache: ClsKotlinBinaryClassCache,
+        preserveBuiltins: Boolean,
+    ): KotlinFileStubImpl? {
         val fileContent = FileContentImpl.createByFile(file)
         val fileType = fileContent.fileType
         val stubBuilder = when (fileType) {
             JavaClassFileType.INSTANCE if binaryClassCache.isKotlinJvmCompiledFile(file, fileContent.content) -> {
                 KotlinClsStubBuilder()
             }
 
-            KotlinBuiltInFileType if file.extension != BuiltInSerializerProtocol.BUILTINS_FILE_EXTENSION -> {
+            KotlinBuiltInFileType if preserveBuiltins || file.extension != BuiltInSerializerProtocol.BUILTINS_FILE_EXTENSION -> {
                 builtInDecompiler.stubBuilder
             }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/symbolProviders/LLKotlinStubBasedLibraryMultifileClassPartCallableSymbolProvider.kt

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2010-2025 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.low.level.api.fir.symbolProviders
+
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.JvmAndBuiltinsDeserializedContainerSourceProvider
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.caches.firCachesFactory
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.name.CallableId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.JvmStandardClassIds
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
+
+/**
+ * Issue: [KT-68484](https://youtrack.jetbrains.com/issue/KT-68484).
+ *
+ * This class provides fallback symbols for top-level callables from synthetic multifile class part
+ * ([MULTIFILE_CLASS_PART][org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader.Kind.MULTIFILE_CLASS_PART]).
+ *
+ * @see org.jetbrains.kotlin.analysis.decompiler.stub.file.ClsClassFinder.isKotlinInternalCompiledFile
+ * @see addCallableIfNeeded
+ **/
+internal class LLKotlinStubBasedLibraryMultifileClassPartCallableSymbolProvider(val session: FirSession) {
+    private val fallbackFunctionCache = session.firCachesFactory.createCache(::loadFunction)
+    private val fallbackPropertyCache = session.firCachesFactory.createCache(::loadProperty)
+
+    /**
+     * This fallback is required for multifile part classes which are not present in indices
+     * but might be requested as in some cases we still build stubs for them.
+     */
+    fun addCallableIfNeeded(
+        callableCandidates: MutableList<FirCallableSymbol<*>>,
+        packageFqName: FqName,
+        shortName: Name,
+        callableDeclaration: KtCallableDeclaration,
+    ) {
+        val fileName = callableDeclaration.containingKtFile.virtualFile?.nameWithoutExtension ?: return
+        if (!fileName.endsWith("Kt") || JvmStandardClassIds.MULTIFILE_PART_NAME_DELIMITER !in fileName) {
+            return
+        }
+
+        val callableId = CallableId(packageFqName, shortName)
+        val symbol = when (callableDeclaration) {
+            is KtNamedFunction -> fallbackFunctionCache.getValue(callableDeclaration, callableId)
+            is KtProperty -> fallbackPropertyCache.getValue(callableDeclaration, callableId)
+            else -> null
+        }
+
+        symbol?.let(callableCandidates::add)
+    }
+
+    private fun loadFunction(function: KtNamedFunction, callableId: CallableId): FirNamedFunctionSymbol? {
+        return LLKotlinStubBasedLibrarySymbolProvider.loadFunction(
+            function = function,
+            callableId = callableId,
+            functionOrigin = FirDeclarationOrigin.Library,
+            deserializedContainerSourceProvider = JvmAndBuiltinsDeserializedContainerSourceProvider,
+            session = session,
+        )
+    }
+
+    private fun loadProperty(property: KtProperty, callableId: CallableId): FirPropertySymbol? {
+        return LLKotlinStubBasedLibrarySymbolProvider.loadProperty(
+            property = property,
+            callableId = callableId,
+            propertyOrigin = FirDeclarationOrigin.Library,
+            deserializedContainerSourceProvider = JvmAndBuiltinsDeserializedContainerSourceProvider,
+            session = session,
+        )
+    }
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/symbolProviders/LLKotlinStubBasedLibrarySymbolProvider.kt

@@ -12,18 +12,15 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.caches.getNotNullValueFor
 import org.jetbrains.kotlin.analysis.low.level.api.fir.projectStructure.LLFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.projectStructure.llFirModuleData
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.DeserializedContainerSourceProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.StubBasedAnnotationDeserializer
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.StubBasedFirDeserializationContext
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.StubBasedFirTypeDeserializer
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.deserializeClassToSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.loadStubByElement
+import org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization.*
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.caches.FirCache
 import org.jetbrains.kotlin.fir.caches.firCachesFactory
 import org.jetbrains.kotlin.fir.caches.getValue
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.isNewPlaceForBodyGeneration
 import org.jetbrains.kotlin.fir.java.deserialization.KotlinBuiltins
+import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolNamesProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
@@ -36,7 +33,8 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getTopmostParentOfType
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
 import org.jetbrains.kotlin.psi.stubs.KotlinClassStub
-import org.jetbrains.kotlin.psi.stubs.impl.*
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinFunctionStubImpl
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinPropertyStubImpl
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 
@@ -183,47 +181,31 @@ internal open class LLKotlinStubBasedLibrarySymbolProvider(
 
         return ArrayList<FirNamedFunctionSymbol>(topLevelFunctions.size).apply {
             for (function in topLevelFunctions) {
-                val functionStub = function.stub as? KotlinFunctionStubImpl ?: loadStubByElement(function)
-                val functionFile = function.containingKtFile
-                val functionOrigin = getDeclarationOriginFor(functionFile)
-                val containerSource =
-                    deserializedContainerSourceProvider.getFacadeContainerSource(functionFile, functionStub?.origin, functionOrigin)
-
-                if (!functionOrigin.isBuiltIns &&
-                    containerSource is FacadeClassSource &&
-                    containerSource.className.internalName in KotlinBuiltins
-                ) {
-                    continue
-                }
-
-                val symbol = FirNamedFunctionSymbol(callableId)
-                val rootContext = StubBasedFirDeserializationContext
-                    .createRootContext(session, moduleData, callableId, function, symbol, functionOrigin, containerSource)
-
-                add(rootContext.memberDeserializer.loadFunction(function, null, session, symbol).symbol)
+                val symbol = loadFunction(
+                    function = function,
+                    callableId = callableId,
+                    functionOrigin = getDeclarationOriginFor(function.containingKtFile),
+                    deserializedContainerSourceProvider = deserializedContainerSourceProvider,
+                    session = session,
+                ) ?: continue
+                add(symbol)
             }
         }
     }
 
     private fun loadPropertiesByCallableId(callableId: CallableId, foundProperties: Collection<KtProperty>?): List<FirPropertySymbol> {
         val topLevelProperties = foundProperties ?: declarationProvider.getTopLevelProperties(callableId)
 
-        return buildList {
+        return ArrayList<FirPropertySymbol>(topLevelProperties.size).apply {
             for (property in topLevelProperties) {
-                val propertyStub = property.stub as? KotlinPropertyStubImpl ?: loadStubByElement(property)
-                val propertyFile = property.containingKtFile
-                val propertyOrigin = getDeclarationOriginFor(propertyFile)
-                val containerSource = deserializedContainerSourceProvider.getFacadeContainerSource(
-                    propertyFile,
-                    propertyStub?.origin,
-                    propertyOrigin,
-                )
-
-                val symbol = FirPropertySymbol(callableId)
-                val rootContext = StubBasedFirDeserializationContext
-                    .createRootContext(session, moduleData, callableId, property, symbol, propertyOrigin, containerSource)
-
-                add(rootContext.memberDeserializer.loadProperty(property, null, symbol).symbol)
+                val symbol = loadProperty(
+                    property = property,
+                    callableId = callableId,
+                    propertyOrigin = getDeclarationOriginFor(property.containingKtFile),
+                    deserializedContainerSourceProvider = deserializedContainerSourceProvider,
+                    session = session,
+                ) ?: continue
+                add(symbol)
             }
         }
     }
@@ -376,6 +358,83 @@ internal open class LLKotlinStubBasedLibrarySymbolProvider(
             is KtProperty -> propertyCache.getValue(callableId)
             else -> null
         }
+
         return callableSymbols?.singleOrNull { it.fir.realPsi == callableDeclaration }
     }
+
+    companion object {
+        fun loadProperty(
+            property: KtProperty,
+            callableId: CallableId,
+            propertyOrigin: FirDeclarationOrigin,
+            deserializedContainerSourceProvider: DeserializedContainerSourceProvider,
+            session: FirSession,
+        ): FirPropertySymbol? {
+            val propertyStub = property.stub as? KotlinPropertyStubImpl ?: loadStubByElement(property)
+            val propertyFile = property.containingKtFile
+            val containerSource = deserializedContainerSourceProvider.getFacadeContainerSource(
+                file = propertyFile,
+                stubOrigin = propertyStub?.origin,
+                declarationOrigin = propertyOrigin,
+            )
+
+            val symbol = FirPropertySymbol(callableId)
+            val rootContext = StubBasedFirDeserializationContext.createRootContext(
+                session = session,
+                moduleData = session.moduleData,
+                callableId = callableId,
+                parameterListOwner = property,
+                symbol = symbol,
+                initialOrigin = propertyOrigin,
+                containerSource = containerSource,
+            )
+
+            return rootContext.memberDeserializer.loadProperty(
+                property = property,
+                classSymbol = null,
+                existingSymbol = symbol,
+            ).symbol
+        }
+
+        fun loadFunction(
+            function: KtNamedFunction,
+            callableId: CallableId,
+            functionOrigin: FirDeclarationOrigin,
+            deserializedContainerSourceProvider: DeserializedContainerSourceProvider,
+            session: FirSession,
+        ): FirNamedFunctionSymbol? {
+            val functionStub = function.stub as? KotlinFunctionStubImpl ?: loadStubByElement(function)
+            val functionFile = function.containingKtFile
+            val containerSource = deserializedContainerSourceProvider.getFacadeContainerSource(
+                file = functionFile,
+                stubOrigin = functionStub?.origin,
+                declarationOrigin = functionOrigin,
+            )
+
+            if (!functionOrigin.isBuiltIns &&
+                containerSource is FacadeClassSource &&
+                containerSource.className.internalName in KotlinBuiltins
+            ) {
+                return null
+            }
+
+            val symbol = FirNamedFunctionSymbol(callableId)
+            val rootContext = StubBasedFirDeserializationContext.createRootContext(
+                session = session,
+                moduleData = session.moduleData,
+                callableId = callableId,
+                parameterListOwner = function,
+                symbol = symbol,
+                initialOrigin = functionOrigin,
+                containerSource = containerSource,
+            )
+
+            return rootContext.memberDeserializer.loadFunction(
+                function = function,
+                classSymbol = null,
+                session = session,
+                existingSymbol = symbol,
+            ).symbol
+        }
+    }
 }