[Stubs] Pass proper container source to stub-based FIR declarations

Backend, which is used by the expression evaluator, relies on the class
name in 'FacadeClassSource'. To pass the correct JVM class name,
stubs for top-level functions and properties got the 'origin'.

analysis/decompiled/decompiler-to-stubs/src/org/jetbrains/kotlin/analysis/decompiler/stub/CallableClsStubBuilder.kt

@@ -208,7 +208,8 @@ private class FunctionClsStubBuilder(
             mayHaveContract = hasContract,
             runIf(hasContract) {
                 ClsContractBuilder(c, typeStubBuilder).loadContract(functionProto)
-            }
+            },
+            origin = createStubOrigin(protoContainer)
         )
     }
 }
@@ -280,7 +281,8 @@ private class PropertyClsStubBuilder(
             isExtension = propertyProto.hasReceiver(),
             hasReturnTypeRef = true,
             fqName = c.containerFqName.child(callableName),
-            initializer
+            initializer,
+            origin = createStubOrigin(protoContainer)
         )
     }
 

analysis/decompiled/decompiler-to-stubs/src/org/jetbrains/kotlin/analysis/decompiler/stub/clsStubBuilding.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.decompiler.stub.flags.FlagsToModifiers
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.SourceElement
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.load.kotlin.FacadeClassSource
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
@@ -221,6 +222,23 @@ fun createTargetedAnnotationStubs(
     }
 }
 
