FE: Make a definition of what built-in class is independent on environment

The idea is that we can always distinguish them by just using
JavaToKotlinClassMap.

The flag -Xcompile-builtins-as-part-of-stdlib remains unused
but cannot be fully removed until the change is bootstrapped.
(see KT-80839)

^KT-80524 Fixed

Author: dzharkov

compiler/fir/fir-jvm/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.fir.java.scopes
 
 import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.config.JvmAnalysisFlags
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fakeElement
@@ -32,7 +31,6 @@ import org.jetbrains.kotlin.fir.java.syntheticPropertiesStorage
 import org.jetbrains.kotlin.fir.java.toConeKotlinTypeProbablyFlexible
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.defaultType
-import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.scopes.impl.AbstractFirUseSiteMemberScope
@@ -991,16 +989,7 @@ class JavaClassUseSiteMemberScope(
             this is FirJavaClass -> superConeTypes.any { type ->
                 type.toFir(session)?.hasKotlinSuper(session, visited) == true
             }
-            isInterface || origin.isBuiltIns -> false
-            session.languageVersionSettings.getFlag(JvmAnalysisFlags.expectBuiltinsAsPartOfStdlib) -> {
-                when (val containingFile = session.firProvider.getFirClassifierContainerFileIfAny(symbol)) {
-                    null ->
-                        // No info about the containing file, so we assume it's a non-built-in Kotlin class
-                        true
-                    else ->
-                        !containingFile.symbol.hasAnnotation(StandardClassIds.Annotations.JvmBuiltin, session)
-                }
-            }
+            isInterface || symbol.isBuiltinClass() -> false
             else -> true
         }
 

compiler/fir/fir-jvm/src/org/jetbrains/kotlin/fir/java/scopes/JavaScopeUtils.kt

@@ -7,14 +7,11 @@
 
 package org.jetbrains.kotlin.fir.java.scopes
 
-import org.jetbrains.kotlin.config.JvmAnalysisFlags
+import org.jetbrains.kotlin.builtins.StandardNames
+import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.hasAnnotation
 import org.jetbrains.kotlin.fir.dispatchReceiverClassLookupTagOrNull
 import org.jetbrains.kotlin.fir.java.scopes.ClassicBuiltinSpecialProperties.getBuiltinSpecialPropertyGetterName
-import org.jetbrains.kotlin.fir.languageVersionSettings
-import org.jetbrains.kotlin.fir.resolve.providers.firProvider
-import org.jetbrains.kotlin.fir.resolve.providers.getContainingFile
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -32,7 +29,6 @@ import org.jetbrains.kotlin.load.java.SpecialGenericSignatures.Companion.ERASED_
 import org.jetbrains.kotlin.load.java.SpecialGenericSignatures.Companion.REMOVE_AT_NAME_AND_SIGNATURE
 import org.jetbrains.kotlin.load.java.SpecialGenericSignatures.Companion.SIGNATURE_TO_JVM_REPRESENTATION_NAME
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.StandardClassIds
 
 fun FirCallableSymbol<*>.doesOverrideBuiltinWithDifferentJvmName(containingScope: FirTypeScope, session: FirSession): Boolean {
     return getOverriddenBuiltinWithDifferentJvmName(containingScope, session) != null
@@ -146,14 +142,16 @@ object ClassicBuiltinSpecialProperties {
 }
 
 private fun FirCallableSymbol<*>.isFromBuiltinClass(session: FirSession): Boolean {
-    return dispatchReceiverClassLookupTagOrNull()?.toSymbol(session)?.isBuiltinClass(session) == true
+    return dispatchReceiverClassLookupTagOrNull()?.toSymbol(session)?.isBuiltinClass() == true
 }
 
-fun FirClassLikeSymbol<*>.isBuiltinClass(session: FirSession): Boolean {
+fun FirClassLikeSymbol<*>.isBuiltinClass(): Boolean {
     if (fir.origin.isBuiltIns) return true
-    if (!session.languageVersionSettings.getFlag(JvmAnalysisFlags.expectBuiltinsAsPartOfStdlib)) return false
-    val containingFile = session.firProvider.getContainingFile(this) ?: return false
-    return containingFile.symbol.hasAnnotation(StandardClassIds.Annotations.JvmBuiltin, session)
+    // Generally the condition above should be enough, but in some environments built-in classes
+    // might be loaded without the correct expected origin, e.g., when building stdlib artifact itself or for K2CL.
+    // See KT-68154 and KT-80524 for details.
+    // Having this branch, we may actually remove the line above, but leaving it as a fast-path.
+    return classId.packageFqName.startsWith(StandardNames.BUILT_INS_PACKAGE_NAME) && JavaToKotlinClassMap.isMappedKotlinClass(classId)
 }
 
 private fun FirNamedFunctionSymbol.firstOverriddenFunction(

core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JavaToKotlinClassMap.kt

@@ -39,6 +39,8 @@ object JavaToKotlinClassMap {
     private val mutableToReadOnlyClassId = HashMap<ClassId, ClassId>()
     private val readOnlyToMutableClassId = HashMap<ClassId, ClassId>()
 
+    private val mappedKotlinClassFqNames = mutableSetOf<FqName>()
+
     // describes mapping for a java class that has separate readOnly and mutable equivalents in Kotlin
     data class PlatformMutabilityMapping(
         val javaClass: ClassId,
@@ -198,10 +200,13 @@ object JavaToKotlinClassMap {
         javaToKotlin[javaClassId.asSingleFqName().toUnsafe()] = kotlinClassId
     }
 
-    private fun addKotlinToJava(kotlinFqNameUnsafe: FqName, javaClassId: ClassId) {
-        kotlinToJava[kotlinFqNameUnsafe.toUnsafe()] = javaClassId
+    private fun addKotlinToJava(kotlinFqName: FqName, javaClassId: ClassId) {
+        mappedKotlinClassFqNames.add(kotlinFqName)
+        kotlinToJava[kotlinFqName.toUnsafe()] = javaClassId
     }
 
+    fun isMappedKotlinClass(kotlinClassId: ClassId): Boolean = mappedKotlinClassFqNames.contains(kotlinClassId.asSingleFqName())
+
     fun isJavaPlatformClass(fqName: FqName): Boolean = mapJavaToKotlin(fqName) != null
 
     fun mutableToReadOnly(fqNameUnsafe: FqNameUnsafe?): FqName? = mutableToReadOnly[fqNameUnsafe]