IR: Refactor IrBuiltIns to abstract it from descriptors

compiler/fir/fir2ir/build.gradle.kts

@@ -32,6 +32,7 @@ dependencies {
     testRuntimeOnly(project(":kotlin-reflect"))
     testRuntimeOnly(project(":core:descriptors.runtime"))
     testRuntimeOnly(project(":compiler:fir:fir2ir:jvm-backend"))
+    testRuntimeOnly(project(":generators"))
 
     testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
     testRuntimeOnly(intellijCoreDep()) { includeJars("intellij-core") }
@@ -58,6 +59,14 @@ sourceSets {
     }
 }
 
+tasks {
+    val compileKotlin by existing(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class) {
+        kotlinOptions {
+            freeCompilerArgs += "-Xopt-in=org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI"
+        }
+    }
+}
+
 if (kotlinBuildProperties.isInJpsBuildIdeaSync) {
     apply(plugin = "idea")
     idea {

compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/Fir2IrJvmSpecialAnnotationSymbolProvider.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.fir.backend.jvm
 import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclarationWithWrappedDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.backend.Fir2IrSpecialSymbolProvider
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.declarations.addConstructor
 import org.jetbrains.kotlin.ir.builders.declarations.buildClass
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.DescriptorlessExternalPackageFragmentSymbol
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrComponents.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.fir.backend.generators.AnnotationGenerator
 import org.jetbrains.kotlin.fir.backend.generators.CallAndReferenceGenerator
 import org.jetbrains.kotlin.fir.backend.generators.FakeOverrideGenerator
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
 interface Fir2IrComponents {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrComponentsStorage.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.fir.signaturer.FirMangler
 import org.jetbrains.kotlin.ir.IrLock
 import org.jetbrains.kotlin.ir.declarations.IrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.util.SymbolTable
 
 class Fir2IrComponentsStorage(

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt

@@ -21,12 +21,12 @@ import org.jetbrains.kotlin.fir.packageFqName
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.signaturer.FirMangler
-import org.jetbrains.kotlin.fir.symbols.FirBuiltinSymbols
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.PsiIrFileEntry
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
 import org.jetbrains.kotlin.ir.util.ExternalDependenciesGenerator
 import org.jetbrains.kotlin.ir.util.IdSignatureComposer
@@ -251,6 +251,7 @@ class Fir2IrConverter(
     }
 
     companion object {
+        @OptIn(ObsoleteDescriptorBasedAPI::class)
         fun createModuleFragment(
             session: FirSession,
             scopeSession: ScopeSession,
@@ -267,8 +268,8 @@ class Fir2IrConverter(
             val symbolTable = SymbolTable(signaturer, irFactory)
             val typeTranslator =
                 TypeTranslatorImpl(symbolTable, languageVersionSettings, moduleDescriptor, extensions = generatorExtensions)
-            val irBuiltIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable)
-            FirBuiltinSymbols(irBuiltIns, moduleDescriptor.builtIns, symbolTable)
+            val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
+//            FirBuiltinSymbols(irBuiltIns, symbolTable)
             val components = Fir2IrComponentsStorage(session, scopeSession, symbolTable, irBuiltIns, irFactory, mangler)
             val conversionScope = Fir2IrConversionScope()
             val classifierStorage = Fir2IrClassifierStorage(components)

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrImplicitCastInserter.kt

@@ -17,8 +17,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl
 import org.jetbrains.kotlin.ir.types.*

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt

@@ -475,8 +475,7 @@ class Fir2IrVisitor(
             )
             is FirUnitExpression -> expression.convertWithOffsets { startOffset, endOffset ->
                 IrGetObjectValueImpl(
-                    startOffset, endOffset, irBuiltIns.unitType,
-                    this.symbolTable.referenceClass(this.irBuiltIns.builtIns.unit)
+                    startOffset, endOffset, irBuiltIns.unitType, this.irBuiltIns.unitClass
                 )
             }
             else -> {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/symbols/FirBuiltinSymbols.kt

@@ -1,35 +0,0 @@
-/*
- * Copyright 2010-2020 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.fir.symbols
-
-import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
-import org.jetbrains.kotlin.name.Name
-
-class FirBuiltinSymbols(
-    irBuiltIns: IrBuiltIns,
-    builtIns: KotlinBuiltIns,
-    symbolTable: ReferenceSymbolTable
-) : BuiltinSymbolsBase(irBuiltIns, builtIns, symbolTable) {
-
-    init {
-        val builtInsPackage = builtInsPackage("kotlin")
-        // Comparable is a base interface for many pre-generated built-in classes,
-        // like String, so it's easier if it's generated together with them
-        // Otherwise we have problems like "IrLazyClass inherits Fir2IrLazyClass",
-        // which does not work properly yet
-        for (name in listOf("Comparable")) {
-            (builtInsPackage.getContributedClassifier(
-                Name.identifier(name),
-                NoLookupLocation.FROM_BACKEND
-            ) as? ClassDescriptor)?.let { symbolTable.referenceClass(it) }
-        }
-    }
-}

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/BackendContext.kt

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.backend.common
 import org.jetbrains.kotlin.backend.common.ir.Ir
 import org.jetbrains.kotlin.backend.common.ir.SharedVariablesManager
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.name.FqName
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/CheckIrElementVisitor.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.backend.common
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/extensions/IrPluginContext.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.backend.common.extensions
 
-import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
@@ -35,8 +34,6 @@ interface IrPluginContext : IrGeneratorContext {
     @ObsoleteDescriptorBasedAPI
     val typeTranslator: TypeTranslator
 
-    val symbols: BuiltinSymbolsBase
-
     val platform: TargetPlatform?
 
     /**

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/extensions/IrPluginContextImpl.kt

@@ -5,15 +5,14 @@
 
 package org.jetbrains.kotlin.backend.common.extensions
 
-import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.util.IdSignature
@@ -35,8 +34,7 @@ open class IrPluginContextImpl constructor(
     override val typeTranslator: TypeTranslator,
     override val irBuiltIns: IrBuiltIns,
     val linker: IrDeserializer,
-    private val diagnosticReporter: IrMessageLogger,
-    override val symbols: BuiltinSymbolsBase = BuiltinSymbolsBase(irBuiltIns, irBuiltIns.builtIns, st)
+    private val diagnosticReporter: IrMessageLogger
 ) : IrPluginContext {
 
     override val platform: TargetPlatform? = module.platform

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/Ir.kt

@@ -7,28 +7,26 @@ package org.jetbrains.kotlin.backend.common.ir
 
 import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.common.lower.LocalDeclarationsLowering
-import org.jetbrains.kotlin.builtins.*
+import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.StandardNames.KOTLIN_REFLECT_FQ_NAME
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
-import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.classOrNull
 import org.jetbrains.kotlin.ir.types.defaultType
-import org.jetbrains.kotlin.ir.util.*
-import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
+import org.jetbrains.kotlin.ir.util.defaultType
+import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
+import org.jetbrains.kotlin.ir.util.getPackageFragment
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.calls.components.isVararg
-import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 
 // This is what Context collects about IR.
 abstract class Ir<out T : CommonBackendContext>(val context: T, val irModule: IrModuleFragment) {
@@ -46,32 +44,15 @@ abstract class Ir<out T : CommonBackendContext>(val context: T, val irModule: Ir
     open fun shouldGenerateHandlerParameterForDefaultBodyFun() = false
 }
 
-/**
- * Symbols for builtins that are available without any context and are not specific to any backend
- */
-open class BuiltinSymbolsBase(protected val irBuiltIns: IrBuiltIns, protected val builtIns: KotlinBuiltIns, private val symbolTable: ReferenceSymbolTable) {
-    protected fun builtInsPackage(vararg packageNameSegments: String) =
-        builtIns.builtInsModule.getPackage(FqName.fromSegments(listOf(*packageNameSegments))).memberScope
-
-    // consider making this public so it can be used to easily locate stdlib functions from any place (in particular, plugins and lowerings)
-    private fun getSimpleFunction(
-        name: Name,
-        vararg packageNameSegments: String = arrayOf("kotlin"),
-        condition: (SimpleFunctionDescriptor) -> Boolean
-    ): IrSimpleFunctionSymbol =
-        symbolTable.referenceSimpleFunction(
-            builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND)
-                .first(condition)
-        )
+// Some symbols below are used in kotlin-native, so they can't be private
+@Suppress("MemberVisibilityCanBePrivate", "PropertyName")
+abstract class Symbols<out T : CommonBackendContext>(
+    val context: T, val irBuiltIns: IrBuiltIns, private val symbolTable: ReferenceSymbolTable
+) {
 
     private fun getClass(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): IrClassSymbol =
-        getClassOrNull(name, *packageNameSegments) ?: error("Class '$name' not found in package '${packageNameSegments.joinToString(".")}'")
-
-    private fun getClassOrNull(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): IrClassSymbol? =
-        (builtInsPackage(*packageNameSegments).getContributedClassifier(
-            name,
-            NoLookupLocation.FROM_BACKEND
-        ) as? ClassDescriptor)?.let { symbolTable.referenceClass(it) }
+        irBuiltIns.findClass(name, *packageNameSegments)
+            ?: error("Class '$name' not found in package '${packageNameSegments.joinToString(".")}'")
 
     /**
      * Use this table to reference external dependencies.
@@ -89,25 +70,23 @@ open class BuiltinSymbolsBase(protected val irBuiltIns: IrBuiltIns, protected va
         type to iteratorClass
     }
 
-    val asserts = builtInsPackage("kotlin")
-        .getContributedFunctions(Name.identifier("assert"), NoLookupLocation.FROM_BACKEND)
-        .map { symbolTable.referenceFunction(it) }
+    val asserts = irBuiltIns.findFunctions(Name.identifier("assert"), "kotlin")
 
     private fun progression(name: String) = getClass(Name.identifier(name), "kotlin", "ranges")
-    private fun progressionOrNull(name: String) = getClassOrNull(Name.identifier(name), "kotlin", "ranges")
+    private fun progressionOrNull(name: String) = irBuiltIns.findClass(Name.identifier(name), "kotlin", "ranges")
 
     // The "...OrNull" variants are used for the classes below because the minimal stdlib used in tests do not include those classes.
     // It was not feasible to add them to the JS reduced runtime because all its transitive dependencies also need to be
     // added, which would include a lot of the full stdlib.
-    open val uByte = getClassOrNull(Name.identifier("UByte"), "kotlin")
-    open val uShort = getClassOrNull(Name.identifier("UShort"), "kotlin")
-    open val uInt = getClassOrNull(Name.identifier("UInt"), "kotlin")
-    open val uLong = getClassOrNull(Name.identifier("ULong"), "kotlin")
+    open val uByte = irBuiltIns.findClass(Name.identifier("UByte"), "kotlin")
+    open val uShort = irBuiltIns.findClass(Name.identifier("UShort"), "kotlin")
+    open val uInt = irBuiltIns.findClass(Name.identifier("UInt"), "kotlin")
+    open val uLong = irBuiltIns.findClass(Name.identifier("ULong"), "kotlin")
     val uIntProgression = progressionOrNull("UIntProgression")
     val uLongProgression = progressionOrNull("ULongProgression")
     val uIntRange = progressionOrNull("UIntRange")
     val uLongRange = progressionOrNull("ULongRange")
-    val sequence = getClassOrNull(Name.identifier("Sequence"), "kotlin", "sequences")
+    val sequence = irBuiltIns.findClass(Name.identifier("Sequence"), "kotlin", "sequences")
 
     val charProgression = progression("CharProgression")
     val intProgression = progression("IntProgression")
@@ -121,46 +100,26 @@ open class BuiltinSymbolsBase(protected val irBuiltIns: IrBuiltIns, protected va
 
     val closedRange = progression("ClosedRange")
 
-    val getProgressionLastElementByReturnType = builtInsPackage("kotlin", "internal")
-        .getContributedFunctions(Name.identifier("getProgressionLastElement"), NoLookupLocation.FROM_BACKEND)
-        .filter { it.containingDeclaration !is BuiltInsPackageFragment }
-        .map { d ->
-            val klass = d.returnType?.constructor?.declarationDescriptor?.let { symbolTable.referenceClassifier(it) }
-            val function = symbolTable.referenceSimpleFunction(d)
-            klass to function
-        }.toMap()
+    open val getProgressionLastElementByReturnType: Map<IrClassifierSymbol?, IrSimpleFunctionSymbol>
+        get() = irBuiltIns.getProgressionLastElementByReturnType
 
-    val toUIntByExtensionReceiver = builtInsPackage("kotlin").getContributedFunctions(
-        Name.identifier("toUInt"),
-        NoLookupLocation.FROM_BACKEND
-    ).filter { it.containingDeclaration !is BuiltInsPackageFragment && it.extensionReceiverParameter != null }
-        .map {
-            val klass = symbolTable.referenceClassifier(it.extensionReceiverParameter!!.type.constructor.declarationDescriptor!!)
-            val function = symbolTable.referenceSimpleFunction(it)
-            klass to function
-        }.toMap()
+    val toUIntByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+        get() = irBuiltIns.toUIntByExtensionReceiver
 
-    val toULongByExtensionReceiver = builtInsPackage("kotlin").getContributedFunctions(
-        Name.identifier("toULong"),
-        NoLookupLocation.FROM_BACKEND
-    ).filter { it.containingDeclaration !is BuiltInsPackageFragment && it.extensionReceiverParameter != null }
-        .map {
-            val klass = symbolTable.referenceClassifier(it.extensionReceiverParameter!!.type.constructor.declarationDescriptor!!)
-            val function = symbolTable.referenceSimpleFunction(it)
-            klass to function
-        }.toMap()
+    val toULongByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+        get() = irBuiltIns.toULongByExtensionReceiver
 
-    val any = symbolTable.referenceClass(builtIns.any)
-    val unit = symbolTable.referenceClass(builtIns.unit)
+    val any get() = irBuiltIns.anyClass
+    val unit get() = irBuiltIns.unitClass
 
-    val char = symbolTable.referenceClass(builtIns.char)
+    val char get() = irBuiltIns.charClass
 
-    val byte = symbolTable.referenceClass(builtIns.byte)
-    val short = symbolTable.referenceClass(builtIns.short)
-    val int = symbolTable.referenceClass(builtIns.int)
-    val long = symbolTable.referenceClass(builtIns.long)
-    val float = symbolTable.referenceClass(builtIns.float)
-    val double = symbolTable.referenceClass(builtIns.double)
+    val byte get() = irBuiltIns.byteClass
+    val short get() = irBuiltIns.shortClass
+    val int get() = irBuiltIns.intClass
+    val long get() = irBuiltIns.longClass
+    val float get() = irBuiltIns.floatClass
+    val double get() = irBuiltIns.doubleClass
 
     val integerClasses = listOf(byte, short, int, long)
 
@@ -168,41 +127,19 @@ open class BuiltinSymbolsBase(protected val irBuiltIns: IrBuiltIns, protected va
         listOfNotNull(byte, short, int, long, char, uByte, uShort, uInt, uLong).map { it.defaultType }
     }
 
-    val arrayOf = getSimpleFunction(Name.identifier("arrayOf")) {
-        it.extensionReceiverParameter == null && it.dispatchReceiverParameter == null && it.valueParameters.size == 1 &&
-                it.valueParameters[0].isVararg
-    }
+    val arrayOf: IrSimpleFunctionSymbol get() = irBuiltIns.arrayOf
+    val arrayOfNulls: IrSimpleFunctionSymbol get() = irBuiltIns.arrayOfNulls
 
-    val primitiveArrayOfByType = PrimitiveType.values().associate { type ->
-        val function = getSimpleFunction(Name.identifier(type.name.toLowerCaseAsciiOnly() + "ArrayOf")) {
-            it.extensionReceiverParameter == null && it.dispatchReceiverParameter == null && it.valueParameters.size == 1 &&
-                    it.valueParameters[0].isVararg
-        }
-        type to function
-    }
+    val array get() = irBuiltIns.arrayClass
 
-    val arrayOfNulls = getSimpleFunction(Name.identifier("arrayOfNulls")) {
-        it.extensionReceiverParameter == null && it.dispatchReceiverParameter == null && it.valueParameters.size == 1 &&
-                KotlinBuiltIns.isInt(it.valueParameters[0].type)
-    }
-
-    val array = symbolTable.referenceClass(builtIns.array)
-
-    private fun primitiveArrayClass(type: PrimitiveType) =
-        symbolTable.referenceClass(builtIns.getPrimitiveArrayClassDescriptor(type))
-
-    private fun unsignedArrayClass(unsignedType: UnsignedType) =
-        builtIns.builtInsModule.findClassAcrossModuleDependencies(unsignedType.arrayClassId)
-            ?.let { symbolTable.referenceClass(it) }
-
-    val byteArray = primitiveArrayClass(PrimitiveType.BYTE)
-    val charArray = primitiveArrayClass(PrimitiveType.CHAR)
-    val shortArray = primitiveArrayClass(PrimitiveType.SHORT)
-    val intArray = primitiveArrayClass(PrimitiveType.INT)
-    val longArray = primitiveArrayClass(PrimitiveType.LONG)
-    val floatArray = primitiveArrayClass(PrimitiveType.FLOAT)
-    val doubleArray = primitiveArrayClass(PrimitiveType.DOUBLE)
-    val booleanArray = primitiveArrayClass(PrimitiveType.BOOLEAN)
+    val byteArray get() = irBuiltIns.byteArray
+    val charArray get() = irBuiltIns.charArray
+    val shortArray get() = irBuiltIns.shortArray
+    val intArray get() = irBuiltIns.intArray
+    val longArray get() = irBuiltIns.longArray
+    val floatArray get() = irBuiltIns.floatArray
+    val doubleArray get() = irBuiltIns.doubleArray
+    val booleanArray get() = irBuiltIns.booleanArray
 
     val byteArrayType get() = byteArray.owner.defaultType
     val charArrayType get() = charArray.owner.defaultType
@@ -213,93 +150,50 @@ open class BuiltinSymbolsBase(protected val irBuiltIns: IrBuiltIns, protected va
     val doubleArrayType get() = doubleArray.owner.defaultType
     val booleanArrayType get() = booleanArray.owner.defaultType
 
-    val unsignedArrays = UnsignedType.values().mapNotNull { unsignedType ->
-        unsignedArrayClass(unsignedType)?.let { unsignedType to it }
-    }.toMap()
+    val primitiveArrays get() = irBuiltIns.primitiveArrays
+    val primitiveArraysToPrimitiveTypes get() = irBuiltIns.primitiveArraysToPrimitiveTypes
+    val unsignedArrays get() = irBuiltIns.unsignedArrays
 
+    val arrays = primitiveArrays + unsignedArrays + array
 
-    val primitiveArrays = PrimitiveType.values().associate { it to primitiveArrayClass(it) }
-
-    val arrays = primitiveArrays.values + unsignedArrays.values + array
-
-    val collection = symbolTable.referenceClass(builtIns.collection)
-    val set = symbolTable.referenceClass(builtIns.set)
-    val list = symbolTable.referenceClass(builtIns.list)
-    val map = symbolTable.referenceClass(builtIns.map)
-    val mapEntry = symbolTable.referenceClass(builtIns.mapEntry)
-    val iterable = symbolTable.referenceClass(builtIns.iterable)
-    val listIterator = symbolTable.referenceClass(builtIns.listIterator)
-    val mutableCollection = symbolTable.referenceClass(builtIns.mutableCollection)
-    val mutableSet = symbolTable.referenceClass(builtIns.mutableSet)
-    val mutableList = symbolTable.referenceClass(builtIns.mutableList)
-    val mutableMap = symbolTable.referenceClass(builtIns.mutableMap)
-    val mutableMapEntry = symbolTable.referenceClass(builtIns.mutableMapEntry)
-    val mutableIterable = symbolTable.referenceClass(builtIns.mutableIterable)
-    val mutableIterator = symbolTable.referenceClass(builtIns.mutableIterator)
-    val mutableListIterator = symbolTable.referenceClass(builtIns.mutableListIterator)
-    val comparable = symbolTable.referenceClass(builtIns.comparable)
+    val collection get() = irBuiltIns.collectionClass
+    val set get() = irBuiltIns.setClass
+    val list get() = irBuiltIns.listClass
+    val map get() = irBuiltIns.mapClass
+    val mapEntry get() = irBuiltIns.mapEntryClass
+    val iterable get() = irBuiltIns.iterableClass
+    val listIterator get() = irBuiltIns.listIteratorClass
+    val mutableCollection get() = irBuiltIns.mutableCollectionClass
+    val mutableSet get() = irBuiltIns.mutableSetClass
+    val mutableList get() = irBuiltIns.mutableListClass
+    val mutableMap get() = irBuiltIns.mutableMapClass
+    val mutableMapEntry get() = irBuiltIns.mutableMapEntryClass
+    val mutableIterable get() = irBuiltIns.mutableIterableClass
+    val mutableIterator get() = irBuiltIns.mutableIteratorClass
+    val mutableListIterator get() = irBuiltIns.mutableListIteratorClass
+    val comparable get() = irBuiltIns.comparableClass
 
     private val binaryOperatorCache = mutableMapOf<Triple<Name, IrType, IrType>, IrSimpleFunctionSymbol>()
 
-    fun getBinaryOperator(name: Name, lhsType: IrType, rhsType: IrType): IrSimpleFunctionSymbol {
-        require(lhsType is IrSimpleType) { "Expected IrSimpleType in getBinaryOperator, got $lhsType" }
-        val classifier = lhsType.classifier
-        require(classifier is IrClassSymbol && classifier.isBound) {
-            "Expected a bound IrClassSymbol for lhsType in getBinaryOperator, got $classifier"
-        }
-        val key = Triple(name, lhsType, rhsType)
-        return binaryOperatorCache.getOrPut(key) {
-            classifier.functions.single {
-                val function = it.owner
-                function.name == name && function.valueParameters.size == 1 && function.valueParameters[0].type == rhsType
-            }
-        }
-    }
+    fun getBinaryOperator(name: Name, lhsType: IrType, rhsType: IrType): IrSimpleFunctionSymbol = 
+        irBuiltIns.getBinaryOperator(name, lhsType, rhsType)
 
-    private val unaryOperatorCache = mutableMapOf<Pair<Name, IrType>, IrSimpleFunctionSymbol>()
+    fun getUnaryOperator(name: Name, receiverType: IrType): IrSimpleFunctionSymbol = irBuiltIns.getUnaryOperator(name, receiverType)
 
-    fun getUnaryOperator(name: Name, receiverType: IrType): IrSimpleFunctionSymbol {
-        require(receiverType is IrSimpleType) { "Expected IrSimpleType in getBinaryOperator, got $receiverType" }
-        val classifier = receiverType.classifier
-        require(classifier is IrClassSymbol && classifier.isBound) {
-            "Expected a bound IrClassSymbol for receiverType in getBinaryOperator, got $classifier"
-        }
-        val key = Pair(name, receiverType)
-        return unaryOperatorCache.getOrPut(key) {
-            classifier.functions.single {
-                val function = it.owner
-                function.name == name && function.valueParameters.isEmpty()
-            }
-        }
-    }
+    open fun functionN(n: Int): IrClassSymbol = irBuiltIns.functionN(n).symbol
+    open fun suspendFunctionN(n: Int): IrClassSymbol = irBuiltIns.suspendFunctionN(n).symbol
 
-    open fun functionN(n: Int): IrClassSymbol = irBuiltIns.function(n)
-    open fun suspendFunctionN(n: Int): IrClassSymbol = irBuiltIns.suspendFunction(n)
+    fun kproperty0(): IrClassSymbol = irBuiltIns.kProperty0Class
+    fun kproperty1(): IrClassSymbol = irBuiltIns.kProperty1Class
+    fun kproperty2(): IrClassSymbol = irBuiltIns.kProperty2Class
 
-    fun kproperty0(): IrClassSymbol = symbolTable.referenceClass(builtIns.kProperty0)
-    fun kproperty1(): IrClassSymbol = symbolTable.referenceClass(builtIns.kProperty1)
-    fun kproperty2(): IrClassSymbol = symbolTable.referenceClass(builtIns.kProperty2)
+    fun kmutableproperty0(): IrClassSymbol = irBuiltIns.kMutableProperty0Class
+    fun kmutableproperty1(): IrClassSymbol = irBuiltIns.kMutableProperty1Class
+    fun kmutableproperty2(): IrClassSymbol = irBuiltIns.kMutableProperty2Class
 
-    fun kmutableproperty0(): IrClassSymbol = symbolTable.referenceClass(builtIns.kMutableProperty0)
-    fun kmutableproperty1(): IrClassSymbol = symbolTable.referenceClass(builtIns.kMutableProperty1)
-    fun kmutableproperty2(): IrClassSymbol = symbolTable.referenceClass(builtIns.kMutableProperty2)
-
-    val extensionToString = getSimpleFunction(Name.identifier("toString")) {
-        it.dispatchReceiverParameter == null && it.extensionReceiverParameter != null &&
-                KotlinBuiltIns.isNullableAny(it.extensionReceiverParameter!!.type) && it.valueParameters.size == 0
-    }
-
-    val stringPlus = getSimpleFunction(Name.identifier("plus")) {
-        it.dispatchReceiverParameter == null && it.extensionReceiverParameter != null &&
-                KotlinBuiltIns.isStringOrNullableString(it.extensionReceiverParameter!!.type) && it.valueParameters.size == 1 &&
-                KotlinBuiltIns.isNullableAny(it.valueParameters.first().type)
-    }
-}
-
-// Some symbols below are used in kotlin-native, so they can't be private
-@Suppress("MemberVisibilityCanBePrivate", "PropertyName")
-abstract class Symbols<out T : CommonBackendContext>(val context: T, irBuiltIns: IrBuiltIns, symbolTable: SymbolTable) :
-    BuiltinSymbolsBase(irBuiltIns, context.builtIns, symbolTable) {
+    val extensionToString: IrSimpleFunctionSymbol get() = irBuiltIns.extensionToString
+    val stringPlus: IrSimpleFunctionSymbol get() = irBuiltIns.stringPlus
+    
     abstract val throwNullPointerException: IrSimpleFunctionSymbol
     abstract val throwTypeCastException: IrSimpleFunctionSymbol
 

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.declarations.addConstructor
 import org.jetbrains.kotlin.ir.builders.declarations.buildReceiverParameter

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/AbstractValueUsageTransformer.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.backend.common.lower
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrStringConcatenationImpl
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/LowerUtils.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.backend.common.lower
 import org.jetbrains.kotlin.backend.common.BackendContext
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.IrSymbol

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/SingleAbstractMethodLowering.kt

@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.*
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrTypeOperator

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/optimizations/FoldConstantLowering.kt

@@ -9,13 +9,17 @@ import org.jetbrains.kotlin.backend.common.BodyLoweringPass
 import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.ir.BuiltInOperatorNames
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrStringConcatenationImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.IrSimpleType
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.getPrimitiveType
+import org.jetbrains.kotlin.ir.types.isStringClassType
 import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
 import org.jetbrains.kotlin.ir.util.isUnsigned
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
@@ -71,29 +75,29 @@ class FoldConstantLowering(
 
         init {
             // IrBuiltins
-            registerBuiltinBinaryOp(DOUBLE, IrBuiltIns.OperatorNames.LESS) { a, b -> a < b }
-            registerBuiltinBinaryOp(DOUBLE, IrBuiltIns.OperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
-            registerBuiltinBinaryOp(DOUBLE, IrBuiltIns.OperatorNames.GREATER) { a, b -> a > b }
-            registerBuiltinBinaryOp(DOUBLE, IrBuiltIns.OperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
-            registerBuiltinBinaryOp(DOUBLE, IrBuiltIns.OperatorNames.IEEE754_EQUALS) { a, b -> a == b }
+            registerBuiltinBinaryOp(DOUBLE, BuiltInOperatorNames.LESS) { a, b -> a < b }
+            registerBuiltinBinaryOp(DOUBLE, BuiltInOperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
+            registerBuiltinBinaryOp(DOUBLE, BuiltInOperatorNames.GREATER) { a, b -> a > b }
+            registerBuiltinBinaryOp(DOUBLE, BuiltInOperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
+            registerBuiltinBinaryOp(DOUBLE, BuiltInOperatorNames.IEEE754_EQUALS) { a, b -> a == b }
 
-            registerBuiltinBinaryOp(FLOAT, IrBuiltIns.OperatorNames.LESS) { a, b -> a < b }
-            registerBuiltinBinaryOp(FLOAT, IrBuiltIns.OperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
-            registerBuiltinBinaryOp(FLOAT, IrBuiltIns.OperatorNames.GREATER) { a, b -> a > b }
-            registerBuiltinBinaryOp(FLOAT, IrBuiltIns.OperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
-            registerBuiltinBinaryOp(FLOAT, IrBuiltIns.OperatorNames.IEEE754_EQUALS) { a, b -> a == b }
+            registerBuiltinBinaryOp(FLOAT, BuiltInOperatorNames.LESS) { a, b -> a < b }
+            registerBuiltinBinaryOp(FLOAT, BuiltInOperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
+            registerBuiltinBinaryOp(FLOAT, BuiltInOperatorNames.GREATER) { a, b -> a > b }
+            registerBuiltinBinaryOp(FLOAT, BuiltInOperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
+            registerBuiltinBinaryOp(FLOAT, BuiltInOperatorNames.IEEE754_EQUALS) { a, b -> a == b }
 
-            registerBuiltinBinaryOp(INT, IrBuiltIns.OperatorNames.LESS) { a, b -> a < b }
-            registerBuiltinBinaryOp(INT, IrBuiltIns.OperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
-            registerBuiltinBinaryOp(INT, IrBuiltIns.OperatorNames.GREATER) { a, b -> a > b }
-            registerBuiltinBinaryOp(INT, IrBuiltIns.OperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
-            registerBuiltinBinaryOp(INT, IrBuiltIns.OperatorNames.EQEQ) { a, b -> a == b }
+            registerBuiltinBinaryOp(INT, BuiltInOperatorNames.LESS) { a, b -> a < b }
+            registerBuiltinBinaryOp(INT, BuiltInOperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
+            registerBuiltinBinaryOp(INT, BuiltInOperatorNames.GREATER) { a, b -> a > b }
+            registerBuiltinBinaryOp(INT, BuiltInOperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
+            registerBuiltinBinaryOp(INT, BuiltInOperatorNames.EQEQ) { a, b -> a == b }
 
-            registerBuiltinBinaryOp(LONG, IrBuiltIns.OperatorNames.LESS) { a, b -> a < b }
-            registerBuiltinBinaryOp(LONG, IrBuiltIns.OperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
-            registerBuiltinBinaryOp(LONG, IrBuiltIns.OperatorNames.GREATER) { a, b -> a > b }
-            registerBuiltinBinaryOp(LONG, IrBuiltIns.OperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
-            registerBuiltinBinaryOp(LONG, IrBuiltIns.OperatorNames.EQEQ) { a, b -> a == b }
+            registerBuiltinBinaryOp(LONG, BuiltInOperatorNames.LESS) { a, b -> a < b }
+            registerBuiltinBinaryOp(LONG, BuiltInOperatorNames.LESS_OR_EQUAL) { a, b -> a <= b }
+            registerBuiltinBinaryOp(LONG, BuiltInOperatorNames.GREATER) { a, b -> a > b }
+            registerBuiltinBinaryOp(LONG, BuiltInOperatorNames.GREATER_OR_EQUAL) { a, b -> a >= b }
+            registerBuiltinBinaryOp(LONG, BuiltInOperatorNames.EQEQ) { a, b -> a == b }
         }
     }
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIntrinsics.kt

@@ -6,23 +6,13 @@
 package org.jetbrains.kotlin.ir.backend.js
 
 import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.ir.backend.js.utils.Namer
-import org.jetbrains.kotlin.ir.builders.declarations.addFunction
-import org.jetbrains.kotlin.ir.builders.declarations.addTypeParameter
-import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
-import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.defaultType
-import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeBuilder
-import org.jetbrains.kotlin.ir.types.impl.buildSimpleType
 import org.jetbrains.kotlin.ir.types.isLong
-import org.jetbrains.kotlin.ir.types.typeWithParameters
 import org.jetbrains.kotlin.ir.util.constructors
 import org.jetbrains.kotlin.ir.util.findDeclaration
 import org.jetbrains.kotlin.ir.util.kotlinPackageFqn
@@ -32,7 +22,8 @@ import org.jetbrains.kotlin.psi2ir.findSingleFunction
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 import java.util.*
 
-class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendContext) {
+@OptIn(ObsoleteDescriptorBasedAPI::class)
+class JsIntrinsics(private val irBuiltIns: IrBuiltInsOverDescriptors, val context: JsIrBackendContext) {
 
     // TODO: Should we drop operator intrinsics in favor of IrDynamicOperatorExpression?
 
@@ -224,10 +215,9 @@ class JsIntrinsics(private val irBuiltIns: IrBuiltIns, val context: JsIrBackendC
     val jsEnsureNonNull = getFunctionInKotlinPackage("ensureNotNull")
 
     // Arrays:
-    val array = context.symbolTable.referenceClass(irBuiltIns.builtIns.array)
+    val array get() = irBuiltIns.arrayClass
 
-    val primitiveArrays = PrimitiveType.values()
-        .associate { context.symbolTable.referenceClass(irBuiltIns.builtIns.getPrimitiveArrayClassDescriptor(it)) to it }
+    val primitiveArrays get() = irBuiltIns.primitiveArraysToPrimitiveTypes
 
     val jsArray = getInternalFunction("arrayWithFun")
     val jsFillArray = getInternalFunction("fillArrayFun")

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt

@@ -16,10 +16,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.IrFileEntry
-import org.jetbrains.kotlin.ir.SourceRangeInfo
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
 import org.jetbrains.kotlin.ir.backend.js.lower.JsInnerClassesSupport
 import org.jetbrains.kotlin.ir.backend.js.utils.JsInlineClassesUtils
@@ -28,7 +25,7 @@ import org.jetbrains.kotlin.ir.builders.declarations.addFunction
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
@@ -181,7 +178,8 @@ class JsIrBackendContext(
     private val coroutineIntrinsicsPackage = module.getPackage(COROUTINE_INTRINSICS_PACKAGE_FQNAME)
 
     val dynamicType: IrDynamicType = IrDynamicTypeImpl(null, emptyList(), Variance.INVARIANT)
-    val intrinsics = JsIntrinsics(irBuiltIns, this)
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
+    val intrinsics = JsIntrinsics(irBuiltIns as IrBuiltInsOverDescriptors, this)
 
     override val sharedVariablesManager = JsSharedVariablesManager(this)
 

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsSharedVariablesManager.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.ir.backend.js
 
 import org.jetbrains.kotlin.backend.common.ir.SharedVariablesManager
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.declarations.buildVariable
 import org.jetbrains.kotlin.ir.declarations.IrVariable
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrSetValue

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/VarargLowering.kt

@@ -41,8 +41,7 @@ private class VarargTransformer(
     private fun List<IrExpression>.toArrayLiteral(type: IrType, varargElementType: IrType): IrExpression {
 
         // TODO: Use symbols when builtins symbol table is fixes
-        val primitiveType = context.intrinsics.primitiveArrays
-            .mapKeys { it.key }[type.classifierOrNull]
+        val primitiveType = context.intrinsics.primitiveArrays.mapKeys { it.key }[type.classifierOrNull]
 
         val intrinsic =
             if (primitiveType != null)

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensionsImpl.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyClass
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrDelegatingConstructorCall
 import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl
 import org.jetbrains.kotlin.ir.symbols.impl.DescriptorlessExternalPackageFragmentSymbol

compiler/ir/backend.jvm/entrypoint/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.backend.jvm
 import org.jetbrains.kotlin.analyzer.hasJdkCapability
 import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension
 import org.jetbrains.kotlin.backend.common.extensions.IrPluginContextImpl
-import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase
 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.phaser.invokeToplevel
 import org.jetbrains.kotlin.backend.jvm.ir.getKtFile
@@ -27,8 +26,7 @@ import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.psi.KtFile
@@ -75,8 +73,6 @@ open class JvmIrCodegenFactory(
         val messageLogger = state.configuration[IrMessageLogger.IR_MESSAGE_LOGGER] ?: IrMessageLogger.None
         val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, symbolTable, jvmGeneratorExtensions)
         val pluginExtensions = IrGenerationExtension.getInstances(state.project)
-        val functionFactory = IrFunctionFactory(psi2irContext.irBuiltIns, symbolTable)
-        psi2irContext.irBuiltIns.functionFactory = functionFactory
 
         val stubGenerator =
             DeclarationStubGeneratorImpl(psi2irContext.moduleDescriptor, symbolTable, psi2irContext.irBuiltIns, jvmGeneratorExtensions)
@@ -95,7 +91,6 @@ open class JvmIrCodegenFactory(
             messageLogger,
             JvmIrTypeSystemContext(psi2irContext.irBuiltIns),
             symbolTable,
-            functionFactory,
             frontEndContext,
             stubGenerator,
             mangler
@@ -103,7 +98,6 @@ open class JvmIrCodegenFactory(
 
         val pluginContext by lazy {
             psi2irContext.run {
-                val symbols = BuiltinSymbolsBase(irBuiltIns, moduleDescriptor.builtIns, symbolTable.lazyWrapper)
                 IrPluginContextImpl(
                     moduleDescriptor,
                     bindingContext,
@@ -112,8 +106,7 @@ open class JvmIrCodegenFactory(
                     typeTranslator,
                     irBuiltIns,
                     irLinker,
-                    messageLogger,
-                    symbols
+                    messageLogger
                 )
             }
         }
@@ -221,7 +214,6 @@ open class JvmIrCodegenFactory(
         symbolTable: SymbolTable,
         extensions: JvmGeneratorExtensionsImpl,
     ): List<IrProvider> {
-        irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable)
         return generateTypicalIrProviderList(
             irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions
         )

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt

@@ -22,12 +22,12 @@ import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.MemoizedInlineClassR
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope
 import org.jetbrains.kotlin.ir.builders.irBlock
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.symbols.*

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrTypeSystemContext.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.backend.jvm
 import org.jetbrains.kotlin.backend.jvm.ir.IrJvmFlexibleType
 import org.jetbrains.kotlin.backend.jvm.ir.asJvmFlexibleType
 import org.jetbrains.kotlin.backend.jvm.ir.isWithFlexibleNullability
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmSymbols.kt

@@ -15,10 +15,11 @@ import org.jetbrains.kotlin.codegen.coroutines.INVOKE_SUSPEND_METHOD_NAME
 import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_CALL_RESULT_NAME
 import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
 import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_CREATE_METHOD_NAME
-import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.builders.declarations.*
 import org.jetbrains.kotlin.ir.declarations.IrClass
@@ -26,7 +27,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
 import org.jetbrains.kotlin.ir.symbols.*
@@ -56,6 +56,8 @@ class JvmSymbols(
     private val javaLangPackage: IrPackageFragment = createPackage(FqName("java.lang"))
     private val javaUtilPackage: IrPackageFragment = createPackage(FqName("java.util"))
 
+    private val kotlinInternalPackage: IrPackageFragment = createPackage(FqName("kotlin.internal"))
+
     // Special package for functions representing dynamic symbols referenced by 'INVOKEDYNAMIC' instruction - e.g.,
     //  'get(Ljava/lang/String;)Ljava/util/function/Supplier;'
     // in
@@ -95,6 +97,7 @@ class JvmSymbols(
                 "kotlin.reflect" -> kotlinReflectPackage
                 "java.lang" -> javaLangPackage
                 "java.util" -> javaUtilPackage
+                "kotlin.internal" -> kotlinInternalPackage
                 else -> error("Other packages are not supported yet: $fqName")
             }
             createImplicitParameterDeclarationWithWrappedDescriptor()
@@ -363,7 +366,7 @@ class JvmSymbols(
         }
     }
 
-    fun getFunction(parameterCount: Int): IrClassSymbol = irBuiltIns.function(parameterCount)
+    fun getFunction(parameterCount: Int): IrClassSymbol = irBuiltIns.functionN(parameterCount).symbol
 
     private val jvmFunctionClasses = storageManager.createMemoizedFunction { n: Int ->
         createFunctionClass(n, false)
@@ -546,6 +549,42 @@ class JvmSymbols(
             returnType = dst.defaultType
         }.symbol
 
+    private val progressionUtilClasses by lazy(LazyThreadSafetyMode.PUBLICATION) {
+        listOf(
+            "kotlin.internal.ProgressionUtilKt" to listOf(int, long),
+            "kotlin.internal.UProgressionUtilKt" to listOfNotNull(uInt, uLong)
+        ).map { (fqn, types) ->
+            createClass(FqName(fqn)) { klass ->
+                for (type in types) {
+                    klass.addFunction("getProgressionLastElement", type.owner.defaultType, isStatic = true).apply {
+                        for (paramName in arrayOf("s", "e")) {
+                            addValueParameter(paramName, type.owner.defaultType)
+                        }
+                        addValueParameter(
+                            "st",
+                            when (type) {
+                                uInt -> int.owner.defaultType
+                                uLong -> long.owner.defaultType
+                                else -> type.owner.defaultType
+                            }
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    override val getProgressionLastElementByReturnType: Map<IrClassifierSymbol?, IrSimpleFunctionSymbol> by lazy(LazyThreadSafetyMode.PUBLICATION) {
+        progressionUtilClasses.flatMap { klass ->
+            klass.functions.filter {
+                it.owner.name.identifier == "getProgressionLastElement"
+            }.map {
+                it.owner.returnType.classifierOrFail to it
+            }
+        }.toMap()
+    }
+
+
     val arrayOfAnyType = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyType)
     val arrayOfAnyNType = irBuiltIns.arrayClass.typeWith(irBuiltIns.anyNType)
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/SharedVariablesManager.kt

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.backend.common.ir.createImplicitParameterDeclaration
 import org.jetbrains.kotlin.backend.jvm.JvmSymbols
 import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.InlineClassAbi
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.builders.declarations.*
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicMethods.kt

@@ -19,8 +19,11 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics
 import org.jetbrains.kotlin.backend.jvm.JvmSymbols
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
+import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
@@ -125,7 +128,7 @@ class IrIntrinsicMethods(val irBuiltIns: IrBuiltIns, val symbols: JvmSymbols) {
             ).toMap()
 
     private fun intrinsicsThatShouldHaveBeenLowered() =
-        (symbols.primitiveArrays.values.map { primitiveClassSymbol ->
+        (symbols.primitiveArrays.map { primitiveClassSymbol ->
             val name = primitiveClassSymbol.owner.name.asString()
             // IntArray -> intArrayOf
             val arrayOfFunName = name.decapitalizeAsciiOnly() + "Of"
@@ -168,7 +171,7 @@ class IrIntrinsicMethods(val irBuiltIns: IrBuiltIns, val symbols: JvmSymbols) {
                 numberConversionMethods(irBuiltIns.numberClass)
 
     private fun arrayMethods(): List<Pair<Key, IntrinsicMethod>> =
-        symbols.primitiveArrays.flatMap { (key, value) -> arrayMethods(key.symbol, value) } +
+        symbols.primitiveArraysToPrimitiveTypes.flatMap { (array, primitiveType) -> arrayMethods(primitiveType.symbol, array) } +
                 arrayMethods(symbols.array.owner.typeParameters.single().symbol, symbols.array)
 
     private fun arrayMethods(elementClass: IrClassifierSymbol, arrayClass: IrClassSymbol) =

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrJvmFlexibleType.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.backend.jvm.JvmSymbols
 import org.jetbrains.kotlin.backend.jvm.codegen.isRawType
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrSimpleType
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.classFqName

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrUtils.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.deserialization.PLATFORM_DEPENDENT_ANNOTATION_FQ_NAME
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.PsiIrFileEntry
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
@@ -26,7 +27,6 @@ import org.jetbrains.kotlin.ir.builders.Scope
 import org.jetbrains.kotlin.ir.builders.declarations.buildProperty
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyClass
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/JvmStaticAnnotationLowering.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.backend.jvm.lower
 
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
-import org.jetbrains.kotlin.backend.common.ir.*
+import org.jetbrains.kotlin.backend.common.ir.simpleFunctions
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.backend.common.phaser.makeIrModulePhase
 import org.jetbrains.kotlin.backend.jvm.CachedFieldsForObjectInstances
@@ -16,9 +16,9 @@ import org.jetbrains.kotlin.backend.jvm.codegen.isEffectivelyInlineOnly
 import org.jetbrains.kotlin.backend.jvm.codegen.isInlineFunctionCall
 import org.jetbrains.kotlin.backend.jvm.ir.replaceThisByStaticReference
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrBlockImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.backend.jvm.lower.inlineclasses
 
-import org.jetbrains.kotlin.backend.common.ir.*
+import org.jetbrains.kotlin.backend.common.ir.copyTo
+import org.jetbrains.kotlin.backend.common.ir.copyTypeParameters
+import org.jetbrains.kotlin.backend.common.ir.copyTypeParametersFrom
+import org.jetbrains.kotlin.backend.common.ir.createDispatchReceiverParameter
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
 import org.jetbrains.kotlin.backend.jvm.codegen.classFileContainsMethod
@@ -17,11 +20,11 @@ import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.InlineClassAbi.mangl
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.builders.declarations.buildProperty
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.ir.types.impl.IrStarProjectionImpl

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/WasmBackendContext.kt

@@ -13,10 +13,7 @@ import org.jetbrains.kotlin.backend.wasm.utils.WasmInlineClassesUtils
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor
-import org.jetbrains.kotlin.ir.IrElement
-import org.jetbrains.kotlin.ir.IrFileEntry
-import org.jetbrains.kotlin.ir.SourceRangeInfo
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.backend.js.JsCommonBackendContext
 import org.jetbrains.kotlin.ir.backend.js.JsMapping
 import org.jetbrains.kotlin.ir.backend.js.lower.JsInnerClassesSupport
@@ -27,7 +24,6 @@ import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.IrPackageFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.impl.DescriptorlessExternalPackageFragmentSymbol
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt

@@ -13,11 +13,11 @@ import org.jetbrains.kotlin.backend.common.ir.returnType
 import org.jetbrains.kotlin.backend.wasm.WasmBackendContext
 import org.jetbrains.kotlin.backend.wasm.WasmSymbols
 import org.jetbrains.kotlin.backend.wasm.utils.*
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.backend.js.utils.realOverrideTarget
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.defaultType

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/ClassInfo.kt

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.backend.wasm.lower.WasmSignature
 import org.jetbrains.kotlin.backend.wasm.lower.wasmSignature
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.backend.js.utils.realOverrideTarget
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.classifierOrFail
 import org.jetbrains.kotlin.ir.util.fqNameWhenAvailable
 import org.jetbrains.kotlin.ir.util.isInterface

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt

@@ -11,10 +11,10 @@ import org.jetbrains.kotlin.backend.wasm.lower.wasmSignature
 import org.jetbrains.kotlin.backend.wasm.utils.*
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.backend.js.utils.realOverrideTarget
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt

@@ -5,11 +5,10 @@
 
 package org.jetbrains.kotlin.backend.wasm.ir2wasm
 
-import org.jetbrains.kotlin.wasm.ir.*
 import org.jetbrains.kotlin.backend.wasm.utils.hasWasmForeignAnnotation
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -17,6 +16,7 @@ import org.jetbrains.kotlin.ir.types.classifierOrNull
 import org.jetbrains.kotlin.ir.types.getClass
 import org.jetbrains.kotlin.ir.util.getInlineClassUnderlyingType
 import org.jetbrains.kotlin.ir.util.isInterface
+import org.jetbrains.kotlin.wasm.ir.*
 
 class WasmTypeTransformer(
     val context: WasmBaseCodegenContext,

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmBridgesConstruction.kt

@@ -5,13 +5,12 @@
 
 package org.jetbrains.kotlin.backend.wasm.lower
 
-import org.jetbrains.kotlin.backend.common.CommonBackendContext
 import org.jetbrains.kotlin.backend.wasm.ir2wasm.erasedUpperBound
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.backend.js.JsCommonBackendContext
 import org.jetbrains.kotlin.ir.backend.js.lower.BridgesConstruction
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.isNullable
 import org.jetbrains.kotlin.ir.types.makeNullable

compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/lower/WasmSharedVariablesManager.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.backend.wasm.lower
 import org.jetbrains.kotlin.backend.common.ir.SharedVariablesManager
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.backend.js.JsCommonBackendContext
 import org.jetbrains.kotlin.ir.backend.js.JsLoweredDeclarationOrigin
@@ -16,7 +17,6 @@ import org.jetbrains.kotlin.ir.builders.declarations.buildClass
 import org.jetbrains.kotlin.ir.builders.declarations.buildValueParameter
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.IrSetValue

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/CallInterceptor.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.ir.interpreter
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
@@ -26,7 +26,10 @@ import org.jetbrains.kotlin.ir.interpreter.state.reflection.KTypeState
 import org.jetbrains.kotlin.ir.interpreter.state.reflection.ReflectionState
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.classOrNull
+import org.jetbrains.kotlin.ir.types.isArray
+import org.jetbrains.kotlin.ir.types.isUnsignedType
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.util.hasAnnotation
 import org.jetbrains.kotlin.name.FqName

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreter.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.ir.interpreter
 
 import org.jetbrains.kotlin.builtins.UnsignedType
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
 import org.jetbrains.kotlin.ir.interpreter.exceptions.InterpreterError
@@ -18,7 +18,10 @@ import org.jetbrains.kotlin.ir.interpreter.proxy.Proxy
 import org.jetbrains.kotlin.ir.interpreter.stack.CallStack
 import org.jetbrains.kotlin.ir.interpreter.stack.Variable
 import org.jetbrains.kotlin.ir.interpreter.state.*
-import org.jetbrains.kotlin.ir.interpreter.state.reflection.*
+import org.jetbrains.kotlin.ir.interpreter.state.reflection.KClassState
+import org.jetbrains.kotlin.ir.interpreter.state.reflection.KFunctionState
+import org.jetbrains.kotlin.ir.interpreter.state.reflection.KPropertyState
+import org.jetbrains.kotlin.ir.interpreter.state.reflection.KTypeState
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/IrInterpreterEnvironment.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.ir.interpreter
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.interpreter.stack.CallStack
 import org.jetbrains.kotlin.ir.interpreter.state.Common
 import org.jetbrains.kotlin.ir.interpreter.state.Complex

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/checker/EvaluationMode.kt

@@ -5,11 +5,17 @@
 
 package org.jetbrains.kotlin.ir.interpreter.checker
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.interpreter.*
+import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.expressions.IrGetObjectValue
+import org.jetbrains.kotlin.ir.expressions.IrGetValue
+import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
+import org.jetbrains.kotlin.ir.interpreter.compileTimeAnnotation
+import org.jetbrains.kotlin.ir.interpreter.contractsDslAnnotation
+import org.jetbrains.kotlin.ir.interpreter.evaluateIntrinsicAnnotation
 import org.jetbrains.kotlin.ir.interpreter.hasAnnotation
+import org.jetbrains.kotlin.ir.interpreter.isUnsigned
 import org.jetbrains.kotlin.ir.types.isAny
 import org.jetbrains.kotlin.ir.types.isPrimitiveType
 import org.jetbrains.kotlin.ir.types.isString

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/reflection/KClassState.kt

@@ -51,7 +51,7 @@ internal class KClassState(val classReference: IrClass, override val irClass: Ir
                             else -> TODO()
                         }
                     }
-                    is IrFunction -> KFunctionProxy(KFunctionState(it, callInterceptor.irBuiltIns.functionFactory), callInterceptor)
+                    is IrFunction -> KFunctionProxy(KFunctionState(it, callInterceptor.irBuiltIns), callInterceptor)
                     else -> TODO()
                 }
             }
@@ -62,7 +62,7 @@ internal class KClassState(val classReference: IrClass, override val irClass: Ir
         if (_constructors != null) return _constructors!!
         _constructors = classReference.declarations
             .filterIsInstance<IrConstructor>()
-            .map { KFunctionProxy(KFunctionState(it, callInterceptor.irBuiltIns.functionFactory), callInterceptor) }
+            .map { KFunctionProxy(KFunctionState(it, callInterceptor.irBuiltIns), callInterceptor) }
         return _constructors!!
     }
 

compiler/ir/ir.interpreter/src/org/jetbrains/kotlin/ir/interpreter/state/reflection/KFunctionState.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.ir.interpreter.state.reflection
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
 import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.interpreter.CallInterceptor
 import org.jetbrains.kotlin.ir.interpreter.proxy.reflection.KParameterProxy
@@ -29,8 +29,8 @@ internal class KFunctionState(val irFunction: IrFunction, override val irClass:
     private var _typeParameters: List<KTypeParameter>? = null
 
     constructor(functionReference: IrFunctionReference) : this(functionReference.symbol.owner, functionReference.type.classOrNull!!.owner)
-    constructor(irFunction: IrFunction, functionFactory: IrAbstractFunctionFactory) :
-            this(irFunction, functionFactory.kFunctionN(irFunction.valueParameters.size))
+    constructor(irFunction: IrFunction, irBuiltIns: IrBuiltIns) :
+            this(irFunction, irBuiltIns.kFunctionN(irFunction.valueParameters.size))
 
     fun getParameters(callInterceptor: CallInterceptor): List<KParameter> {
         if (_parameters != null) return _parameters!!

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/Psi2IrTranslator.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
@@ -63,7 +63,7 @@ class Psi2IrTranslator(
             symbolTable,
             extensions,
             typeTranslator,
-            IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable),
+            IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable),
         )
     }
 

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt

@@ -36,7 +36,6 @@ import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsResultOfLambda
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
 import org.jetbrains.kotlin.types.KotlinType
-import java.util.*
 
 class BodyGenerator(
     val scopeOwnerSymbol: IrSymbol,
@@ -112,7 +111,7 @@ class BodyGenerator(
                     ktBody.startOffsetSkippingComments, ktBody.endOffset,
                     IrGetObjectValueImpl(
                         ktBody.startOffsetSkippingComments, ktBody.endOffset, context.irBuiltIns.unitType,
-                        context.symbolTable.referenceClass(context.builtIns.unit)
+                        context.irBuiltIns.unitClass
                     )
                 )
             )
@@ -262,7 +261,7 @@ class BodyGenerator(
     }
 
     private fun generateAnySuperConstructorCall(body: IrBlockBody, ktElement: KtPureElement) {
-        val anyConstructor = context.builtIns.any.constructors.single()
+        val anyConstructor = context.irBuiltIns.anyClass.descriptor.constructors.single()
         body.statements.add(
             IrDelegatingConstructorCallImpl.fromSymbolDescriptor(
                 ktElement.pureStartOffset, ktElement.pureEndOffset,
@@ -273,7 +272,7 @@ class BodyGenerator(
     }
 
     private fun generateEnumSuperConstructorCall(body: IrBlockBody, ktElement: KtElement, classDescriptor: ClassDescriptor) {
-        val enumConstructor = context.builtIns.enum.constructors.single()
+        val enumConstructor = context.irBuiltIns.enumClass.descriptor.constructors.single()
         body.statements.add(
             IrEnumConstructorCallImpl.fromSymbolDescriptor(
                 ktElement.startOffsetSkippingComments, ktElement.endOffset,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DataClassMembersGenerator.kt

@@ -92,7 +92,7 @@ class DataClassMembersGenerator(
 
             private fun getHashCodeFunction(type: KotlinType): FunctionDescriptor =
                 type.memberScope.findHashCodeFunctionOrNull()
-                    ?: context.builtIns.any.unsubstitutedMemberScope.findHashCodeFunctionOrNull()!!
+                    ?: context.irBuiltIns.anyClass.descriptor.unsubstitutedMemberScope.findHashCodeFunctionOrNull()!!
 
             private fun getHashCodeFunction(
                 type: KotlinType,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationStubGeneratorImpl.kt

@@ -6,8 +6,8 @@
 package org.jetbrains.kotlin.psi2ir.generators
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.lazy.LazyScopedTypeParametersResolver
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/Generator.kt

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
-import java.lang.RuntimeException
 
 
 interface Generator : IrGenerator {
@@ -55,7 +54,7 @@ fun Generator.getExpressionTypeWithCoercionToUnit(key: KtExpression): KotlinType
     if (key.isUsedAsExpression(context.bindingContext))
         getTypeInferredByFrontend(key)
     else
-        context.builtIns.unitType
+        context.irBuiltInsOverDescriptors.unit
 
 fun Generator.getExpressionTypeWithCoercionToUnitOrFail(key: KtExpression): KotlinType =
     getExpressionTypeWithCoercionToUnit(key) ?: throw RuntimeException("No type for expression: ${key.text}")

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt

@@ -11,8 +11,9 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.NotFoundClasses
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.IrGeneratorContext
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.expressions.IrDeclarationReference
 import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.ir.util.TypeTranslator
@@ -65,6 +66,8 @@ class GeneratorContext private constructor(
 
     val samTypeApproximator = SamTypeApproximator(moduleDescriptor.builtIns, languageVersionSettings)
 
+    val irBuiltInsOverDescriptors: IrBuiltInsOverDescriptors get() = irBuiltIns as IrBuiltInsOverDescriptors
+
     fun createFileScopeContext(ktFile: KtFile): GeneratorContext {
         return GeneratorContext(
             configuration,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt

@@ -45,7 +45,18 @@ import org.jetbrains.kotlin.resolve.checkers.PrimitiveNumericComparisonInfo
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.checker.intersectTypes
-import org.jetbrains.kotlin.types.typeUtil.*
+import org.jetbrains.kotlin.types.typeUtil.isPrimitiveNumberType
+import org.jetbrains.kotlin.types.typeUtil.makeNotNullable
+import org.jetbrains.kotlin.types.typeUtil.makeNullable
+import kotlin.collections.Map
+import kotlin.collections.contains
+import kotlin.collections.get
+import kotlin.collections.listOf
+import kotlin.collections.mapOf
+import kotlin.collections.mapTo
+import kotlin.collections.set
+import kotlin.collections.toMap
+import kotlin.collections.zip
 
 
 class OperatorExpressionGenerator(statementGenerator: StatementGenerator) : StatementGeneratorExtension(statementGenerator) {
@@ -205,7 +216,7 @@ class OperatorExpressionGenerator(statementGenerator: StatementGenerator) : Stat
         // Infer type for elvis manually. Take into account possibly nested elvises.
         val rightType = getResultTypeForElvis(binaryExpression.right!!).unwrap()
         val leftType = getResultTypeForElvis(binaryExpression.left!!).unwrap()
-        val leftNNType = intersectTypes(listOf(leftType, context.builtIns.anyType))
+        val leftNNType = intersectTypes(listOf(leftType, context.irBuiltInsOverDescriptors.any))
         return NewCommonSuperTypeCalculator.commonSuperType(listOf(rightType, leftNNType))
     }
 
@@ -432,7 +443,7 @@ class OperatorExpressionGenerator(statementGenerator: StatementGenerator) : Stat
         return memberScope.findSingleFunction(Name.identifier("to$targetTypeName"))
     }
 
-    private val primitiveTypeMapping = context.irBuiltIns.run { primitiveTypes.zip(primitiveIrTypes).toMap() }
+    private val primitiveTypeMapping = context.irBuiltInsOverDescriptors.run { primitiveTypes.zip(primitiveIrTypes).toMap() }
     private fun kotlinTypeToIrType(kotlinType: KotlinType?) = kotlinType?.let { primitiveTypeMapping[it] }
 
     private fun generateComparisonOperator(ktExpression: KtBinaryExpression, origin: IrStatementOrigin): IrExpression {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ReflectionReferencesGenerator.kt

@@ -19,10 +19,8 @@ package org.jetbrains.kotlin.psi2ir.generators
 import org.jetbrains.kotlin.builtins.*
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.declarations.DescriptorMetadataSource
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.*
@@ -537,7 +535,7 @@ class ReflectionReferencesGenerator(statementGenerator: StatementGenerator) : St
     }
 
     private fun KotlinType.kFunctionTypeToFunctionType(suspendFunction: Boolean) = createFunctionType(
-        statementGenerator.context.builtIns,
+        (statementGenerator.context.irBuiltIns as IrBuiltInsOverDescriptors).builtIns,
         annotations,
         null,
         arguments.dropLast(1).map { it.type },

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.builders.Scope
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
@@ -191,7 +190,7 @@ class StatementGenerator(
         val irReturnedExpression = expression.returnedExpression?.let { generateExpression(it) }
             ?: IrGetObjectValueImpl(
                 expression.startOffsetSkippingComments, expression.endOffset, context.irBuiltIns.unitType,
-                context.symbolTable.referenceClass(context.builtIns.unit)
+                context.irBuiltIns.unitClass
             )
         return IrReturnImpl(
             expression.startOffsetSkippingComments, expression.endOffset, context.irBuiltIns.nothingType,

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/ArrayAccessAssignmentReceiver.kt

@@ -71,7 +71,7 @@ class ArrayAccessAssignmentReceiver(
                 ?: throw AssertionError("Array access should have either indexed-get call or indexed-set call")
 
         val hasResult = origin.isAssignmentOperatorWithResult()
-        val resultType = if (hasResult) kotlinType else callGenerator.context.builtIns.unitType
+        val resultType = if (hasResult) kotlinType else callGenerator.context.irBuiltInsOverDescriptors.unit
         val irResultType = callGenerator.translateType(resultType)
 
         if (indexedGetDescriptor?.isDynamic() != false && indexedSetDescriptor?.isDynamic() != false) {

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/transformations/InsertImplicitCasts.kt

@@ -22,13 +22,12 @@ import org.jetbrains.kotlin.builtins.isFunctionType
 import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.PsiIrFileEntry
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.descriptors.IrBasedDeclarationDescriptor
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrConstImpl
@@ -60,7 +59,6 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
 
 fun insertImplicitCasts(file: IrFile, context: GeneratorContext) {
     InsertImplicitCasts(
-        context.builtIns,
         context.irBuiltIns,
         context.typeTranslator,
         context.callToSubstitutedDescriptorMap,
@@ -71,7 +69,6 @@ fun insertImplicitCasts(file: IrFile, context: GeneratorContext) {
 }
 
 internal class InsertImplicitCasts(
-    private val builtIns: KotlinBuiltIns,
     private val irBuiltIns: IrBuiltIns,
     private val typeTranslator: TypeTranslator,
     private val callToSubstitutedDescriptorMap: Map<IrDeclarationReference, CallableDescriptor>,
@@ -260,20 +257,20 @@ internal class InsertImplicitCasts(
     override fun visitWhen(expression: IrWhen): IrExpression =
         expression.transformPostfix {
             for (irBranch in branches) {
-                irBranch.condition = irBranch.condition.cast(builtIns.booleanType)
+                irBranch.condition = irBranch.condition.cast(irBuiltIns.booleanType)
                 irBranch.result = irBranch.result.cast(type)
             }
         }
 
     override fun visitLoop(loop: IrLoop): IrExpression =
         loop.transformPostfix {
-            condition = condition.cast(builtIns.booleanType)
+            condition = condition.cast(irBuiltIns.booleanType)
             body = body?.coerceToUnit()
         }
 
     override fun visitThrow(expression: IrThrow): IrExpression =
         expression.transformPostfix {
-            value = value.cast(builtIns.throwable.defaultType)
+            value = value.cast(irBuiltIns.throwableType)
         }
 
     override fun visitTry(aTry: IrTry): IrExpression =
@@ -469,7 +466,7 @@ internal class InsertImplicitCasts(
     }
 
     private fun IrExpression.invokeIntegerCoercionFunction(targetType: KotlinType, coercionFunName: String): IrExpression {
-        val coercionFunction = builtIns.int.unsubstitutedMemberScope.findSingleFunction(Name.identifier(coercionFunName))
+        val coercionFunction = irBuiltIns.intClass.descriptor.unsubstitutedMemberScope.findSingleFunction(Name.identifier(coercionFunName))
         return IrCallImpl(
             startOffset, endOffset,
             targetType.toIrType(),

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrBuiltIns.kt

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2010-2021 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.ir
+
+import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl
+import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.util.SymbolTable
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+
+/**
+ * Symbols for builtins that are available without any context and are not specific to any backend
+ * (but specific to the frontend)
+ */
+abstract class IrBuiltIns {
+    abstract val languageVersionSettings: LanguageVersionSettings
+
+    abstract val irFactory: IrFactory
+
+    abstract val anyType: IrType
+    abstract val anyClass: IrClassSymbol
+    abstract val anyNType: IrType
+    abstract val booleanType: IrType
+    abstract val booleanClass: IrClassSymbol
+    abstract val charType: IrType
+    abstract val charClass: IrClassSymbol
+    abstract val numberType: IrType
+    abstract val numberClass: IrClassSymbol
+    abstract val byteType: IrType
+    abstract val byteClass: IrClassSymbol
+    abstract val shortType: IrType
+    abstract val shortClass: IrClassSymbol
+    abstract val intType: IrType
+    abstract val intClass: IrClassSymbol
+    abstract val longType: IrType
+    abstract val longClass: IrClassSymbol
+    abstract val floatType: IrType
+    abstract val floatClass: IrClassSymbol
+    abstract val doubleType: IrType
+    abstract val doubleClass: IrClassSymbol
+    abstract val nothingType: IrType
+    abstract val nothingClass: IrClassSymbol
+    abstract val nothingNType: IrType
+    abstract val unitType: IrType
+    abstract val unitClass: IrClassSymbol
+    abstract val stringType: IrType
+    abstract val stringClass: IrClassSymbol
+    abstract val charSequenceClass: IrClassSymbol
+
+    abstract val collectionClass: IrClassSymbol
+    abstract val arrayClass: IrClassSymbol
+    abstract val setClass: IrClassSymbol
+    abstract val listClass: IrClassSymbol
+    abstract val mapClass: IrClassSymbol
+    abstract val mapEntryClass: IrClassSymbol
+    abstract val iterableClass: IrClassSymbol
+    abstract val iteratorClass: IrClassSymbol
+    abstract val listIteratorClass: IrClassSymbol
+    abstract val mutableCollectionClass: IrClassSymbol
+    abstract val mutableSetClass: IrClassSymbol
+    abstract val mutableListClass: IrClassSymbol
+    abstract val mutableMapClass: IrClassSymbol
+    abstract val mutableMapEntryClass: IrClassSymbol
+    abstract val mutableIterableClass: IrClassSymbol
+    abstract val mutableIteratorClass: IrClassSymbol
+    abstract val mutableListIteratorClass: IrClassSymbol
+
+    abstract val comparableClass: IrClassSymbol
+    abstract val throwableType: IrType
+    abstract val throwableClass: IrClassSymbol
+    abstract val kCallableClass: IrClassSymbol
+    abstract val kPropertyClass: IrClassSymbol
+    abstract val kClassClass: IrClassSymbol
+    abstract val kProperty0Class: IrClassSymbol
+    abstract val kProperty1Class: IrClassSymbol
+    abstract val kProperty2Class: IrClassSymbol
+    abstract val kMutableProperty0Class: IrClassSymbol
+    abstract val kMutableProperty1Class: IrClassSymbol
+    abstract val kMutableProperty2Class: IrClassSymbol
+    abstract val functionClass: IrClassSymbol
+    abstract val kFunctionClass: IrClassSymbol
+    abstract val annotationType: IrType
+    abstract val annotationClass: IrClassSymbol
+
+    // TODO: consider removing to get rid of descriptor-related dependencies
+    abstract val primitiveTypeToIrType: Map<PrimitiveType, IrType>
+
+    abstract val primitiveIrTypes: List<IrType>
+    abstract val primitiveIrTypesWithComparisons: List<IrType>
+    abstract val primitiveFloatingPointIrTypes: List<IrType>
+
+    abstract val byteArray: IrClassSymbol
+    abstract val charArray: IrClassSymbol
+    abstract val shortArray: IrClassSymbol
+    abstract val intArray: IrClassSymbol
+    abstract val longArray: IrClassSymbol
+    abstract val floatArray: IrClassSymbol
+    abstract val doubleArray: IrClassSymbol
+    abstract val booleanArray: IrClassSymbol
+
+    abstract val primitiveArraysToPrimitiveTypes: Map<IrClassSymbol, PrimitiveType>
+    abstract val primitiveArrays: Set<IrClassSymbol>
+    abstract val primitiveArrayElementTypes: Map<IrClassSymbol, IrType?>
+    abstract val primitiveArrayForType: Map<IrType?, IrClassSymbol>
+
+    abstract val unsignedArrays: Set<IrClassSymbol>
+
+    abstract val lessFunByOperandType: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val lessOrEqualFunByOperandType: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val greaterOrEqualFunByOperandType: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val greaterFunByOperandType: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val ieee754equalsFunByOperandType: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val booleanNotSymbol: IrSimpleFunctionSymbol
+    abstract val eqeqeqSymbol: IrSimpleFunctionSymbol
+    abstract val eqeqSymbol: IrSimpleFunctionSymbol
+    abstract val throwCceSymbol: IrSimpleFunctionSymbol
+    abstract val throwIseSymbol: IrSimpleFunctionSymbol
+    abstract val andandSymbol: IrSimpleFunctionSymbol
+    abstract val ororSymbol: IrSimpleFunctionSymbol
+    abstract val noWhenBranchMatchedExceptionSymbol: IrSimpleFunctionSymbol
+    abstract val illegalArgumentExceptionSymbol: IrSimpleFunctionSymbol
+    abstract val checkNotNullSymbol: IrSimpleFunctionSymbol
+    abstract val dataClassArrayMemberHashCodeSymbol: IrSimpleFunctionSymbol
+    abstract val dataClassArrayMemberToStringSymbol: IrSimpleFunctionSymbol
+    abstract fun getKPropertyClass(mutable: Boolean, n: Int): IrClassSymbol
+    abstract val enumClass: IrClassSymbol
+
+    abstract val intPlusSymbol: IrSimpleFunctionSymbol
+    abstract val intTimesSymbol: IrSimpleFunctionSymbol
+
+    abstract val extensionToString: IrSimpleFunctionSymbol
+    abstract val stringPlus: IrSimpleFunctionSymbol
+
+    abstract val arrayOf: IrSimpleFunctionSymbol
+    abstract val arrayOfNulls: IrSimpleFunctionSymbol
+
+    abstract val toUIntByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+    abstract val toULongByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol>
+
+    abstract fun functionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass
+    abstract fun kFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass
+    abstract fun suspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass
+    abstract fun kSuspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass
+
+    abstract fun functionN(arity: Int): IrClass
+    abstract fun kFunctionN(arity: Int): IrClass
+    abstract fun suspendFunctionN(arity: Int): IrClass
+    abstract fun kSuspendFunctionN(arity: Int): IrClass
+
+    abstract fun findFunctions(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): Iterable<IrSimpleFunctionSymbol>
+    abstract fun findClass(name: Name, vararg packageNameSegments: String = arrayOf("kotlin")): IrClassSymbol?
+
+    abstract fun getBinaryOperator(name: Name, lhsType: IrType, rhsType: IrType): IrSimpleFunctionSymbol
+    abstract fun getUnaryOperator(name: Name, receiverType: IrType): IrSimpleFunctionSymbol
+
+    abstract val getProgressionLastElementByReturnType: Map<IrClassifierSymbol?, IrSimpleFunctionSymbol>
+
+    companion object {
+        val KOTLIN_INTERNAL_IR_FQN = FqName("kotlin.internal.ir")
+        val BUILTIN_OPERATOR = object : IrDeclarationOriginImpl("OPERATOR") {}
+    }
+}
+
+object BuiltInOperatorNames {
+    const val LESS = "less"
+    const val LESS_OR_EQUAL = "lessOrEqual"
+    const val GREATER = "greater"
+    const val GREATER_OR_EQUAL = "greaterOrEqual"
+    const val EQEQ = "EQEQ"
+    const val EQEQEQ = "EQEQEQ"
+    const val IEEE754_EQUALS = "ieee754equals"
+    const val THROW_CCE = "THROW_CCE"
+    const val THROW_ISE = "THROW_ISE"
+    const val NO_WHEN_BRANCH_MATCHED_EXCEPTION = "noWhenBranchMatchedException"
+    const val ILLEGAL_ARGUMENT_EXCEPTION = "illegalArgumentException"
+    const val ANDAND = "ANDAND"
+    const val OROR = "OROR"
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/IrGenerator.kt

@@ -16,10 +16,8 @@
 
 package org.jetbrains.kotlin.ir.builders
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 
 interface IrGenerator {
     val context: IrGeneratorContext
@@ -34,9 +32,6 @@ interface IrGeneratorContextInterface {
 }
 
 interface IrGeneratorContext : IrGeneratorContextInterface {
-    @ObsoleteDescriptorBasedAPI
-    val builtIns: KotlinBuiltIns get() = irBuiltIns.builtIns
-
     val irFactory: IrFactory get() = irBuiltIns.irFactory
 }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModuleFragment.kt

@@ -17,10 +17,10 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.name.Name
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrModuleFragmentImpl.kt

@@ -17,9 +17,9 @@
 package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt

@@ -1,348 +0,0 @@
-/*
- * Copyright 2010-2018 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.ir.descriptors
-
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl
-import org.jetbrains.kotlin.ir.declarations.IrFactory
-import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
-import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
-import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
-import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.types.classifierOrFail
-import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeBuilder
-import org.jetbrains.kotlin.ir.types.impl.buildSimpleType
-import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
-import org.jetbrains.kotlin.ir.types.makeNullable
-import org.jetbrains.kotlin.ir.types.withHasQuestionMark
-import org.jetbrains.kotlin.ir.util.SymbolTable
-import org.jetbrains.kotlin.ir.util.TypeTranslator
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.types.*
-
-class IrBuiltIns(
-    val builtIns: KotlinBuiltIns,
-    private val typeTranslator: TypeTranslator,
-    private val symbolTable: SymbolTable
-) {
-    val languageVersionSettings = typeTranslator.languageVersionSettings
-
-    lateinit var functionFactory: IrAbstractFunctionFactory
-    val irFactory: IrFactory = symbolTable.irFactory
-
-    private val builtInsModule = builtIns.builtInsModule
-
-    private val packageFragmentDescriptor = IrBuiltinsPackageFragmentDescriptorImpl(builtInsModule, KOTLIN_INTERNAL_IR_FQN)
-    val packageFragment = symbolTable.declareExternalPackageFragmentIfNotExists(packageFragmentDescriptor)
-
-    private fun ClassDescriptor.toIrSymbol() = symbolTable.referenceClass(this)
-    private fun KotlinType.toIrType() = typeTranslator.translateType(this)
-
-    private fun defineOperator(name: String, returnType: IrType, valueParameterTypes: List<IrType>): IrSimpleFunctionSymbol {
-        val operatorDescriptor =
-            IrSimpleBuiltinOperatorDescriptorImpl(packageFragmentDescriptor, Name.identifier(name), returnType.originalKotlinType!!)
-
-        for ((i, valueParameterType) in valueParameterTypes.withIndex()) {
-            operatorDescriptor.addValueParameter(
-                IrBuiltinValueParameterDescriptorImpl(
-                    operatorDescriptor, Name.identifier("arg$i"), i, valueParameterType.originalKotlinType!!
-                )
-            )
-        }
-
-        val symbol = symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) {
-            val operator = irFactory.createFunction(
-                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, it, Name.identifier(name), DescriptorVisibilities.PUBLIC, Modality.FINAL,
-                returnType, isInline = false, isExternal = false, isTailrec = false, isSuspend = false,
-                isOperator = false, isInfix = false, isExpect = false, isFakeOverride = false
-            )
-            operator.parent = packageFragment
-            packageFragment.declarations += operator
-
-            operator.valueParameters = valueParameterTypes.withIndex().map { (i, valueParameterType) ->
-                val valueParameterDescriptor = operatorDescriptor.valueParameters[i]
-                val valueParameterSymbol = IrValueParameterSymbolImpl(valueParameterDescriptor)
-                irFactory.createValueParameter(
-                    UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, valueParameterSymbol, Name.identifier("arg$i"), i,
-                    valueParameterType, null, isCrossinline = false, isNoinline = false, isHidden = false, isAssignable = false
-                ).apply {
-                    parent = operator
-                }
-            }
-
-            operator
-        }
-
-        return symbol.symbol
-    }
-
-    private fun defineCheckNotNullOperator(): IrSimpleFunctionSymbol {
-        val name = Name.identifier("CHECK_NOT_NULL")
-        val typeParameterDescriptor: TypeParameterDescriptor
-        val valueParameterDescriptor: ValueParameterDescriptor
-
-        val returnKotlinType: SimpleType
-        val valueKotlinType: SimpleType
-
-        // Note: We still need a complete function descriptor here because `CHECK_NOT_NULL` is being substituted by psi2ir
-        val operatorDescriptor = SimpleFunctionDescriptorImpl.create(
-            packageFragmentDescriptor,
-            Annotations.EMPTY,
-            name,
-            CallableMemberDescriptor.Kind.SYNTHESIZED,
-            SourceElement.NO_SOURCE
-        ).apply {
-            typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
-                this, Annotations.EMPTY, false, Variance.INVARIANT, Name.identifier("T0"),
-                0, SourceElement.NO_SOURCE, LockBasedStorageManager.NO_LOCKS
-            ).apply {
-                addUpperBound(any)
-                setInitialized()
-            }
-
-            valueKotlinType = typeParameterDescriptor.typeConstructor.makeNullableType()
-
-            valueParameterDescriptor = ValueParameterDescriptorImpl(
-                this, null, 0, Annotations.EMPTY, Name.identifier("arg0"), valueKotlinType,
-                declaresDefaultValue = false, isCrossinline = false, isNoinline = false, varargElementType = null,
-                source = SourceElement.NO_SOURCE
-            )
-
-            returnKotlinType = typeParameterDescriptor.typeConstructor.makeNonNullType()
-
-            initialize(
-                null, null, listOf(typeParameterDescriptor), listOf(valueParameterDescriptor), returnKotlinType,
-                Modality.FINAL, DescriptorVisibilities.PUBLIC
-            )
-        }
-
-        val typeParameterSymbol = IrTypeParameterSymbolImpl(typeParameterDescriptor)
-        val typeParameter = irFactory.createTypeParameter(
-            UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, typeParameterSymbol, Name.identifier("T0"), 0, true, Variance.INVARIANT
-        ).apply {
-            superTypes += anyType
-        }
-
-        val returnIrType = IrSimpleTypeBuilder().run {
-            classifier = typeParameterSymbol
-            kotlinType = returnKotlinType
-            hasQuestionMark = false
-            buildSimpleType()
-        }
-
-        val valueIrType = IrSimpleTypeBuilder().run {
-            classifier = typeParameterSymbol
-            kotlinType = valueKotlinType
-            hasQuestionMark = true
-            buildSimpleType()
-        }
-
-        return symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) {
-            val operator = irFactory.createFunction(
-                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, it, name, DescriptorVisibilities.PUBLIC, Modality.FINAL, returnIrType,
-                isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = false, isInfix = false,
-                isExpect = false, isFakeOverride = false
-            )
-            operator.parent = packageFragment
-            packageFragment.declarations += operator
-
-            val valueParameterSymbol = IrValueParameterSymbolImpl(valueParameterDescriptor)
-            val valueParameter = irFactory.createValueParameter(
-                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, valueParameterSymbol, Name.identifier("arg0"), 0,
-                valueIrType, null, isCrossinline = false, isNoinline = false, isHidden = false, isAssignable = false
-            )
-
-            valueParameter.parent = operator
-            typeParameter.parent = operator
-
-            operator.valueParameters += valueParameter
-            operator.typeParameters += typeParameter
-
-            operator
-        }.symbol
-    }
-
-    private fun defineComparisonOperator(name: String, operandType: IrType) =
-        defineOperator(name, booleanType, listOf(operandType, operandType))
-
-    private fun List<IrType>.defineComparisonOperatorForEachIrType(name: String) =
-        associate { it.classifierOrFail to defineComparisonOperator(name, it) }
-
-    val any = builtIns.anyType
-    val anyType = any.toIrType()
-    val anyClass = builtIns.any.toIrSymbol()
-    val anyNType = anyType.withHasQuestionMark(true)
-
-    val bool = builtIns.booleanType
-    val booleanType = bool.toIrType()
-    val booleanClass = builtIns.boolean.toIrSymbol()
-
-    val char = builtIns.charType
-    val charType = char.toIrType()
-    val charClass = builtIns.char.toIrSymbol()
-
-    val number = builtIns.number.defaultType
-    val numberType = number.toIrType()
-    val numberClass = builtIns.number.toIrSymbol()
-
-    val byte = builtIns.byteType
-    val byteType = byte.toIrType()
-    val byteClass = builtIns.byte.toIrSymbol()
-
-    val short = builtIns.shortType
-    val shortType = short.toIrType()
-    val shortClass = builtIns.short.toIrSymbol()
-
-    val int = builtIns.intType
-    val intType = int.toIrType()
-    val intClass = builtIns.int.toIrSymbol()
-
-    val long = builtIns.longType
-    val longType = long.toIrType()
-    val longClass = builtIns.long.toIrSymbol()
-
-    val float = builtIns.floatType
-    val floatType = float.toIrType()
-    val floatClass = builtIns.float.toIrSymbol()
-
-    val double = builtIns.doubleType
-    val doubleType = double.toIrType()
-    val doubleClass = builtIns.double.toIrSymbol()
-
-    val nothing = builtIns.nothingType
-    val nothingType = nothing.toIrType()
-    val nothingClass = builtIns.nothing.toIrSymbol()
-    val nothingNType = nothingType.withHasQuestionMark(true)
-
-    val unit = builtIns.unitType
-    val unitType = unit.toIrType()
-    val unitClass = builtIns.unit.toIrSymbol()
-
-    val string = builtIns.stringType
-    val stringType = string.toIrType()
-    val stringClass = builtIns.string.toIrSymbol()
-
-    val iterableClass = builtIns.iterable.toIrSymbol()
-    val iteratorClass = builtIns.iterator.toIrSymbol()
-    val listIteratorClass = builtIns.listIterator.toIrSymbol()
-    val listClass = builtIns.list.toIrSymbol()
-    val collectionClass = builtIns.collection.toIrSymbol()
-    val setClass = builtIns.set.toIrSymbol()
-    val mapClass = builtIns.map.toIrSymbol()
-    val mapEntryClass = builtIns.mapEntry.toIrSymbol()
-
-    val arrayClass = builtIns.array.toIrSymbol()
-
-    val throwableType = builtIns.throwable.defaultType.toIrType()
-    val throwableClass = builtIns.throwable.toIrSymbol()
-
-    val kCallableClass = builtIns.kCallable.toIrSymbol()
-    val kPropertyClass = builtIns.kProperty.toIrSymbol()
-    val kClassClass = builtIns.kClass.toIrSymbol()
-
-    private val kProperty0Class = builtIns.kProperty0.toIrSymbol()
-    private val kProperty1Class = builtIns.kProperty1.toIrSymbol()
-    private val kProperty2Class = builtIns.kProperty2.toIrSymbol()
-    private val kMutableProperty0Class = builtIns.kMutableProperty0.toIrSymbol()
-    private val kMutableProperty1Class = builtIns.kMutableProperty1.toIrSymbol()
-    private val kMutableProperty2Class = builtIns.kMutableProperty2.toIrSymbol()
-
-    val functionClass = builtIns.getBuiltInClassByFqName(FqName("kotlin.Function")).toIrSymbol()
-    val kFunctionClass = builtIns.getBuiltInClassByFqName(FqName("kotlin.reflect.KFunction")).toIrSymbol()
-
-    fun getKPropertyClass(mutable: Boolean, n: Int): IrClassSymbol = when (n) {
-        0 -> if (mutable) kMutableProperty0Class else kProperty0Class
-        1 -> if (mutable) kMutableProperty1Class else kProperty1Class
-        2 -> if (mutable) kMutableProperty2Class else kProperty2Class
-        else -> error("No KProperty for n=$n mutable=$mutable")
-    }
-
-    // TODO switch to IrType
-    val primitiveTypes = listOf(bool, char, byte, short, int, float, long, double)
-    val primitiveIrTypes = listOf(booleanType, charType, byteType, shortType, intType, floatType, longType, doubleType)
-    private val primitiveIrTypesWithComparisons = listOf(charType, byteType, shortType, intType, floatType, longType, doubleType)
-    private val primitiveFloatingPointIrTypes = listOf(floatType, doubleType)
-    val primitiveArrays = PrimitiveType.values().map { builtIns.getPrimitiveArrayClassDescriptor(it).toIrSymbol() }
-    val primitiveArrayElementTypes = primitiveArrays.zip(primitiveIrTypes).toMap()
-    val primitiveArrayForType = primitiveArrayElementTypes.asSequence().associate { it.value to it.key }
-
-    val primitiveTypeToIrType = mapOf(
-        PrimitiveType.BOOLEAN to booleanType,
-        PrimitiveType.CHAR to charType,
-        PrimitiveType.BYTE to byteType,
-        PrimitiveType.SHORT to shortType,
-        PrimitiveType.INT to intType,
-        PrimitiveType.FLOAT to floatType,
-        PrimitiveType.LONG to longType,
-        PrimitiveType.DOUBLE to doubleType
-    )
-
-    val lessFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(OperatorNames.LESS)
-    val lessOrEqualFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(OperatorNames.LESS_OR_EQUAL)
-    val greaterOrEqualFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(OperatorNames.GREATER_OR_EQUAL)
-    val greaterFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(OperatorNames.GREATER)
-
-    val ieee754equalsFunByOperandType =
-        primitiveFloatingPointIrTypes.map {
-            it.classifierOrFail to defineOperator(OperatorNames.IEEE754_EQUALS, booleanType, listOf(it.makeNullable(), it.makeNullable()))
-        }.toMap()
-
-    private val booleanNot = builtIns.boolean.unsubstitutedMemberScope.getContributedFunctions(Name.identifier("not"), NoLookupLocation.FROM_BACKEND).single()
-    val booleanNotSymbol = symbolTable.referenceSimpleFunction(booleanNot)
-
-    val eqeqeqSymbol = defineOperator(OperatorNames.EQEQEQ, booleanType, listOf(anyNType, anyNType))
-    val eqeqSymbol = defineOperator(OperatorNames.EQEQ, booleanType, listOf(anyNType, anyNType))
-    val throwCceSymbol = defineOperator(OperatorNames.THROW_CCE, nothingType, listOf())
-    val throwIseSymbol = defineOperator(OperatorNames.THROW_ISE, nothingType, listOf())
-    val andandSymbol = defineOperator(OperatorNames.ANDAND, booleanType, listOf(booleanType, booleanType))
-    val ororSymbol = defineOperator(OperatorNames.OROR, booleanType, listOf(booleanType, booleanType))
-    val noWhenBranchMatchedExceptionSymbol = defineOperator(OperatorNames.NO_WHEN_BRANCH_MATCHED_EXCEPTION, nothingType, listOf())
-    val illegalArgumentExceptionSymbol = defineOperator(OperatorNames.ILLEGAL_ARGUMENT_EXCEPTION, nothingType, listOf(stringType))
-
-    val checkNotNullSymbol = defineCheckNotNullOperator()
-
-    private fun TypeConstructor.makeNonNullType() = KotlinTypeFactory.simpleType(Annotations.EMPTY, this, listOf(), false)
-    private fun TypeConstructor.makeNullableType() = KotlinTypeFactory.simpleType(Annotations.EMPTY, this, listOf(), true)
-
-    val dataClassArrayMemberHashCodeSymbol = defineOperator("dataClassArrayMemberHashCode", intType, listOf(anyType))
-
-    val dataClassArrayMemberToStringSymbol = defineOperator("dataClassArrayMemberToString", stringType, listOf(anyNType))
-
-    fun function(n: Int): IrClassSymbol = functionFactory.functionN(n).symbol
-    fun suspendFunction(n: Int): IrClassSymbol = functionFactory.suspendFunctionN(n).symbol
-
-    companion object {
-        val KOTLIN_INTERNAL_IR_FQN = FqName("kotlin.internal.ir")
-        val BUILTIN_OPERATOR = object : IrDeclarationOriginImpl("OPERATOR") {}
-    }
-
-    object OperatorNames {
-        const val LESS = "less"
-        const val LESS_OR_EQUAL = "lessOrEqual"
-        const val GREATER = "greater"
-        const val GREATER_OR_EQUAL = "greaterOrEqual"
-        const val EQEQ = "EQEQ"
-        const val EQEQEQ = "EQEQEQ"
-        const val IEEE754_EQUALS = "ieee754equals"
-        const val THROW_CCE = "THROW_CCE"
-        const val THROW_ISE = "THROW_ISE"
-        const val NO_WHEN_BRANCH_MATCHED_EXCEPTION = "noWhenBranchMatchedException"
-        const val ILLEGAL_ARGUMENT_EXCEPTION = "illegalArgumentException"
-        const val ANDAND = "ANDAND"
-        const val OROR = "OROR"
-    }
-}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltInsOverDescriptors.kt

@@ -0,0 +1,520 @@
+/*
+ * Copyright 2010-2018 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.ir.descriptors
+
+import org.jetbrains.kotlin.builtins.BuiltInsPackageFragment
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.PrimitiveType
+import org.jetbrains.kotlin.builtins.UnsignedType
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.ir.BuiltInOperatorNames
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
+import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl
+import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
+import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
+import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeBuilder
+import org.jetbrains.kotlin.ir.types.impl.buildSimpleType
+import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
+import org.jetbrains.kotlin.ir.util.SymbolTable
+import org.jetbrains.kotlin.ir.util.TypeTranslator
+import org.jetbrains.kotlin.ir.util.functions
+import org.jetbrains.kotlin.ir.util.referenceClassifier
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
+
+@ObsoleteDescriptorBasedAPI
+class IrBuiltInsOverDescriptors(
+    val builtIns: KotlinBuiltIns,
+    private val typeTranslator: TypeTranslator,
+    private val symbolTable: SymbolTable
+) : IrBuiltIns() {
+    override val languageVersionSettings = typeTranslator.languageVersionSettings
+
+    private var _functionFactory: IrAbstractDescriptorBasedFunctionFactory? = null
+    var functionFactory: IrAbstractDescriptorBasedFunctionFactory
+        get() =
+            synchronized(this) {
+                if (_functionFactory == null) {
+                    _functionFactory = IrDescriptorBasedFunctionFactory(this, symbolTable)
+                }
+                _functionFactory!!
+            }
+        set(value) {
+            synchronized(this) {
+                if (_functionFactory != null) {
+                    error("functionFactory already set")
+                } else {
+                    _functionFactory = value
+                }
+            }
+        }
+
+    override val irFactory: IrFactory = symbolTable.irFactory
+
+    private val builtInsModule = builtIns.builtInsModule
+
+    private val packageFragmentDescriptor = IrBuiltinsPackageFragmentDescriptorImpl(builtInsModule, KOTLIN_INTERNAL_IR_FQN)
+    val packageFragment =
+        IrExternalPackageFragmentImpl(symbolTable.referenceExternalPackageFragment(packageFragmentDescriptor), KOTLIN_INTERNAL_IR_FQN)
+
+    private fun ClassDescriptor.toIrSymbol() = symbolTable.referenceClass(this)
+    private fun KotlinType.toIrType() = typeTranslator.translateType(this)
+
+    private fun defineOperator(name: String, returnType: IrType, valueParameterTypes: List<IrType>): IrSimpleFunctionSymbol {
+        val operatorDescriptor =
+            IrSimpleBuiltinOperatorDescriptorImpl(packageFragmentDescriptor, Name.identifier(name), returnType.originalKotlinType!!)
+
+        for ((i, valueParameterType) in valueParameterTypes.withIndex()) {
+            operatorDescriptor.addValueParameter(
+                IrBuiltinValueParameterDescriptorImpl(
+                    operatorDescriptor, Name.identifier("arg$i"), i, valueParameterType.originalKotlinType!!
+                )
+            )
+        }
+
+        val symbol = symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) {
+            val operator = irFactory.createFunction(
+                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, it, Name.identifier(name), DescriptorVisibilities.PUBLIC, Modality.FINAL,
+                returnType, isInline = false, isExternal = false, isTailrec = false, isSuspend = false,
+                isOperator = false, isInfix = false, isExpect = false, isFakeOverride = false
+            )
+            operator.parent = packageFragment
+            packageFragment.declarations += operator
+
+            operator.valueParameters = valueParameterTypes.withIndex().map { (i, valueParameterType) ->
+                val valueParameterDescriptor = operatorDescriptor.valueParameters[i]
+                val valueParameterSymbol = IrValueParameterSymbolImpl(valueParameterDescriptor)
+                irFactory.createValueParameter(
+                    UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, valueParameterSymbol, Name.identifier("arg$i"), i,
+                    valueParameterType, null, isCrossinline = false, isNoinline = false, isHidden = false, isAssignable = false
+                ).apply {
+                    parent = operator
+                }
+            }
+
+            operator
+        }
+
+        return symbol.symbol
+    }
+
+    private fun defineCheckNotNullOperator(): IrSimpleFunctionSymbol {
+        val name = Name.identifier("CHECK_NOT_NULL")
+        val typeParameterDescriptor: TypeParameterDescriptor
+        val valueParameterDescriptor: ValueParameterDescriptor
+
+        val returnKotlinType: SimpleType
+        val valueKotlinType: SimpleType
+
+        // Note: We still need a complete function descriptor here because `CHECK_NOT_NULL` is being substituted by psi2ir
+        val operatorDescriptor = SimpleFunctionDescriptorImpl.create(
+            packageFragmentDescriptor,
+            Annotations.EMPTY,
+            name,
+            CallableMemberDescriptor.Kind.SYNTHESIZED,
+            SourceElement.NO_SOURCE
+        ).apply {
+            typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
+                this, Annotations.EMPTY, false, Variance.INVARIANT, Name.identifier("T0"),
+                0, SourceElement.NO_SOURCE, LockBasedStorageManager.NO_LOCKS
+            ).apply {
+                addUpperBound(any)
+                setInitialized()
+            }
+
+            valueKotlinType = typeParameterDescriptor.typeConstructor.makeNullableType()
+
+            valueParameterDescriptor = ValueParameterDescriptorImpl(
+                this, null, 0, Annotations.EMPTY, Name.identifier("arg0"), valueKotlinType,
+                declaresDefaultValue = false, isCrossinline = false, isNoinline = false, varargElementType = null,
+                source = SourceElement.NO_SOURCE
+            )
+
+            returnKotlinType = typeParameterDescriptor.typeConstructor.makeNonNullType()
+
+            initialize(
+                null, null, listOf(typeParameterDescriptor), listOf(valueParameterDescriptor), returnKotlinType,
+                Modality.FINAL, DescriptorVisibilities.PUBLIC
+            )
+        }
+
+        val typeParameterSymbol = IrTypeParameterSymbolImpl(typeParameterDescriptor)
+        val typeParameter = irFactory.createTypeParameter(
+            UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, typeParameterSymbol, Name.identifier("T0"), 0, true, Variance.INVARIANT
+        ).apply {
+            superTypes += anyType
+        }
+
+        val returnIrType = IrSimpleTypeBuilder().run {
+            classifier = typeParameterSymbol
+            kotlinType = returnKotlinType
+            hasQuestionMark = false
+            buildSimpleType()
+        }
+
+        val valueIrType = IrSimpleTypeBuilder().run {
+            classifier = typeParameterSymbol
+            kotlinType = valueKotlinType
+            hasQuestionMark = true
+            buildSimpleType()
+        }
+
+        return symbolTable.declareSimpleFunctionIfNotExists(operatorDescriptor) {
+            val operator = irFactory.createFunction(
+                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, it, name, DescriptorVisibilities.PUBLIC, Modality.FINAL, returnIrType,
+                isInline = false, isExternal = false, isTailrec = false, isSuspend = false, isOperator = false, isInfix = false,
+                isExpect = false, isFakeOverride = false
+            )
+            operator.parent = packageFragment
+            packageFragment.declarations += operator
+
+            val valueParameterSymbol = IrValueParameterSymbolImpl(valueParameterDescriptor)
+            val valueParameter = irFactory.createValueParameter(
+                UNDEFINED_OFFSET, UNDEFINED_OFFSET, BUILTIN_OPERATOR, valueParameterSymbol, Name.identifier("arg0"), 0,
+                valueIrType, null, isCrossinline = false, isNoinline = false, isHidden = false, isAssignable = false
+            )
+
+            valueParameter.parent = operator
+            typeParameter.parent = operator
+
+            operator.valueParameters += valueParameter
+            operator.typeParameters += typeParameter
+
+            operator
+        }.symbol
+    }
+
+    private fun defineComparisonOperator(name: String, operandType: IrType) =
+        defineOperator(name, booleanType, listOf(operandType, operandType))
+
+    private fun List<IrType>.defineComparisonOperatorForEachIrType(name: String) =
+        associate { it.classifierOrFail to defineComparisonOperator(name, it) }
+
+    val any = builtIns.anyType
+    override val anyType = any.toIrType()
+    override val anyClass = builtIns.any.toIrSymbol()
+    override val anyNType = anyType.withHasQuestionMark(true)
+
+    val bool = builtIns.booleanType
+    override val booleanType = bool.toIrType()
+    override val booleanClass = builtIns.boolean.toIrSymbol()
+
+    val char = builtIns.charType
+    override val charType = char.toIrType()
+    override val charClass = builtIns.char.toIrSymbol()
+
+    val number = builtIns.number.defaultType
+    override val numberType = number.toIrType()
+    override val numberClass = builtIns.number.toIrSymbol()
+
+    val byte = builtIns.byteType
+    override val byteType = byte.toIrType()
+    override val byteClass = builtIns.byte.toIrSymbol()
+
+    val short = builtIns.shortType
+    override val shortType = short.toIrType()
+    override val shortClass = builtIns.short.toIrSymbol()
+
+    val int = builtIns.intType
+    override val intType = int.toIrType()
+    override val intClass = builtIns.int.toIrSymbol()
+
+    val long = builtIns.longType
+    override val longType = long.toIrType()
+    override val longClass = builtIns.long.toIrSymbol()
+
+    val float = builtIns.floatType
+    override val floatType = float.toIrType()
+    override val floatClass = builtIns.float.toIrSymbol()
+
+    val double = builtIns.doubleType
+    override val doubleType = double.toIrType()
+    override val doubleClass = builtIns.double.toIrSymbol()
+
+    val nothing = builtIns.nothingType
+    override val nothingType = nothing.toIrType()
+    override val nothingClass = builtIns.nothing.toIrSymbol()
+    override val nothingNType = nothingType.withHasQuestionMark(true)
+
+    val unit = builtIns.unitType
+    override val unitType = unit.toIrType()
+    override val unitClass = builtIns.unit.toIrSymbol()
+
+    val string = builtIns.stringType
+    override val stringType = string.toIrType()
+    override val stringClass = builtIns.string.toIrSymbol()
+    // TODO: check if correct
+    override val charSequenceClass = findClass(Name.identifier("CharSequence"), "kotlin")!!
+
+    override val collectionClass = builtIns.collection.toIrSymbol()
+    override val setClass = builtIns.set.toIrSymbol()
+    override val listClass = builtIns.list.toIrSymbol()
+    override val mapClass = builtIns.map.toIrSymbol()
+    override val mapEntryClass = builtIns.mapEntry.toIrSymbol()
+    override val iterableClass = builtIns.iterable.toIrSymbol()
+    override val iteratorClass = builtIns.iterator.toIrSymbol()
+    override val listIteratorClass = builtIns.listIterator.toIrSymbol()
+    override val mutableCollectionClass = builtIns.mutableCollection.toIrSymbol()
+    override val mutableSetClass = builtIns.mutableSet.toIrSymbol()
+    override val mutableListClass = builtIns.mutableList.toIrSymbol()
+    override val mutableMapClass = builtIns.mutableMap.toIrSymbol()
+    override val mutableMapEntryClass = builtIns.mutableMapEntry.toIrSymbol()
+    override val mutableIterableClass = builtIns.mutableIterable.toIrSymbol()
+    override val mutableIteratorClass = builtIns.mutableIterator.toIrSymbol()
+    override val mutableListIteratorClass = builtIns.mutableListIterator.toIrSymbol()
+    override val comparableClass = builtIns.comparable.toIrSymbol()
+
+    override val arrayClass = builtIns.array.toIrSymbol()
+
+    override val throwableType = builtIns.throwable.defaultType.toIrType()
+    override val throwableClass = builtIns.throwable.toIrSymbol()
+
+    override val kCallableClass = builtIns.kCallable.toIrSymbol()
+    override val kPropertyClass = builtIns.kProperty.toIrSymbol()
+    override val kClassClass = builtIns.kClass.toIrSymbol()
+
+    override val kProperty0Class = builtIns.kProperty0.toIrSymbol()
+    override val kProperty1Class = builtIns.kProperty1.toIrSymbol()
+    override val kProperty2Class = builtIns.kProperty2.toIrSymbol()
+    override val kMutableProperty0Class = builtIns.kMutableProperty0.toIrSymbol()
+    override val kMutableProperty1Class = builtIns.kMutableProperty1.toIrSymbol()
+    override val kMutableProperty2Class = builtIns.kMutableProperty2.toIrSymbol()
+
+    override val functionClass = builtIns.getBuiltInClassByFqName(FqName("kotlin.Function")).toIrSymbol()
+    override val kFunctionClass = builtIns.getBuiltInClassByFqName(FqName("kotlin.reflect.KFunction")).toIrSymbol()
+
+    override val annotationClass: IrClassSymbol = builtIns.annotation.toIrSymbol()
+    override val annotationType: IrType = builtIns.annotationType.toIrType()
+
+    override fun getKPropertyClass(mutable: Boolean, n: Int): IrClassSymbol = when (n) {
+        0 -> if (mutable) kMutableProperty0Class else kProperty0Class
+        1 -> if (mutable) kMutableProperty1Class else kProperty1Class
+        2 -> if (mutable) kMutableProperty2Class else kProperty2Class
+        else -> error("No KProperty for n=$n mutable=$mutable")
+    }
+
+    override val primitiveTypeToIrType = mapOf(
+        PrimitiveType.BOOLEAN to booleanType,
+        PrimitiveType.CHAR to charType,
+        PrimitiveType.BYTE to byteType,
+        PrimitiveType.SHORT to shortType,
+        PrimitiveType.INT to intType,
+        PrimitiveType.FLOAT to floatType,
+        PrimitiveType.LONG to longType,
+        PrimitiveType.DOUBLE to doubleType
+    )
+
+    // TODO switch to IrType
+    val primitiveTypes = listOf(bool, char, byte, short, int, float, long, double)
+    override val primitiveIrTypes = listOf(booleanType, charType, byteType, shortType, intType, floatType, longType, doubleType)
+    override val primitiveIrTypesWithComparisons = listOf(charType, byteType, shortType, intType, floatType, longType, doubleType)
+    override val primitiveFloatingPointIrTypes = listOf(floatType, doubleType)
+
+    override val byteArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BYTE).toIrSymbol()
+    override val charArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.CHAR).toIrSymbol()
+    override val shortArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.SHORT).toIrSymbol()
+    override val intArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.INT).toIrSymbol()
+    override val longArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.LONG).toIrSymbol()
+    override val floatArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.FLOAT).toIrSymbol()
+    override val doubleArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.DOUBLE).toIrSymbol()
+    override val booleanArray = builtIns.getPrimitiveArrayClassDescriptor(PrimitiveType.BOOLEAN).toIrSymbol()
+
+    override val primitiveArraysToPrimitiveTypes = PrimitiveType.values().associate { builtIns.getPrimitiveArrayClassDescriptor(it).toIrSymbol() to it }
+    override val primitiveArrays = primitiveArraysToPrimitiveTypes.keys
+    override val primitiveArrayElementTypes = primitiveArraysToPrimitiveTypes.mapValues { primitiveTypeToIrType[it.value] }
+    override val primitiveArrayForType = primitiveArrayElementTypes.asSequence().associate { it.value to it.key }
+
+    override val unsignedArrays: Set<IrClassSymbol> = UnsignedType.values().mapNotNullTo(mutableSetOf()) { unsignedType ->
+        builtIns.builtInsModule.findClassAcrossModuleDependencies(unsignedType.arrayClassId)?.toIrSymbol()
+    }
+
+    override val lessFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(BuiltInOperatorNames.LESS)
+    override val lessOrEqualFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(BuiltInOperatorNames.LESS_OR_EQUAL)
+    override val greaterOrEqualFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(BuiltInOperatorNames.GREATER_OR_EQUAL)
+    override val greaterFunByOperandType = primitiveIrTypesWithComparisons.defineComparisonOperatorForEachIrType(BuiltInOperatorNames.GREATER)
+
+    override val ieee754equalsFunByOperandType =
+        primitiveFloatingPointIrTypes.map {
+            it.classifierOrFail to defineOperator(BuiltInOperatorNames.IEEE754_EQUALS, booleanType, listOf(it.makeNullable(), it.makeNullable()))
+        }.toMap()
+
+    val booleanNot = builtIns.boolean.unsubstitutedMemberScope.getContributedFunctions(Name.identifier("not"), NoLookupLocation.FROM_BACKEND).single()
+    override val booleanNotSymbol = symbolTable.referenceSimpleFunction(booleanNot)
+
+    override val eqeqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQEQ, booleanType, listOf(anyNType, anyNType))
+    override val eqeqSymbol = defineOperator(BuiltInOperatorNames.EQEQ, booleanType, listOf(anyNType, anyNType))
+    override val throwCceSymbol = defineOperator(BuiltInOperatorNames.THROW_CCE, nothingType, listOf())
+    override val throwIseSymbol = defineOperator(BuiltInOperatorNames.THROW_ISE, nothingType, listOf())
+    override val andandSymbol = defineOperator(BuiltInOperatorNames.ANDAND, booleanType, listOf(booleanType, booleanType))
+    override val ororSymbol = defineOperator(BuiltInOperatorNames.OROR, booleanType, listOf(booleanType, booleanType))
+    override val noWhenBranchMatchedExceptionSymbol = defineOperator(BuiltInOperatorNames.NO_WHEN_BRANCH_MATCHED_EXCEPTION, nothingType, listOf())
+    override val illegalArgumentExceptionSymbol = defineOperator(BuiltInOperatorNames.ILLEGAL_ARGUMENT_EXCEPTION, nothingType, listOf(stringType))
+
+    override val checkNotNullSymbol = defineCheckNotNullOperator()
+
+    private fun TypeConstructor.makeNonNullType() = KotlinTypeFactory.simpleType(Annotations.EMPTY, this, listOf(), false)
+    private fun TypeConstructor.makeNullableType() = KotlinTypeFactory.simpleType(Annotations.EMPTY, this, listOf(), true)
+
+    override val dataClassArrayMemberHashCodeSymbol = defineOperator("dataClassArrayMemberHashCode", intType, listOf(anyType))
+
+    override val dataClassArrayMemberToStringSymbol = defineOperator("dataClassArrayMemberToString", stringType, listOf(anyNType))
+
+    override val intTimesSymbol: IrSimpleFunctionSymbol =
+        builtIns.int.unsubstitutedMemberScope.findFirstFunction("times") {
+            KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int)
+        }.let { symbolTable.referenceSimpleFunction(it) }
+
+    override val intPlusSymbol: IrSimpleFunctionSymbol =
+        builtIns.int.unsubstitutedMemberScope.findFirstFunction("plus") {
+            KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, int)
+        }.let { symbolTable.referenceSimpleFunction(it) }
+
+    override val arrayOf = findFunctions(Name.identifier("arrayOf")).first {
+        it.descriptor.extensionReceiverParameter == null && it.descriptor.dispatchReceiverParameter == null &&
+                it.descriptor.valueParameters.size == 1 && it.descriptor.valueParameters[0].varargElementType != null
+    }
+
+    override val arrayOfNulls = findFunctions(Name.identifier("arrayOfNulls")).first {
+        it.descriptor.extensionReceiverParameter == null && it.descriptor.dispatchReceiverParameter == null &&
+                it.descriptor.valueParameters.size == 1 && KotlinBuiltIns.isInt(it.descriptor.valueParameters[0].type)
+    }
+
+    override val enumClass = builtIns.enum.toIrSymbol()
+
+    private fun builtInsPackage(vararg packageNameSegments: String) =
+        builtIns.builtInsModule.getPackage(FqName.fromSegments(listOf(*packageNameSegments))).memberScope
+
+    override fun findFunctions(name: Name, vararg packageNameSegments: String): Iterable<IrSimpleFunctionSymbol> =
+        builtInsPackage(*packageNameSegments).getContributedFunctions(name, NoLookupLocation.FROM_BACKEND).map {
+            symbolTable.referenceSimpleFunction(it)
+        }
+
+    override fun findClass(name: Name, vararg packageNameSegments: String): IrClassSymbol? =
+        (builtInsPackage(*packageNameSegments).getContributedClassifier(
+            name,
+            NoLookupLocation.FROM_BACKEND
+        ) as? ClassDescriptor)?.let { symbolTable.referenceClass(it) }
+
+    private val binaryOperatorCache = mutableMapOf<Triple<Name, IrType, IrType>, IrSimpleFunctionSymbol>()
+
+    override fun getBinaryOperator(name: Name, lhsType: IrType, rhsType: IrType): IrSimpleFunctionSymbol {
+        require(lhsType is IrSimpleType) { "Expected IrSimpleType in getBinaryOperator, got $lhsType" }
+        val classifier = lhsType.classifier
+        require(classifier is IrClassSymbol && classifier.isBound) {
+            "Expected a bound IrClassSymbol for lhsType in getBinaryOperator, got $classifier"
+        }
+        val key = Triple(name, lhsType, rhsType)
+        return binaryOperatorCache.getOrPut(key) {
+            classifier.functions.single {
+                val function = it.owner
+                function.name == name && function.valueParameters.size == 1 && function.valueParameters[0].type == rhsType
+            }
+        }
+    }
+
+    private val unaryOperatorCache = mutableMapOf<Pair<Name, IrType>, IrSimpleFunctionSymbol>()
+
+    override fun getUnaryOperator(name: Name, receiverType: IrType): IrSimpleFunctionSymbol {
+        require(receiverType is IrSimpleType) { "Expected IrSimpleType in getBinaryOperator, got $receiverType" }
+        val classifier = receiverType.classifier
+        require(classifier is IrClassSymbol && classifier.isBound) {
+            "Expected a bound IrClassSymbol for receiverType in getBinaryOperator, got $classifier"
+        }
+        val key = Pair(name, receiverType)
+        return unaryOperatorCache.getOrPut(key) {
+            classifier.functions.single {
+                val function = it.owner
+                function.name == name && function.valueParameters.isEmpty()
+            }
+        }
+    }
+
+    override val toUIntByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol> =
+        builtInsPackage("kotlin").getContributedFunctions(
+            Name.identifier("toUInt"),
+            NoLookupLocation.FROM_BACKEND
+        ).filter { it.containingDeclaration !is BuiltInsPackageFragment && it.extensionReceiverParameter != null }
+            .map {
+                val klass = symbolTable.referenceClassifier(it.extensionReceiverParameter!!.type.constructor.declarationDescriptor!!)
+                val function = symbolTable.referenceSimpleFunction(it)
+                klass to function
+            }.toMap()
+
+    override val toULongByExtensionReceiver: Map<IrClassifierSymbol, IrSimpleFunctionSymbol> =
+        builtInsPackage("kotlin").getContributedFunctions(
+            Name.identifier("toULong"),
+            NoLookupLocation.FROM_BACKEND
+        ).filter { it.containingDeclaration !is BuiltInsPackageFragment && it.extensionReceiverParameter != null }
+            .map {
+                val klass = symbolTable.referenceClassifier(it.extensionReceiverParameter!!.type.constructor.declarationDescriptor!!)
+                val function = symbolTable.referenceSimpleFunction(it)
+                klass to function
+            }.toMap()
+
+    override val extensionToString: IrSimpleFunctionSymbol = findFunctions(Name.identifier("toString"), "kotlin").first {
+        val descriptor = it.descriptor
+        descriptor is SimpleFunctionDescriptor && descriptor.dispatchReceiverParameter == null &&
+                descriptor.extensionReceiverParameter != null &&
+                KotlinBuiltIns.isNullableAny(descriptor.extensionReceiverParameter!!.type) && descriptor.valueParameters.size == 0
+    }
+
+    override val stringPlus: IrSimpleFunctionSymbol = findFunctions(Name.identifier("plus"), "kotlin").first {
+        val descriptor = it.descriptor
+        descriptor is SimpleFunctionDescriptor && descriptor.dispatchReceiverParameter == null &&
+                descriptor.extensionReceiverParameter != null &&
+                KotlinBuiltIns.isStringOrNullableString(descriptor.extensionReceiverParameter!!.type) &&
+                descriptor.valueParameters.size == 1 &&
+                KotlinBuiltIns.isNullableAny(descriptor.valueParameters.first().type)
+    }
+
+    override fun functionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass =
+        functionFactory.functionN(arity, declarator)
+
+    override fun kFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass =
+        functionFactory.kFunctionN(arity, declarator)
+
+    override fun suspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass =
+        functionFactory.suspendFunctionN(arity, declarator)
+
+    override fun kSuspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass =
+        functionFactory.kSuspendFunctionN(arity, declarator)
+
+    override fun functionN(arity: Int): IrClass = functionFactory.functionN(arity)
+    override fun kFunctionN(arity: Int): IrClass = functionFactory.kFunctionN(arity)
+    override fun suspendFunctionN(arity: Int): IrClass = functionFactory.suspendFunctionN(arity)
+    override fun kSuspendFunctionN(arity: Int): IrClass = functionFactory.kSuspendFunctionN(arity)
+
+    override val getProgressionLastElementByReturnType: Map<IrClassifierSymbol?, IrSimpleFunctionSymbol> =
+        builtInsPackage("kotlin", "internal")
+            .getContributedFunctions(Name.identifier("getProgressionLastElement"), NoLookupLocation.FROM_BACKEND)
+            .filter { it.containingDeclaration !is BuiltInsPackageFragment }
+            .map { d ->
+                val klass = d.returnType?.constructor?.declarationDescriptor?.let { symbolTable.referenceClassifier(it) }
+                val function = symbolTable.referenceSimpleFunction(d)
+                klass to function
+            }
+            .toMap()
+}
+
+private inline fun MemberScope.findFirstFunction(name: String, predicate: (CallableMemberDescriptor) -> Boolean) =
+    getContributedFunctions(Name.identifier(name), NoLookupLocation.FROM_BACKEND).first(predicate)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDescriptorBasedFunctionFactory.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.ir.descriptors
 
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.StandardNames.KOTLIN_REFLECT_FQ_NAME
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
-import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
-abstract class IrAbstractFunctionFactory {
+abstract class IrAbstractDescriptorBasedFunctionFactory {
 
     abstract fun functionClassDescriptor(arity: Int): FunctionClassDescriptor
     abstract fun kFunctionClassDescriptor(arity: Int): FunctionClassDescriptor
@@ -74,11 +74,16 @@ abstract class IrAbstractFunctionFactory {
         val classOrigin = object : IrDeclarationOriginImpl("FUNCTION_INTERFACE_CLASS") {}
         val memberOrigin = object : IrDeclarationOriginImpl("FUNCTION_INTERFACE_MEMBER") {}
         const val offset = SYNTHETIC_OFFSET
+
+        internal fun functionClassName(isK: Boolean, isSuspend: Boolean, arity: Int): String =
+            "${if (isK) "K" else ""}${if (isSuspend) "Suspend" else ""}Function$arity"
     }
 }
 
 @OptIn(ObsoleteDescriptorBasedAPI::class)
-class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTable: SymbolTable) : IrAbstractFunctionFactory() {
+class IrDescriptorBasedFunctionFactory(
+    private val irBuiltIns: IrBuiltInsOverDescriptors, private val symbolTable: SymbolTable
+) : IrAbstractDescriptorBasedFunctionFactory() {
 
     // TODO: Lazieness
 
@@ -89,9 +94,25 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
 
     private val irFactory: IrFactory get() = symbolTable.irFactory
 
+    val functionClass = symbolTable.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.Function")))
+    val kFunctionClass = symbolTable.referenceClass(irBuiltIns.builtIns.getBuiltInClassByFqName(FqName("kotlin.reflect.KFunction")))
+
     override fun functionClassDescriptor(arity: Int): FunctionClassDescriptor =
         irBuiltIns.builtIns.getFunction(arity) as FunctionClassDescriptor
 
+    override fun suspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor =
+        irBuiltIns.builtIns.getSuspendFunction(arity) as FunctionClassDescriptor
+
+    override fun kFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
+        val kFunctionFqn = reflectFunctionClassFqn(reflectionFunctionClassName(false, arity))
+        return irBuiltIns.builtIns.getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
+    }
+
+    override fun kSuspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
+        val kFunctionFqn = reflectFunctionClassFqn(reflectionFunctionClassName(true, arity))
+        return irBuiltIns.builtIns.getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
+    }
+
     override fun functionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass {
         return functionNMap.getOrPut(arity) {
             symbolTable.declarator { symbol ->
@@ -102,9 +123,6 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         }
     }
 
-    override fun suspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor =
-        irBuiltIns.builtIns.getSuspendFunction(arity) as FunctionClassDescriptor
-
     override fun suspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass {
         return suspendFunctionNMap.getOrPut(arity) {
             symbolTable.declarator { symbol ->
@@ -115,11 +133,6 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         }
     }
 
-    override fun kFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
-        val kFunctionFqn = reflectFunctionClassFqn(reflectionFunctionClassName(false, arity))
-        return irBuiltIns.builtIns.getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
-    }
-
     override fun kFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass {
         return kFunctionNMap.getOrPut(arity) {
             symbolTable.declarator { symbol ->
@@ -130,11 +143,6 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         }
     }
 
-    override fun kSuspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
-        val kFunctionFqn = reflectFunctionClassFqn(reflectionFunctionClassName(true, arity))
-        return irBuiltIns.builtIns.getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
-    }
-
     override fun kSuspendFunctionN(arity: Int, declarator: SymbolTable.((IrClassSymbol) -> IrClass) -> IrClass): IrClass {
         return kSuspendFunctionNMap.getOrPut(arity) {
             symbolTable.declarator { symbol ->
@@ -145,21 +153,11 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         }
     }
 
-    companion object {
-        private fun reflectFunctionClassFqn(shortName: Name): FqName = KOTLIN_REFLECT_FQ_NAME.child(shortName)
-        private fun reflectionFunctionClassName(isSuspend: Boolean, arity: Int): Name =
-            Name.identifier("K${if (isSuspend) "Suspend" else ""}Function$arity")
-
-        private fun functionClassName(isK: Boolean, isSuspend: Boolean, arity: Int): String =
-            "${if (isK) "K" else ""}${if (isSuspend) "Suspend" else ""}Function$arity"
-    }
-
     private sealed class FunctionDescriptorFactory(protected val symbolTable: SymbolTable) {
         abstract fun memberDescriptor(name: String, factory: (IrSimpleFunctionSymbol) -> IrSimpleFunction): IrSimpleFunctionSymbol
         abstract fun FunctionDescriptor.valueParameterDescriptor(index: Int): ValueParameterDescriptor
         abstract fun typeParameterDescriptor(index: Int, factory: (IrTypeParameterSymbol) -> IrTypeParameter): IrTypeParameterSymbol
         abstract fun classReceiverParameterDescriptor(): ReceiverParameterDescriptor
-        abstract fun FunctionDescriptor.memberReceiverParameterDescriptor(): ReceiverParameterDescriptor
 
         class RealDescriptorFactory(private val classDescriptor: ClassDescriptor, symbolTable: SymbolTable) :
             FunctionDescriptorFactory(symbolTable) {
@@ -189,11 +187,6 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
             override fun classReceiverParameterDescriptor(): ReceiverParameterDescriptor {
                 return classDescriptor.thisAsReceiverParameter
             }
-
-            override fun FunctionDescriptor.memberReceiverParameterDescriptor(): ReceiverParameterDescriptor {
-                assert(containingDeclaration === classDescriptor)
-                return dispatchReceiverParameter ?: error("Expected dispatch receiver at $this")
-            }
         }
     }
 
@@ -276,24 +269,6 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         return vDeclaration
     }
 
-    private fun FunctionClassDescriptor.createFunctionClass(): IrClass {
-        val s = symbolTable.referenceClass(this)
-        if (s.isBound) return s.owner
-        return symbolTable.declareClass(this) {
-            val factory = FunctionDescriptorFactory.RealDescriptorFactory(this, symbolTable)
-            when (functionKind) {
-                FunctionClassKind.Function ->
-                    createFunctionClass(it, false, false, arity, irBuiltIns.functionClass, kotlinPackageFragment, factory)
-                FunctionClassKind.SuspendFunction ->
-                    createFunctionClass(it, false, true, arity, irBuiltIns.functionClass, kotlinCoroutinesPackageFragment, factory)
-                FunctionClassKind.KFunction ->
-                    createFunctionClass(it, true, false, arity, irBuiltIns.kFunctionClass, kotlinReflectPackageFragment, factory)
-                FunctionClassKind.KSuspendFunction ->
-                    createFunctionClass(it, true, true, arity, irBuiltIns.kFunctionClass, kotlinReflectPackageFragment, factory)
-            }
-        }
-    }
-
     private fun IrClass.createMembers(isK: Boolean, isSuspend: Boolean, descriptorFactory: FunctionDescriptorFactory) {
         if (!isK) {
             val invokeSymbol = descriptorFactory.memberDescriptor("invoke") {
@@ -468,3 +443,28 @@ class IrFunctionFactory(private val irBuiltIns: IrBuiltIns, private val symbolTa
         return klass
     }
 }
+
+private fun reflectFunctionClassFqn(shortName: Name): FqName = KOTLIN_REFLECT_FQ_NAME.child(shortName)
+private fun reflectionFunctionClassName(isSuspend: Boolean, arity: Int): Name =
+    Name.identifier("K${if (isSuspend) "Suspend" else ""}Function$arity")
+
+@OptIn(ObsoleteDescriptorBasedAPI::class)
+fun KotlinBuiltIns.functionClassDescriptor(arity: Int): FunctionClassDescriptor =
+    getFunction(arity) as FunctionClassDescriptor
+
+@OptIn(ObsoleteDescriptorBasedAPI::class)
+fun KotlinBuiltIns.suspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor =
+    getSuspendFunction(arity) as FunctionClassDescriptor
+
+@OptIn(ObsoleteDescriptorBasedAPI::class)
+fun KotlinBuiltIns.kFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
+    val kFunctionFqn = reflectFunctionClassFqn(reflectionFunctionClassName(false, arity))
+    return getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
+}
+
+@OptIn(ObsoleteDescriptorBasedAPI::class)
+fun KotlinBuiltIns.kSuspendFunctionClassDescriptor(arity: Int): FunctionClassDescriptor {
+    val kFunctionFqn =
+        reflectFunctionClassFqn(reflectionFunctionClassName(true, arity))
+    return getBuiltInClassByFqName(kFunctionFqn) as FunctionClassDescriptor
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/overrides/IrOverridingUtil.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.types.*

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerContext.kt

@@ -5,10 +5,11 @@
 
 package org.jetbrains.kotlin.ir.types
 
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.types.AbstractTypeCheckerContext
-import org.jetbrains.kotlin.types.model.*
+import org.jetbrains.kotlin.types.model.KotlinTypeMarker
+import org.jetbrains.kotlin.types.model.SimpleTypeMarker
 
 open class IrTypeCheckerContext(override val typeSystemContext: IrTypeSystemContext): AbstractTypeCheckerContext() {
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeCheckerUtils.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.ir.types
 
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
 import org.jetbrains.kotlin.types.model.TypeConstructorMarker
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSubstitutor.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.ir.types
 
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.impl.IrCapturedType
 import org.jetbrains.kotlin.ir.types.impl.buildSimpleType

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt

@@ -10,9 +10,9 @@ import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.FqNameEqualityChecker

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeUtils.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.ir.types
 
 import org.jetbrains.kotlin.builtins.StandardNames
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.FqNameEqualityChecker
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.classifierOrNull
 import org.jetbrains.kotlin.ir.types.isNullable
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 
 /**
  * A platform-, frontend-independent logic for generating synthetic members of data class: equals, hashCode, toString, componentN, and copy.
@@ -139,19 +138,6 @@ abstract class DataClassMembersGenerator(
             +irReturnTrue()
         }
 
-        private val intClass = context.builtIns.int
-        private val intType = context.builtIns.intType
-
-        private val intTimesSymbol: IrSimpleFunctionSymbol =
-            intClass.unsubstitutedMemberScope.findFirstFunction("times") {
-                KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType)
-            }.let { symbolTable.referenceSimpleFunction(it) }
-
-        private val intPlusSymbol: IrSimpleFunctionSymbol =
-            intClass.unsubstitutedMemberScope.findFirstFunction("plus") {
-                KotlinTypeChecker.DEFAULT.equalTypes(it.valueParameters[0].type, intType)
-            }.let { symbolTable.referenceSimpleFunction(it) }
-
         fun generateHashCodeMethodBody(properties: List<IrProperty>) {
             if (properties.isEmpty()) {
                 +irReturn(irInt(0))
@@ -176,8 +162,8 @@ abstract class DataClassMembersGenerator(
             +irResultVar
 
             for (property in properties.drop(1)) {
-                val shiftedResult = irCallOp(intTimesSymbol, irIntType, irGet(irResultVar), irInt(31))
-                val irRhs = irCallOp(intPlusSymbol, irIntType, shiftedResult, getHashCodeOfProperty(property))
+                val shiftedResult = irCallOp(context.irBuiltIns.intTimesSymbol, irIntType, irGet(irResultVar), irInt(31))
+                val irRhs = irCallOp(context.irBuiltIns.intPlusSymbol, irIntType, shiftedResult, getHashCodeOfProperty(property))
                 +irSet(irResultVar.symbol, irRhs)
             }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.ir.util
 
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
 import org.jetbrains.kotlin.ir.expressions.impl.*
 import org.jetbrains.kotlin.ir.symbols.*

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/overrides/FakeOverrides.kt

@@ -19,10 +19,8 @@ package org.jetbrains.kotlin.backend.common.overrides
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.GlobalDeclarationTable
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.overrides.FakeOverrideBuilderStrategy
 import org.jetbrains.kotlin.ir.overrides.IrOverridingUtil
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/DeclarationTable.kt

@@ -11,10 +11,11 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.expressions.IrFunctionExpression
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
@@ -42,7 +43,7 @@ abstract class GlobalDeclarationTable(
     constructor(mangler: KotlinMangler.IrMangler) : this(mangler, IdSignatureClashTracker.DEFAULT_TRACKER)
 
     protected fun loadKnownBuiltins(builtIns: IrBuiltIns) {
-        builtIns.knownBuiltins.forEach {
+        (builtIns as IrBuiltInsOverDescriptors).knownBuiltins.forEach {
             val symbol = (it as IrSymbolOwner).symbol
             table[it] = symbol.signature!!.also { id -> clashTracker.commit(it, id) }
         }
@@ -104,5 +105,5 @@ open class DeclarationTable(globalTable: GlobalDeclarationTable) {
 }
 
 // This is what we pre-populate tables with
-val IrBuiltIns.knownBuiltins: List<IrDeclaration>
+val IrBuiltInsOverDescriptors.knownBuiltins: List<IrDeclaration>
     get() = packageFragment.declarations

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IncrementalCompilationSupport.kt

@@ -10,9 +10,10 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.DeserializedDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.IrSymbolOwner
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.SymbolTable
@@ -131,7 +132,7 @@ class CurrentModuleWithICDeserializer(
     }
 
     override fun init(delegate: IrModuleDeserializer) {
-        val knownBuiltIns = irBuiltIns.knownBuiltins.map { (it as IrSymbolOwner).symbol }.toSet()
+        val knownBuiltIns = (irBuiltIns as IrBuiltInsOverDescriptors).knownBuiltins.map { (it as IrSymbolOwner).symbol }.toSet()
         symbolTable.forEachPublicSymbol {
             if (it.descriptor.isDirtyDescriptor()) { // public && non-deserialized should be dirty symbol
                 if (it !in knownBuiltIns) {

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrBodyDeserializer.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrOperation.Opera
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlockReturn
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrStatement.StatementCase
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrVarargElement.VarargElementCase
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
@@ -43,8 +44,6 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrErrorExpression
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrExpression as ProtoExpression
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionExpression as ProtoFunctionExpression
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionReference as ProtoFunctionReference
-import org.jetbrains.kotlin.backend.common.serialization.proto.IrRawFunctionReference as ProtoRawFunctionReference
-import org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlock as ProtoReturnableBlock
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetClass as ProtoGetClass
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetEnumValue as ProtoGetEnumValue
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrGetField as ProtoGetField
@@ -54,7 +53,9 @@ import org.jetbrains.kotlin.backend.common.serialization.proto.IrInstanceInitial
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrLocalDelegatedPropertyReference as ProtoLocalDelegatedPropertyReference
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrOperation as ProtoOperation
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrPropertyReference as ProtoPropertyReference
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrRawFunctionReference as ProtoRawFunctionReference
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrReturn as ProtoReturn
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrReturnableBlock as ProtoReturnableBlock
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrSetField as ProtoSetField
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrSetValue as ProtoSetValue
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrSpreadElement as ProtoSpreadElement

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrDeclarationDeserializer.kt

@@ -11,17 +11,11 @@ import org.jetbrains.kotlin.backend.common.serialization.encodings.*
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration.DeclaratorCase.*
 import org.jetbrains.kotlin.backend.common.serialization.proto.IrType.KindCase.*
 import org.jetbrains.kotlin.descriptors.InlineClassRepresentation
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl
 import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.expressions.IrBlockBody
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
-import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
-import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin
-import org.jetbrains.kotlin.ir.expressions.IrStatementOriginImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrErrorExpressionImpl
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.symbols.impl.IrPublicSymbolBase

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/IrModuleDeserializer.kt

@@ -9,9 +9,9 @@ import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolD
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.*
 import org.jetbrains.kotlin.ir.symbols.*
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.library.IrLibrary
@@ -96,10 +96,10 @@ abstract class IrModuleDeserializer(val moduleDescriptor: ModuleDescriptor, val
 }
 
 // Used to resolve built in symbols like `kotlin.ir.internal.*` or `kotlin.FunctionN`
+@OptIn(ObsoleteDescriptorBasedAPI::class)
 class IrModuleDeserializerWithBuiltIns(
-    builtIns: IrBuiltIns,
-    private val functionFactory: IrAbstractFunctionFactory,
-    private val delegate: IrModuleDeserializer,
+    private val builtIns: IrBuiltInsOverDescriptors,
+    private val delegate: IrModuleDeserializer
 ) : IrModuleDeserializer(delegate.moduleDescriptor, delegate.libraryAbiVersion) {
 
     init {
@@ -140,7 +140,7 @@ class IrModuleDeserializerWithBuiltIns(
         val isK = className[0] == 'K'
         val isSuspend = (if (isK) className[1] else className[0]) == 'S'
         val arity = className.run { substring(indexOfFirst { it.isDigit() }).toInt(10) }
-        return functionFactory.run {
+        return builtIns.builtIns.run {
             when {
                 isK && isSuspend -> kSuspendFunctionClassDescriptor(arity)
                 isK -> kFunctionClassDescriptor(arity)
@@ -160,16 +160,16 @@ class IrModuleDeserializerWithBuiltIns(
         val topLevelSignature = IdSignature.CommonSignature(publicSig.packageFqName, className, null, publicSig.mask)
 
         val functionClass = when (functionDescriptor.functionKind) {
-            FunctionClassKind.KSuspendFunction -> functionFactory.kSuspendFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.KSuspendFunction -> builtIns.kSuspendFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassKind.KFunction -> functionFactory.kFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.KFunction -> builtIns.kFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassKind.SuspendFunction -> functionFactory.suspendFunctionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.SuspendFunction -> builtIns.suspendFunctionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
-            FunctionClassKind.Function -> functionFactory.functionN(functionDescriptor.arity) { callback ->
+            FunctionClassKind.Function -> builtIns.functionN(functionDescriptor.arity) { callback ->
                 declareClassFromLinker(functionDescriptor, topLevelSignature) { callback(it) }
             }
         }

compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/KotlinIrLinker.kt

@@ -11,11 +11,12 @@ import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolD
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.linkage.KotlinIrLinkerInternalException
 import org.jetbrains.kotlin.ir.symbols.*
@@ -90,8 +91,6 @@ abstract class KotlinIrLinker(
         strategy: DeserializationStrategy,
     ): IrModuleDeserializer
 
-    protected abstract val functionalInterfaceFactory: IrAbstractFunctionFactory
-
     protected abstract fun isBuiltInModule(moduleDescriptor: ModuleDescriptor): Boolean
 
     private fun deserializeAllReachableTopLevels() {
@@ -103,6 +102,7 @@ abstract class KotlinIrLinker(
         }
     }
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     private fun findDeserializedDeclarationForSymbol(symbol: IrSymbol): DeclarationDescriptor? {
 
         if (symbol in triedToDeserializeDeclarationForSymbol || symbol in deserializedSymbols) {
@@ -124,6 +124,7 @@ abstract class KotlinIrLinker(
 
     protected open fun platformSpecificSymbol(symbol: IrSymbol): Boolean = false
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     private fun tryResolveCustomDeclaration(symbol: IrSymbol): IrDeclaration? {
         if (!symbol.hasDescriptor) return null
 
@@ -145,6 +146,7 @@ abstract class KotlinIrLinker(
         }
     }
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     override fun getDeclaration(symbol: IrSymbol): IrDeclaration? {
 
         if (!symbol.isPublicApi) {
@@ -307,11 +309,12 @@ abstract class KotlinIrLinker(
         return deserializerForModule.moduleFragment
     }
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     private fun maybeWrapWithBuiltInAndInit(
         moduleDescriptor: ModuleDescriptor,
         moduleDeserializer: IrModuleDeserializer
     ): IrModuleDeserializer =
-        if (isBuiltInModule(moduleDescriptor)) IrModuleDeserializerWithBuiltIns(builtIns, functionalInterfaceFactory, moduleDeserializer)
+        if (isBuiltInModule(moduleDescriptor)) IrModuleDeserializerWithBuiltIns(builtIns as IrBuiltInsOverDescriptors, moduleDeserializer)
         else moduleDeserializer
 
     fun deserializeIrModuleHeader(moduleDescriptor: ModuleDescriptor, kotlinLibrary: KotlinLibrary?, moduleName: String): IrModuleFragment {

compiler/ir/serialization.js/build.gradle.kts

@@ -15,3 +15,11 @@ dependencies {
 sourceSets {
     "main" { projectDefault() }
 }
+
+tasks {
+    val compileKotlin by existing(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class) {
+        kotlinOptions {
+            freeCompilerArgs += "-Xopt-in=org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI"
+        }
+    }
+}

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt

@@ -28,14 +28,15 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrModuleSerializer
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.ExternalDependenciesGenerator
@@ -170,8 +171,6 @@ fun generateKLib(
     val allDependencies = depsDescriptors.allDependencies
     val (psi2IrContext, hasErrors) = runAnalysisAndPreparePsi2Ir(depsDescriptors, irFactory, errorPolicy)
     val irBuiltIns = psi2IrContext.irBuiltIns
-    val functionFactory = IrFunctionFactory(irBuiltIns, psi2IrContext.symbolTable)
-    irBuiltIns.functionFactory = functionFactory
 
     val expectDescriptorToSymbol = mutableMapOf<DeclarationDescriptor, IrSymbol>()
     val feContext = psi2IrContext.run {
@@ -182,7 +181,6 @@ fun generateKLib(
         messageLogger,
         psi2IrContext.irBuiltIns,
         psi2IrContext.symbolTable,
-        functionFactory,
         feContext,
         serializedIrFiles?.let { ICData(it, errorPolicy.allowErrors) }
     )
@@ -246,6 +244,7 @@ private fun sortDependencies(resolvedDependencies: List<KotlinResolvedLibrary>,
     }.reversed()
 }
 
+@OptIn(ObsoleteDescriptorBasedAPI::class)
 fun loadIr(
     project: Project,
     mainModule: MainModule,
@@ -266,14 +265,12 @@ fun loadIr(
             val (psi2IrContext, _) = runAnalysisAndPreparePsi2Ir(depsDescriptors, irFactory, errorPolicy)
             val irBuiltIns = psi2IrContext.irBuiltIns
             val symbolTable = psi2IrContext.symbolTable
-            val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
-            irBuiltIns.functionFactory = functionFactory
             val feContext = psi2IrContext.run {
                 JsIrLinker.JsFePluginContext(moduleDescriptor, symbolTable, typeTranslator, irBuiltIns)
             }
             val moduleFragmentToUniqueName = mutableMapOf<IrModuleFragment, String>()
             val irLinker =
-                JsIrLinker(psi2IrContext.moduleDescriptor, messageLogger, irBuiltIns, symbolTable, functionFactory, feContext, null)
+                JsIrLinker(psi2IrContext.moduleDescriptor, messageLogger, irBuiltIns, symbolTable, feContext, null)
             val deserializedModuleFragments = sortDependencies(allDependencies, depsDescriptors.descriptors).map { klib ->
                 irLinker.deserializeIrModuleHeader(
                     depsDescriptors.getModuleDescriptor(klib),
@@ -301,7 +298,7 @@ fun loadIr(
             }
 
             if (verifySignatures) {
-                irBuiltIns.knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
+                (irBuiltIns as IrBuiltInsOverDescriptors).knownBuiltins.forEach { it.acceptVoid(mangleChecker) }
             }
 
             return IrModuleInfo(moduleFragment, deserializedModuleFragments, irBuiltIns, symbolTable, irLinker, moduleFragmentToUniqueName)
@@ -315,10 +312,9 @@ fun loadIr(
             val symbolTable = SymbolTable(signaturer, irFactory)
             val typeTranslator =
                 TypeTranslatorImpl(symbolTable, depsDescriptors.compilerConfiguration.languageVersionSettings, moduleDescriptor)
-            val irBuiltIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable)
-            val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
+            val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
             val irLinker =
-                JsIrLinker(null, messageLogger, irBuiltIns, symbolTable, functionFactory, null, null)
+                JsIrLinker(null, messageLogger, irBuiltIns, symbolTable, null, null)
 
             val moduleFragmentToUniqueName = mutableMapOf<IrModuleFragment, String>()
 
@@ -335,7 +331,6 @@ fun loadIr(
                     }
                 }
             }
-            irBuiltIns.functionFactory = functionFactory
 
             val moduleFragment = deserializedModuleFragments.last()
 

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsDeclarationTable.kt

@@ -7,12 +7,10 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 
 import org.jetbrains.kotlin.backend.common.serialization.GlobalDeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IdSignatureClashTracker
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.ir.util.render
 

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrLinker.kt

@@ -8,10 +8,9 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 import org.jetbrains.kotlin.backend.common.overrides.FakeOverrideBuilder
 import org.jetbrains.kotlin.backend.common.serialization.*
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable
@@ -24,7 +23,6 @@ import org.jetbrains.kotlin.library.containsErrorCode
 
 class JsIrLinker(
     private val currentModule: ModuleDescriptor?, messageLogger: IrMessageLogger, builtIns: IrBuiltIns, symbolTable: SymbolTable,
-    override val functionalInterfaceFactory: IrAbstractFunctionFactory,
     override val translationPluginContext: TranslationPluginContext?,
     private val icData: ICData? = null
 ) : KotlinIrLinker(currentModule, messageLogger, builtIns, symbolTable, emptyList()) {

compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/lower/serialization/ir/JsIrModuleSerializer.kt

@@ -8,11 +8,9 @@ package org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir
 import org.jetbrains.kotlin.backend.common.serialization.CompatibilityMode
 import org.jetbrains.kotlin.backend.common.serialization.DeclarationTable
 import org.jetbrains.kotlin.backend.common.serialization.IrModuleSerializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureSerializer
-import org.jetbrains.kotlin.backend.common.serialization.signature.PublicIdSignatureComputer
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.IrFile
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 

compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/ir/backend/jvm/serialization/JvmIrLinker.kt

@@ -15,7 +15,6 @@ import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl
-import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.types.IrTypeSystemContext
@@ -37,7 +36,6 @@ class JvmIrLinker(
     messageLogger: IrMessageLogger,
     typeSystem: IrTypeSystemContext,
     symbolTable: SymbolTable,
-    override val functionalInterfaceFactory: IrAbstractFunctionFactory,
     override val translationPluginContext: TranslationPluginContext?,
     private val stubGenerator: DeclarationStubGenerator,
     private val manglerDesc: JvmDescriptorMangler

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver
 import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendExtension
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
@@ -75,7 +74,6 @@ class Fir2IrResultsConverter(
             FirJvmBackendClassResolver(components)
         ).build()
 
-        irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable)
         val irProviders = codegenFactory.configureBuiltInsAndGenerateIrProvidersInFrontendIRMode(irModuleFragment, symbolTable, extensions)
 
         return IrBackendInput(

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/ComposeLikeGenerationExtension.kt

@@ -274,7 +274,7 @@ class ComposeLikeDefaultArgumentRewriter(
     }
 
     private fun IrType.binaryOperator(name: Name, paramType: IrType): IrFunctionSymbol =
-        context.symbols.getBinaryOperator(name, this, paramType)
+        context.irBuiltIns.getBinaryOperator(name, this, paramType)
 
     private fun irAnd(lhs: IrExpression, rhs: IrExpression): IrCallImpl {
         return irCall(

generators/interpreter/GenerateInterpreterMap.kt

@@ -14,11 +14,16 @@ import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil
+import org.jetbrains.kotlin.ir.BuiltInOperatorNames
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.types.impl.originalKotlinType
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.util.IdSignatureComposer
+import org.jetbrains.kotlin.ir.util.SymbolTable
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -165,7 +170,7 @@ private data class Operation(
             val receiver = castValueParenthesized("a", typeA)
             println(name)
             return when {
-                name == IrBuiltIns.OperatorNames.EQEQEQ && parameterTypes.all { it == "Any?" } ->
+                name == BuiltInOperatorNames.EQEQEQ && parameterTypes.all { it == "Any?" } ->
                     "if (a is Proxy && b is Proxy) a.state === b.state else a === b"
                 customExpression != null -> customExpression
                 else -> buildString {
@@ -244,19 +249,20 @@ private fun getBinaryIrOperationMap(irBuiltIns: IrBuiltIns): List<Operation> {
 
 private fun getIrMethodSymbolByName(methodName: String): String {
     return when (methodName) {
-        IrBuiltIns.OperatorNames.LESS -> "<"
-        IrBuiltIns.OperatorNames.LESS_OR_EQUAL -> "<="
-        IrBuiltIns.OperatorNames.GREATER -> ">"
-        IrBuiltIns.OperatorNames.GREATER_OR_EQUAL -> ">="
-        IrBuiltIns.OperatorNames.EQEQ -> "=="
-        IrBuiltIns.OperatorNames.EQEQEQ -> "==="
-        IrBuiltIns.OperatorNames.IEEE754_EQUALS -> "=="
-        IrBuiltIns.OperatorNames.ANDAND -> "&&"
-        IrBuiltIns.OperatorNames.OROR -> "||"
+        BuiltInOperatorNames.LESS -> "<"
+        BuiltInOperatorNames.LESS_OR_EQUAL -> "<="
+        BuiltInOperatorNames.GREATER -> ">"
+        BuiltInOperatorNames.GREATER_OR_EQUAL -> ">="
+        BuiltInOperatorNames.EQEQ -> "=="
+        BuiltInOperatorNames.EQEQEQ -> "==="
+        BuiltInOperatorNames.IEEE754_EQUALS -> "=="
+        BuiltInOperatorNames.ANDAND -> "&&"
+        BuiltInOperatorNames.OROR -> "||"
         else -> throw UnsupportedOperationException("Unknown ir operation \"$methodName\"")
     }
 }
 
+@OptIn(ObsoleteDescriptorBasedAPI::class)
 private fun getIrBuiltIns(): IrBuiltIns {
     val languageSettings = LanguageVersionSettingsImpl(LanguageVersion.KOTLIN_1_3, ApiVersion.KOTLIN_1_3)
 
@@ -272,5 +278,5 @@ private fun getIrBuiltIns(): IrBuiltIns {
     }
     val symbolTable = SymbolTable(signaturer, IrFactoryImpl)
     val typeTranslator = TypeTranslatorImpl(symbolTable, languageSettings, moduleDescriptor)
-    return IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable)
+    return IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
 }

js/js.tests/test/org/jetbrains/kotlin/benchmarks/GenerateIrRuntime.kt

@@ -32,6 +32,8 @@ import org.jetbrains.kotlin.incremental.EmptyICReporter
 import org.jetbrains.kotlin.incremental.IncrementalJsCompilerRunner
 import org.jetbrains.kotlin.incremental.multiproject.EmptyModulesApiHistory
 import org.jetbrains.kotlin.incremental.withJsIC
+import org.jetbrains.kotlin.ir.IrBuiltIns
+import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrModuleSerializer
@@ -39,8 +41,7 @@ import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
-import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory
+import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.util.ExternalDependenciesGenerator
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.ir.util.SymbolTable
@@ -457,16 +458,11 @@ class GenerateIrRuntime {
         val symbolTable = SymbolTable(IdSignatureDescriptor(JsManglerDesc), PersistentIrFactory())
         val psi2IrContext = psi2Ir.createGeneratorContext(analysisResult.moduleDescriptor, analysisResult.bindingContext, symbolTable)
 
-        val irBuiltIns = psi2IrContext.irBuiltIns
-        val functionFactory = IrFunctionFactory(irBuiltIns, psi2IrContext.symbolTable)
-        irBuiltIns.functionFactory = functionFactory
-
         val irLinker = JsIrLinker(
             psi2IrContext.moduleDescriptor,
             IrMessageLogger.None,
             psi2IrContext.irBuiltIns,
             psi2IrContext.symbolTable,
-            functionFactory,
             null
         )
 
@@ -516,17 +512,15 @@ class GenerateIrRuntime {
         writer.writeIr(serializedIrModule)
     }
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     private fun doDeserializeIrModule(moduleDescriptor: ModuleDescriptorImpl): DeserializedModuleInfo {
         val mangler = JsManglerDesc
         val signaturer = IdSignatureDescriptor(mangler)
         val symbolTable = SymbolTable(signaturer, PersistentIrFactory())
         val typeTranslator = TypeTranslatorImpl(symbolTable, languageVersionSettings, moduleDescriptor)
+        val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
 
-        val irBuiltIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable)
-        val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
-        irBuiltIns.functionFactory = functionFactory
-
-        val jsLinker = JsIrLinker(moduleDescriptor, IrMessageLogger.None, irBuiltIns, symbolTable, functionFactory, null)
+        val jsLinker = JsIrLinker(moduleDescriptor, IrMessageLogger.None, irBuiltIns, symbolTable, null)
 
         val moduleFragment = jsLinker.deserializeFullModule(moduleDescriptor, moduleDescriptor.kotlinLibrary)
         jsLinker.init(null, emptyList())
@@ -541,6 +535,7 @@ class GenerateIrRuntime {
         return DeserializedModuleInfo(moduleFragment, symbolTable, irBuiltIns, jsLinker)
     }
 
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
     private fun doDeserializeModule(modulePath: String): DeserializedModuleInfo {
         val moduleRef = loadKlib(modulePath, false)
         val moduleDescriptor = doDeserializeModuleMetadata(moduleRef)
@@ -548,12 +543,9 @@ class GenerateIrRuntime {
         val signaturer = IdSignatureDescriptor(mangler)
         val symbolTable = SymbolTable(signaturer, PersistentIrFactory())
         val typeTranslator = TypeTranslatorImpl(symbolTable, languageVersionSettings, moduleDescriptor)
-        val irBuiltIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, symbolTable)
+        val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
 
-        val functionFactory = IrFunctionFactory(irBuiltIns, symbolTable)
-        irBuiltIns.functionFactory = functionFactory
-
-        val jsLinker = JsIrLinker(moduleDescriptor, IrMessageLogger.None, irBuiltIns, symbolTable, functionFactory, null)
+        val jsLinker = JsIrLinker(moduleDescriptor, IrMessageLogger.None, irBuiltIns, symbolTable, null)
 
         val moduleFragment = jsLinker.deserializeFullModule(moduleDescriptor, moduleDescriptor.kotlinLibrary)
         // Create stubs

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/common/AbstractValueUsageTransformer.kt

@@ -7,11 +7,14 @@ package org.jetbrains.kotlin.backend.common
 
 import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.*
-import org.jetbrains.kotlin.ir.symbols.*
+import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
+import org.jetbrains.kotlin.ir.symbols.IrReturnTargetSymbol
+import org.jetbrains.kotlin.ir.symbols.IrReturnableBlockSymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.defaultType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Boxing.kt

@@ -5,20 +5,24 @@
 
 package org.jetbrains.kotlin.backend.konan
 
-import llvm.*
+import llvm.LLVMConstInt
+import llvm.LLVMTypeRef
 import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.backend.konan.llvm.*
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.IrType
-import org.jetbrains.kotlin.ir.util.*
+import org.jetbrains.kotlin.ir.util.defaultOrNullableType
+import org.jetbrains.kotlin.ir.util.defaultType
+import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization
+import org.jetbrains.kotlin.ir.util.getContainingFile
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.name.Name
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BuiltInFictitiousFunctionIrClassFactory.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.*
 import org.jetbrains.kotlin.ir.descriptors.IrAbstractFunctionFactory
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrProvider
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/PsiToIr.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
 import org.jetbrains.kotlin.ir.builders.TranslationPluginContext
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.linkage.IrDeserializer
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.util.*

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/cgen/InteropIrUtils.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.backend.konan.ir.isObjCObjectType
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.types.*
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.konan.target.KonanTarget

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt

@@ -7,17 +7,19 @@ package org.jetbrains.kotlin.backend.konan.descriptors
 
 import org.jetbrains.kotlin.backend.common.atMostOne
 import org.jetbrains.kotlin.backend.konan.*
-import org.jetbrains.kotlin.backend.konan.ir.*
+import org.jetbrains.kotlin.backend.konan.ir.getSuperClassNotAny
+import org.jetbrains.kotlin.backend.konan.ir.getSuperInterfaces
 import org.jetbrains.kotlin.backend.konan.llvm.isVoidAsReturnType
 import org.jetbrains.kotlin.backend.konan.llvm.longName
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.classifierOrFail
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.resolve.annotations.argumentValue
 import org.jetbrains.kotlin.resolve.constants.StringValue

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/NewIrUtils.kt

@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.backend.konan.descriptors.isInteropLibrary
 import org.jetbrains.kotlin.backend.konan.llvm.KonanMetadata
 import org.jetbrains.kotlin.backend.konan.serialization.KonanFileMetadataSource
 import org.jetbrains.kotlin.backend.konan.serialization.KonanIrModuleFragmentImpl
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
+import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.klibModuleOrigin
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.lazy.IrLazyDeclarationBase
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.expressions.IrConst
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/DescriptorToIrTranslationUtils.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.backend.konan.ir.interop
 import org.jetbrains.kotlin.backend.common.ir.createParameterDeclarations
 import org.jetbrains.kotlin.backend.konan.InteropBuiltIns
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.IrBuilder
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrConstructorImpl
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.impl.IrInstanceInitializerCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/interop/cenum/CEnumByValueFunctionGenerator.kt

@@ -8,10 +8,10 @@ import org.jetbrains.kotlin.backend.konan.ir.KonanSymbols
 import org.jetbrains.kotlin.backend.konan.ir.interop.DescriptorToIrTranslationMixin
 import org.jetbrains.kotlin.backend.konan.ir.interop.findDeclarationByName
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
+import org.jetbrains.kotlin.ir.IrBuiltIns
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns
 import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.types.classOrNull