+internal fun createStubOrigin(protoContainer: ProtoContainer): KotlinStubOrigin? {
+    if (protoContainer is ProtoContainer.Package) {
+        val source = protoContainer.source
+        if (source is FacadeClassSource) {
+            val className = source.className.internalName
+            val facadeClassName = source.facadeClassName?.internalName
+            if (facadeClassName != null) {
+                return KotlinStubOrigin.MultiFileFacade(className, facadeClassName)
+            }
+
+            return KotlinStubOrigin.Facade(className)
+        }
+    }
+
+    return null
+}
+
 val MessageLite.annotatedCallableKind: AnnotatedCallableKind
     get() = when (this) {
         is ProtoBuf.Property -> AnnotatedCallableKind.PROPERTY

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/JvmStubBasedFirDeserializedSymbolProvider.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirKotlinSymbolProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.LLFirKotlinSymbolNamesProvider
@@ -27,6 +26,7 @@ import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.stubs.impl.*
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragment
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
@@ -124,11 +124,7 @@ internal open class JvmStubBasedFirDeserializedSymbolProvider(
                 StubBasedAnnotationDeserializer(session),
                 kotlinScopeProvider,
                 parentContext = context,
-                containerSource = if (initialOrigin == FirDeclarationOrigin.BuiltIns) null else JvmFromStubDecompilerSource(
-                    JvmClassName.byClassId(
-                        classId
-                    )
-                ),
+                containerSource = if (initialOrigin == FirDeclarationOrigin.BuiltIns) null else JvmStubDeserializedContainerSource(classId),
                 deserializeNestedClass = this::getClass,
                 initialOrigin = initialOrigin
             )
@@ -146,14 +142,20 @@ internal open class JvmStubBasedFirDeserializedSymbolProvider(
         return ArrayList<FirNamedFunctionSymbol>(topLevelFunctions.size).apply {
             for (function in topLevelFunctions) {
                 val file = function.containingKtFile
-                val virtualFile = file.virtualFile.takeIf { it.extension != MetadataPackageFragment.METADATA_FILE_EXTENSION } ?: continue
-                val facadeClassName = computeFacadeClassName(file, virtualFile)
+                if (file.virtualFile.extension == MetadataPackageFragment.METADATA_FILE_EXTENSION) {
+                    continue
+                }
 
-                if (initialOrigin != FirDeclarationOrigin.BuiltIns && facadeClassName.internalName in KotlinBuiltins) continue
+                val functionStub = function.stub as? KotlinFunctionStubImpl ?: loadStubByElement(function)
+                val containerSource = getFacadeContainerSource(function.containingKtFile, functionStub?.origin)
+
+                if (initialOrigin != FirDeclarationOrigin.BuiltIns && containerSource.className.internalName in KotlinBuiltins) {
+                    continue
+                }
 
                 val symbol = FirNamedFunctionSymbol(callableId)
                 val rootContext = StubBasedFirDeserializationContext
-                    .createRootContext(session, moduleData, callableId, function, symbol, initialOrigin)
+                    .createRootContext(session, moduleData, callableId, function, symbol, initialOrigin, containerSource)
 
                 add(rootContext.memberDeserializer.loadFunction(function, null, session, symbol).symbol)
             }
@@ -165,18 +167,36 @@ internal open class JvmStubBasedFirDeserializedSymbolProvider(
 
         return buildList {
             for (property in topLevelProperties) {
+                val propertyStub = property.stub as? KotlinPropertyStubImpl ?: loadStubByElement(property)
+                val containerSource = getFacadeContainerSource(property.containingKtFile, propertyStub?.origin)
+
                 val symbol = FirPropertySymbol(callableId)
                 val rootContext = StubBasedFirDeserializationContext
-                    .createRootContext(session, moduleData, callableId, property, symbol, initialOrigin)
+                    .createRootContext(session, moduleData, callableId, property, symbol, initialOrigin, containerSource)
 
                 add(rootContext.memberDeserializer.loadProperty(property, null, symbol).symbol)
             }
         }
     }
 
-    private fun computeFacadeClassName(file: KtFile, virtualFile: VirtualFile = file.virtualFile): JvmClassName {
-        val internalName = file.packageFqName.asString().replace(".", "/") + "/" + virtualFile.nameWithoutExtension
-        return JvmClassName.byInternalName(internalName)
+    private fun getFacadeContainerSource(file: KtFile, origin: KotlinStubOrigin?): JvmStubDeserializedFacadeContainerSource {
+        return when (origin) {
+            is KotlinStubOrigin.Facade -> {
+                val className = JvmClassName.byInternalName(origin.className)
+                JvmStubDeserializedFacadeContainerSource(className, facadeClassName = null)
+            }
+            is KotlinStubOrigin.MultiFileFacade -> {
+                val className = JvmClassName.byInternalName(origin.className)
+                val facadeClassName = JvmClassName.byInternalName(origin.className)
+                JvmStubDeserializedFacadeContainerSource(className, facadeClassName)
+            }
+            else -> {
+                val virtualFile = file.virtualFile
+                val classId = ClassId(file.packageFqName, Name.identifier(virtualFile.nameWithoutExtension))
+                val className = JvmClassName.byClassId(classId)
+                JvmStubDeserializedFacadeContainerSource(className, facadeClassName = null)
+            }
+        }
     }
 
     private fun getClass(

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/JvmStubDeserializedContainerSource.kt

@@ -6,10 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization
 
 import org.jetbrains.kotlin.descriptors.SourceFile
-import org.jetbrains.kotlin.load.kotlin.FacadeClassSource
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerAbiStability
@@ -17,20 +14,20 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ
 
 //required for LLFirDependenciesSymbolProvider#jvmClassName, to resolve ambiguities
 //todo check if moving builtins to stubs would solve the issue
-internal class JvmFromStubDecompilerSource(
-    override val className: JvmClassName,
-    override val facadeClassName: JvmClassName? = null,
-    override val incompatibility: IncompatibleVersionErrorData<JvmMetadataVersion>? = null,
-    override val isPreReleaseInvisible: Boolean = false,
-    override val abiStability: DeserializedContainerAbiStability = DeserializedContainerAbiStability.STABLE,
-) : DeserializedContainerSource, FacadeClassSource {
-    constructor(packageName: FqName) :
-            this(JvmClassName.byClassId(ClassId.topLevel(JvmClassName.byInternalName(packageName.asString()).fqNameForTopLevelClassMaybeWithDollars)))
+internal class JvmStubDeserializedContainerSource(classId: ClassId) : DeserializedContainerSource {
+    private val className = JvmClassName.byClassId(classId)
 
-    override fun getContainingFile(): SourceFile {
-        return SourceFile.NO_SOURCE_FILE
-    }
+    override val incompatibility: IncompatibleVersionErrorData<*>?
+        get() = null
+
+    override val isPreReleaseInvisible: Boolean
+        get() = false
+
+    override val abiStability: DeserializedContainerAbiStability
+        get() = DeserializedContainerAbiStability.STABLE
 
     override val presentableString: String
         get() = className.internalName
+
+    override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/JvmStubDeserializedFacadeContainerSource.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.low.level.api.fir.stubBased.deserialization
+
+import org.jetbrains.kotlin.descriptors.SourceFile
+import org.jetbrains.kotlin.load.kotlin.FacadeClassSource
+import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerAbiStability
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+
+internal class JvmStubDeserializedFacadeContainerSource(
+    override val className: JvmClassName,
+    override val facadeClassName: JvmClassName?
+) : DeserializedContainerSource, FacadeClassSource {
+    override val incompatibility: IncompatibleVersionErrorData<*>?
+        get() = null
+
+    override val isPreReleaseInvisible: Boolean
+        get() = false
+
+    override val abiStability: DeserializedContainerAbiStability
+        get() = DeserializedContainerAbiStability.STABLE
+
+    override val presentableString: String
+        get() = className.internalName
+
+    override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
+}

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/stubBased/deserialization/StubBasedFirMemberDeserializer.kt

@@ -142,19 +142,21 @@ internal class StubBasedFirDeserializationContext(
             callableId: CallableId,
             parameterListOwner: KtTypeParameterListOwner,
             symbol: FirBasedSymbol<*>,
-            initialOrigin: FirDeclarationOrigin
-        ): StubBasedFirDeserializationContext = createRootContext(
-            moduleData,
-            StubBasedAnnotationDeserializer(session),
-            callableId.packageName,
-            callableId.className,
-            parameterListOwner,
-            containerSource = if (initialOrigin == FirDeclarationOrigin.BuiltIns || callableId.packageName.isRoot)
-                null else JvmFromStubDecompilerSource(callableId.packageName),
-            outerClassSymbol = null,
-            symbol,
-            initialOrigin
-        )
+            initialOrigin: FirDeclarationOrigin,
+            containerSource: DeserializedContainerSource
+        ): StubBasedFirDeserializationContext {
+            return createRootContext(
+                moduleData,
+                StubBasedAnnotationDeserializer(session),
+                callableId.packageName,
+                callableId.className,
+                parameterListOwner,
+                containerSource = containerSource.takeIf { initialOrigin != FirDeclarationOrigin.BuiltIns },
+                outerClassSymbol = null,
+                symbol,
+                initialOrigin
+            )
+        }
     }
 }