[JS IR] IC invalidation refactoring

- Huge refactoring for IC
  - Update hash combination logic
  - Introduce value class for IC hashes
  - Calc md5 directly by function IR
  - Split IC logic by classes
  - Move JsIrLinkerLoader into separate file
  - CacheUpdateStatus is a sealed class
  - Render TYPE_PARAMETER reified flag

^KT-51081 Fixed
^KT-51084 Fixed

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -210,22 +210,37 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
             var start = System.currentTimeMillis()
 
-            actualizeCaches(
+            val cacheUpdater = CacheUpdater(
                 includes,
-                configurationJs,
                 libraries,
+                configurationJs,
                 cacheDirectories,
                 { IrFactoryImplForJsIC(WholeWorldStageController()) },
                 mainCallArguments,
-                ::buildCacheForModuleFiles,
-            ) { updateStatus, updatedModule ->
+                ::buildCacheForModuleFiles
+            )
+            cacheUpdater.actualizeCaches { updateStatus, updatedModule ->
                 val now = System.currentTimeMillis()
-                val strStatus = when (updateStatus) {
-                    CacheUpdateStatus.FAST_PATH -> "up-to-date; fast check"
-                    CacheUpdateStatus.NO_DIRTY_FILES -> "up-to-date; full check"
-                    CacheUpdateStatus.DIRTY -> "dirty; cache building"
+                fun reportCacheStatus(status: String, removed: Set<String> = emptySet(), updated: Set<String> = emptySet()) {
+                    messageCollector.report(INFO, "IC per-file is $status duration ${now - start}ms; module [${File(updatedModule).name}]")
+                    removed.forEach { messageCollector.report(INFO, "  Removed: $it") }
+                    updated.forEach { messageCollector.report(INFO, "  Updated: $it") }
+                }
+                when (updateStatus) {
+                    is CacheUpdateStatus.FastPath -> reportCacheStatus("up-to-date; fast check")
+                    is CacheUpdateStatus.NoDirtyFiles -> reportCacheStatus("up-to-date; full check", updateStatus.removed)
+                    is CacheUpdateStatus.Dirty -> {
+                        var updated = updateStatus.updated
+                        val status = StringBuilder("dirty").apply {
+                            if (updateStatus.updatedAll) {
+                                append("; all ${updated.size} sources updated")
+                                updated = emptySet()
+                            }
+                            append("; cache building")
+                        }.toString()
+                        reportCacheStatus(status, updateStatus.removed, updated)
+                    }
                 }
-                messageCollector.report(INFO, "IC per-file is $strStatus duration ${now - start}ms; module [${File(updatedModule).name}]")
                 start = now
             }
         } else emptyList()
@@ -274,7 +289,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
                 val beforeIc2Js = System.currentTimeMillis()
 
-                val caches = loadModuleCaches(icCaches)
                 val moduleKind = configurationJs[JSConfigurationKeys.MODULE_KIND]!!
 
                 val translationMode = TranslationMode.fromFlags(false, arguments.irPerModule)
@@ -284,7 +298,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     moduleKind,
                     SourceMapsInfo.from(configurationJs),
                     setOf(translationMode),
-                    caches,
+                    icCaches,
                     relativeRequirePath = true
                 )
 

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

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.backend.common.phaser.PhaserState
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
-import org.jetbrains.kotlin.ir.backend.js.ic.ModuleCache
-import org.jetbrains.kotlin.ir.backend.js.ic.PersistentCacheConsumer
+import org.jetbrains.kotlin.ir.backend.js.ic.ArtifactCache
+import org.jetbrains.kotlin.ir.backend.js.ic.KLibArtifact
 import org.jetbrains.kotlin.ir.backend.js.lower.collectNativeImplementations
 import org.jetbrains.kotlin.ir.backend.js.lower.generateJsTests
 import org.jetbrains.kotlin.ir.backend.js.lower.moveBodilessDeclarationsToSeparatePlace
@@ -49,7 +49,7 @@ fun compileWithIC(
     safeExternalBoolean: Boolean = false,
     safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null,
     filesToLower: Set<String>?,
-    cacheConsumer: PersistentCacheConsumer,
+    artifactCache: ArtifactCache,
 ) {
 
     val mainModule = module
@@ -101,7 +101,7 @@ fun compileWithIC(
 
     val ast = transformer.generateBinaryAst(dirtyFiles, allModules)
 
-    ast.entries.forEach { (path, bytes) -> cacheConsumer.commitBinaryAst(path, bytes) }
+    ast.entries.forEach { (path, bytes) -> artifactCache.saveBinaryAst(path, bytes) }
 }
 
 fun lowerPreservingTags(modules: Iterable<IrModuleFragment>, context: JsIrBackendContext, phaseConfig: PhaseConfig, controller: WholeWorldStageController) {
@@ -125,16 +125,18 @@ fun generateJsFromAst(
     moduleKind: ModuleKind,
     sourceMapsInfo: SourceMapsInfo?,
     translationModes: Set<TranslationMode>,
-    caches: Map<String, ModuleCache>,
+    caches: List<KLibArtifact>,
     relativeRequirePath: Boolean = false,
 ): CompilerResult {
     fun compilationOutput(multiModule: Boolean): CompilationOutputs {
         val deserializer = JsIrAstDeserializer()
-        val jsIrProgram = JsIrProgram(caches.values.map {
+        val jsIrProgram = JsIrProgram(caches.map { cacheArtifact ->
             JsIrModule(
-                it.name.safeModuleName,
-                sanitizeName(it.name.safeModuleName),
-                it.asts.values.sortedBy { it.name }.mapNotNull { it.ast?.let { deserializer.deserialize(ByteArrayInputStream(it)) } })
+                cacheArtifact.moduleName.safeModuleName,
+                sanitizeName(cacheArtifact.moduleName.safeModuleName),
+                cacheArtifact.fileArtifacts.sortedBy { it.srcFilePath }.mapNotNull { srcFileArtifact ->
+                    srcFileArtifact.astFileArtifact.fetchBinaryAst()?.let { deserializer.deserialize(ByteArrayInputStream(it)) }
+                })
         })
 
         return generateWrappedModuleBody(
@@ -149,4 +151,4 @@ fun generateJsFromAst(
     }
 
     return CompilerResult(translationModes.associate { it to compilationOutput(it.perModule) }, null)
-}
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ArtifactCache.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2022 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.backend.js.ic
+
+import java.io.File
+
+class SrcFileArtifact(val srcFilePath: String, astArtifactFilePath: String, astBinaryData: ByteArray?) {
+    class Artifact(private val artifactFilePath: String, private var binaryData: ByteArray?) {
+        fun fetchBinaryAst(): ByteArray? {
+            if (binaryData == null) {
+                binaryData = File(artifactFilePath).ifExists { readBytes() }
+            }
+            return binaryData
+        }
+    }
+
+    val astFileArtifact = Artifact(astArtifactFilePath, astBinaryData)
+}
+
+class KLibArtifact(val moduleName: String, val fileArtifacts: List<SrcFileArtifact>)
+
+abstract class ArtifactCache {
+    protected val binaryAsts = mutableMapOf<String, ByteArray>()
+
+    fun saveBinaryAst(srcPath: String, astData: ByteArray) {
+        binaryAsts[srcPath] = astData
+    }
+
+    abstract fun fetchArtifacts(): KLibArtifact
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheInfo.kt

@@ -1,36 +0,0 @@
-/*
- * 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.backend.js.ic
-
-import java.io.File
-
-// TODO md5 hash
-data class CacheInfo(
-    val path: String,
-    val libPath: String,
-    val moduleName: String?,
-    var flatHash: ULong,
-    var transHash: ULong,
-    var configHash: ULong
-) {
-    companion object {
-        fun load(path: String): CacheInfo? {
-            val info = File(File(path), "info")
-
-            if (!info.exists()) return null
-
-            val (libPath, moduleName, flatHash, transHash, configHash) = info.readLines()
-
-            // safe cast for the backward compatibility with the cache from the previous compiler versions
-            val configHashULong = configHash.toULongOrNull(16) ?: 0UL
-            return CacheInfo(path, libPath, moduleName, flatHash.toULong(16), transHash.toULong(16), configHashULong)
-        }
-
-        fun loadOrCreate(path: String, libPath: String): CacheInfo {
-            return load(path) ?: CacheInfo(path, libPath, null, 0UL, 0UL, 0UL)
-        }
-    }
-}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheLazyLoader.kt

@@ -1,86 +0,0 @@
-/*
- * Copyright 2010-2022 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.backend.js.ic
-
-import org.jetbrains.kotlin.backend.common.serialization.IdSignatureDeserializer
-import org.jetbrains.kotlin.backend.common.serialization.IrLibraryBytesSource
-import org.jetbrains.kotlin.backend.common.serialization.IrLibraryFileFromBytes
-import org.jetbrains.kotlin.backend.common.serialization.codedInputStream
-import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile
-import org.jetbrains.kotlin.ir.util.IdSignature
-import org.jetbrains.kotlin.library.KotlinLibrary
-import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite
-
-
-class CacheLazyLoader(private val cacheProvider: PersistentCacheProvider, private val library: KotlinLibrary) {
-    private val graphInlineCache = mutableMapOf<String, Collection<Pair<IdSignature, TransHash>>>()
-    private val fingerPrintCache = mutableMapOf<String, Hash>()
-
-    val signatureReadersList: List<Pair<String, IdSignatureDeserializer>> by lazy {
-        library.filesAndSigReaders()
-    }
-
-    private val signatureReadersMap: Map<String, IdSignatureDeserializer> by lazy {
-        signatureReadersList.toMap()
-    }
-
-    val allInlineFunctionHashes: Map<IdSignature, TransHash> by lazy {
-        cacheProvider.allInlineHashes { librarySrc, index ->
-            val libReader = signatureReadersMap[librarySrc] ?: error("No module reader for lib $librarySrc")
-            libReader.deserializeIdSignature(index)
-        }
-    }
-
-    fun getInlineHashesByFile() = signatureReadersList.associateTo(mutableMapOf()) {
-        it.first to cacheProvider.inlineHashes(it.first) { index -> it.second.deserializeIdSignature(index) }
-    }
-
-    fun getInlineGraphForFile(srcFile: String) = graphInlineCache.getOrPut(srcFile) {
-        val fileReader = signatureReadersMap[srcFile] ?: error("Cannot find signature reader for $srcFile")
-        cacheProvider.inlineGraphForFile(srcFile) { index -> fileReader.deserializeIdSignature(index) }
-    }
-
-    fun getFileFingerPrint(srcFile: String) = fingerPrintCache.getOrPut(srcFile) {
-        cacheProvider.fileFingerPrint(srcFile)
-    }
-
-    fun getFilePaths() = cacheProvider.filePaths()
-
-    fun clearCaches() {
-        graphInlineCache.clear()
-        fingerPrintCache.clear()
-    }
-
-    private fun KotlinLibrary.filesAndSigReaders(): List<Pair<String, IdSignatureDeserializer>> {
-        val fileSize = fileCount()
-        val result = ArrayList<Pair<String, IdSignatureDeserializer>>(fileSize)
-        val extReg = ExtensionRegistryLite.newInstance()
-
-        for (i in 0 until fileSize) {
-            val fileStream = file(i).codedInputStream
-            val fileProto = IrFile.parseFrom(fileStream, extReg)
-            val sigReader = IdSignatureDeserializer(IrLibraryFileFromBytes(object : IrLibraryBytesSource() {
-                private fun err(): Nothing = error("Not supported")
-                override fun irDeclaration(index: Int): ByteArray = err()
-
-                override fun type(index: Int): ByteArray = err()
-
-                override fun signature(index: Int): ByteArray = signature(index, i)
-
-                override fun string(index: Int): ByteArray = string(index, i)
-
-                override fun body(index: Int): ByteArray = err()
-
-                override fun debugInfo(index: Int): ByteArray? = null
-            }), null)
-
-            result.add(fileProto.fileEntry.name to sigReader)
-        }
-
-        return result
-    }
-}
-

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/HashCalculatorForIC.kt

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2010-2022 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.backend.js.ic
+
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.util.DumpIrTreeVisitor
+import org.jetbrains.kotlin.js.config.JSConfigurationKeys
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.protobuf.CodedInputStream
+import org.jetbrains.kotlin.protobuf.CodedOutputStream
+import java.io.File
+import java.security.MessageDigest
+
+@JvmInline
+value class ICHash(private val value: ULong = 0UL) {
+    fun combineWith(other: ICHash) = ICHash(value xor (other.value + 0x9e3779b97f4a7c15UL + (value shl 12) + (value shr 4)))
+
+    override fun toString() = value.toString(16)
+
+    fun toProtoStream(out: CodedOutputStream) = out.writeFixed64NoTag(value.toLong())
+
+    companion object {
+        fun fromProtoStream(input: CodedInputStream) = ICHash(input.readFixed64().toULong())
+    }
+}
+
+private class HashCalculatorForIC {
+    private companion object {
+        private val md5 = MessageDigest.getInstance("MD5")
+    }
+
+    init {
+        md5.reset()
+    }
+
+    fun update(data: ByteArray) = md5.update(data)
+    fun update(data: String) = md5.update(data.toByteArray())
+
+    private fun bytesToULong(d: ByteArray, offset: Int): ULong {
+        var hash = 0UL
+        repeat(8) {
+            hash = hash or ((d[it + offset].toULong() and 0xFFUL) shl (it * 8))
+        }
+        return hash
+    }
+
+    fun finalize(): ICHash {
+        val d = md5.digest()
+        return ICHash(bytesToULong(d, 0)).combineWith(ICHash(bytesToULong(d, 8)))
+    }
+}
+
+internal fun File.fileHashForIC(): ICHash {
+    val md5 = HashCalculatorForIC()
+    fun File.process(prefix: String = "") {
+        if (isDirectory) {
+            this.listFiles()!!.sortedBy { it.name }.forEach {
+                md5.update(prefix + it.name)
+                it.process(prefix + it.name + "/")
+            }
+        } else {
+            md5.update(readBytes())
+        }
+    }
+    this.process()
+    return md5.finalize()
+}
+
+internal fun CompilerConfiguration.configHashForIC() = HashCalculatorForIC().apply {
+    val importantBooleanSettingKeys = listOf(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION)
+    for (key in importantBooleanSettingKeys) {
+        update(key.toString())
+        update(getBoolean(key).toString())
+    }
+}.finalize()
+
+internal fun IrElement.irElementHashForIC() = HashCalculatorForIC().also {
+    accept(
+        visitor = DumpIrTreeVisitor(
+            out = object : Appendable {
+                override fun append(csq: CharSequence) = this.apply { it.update(csq.toString()) }
+                override fun append(csq: CharSequence, start: Int, end: Int) = append(csq.subSequence(start, end))
+                override fun append(c: Char) = this.apply { it.update(c.toString()) }
+            }
+        ), data = ""
+    )
+}.finalize()
+
+internal fun String.stringHashForIC() = HashCalculatorForIC().also { it.update(this) }.finalize()
+
+internal fun KotlinLibrary.fingerprint(fileIndex: Int) = HashCalculatorForIC().apply {
+    update(types(fileIndex))
+    update(signatures(fileIndex))
+    update(strings(fileIndex))
+    update(declarations(fileIndex))
+    update(bodies(fileIndex))
+}.finalize()

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IncrementalCache.kt

@@ -0,0 +1,308 @@
+/*
+ * Copyright 2010-2022 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.backend.js.ic
+
+import org.jetbrains.kotlin.backend.common.serialization.IdSignatureDeserializer
+import org.jetbrains.kotlin.backend.common.serialization.IrLibraryBytesSource
+import org.jetbrains.kotlin.backend.common.serialization.IrLibraryFileFromBytes
+import org.jetbrains.kotlin.backend.common.serialization.codedInputStream
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.protobuf.CodedInputStream
+import org.jetbrains.kotlin.protobuf.CodedOutputStream
+import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite
+import java.io.File
+
+
+class IncrementalCache(private val library: KotlinLibrary, cachePath: String) : ArtifactCache() {
+    companion object {
+        private const val cacheFullInfoFile = "cache.full.info"
+        private const val cacheFastInfoFile = "cache.fast.info"
+        private const val binaryAstSuffix = "binary.ast"
+    }
+
+    class CacheFastInfo(
+        var moduleName: String? = null,
+        var flatHash: ICHash = ICHash(),
+        var transHash: ICHash = ICHash(),
+        var configHash: ICHash = ICHash(),
+        var initialFlatHash: ICHash = ICHash()
+    )
+
+    private enum class CacheState { NON_LOADED, FETCHED_FOR_DEPENDENCY, FETCHED_FULL }
+
+    private var state = CacheState.NON_LOADED
+
+    private val cacheDir = File(cachePath)
+    private val signatureToIdMapping = mutableMapOf<String, Map<IdSignature, Int>>()
+
+    private val fingerprints = mutableMapOf<String, ICHash>()
+    private val usedInlineFunctions = mutableMapOf<String, Map<IdSignature, ICHash>>()
+    private val implementedInlineFunctions = mutableMapOf<String, Map<IdSignature, ICHash>>()
+
+    private var cacheFastInfo = CacheFastInfo().apply {
+        File(cacheDir, cacheFastInfoFile).useCodedInputIfExists {
+            moduleName = readString()
+            flatHash = ICHash.fromProtoStream(this)
+            transHash = ICHash.fromProtoStream(this)
+            configHash = ICHash.fromProtoStream(this)
+        }
+        initialFlatHash = flatHash
+    }
+
+    val srcFingerprints: Map<String, ICHash> get() = fingerprints
+    val usedFunctions: Map<String, Map<IdSignature, ICHash>> get() = usedInlineFunctions
+    val implementedFunctions: Collection<Map<IdSignature, ICHash>> get() = implementedInlineFunctions.values
+
+    val klibUpdated: Boolean get() = cacheFastInfo.run { initialFlatHash == ICHash() || initialFlatHash != flatHash }
+
+    val klibTransitiveHash: ICHash get() = cacheFastInfo.transHash
+
+    var srcFilesInOrderFromKLib: List<String> = emptyList()
+        private set
+
+    var deletedSrcFiles: Set<String> = emptySet()
+        private set
+
+    fun updateSignatureToIdMapping(srcPath: String, mapping: Map<IdSignature, Int>) {
+        signatureToIdMapping[srcPath] = mapping
+    }
+
+    fun updateHashes(
+        srcPath: String, fingerprint: ICHash, usedFunctions: Map<IdSignature, ICHash>?, implementedFunctions: Map<IdSignature, ICHash>?
+    ) {
+        fingerprints[srcPath] = fingerprint
+        usedFunctions?.let { usedInlineFunctions[srcPath] = it }
+        implementedFunctions?.let { implementedInlineFunctions[srcPath] = it }
+    }
+
+    fun invalidateCacheForNewConfig(configHash: ICHash) {
+        if (cacheFastInfo.configHash != configHash) {
+            invalidate()
+            cacheFastInfo.configHash = configHash
+        }
+    }
+
+    fun checkAndUpdateCacheFastInfo(flatHash: ICHash, transHash: ICHash): Boolean {
+        if (cacheFastInfo.transHash != transHash) {
+            cacheFastInfo.flatHash = flatHash
+            cacheFastInfo.transHash = transHash
+            return false
+        }
+        return true
+    }
+
+    private fun commitCacheFastInfo(klibModuleName: String? = null): Unit = cacheFastInfo.run {
+        moduleName = klibModuleName ?: moduleName
+        val name = moduleName ?: error("Internal error: uninitialized fast cache info for ${library.libraryName}")
+        File(cacheDir, cacheFastInfoFile).useCodedOutput {
+            writeStringNoTag(name)
+            flatHash.toProtoStream(this)
+            transHash.toProtoStream(this)
+            configHash.toProtoStream(this)
+        }
+    }
+
+    private fun CodedInputStream.readFunctionHashes(
+        deserializer: IdSignatureDeserializer, signatureToId: MutableMap<IdSignature, Int>? = null
+    ): Map<IdSignature, ICHash>? {
+        val functions = readInt32()
+        if (functions == 0) {
+            return null
+        }
+        val result = mutableMapOf<IdSignature, ICHash>()
+        for (funIndex in 0 until functions) {
+            val sigId = readInt32()
+            val hash = ICHash.fromProtoStream(this)
+            try {
+                val signature = deserializer.deserializeIdSignature(sigId)
+                result[signature] = hash
+                signatureToId?.let { it[signature] = sigId }
+            } catch (ex: IndexOutOfBoundsException) {
+                // Signature has been removed
+            }
+        }
+        return result
+    }
+
+    fun fetchFullCacheData() {
+        when (state) {
+            CacheState.FETCHED_FULL -> return
+            CacheState.FETCHED_FOR_DEPENDENCY ->
+                error("Internal error: cache for ${library.libraryName} has been already fetched for dependency")
+            CacheState.NON_LOADED -> {
+                state = CacheState.FETCHED_FULL
+                val signatureReaders = library.filesAndSigReaders()
+                srcFilesInOrderFromKLib = signatureReaders.map { it.first }
+
+                File(cacheDir, cacheFullInfoFile).useCodedInputIfExists {
+                    val deleted = mutableSetOf<String>()
+
+                    val signatureReadersMap = signatureReaders.toMap()
+                    val srcFiles = readInt32()
+                    for (srcIndex in 0 until srcFiles) {
+                        val srcPath = readString()
+                        val fingerprint = ICHash.fromProtoStream(this)
+
+                        val deserializer = signatureReadersMap[srcPath]
+                        if (deserializer != null) {
+                            fingerprints[srcPath] = fingerprint
+                            val signatureToId = mutableMapOf<IdSignature, Int>()
+                            readFunctionHashes(deserializer, signatureToId)?.let { implementedInlineFunctions[srcPath] = it }
+                            readFunctionHashes(deserializer, signatureToId)?.let { usedInlineFunctions[srcPath] = it }
+                            if (signatureToId.isNotEmpty()) {
+                                signatureToIdMapping[srcPath] = signatureToId
+                            }
+                        } else {
+                            deleted.add(srcPath)
+                            skipFunctionHashes()
+                            skipFunctionHashes()
+                        }
+                    }
+
+                    deletedSrcFiles = deleted
+                }
+            }
+        }
+    }
+
+    private fun CodedInputStream.skipFunctionHashes() {
+        val functions = readInt32()
+        for (funIndex in 0 until functions) {
+            readInt32() // skip sigid
+            readFixed64() // skip hash
+        }
+    }
+
+    fun fetchCacheDataForDependency() = File(cacheDir, cacheFullInfoFile).useCodedInputIfExists {
+        if (state == CacheState.NON_LOADED) {
+            state = CacheState.FETCHED_FOR_DEPENDENCY
+            val signatureReadersMap = library.filesAndSigReaders().toMap()
+
+            val srcFiles = readInt32()
+            for (srcIndex in 0 until srcFiles) {
+                val srcPath = readString()
+                val fingerprint = ICHash.fromProtoStream(this)
+
+                val deserializer = signatureReadersMap[srcPath]
+                if (deserializer != null) {
+                    fingerprints[srcPath] = fingerprint
+                    readFunctionHashes(deserializer)?.let { implementedInlineFunctions[srcPath] = it }
+                }
+                skipFunctionHashes()
+            }
+        }
+    }
+
+    private fun getBinaryAstPath(srcFile: String): File {
+        val binaryAstFileName = "${File(srcFile).name}.${srcFile.stringHashForIC()}.$binaryAstSuffix"
+        return File(cacheDir, binaryAstFileName)
+    }
+
+    private fun CodedOutputStream.writeFunctionHashes(sigToIndexMap: Map<IdSignature, Int>, hashes: Map<IdSignature, ICHash>) {
+        writeInt32NoTag(hashes.size)
+        for ((sig, functionHash) in hashes) {
+            val sigId = sigToIndexMap[sig] ?: error("No index found for sig $sig")
+            writeInt32NoTag(sigId)
+            functionHash.toProtoStream(this)
+        }
+    }
+
+    private fun commitCacheFullInfo() {
+        if (state != CacheState.FETCHED_FULL) {
+            error("Internal error: cache for ${library.libraryName} has not been fetched fully")
+        }
+
+        File(cacheDir, cacheFullInfoFile).useCodedOutput {
+            writeInt32NoTag(fingerprints.size)
+            for ((srcPath, fingerprint) in fingerprints) {
+                writeStringNoTag(srcPath)
+                fingerprint.toProtoStream(this)
+
+                val sigToIndexMap = signatureToIdMapping[srcPath] ?: emptyMap()
+                writeFunctionHashes(sigToIndexMap, implementedInlineFunctions[srcPath] ?: emptyMap())
+                writeFunctionHashes(sigToIndexMap, usedInlineFunctions[srcPath] ?: emptyMap())
+            }
+        }
+    }
+
+    private fun clearCacheAfterCommit() {
+        state = CacheState.FETCHED_FOR_DEPENDENCY
+        signatureToIdMapping.clear()
+        usedInlineFunctions.clear()
+        srcFilesInOrderFromKLib = emptyList()
+        deletedSrcFiles = emptySet()
+    }
+
+    fun commitCacheForRemovedSrcFiles() {
+        commitCacheFastInfo()
+        if (deletedSrcFiles.isNotEmpty()) {
+            commitCacheFullInfo()
+        }
+        clearCacheAfterCommit()
+    }
+
+    fun commitCacheForRebuiltSrcFiles(klibModuleName: String) {
+        commitCacheFastInfo(klibModuleName)
+        commitCacheFullInfo()
+        for ((srcPath, ast) in binaryAsts) {
+            getBinaryAstPath(srcPath).apply { recreate() }.writeBytes(ast)
+        }
+        clearCacheAfterCommit()
+    }
+
+    override fun fetchArtifacts() = KLibArtifact(
+        moduleName = cacheFastInfo.moduleName ?: error("Internal error: missing module name"),
+        fileArtifacts = fingerprints.keys.map {
+            SrcFileArtifact(it, getBinaryAstPath(it).absolutePath, binaryAsts[it])
+        })
+
+    fun invalidate() {
+        cacheDir.deleteRecursively()
+        signatureToIdMapping.clear()
+        implementedInlineFunctions.clear()
+        usedInlineFunctions.clear()
+        fingerprints.clear()
+        binaryAsts.clear()
+        cacheFastInfo = CacheFastInfo()
+        srcFilesInOrderFromKLib = emptyList()
+        deletedSrcFiles = emptySet()
+    }
+
+    fun invalidateForSrcFile(srcPath: String) {
+        getBinaryAstPath(srcPath).delete()
+        signatureToIdMapping.remove(srcPath)
+        implementedInlineFunctions.remove(srcPath)
+        usedInlineFunctions.remove(srcPath)
+        fingerprints.remove(srcPath)
+        binaryAsts.remove(srcPath)
+    }
+
+    private fun KotlinLibrary.filesAndSigReaders(): List<Pair<String, IdSignatureDeserializer>> {
+        val fileSize = fileCount()
+        val result = ArrayList<Pair<String, IdSignatureDeserializer>>(fileSize)
+        val extReg = ExtensionRegistryLite.newInstance()
+
+        for (i in 0 until fileSize) {
+            val fileStream = file(i).codedInputStream
+            val fileProto = IrFile.parseFrom(fileStream, extReg)
+            val sigReader = IdSignatureDeserializer(IrLibraryFileFromBytes(object : IrLibraryBytesSource() {
+                private fun err(): Nothing = error("Not supported")
+                override fun irDeclaration(index: Int): ByteArray = err()
+                override fun type(index: Int): ByteArray = err()
+                override fun signature(index: Int): ByteArray = signature(index, i)
+                override fun string(index: Int): ByteArray = string(index, i)
+                override fun body(index: Int): ByteArray = err()
+                override fun debugInfo(index: Int): ByteArray? = null
+            }), null)
+
+            result.add(fileProto.fileEntry.name to sigReader)
+        }
+
+        return result
+    }
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineGraphTracker.kt

@@ -10,63 +10,39 @@ import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
 import org.jetbrains.kotlin.ir.expressions.IrCall
 import org.jetbrains.kotlin.ir.util.IdSignature
-import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.file
 import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
-import org.jetbrains.kotlin.utils.DFS
-import java.security.MessageDigest
 
-fun ByteArray.md5(): Hash {
-    val d = MessageDigest.getInstance("MD5").digest(this)!!
-    return ((d[0].toLong() and 0xFFL)
-            or ((d[1].toLong() and 0xFFL) shl 8)
-            or ((d[2].toLong() and 0xFFL) shl 16)
-            or ((d[3].toLong() and 0xFFL) shl 24)
-            or ((d[4].toLong() and 0xFFL) shl 32)
-            or ((d[5].toLong() and 0xFFL) shl 40)
-            or ((d[6].toLong() and 0xFFL) shl 48)
-            or ((d[7].toLong() and 0xFFL) shl 56))
-}
 
 class InlineFunctionFlatHashBuilder : IrElementVisitorVoid {
     override fun visitElement(element: IrElement) {
         element.acceptChildren(this, null)
     }
 
-
-    private val fileToHash: MutableMap<IrFile, MutableMap<IrSimpleFunction, FlatHash>> = mutableMapOf()
-
-    private var currentMap: MutableMap<IrSimpleFunction, FlatHash>? = null
-
-    override fun visitFile(declaration: IrFile) {
-        currentMap = fileToHash.getOrPut(declaration) { mutableMapOf() }
-        declaration.acceptChildren(this, null)
-        currentMap = null
-    }
-
     override fun visitSimpleFunction(declaration: IrSimpleFunction) {
         if (declaration.isInline) {
-            val m = currentMap ?: error("No graph map set for ${declaration.render()}")
-            m[declaration] = declaration.dump().toByteArray().md5()
+            flatHashes[declaration] = declaration.irElementHashForIC()
         }
-        // do not go deeper since local declaration cannot be public api
+        // go deeper since local inline special declarations (like a reference adaptor) may appear
+        declaration.acceptChildren(this, null)
     }
 
-    val idToHashMap: Map<IrSimpleFunction, FlatHash> get() = fileToHash.values.flatMap { it.entries }.map { it.key to it.value }.toMap()
+    private val flatHashes = mutableMapOf<IrSimpleFunction, ICHash>()
 
+    fun getFlatHashes() = flatHashes
 }
 
 interface InlineFunctionHashProvider {
-    fun hashForExternalFunction(declaration: IrSimpleFunction): TransHash?
+    fun hashForExternalFunction(declaration: IrSimpleFunction): ICHash?
 }
 
 class InlineFunctionHashBuilder(
     private val hashProvider: InlineFunctionHashProvider,
-    private val flatHashes: Map<IrSimpleFunction, FlatHash>
+    private val flatHashes: Map<IrSimpleFunction, ICHash>
 ) {
-    private val inlineGraph: MutableMap<IrSimpleFunction, Set<IrSimpleFunction>> = mutableMapOf()
+    private val inlineFunctionCallGraph: MutableMap<IrSimpleFunction, Set<IrSimpleFunction>> = mutableMapOf()
 
     private inner class GraphBuilder : IrElementVisitor<Unit, MutableSet<IrSimpleFunction>> {
 
@@ -76,7 +52,7 @@ class InlineFunctionHashBuilder(
 
         override fun visitSimpleFunction(declaration: IrSimpleFunction, data: MutableSet<IrSimpleFunction>) {
             val newGraph = mutableSetOf<IrSimpleFunction>()
-            inlineGraph[declaration] = newGraph
+            inlineFunctionCallGraph[declaration] = newGraph
             declaration.acceptChildren(this, newGraph)
         }
 
@@ -92,95 +68,69 @@ class InlineFunctionHashBuilder(
         }
     }
 
+    private inner class InlineFunctionHashProcessor {
+        private val computedHashes = mutableMapOf<IrSimpleFunction, ICHash>()
+        private val processingFunctions = mutableSetOf<IrSimpleFunction>()
 
-    private fun topologicalOrder(): List<IrSimpleFunction> {
-        return DFS.topologicalOrder(inlineGraph.keys) {
-            inlineGraph[it]?.filter { f -> f in inlineGraph } ?: run {
-//                assert() not in current module
-                emptySet()
+        private fun processInlineFunction(f: IrSimpleFunction): ICHash = computedHashes.getOrPut(f) {
+            if (!processingFunctions.add(f)) {
+                error("Inline circle through function ${f.render()} detected")
             }
+            val callees = inlineFunctionCallGraph[f] ?: error("Internal error: Inline function is missed in inline graph ${f.render()}")
+            val flatHash = flatHashes[f] ?: error("Internal error: No flat hash for ${f.render()}")
+            var functionInlineHash = flatHash
+            for (callee in callees) {
+                functionInlineHash = functionInlineHash.combineWith(processCallee(callee))
+            }
+            processingFunctions.remove(f)
+            functionInlineHash
+        }
+
+        private fun processCallee(callee: IrSimpleFunction): ICHash {
+            if (callee in flatHashes) {
+                return processInlineFunction(callee)
+            }
+            return hashProvider.hashForExternalFunction(callee) ?: error("Internal error: No hash found for ${callee.render()}")
+        }
+
+        fun process(): Map<IrSimpleFunction, ICHash> {
+            for ((f, callees) in inlineFunctionCallGraph.entries) {
+                if (f.isInline) {
+                    processInlineFunction(f)
+                } else {
+                    callees.forEach(::processCallee)
+                }
+            }
+            return computedHashes
         }
     }
 
-    private fun checkCircles() {
-
-        val visited = mutableSetOf<IrSimpleFunction>()
-
-        // TODO: check whether algorithm is correct
-        for (f in inlineGraph.keys) {
-
-            fun walk(current: IrSimpleFunction) {
-                if (!visited.add(current)) {
-                    error("Inline circle detected: ${current.render()} into ${f.render()}")
-                }
-
-                inlineGraph[current]?.let {
-                    it.forEach { callee -> walk(callee) }
-                }
-
-                visited.remove(current)
-            }
-
-            walk(f)
-
-            assert(visited.isEmpty())
-        }
-    }
-
-
-    fun buildHashes(dirtyFiles: Collection<IrFile>): Map<IrSimpleFunction, TransHash> {
-
+    fun buildHashes(dirtyFiles: Collection<IrFile>): Map<IrSimpleFunction, ICHash> {
         dirtyFiles.forEach { it.acceptChildren(GraphBuilder(), mutableSetOf()) }
-
-        checkCircles()
-
-        val rpo = topologicalOrder()
-
-        val computedHashes = mutableMapOf<IrSimpleFunction, TransHash>()
-
-        fun transHash(callee: IrSimpleFunction): TransHash {
-            return computedHashes[callee] ?: hashProvider.hashForExternalFunction(callee)
-            ?: error("Internal error: No has found for ${callee.render()}")
-        }
-
-        for (f in rpo.asReversed()) {
-            if (!f.isInline) continue
-            val stringHash = buildString {
-                val callees = inlineGraph[f]
-                    ?: error("Expected to be in")
-                // TODO: should it be a kind of stable order?
-                for (callee in callees) {
-                    val hash = transHash(callee)
-                    append(hash.toString(Character.MAX_RADIX))
-                }
-
-                append(flatHashes[f] ?: error("Internal error: No flat hash for ${f.render()}"))
-            }
-
-            computedHashes[f] = stringHash.toByteArray().md5()
-        }
-
-        return computedHashes
+        return InlineFunctionHashProcessor().process()
     }
 
-    fun buildInlineGraph(computedHashed: Map<IrSimpleFunction, TransHash>): Map<IrFile, Collection<Pair<IdSignature, TransHash>>> {
-        val perFileInlineGraph = inlineGraph.entries.groupBy({ it.key.file }) {
+    fun buildInlineGraph(computedHashed: Map<IrSimpleFunction, ICHash>): Map<IrFile, Map<IdSignature, ICHash>> {
+        val perFileInlineGraph = inlineFunctionCallGraph.entries.groupBy({ it.key.file }) {
             it.value
         }
 
-        return perFileInlineGraph.map {
-            it.key to it.value.flatMap { edges ->
-                edges.mapNotNull { callee ->
-                    // TODO: use resolved FO
+        return perFileInlineGraph.entries.associate {
+            val usedInlineFunctions = mutableMapOf<IdSignature, ICHash>()
+            it.value.forEach { edges ->
+                edges.forEach { callee ->
                     if (!callee.isFakeOverride) {
                         val signature = callee.symbol.signature // ?: error("Expecting signature for ${callee.render()}")
                         if (signature?.visibleCrossFile == true) {
-                            signature to (computedHashed[callee] ?: hashProvider.hashForExternalFunction(callee)
-                            ?: error("Internal error: No has found for ${callee.render()}"))
-                        } else null
-                    } else null
+                            val calleeHash = computedHashed[callee]
+                                ?: hashProvider.hashForExternalFunction(callee)
+                                ?: error("Internal error: No has found for ${callee.render()}")
+                            usedInlineFunctions[signature] = calleeHash
+                        }
+                    }
                 }
             }
-        }.toMap()
+            it.key to usedInlineFunctions
+        }
     }
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsIrLinkerLoader.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2010-2022 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.backend.js.ic
+
+import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.languageVersionSettings
+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.ObsoleteDescriptorBasedAPI
+import org.jetbrains.kotlin.ir.backend.js.JsFactories
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
+import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
+import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
+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
+import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.unresolvedDependencies
+import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+
+
+internal class JsIrLinkerLoader(
+    private val compilerConfiguration: CompilerConfiguration,
+    private val library: KotlinLibrary,
+    private val dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>,
+    private val irFactory: IrFactory
+) {
+    @OptIn(ObsoleteDescriptorBasedAPI::class)
+    private fun createLinker(loadedModules: Map<ModuleDescriptor, KotlinLibrary>): JsIrLinker {
+        val logger = compilerConfiguration[IrMessageLogger.IR_MESSAGE_LOGGER] ?: IrMessageLogger.None
+        val signaturer = IdSignatureDescriptor(JsManglerDesc)
+        val symbolTable = SymbolTable(signaturer, irFactory)
+        val moduleDescriptor = loadedModules.keys.last()
+        val typeTranslator = TypeTranslatorImpl(symbolTable, compilerConfiguration.languageVersionSettings, moduleDescriptor)
+        val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
+        return JsIrLinker(null, logger, irBuiltIns, symbolTable, null)
+    }
+
+    private fun loadModules(): Map<ModuleDescriptor, KotlinLibrary> {
+        val descriptors = mutableMapOf<KotlinLibrary, ModuleDescriptorImpl>()
+        var runtimeModule: ModuleDescriptorImpl? = null
+
+        // TODO: deduplicate this code using part from klib.kt
+        fun getModuleDescriptor(current: KotlinLibrary): ModuleDescriptorImpl = descriptors.getOrPut(current) {
+            val isBuiltIns = current.unresolvedDependencies.isEmpty()
+
+            val lookupTracker = LookupTracker.DO_NOTHING
+            val md = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(
+                current,
+                compilerConfiguration.languageVersionSettings,
+                LockBasedStorageManager.NO_LOCKS,
+                runtimeModule?.builtIns,
+                packageAccessHandler = null, // TODO: This is a speed optimization used by Native. Don't bother for now.
+                lookupTracker = lookupTracker
+            )
+            if (isBuiltIns) runtimeModule = md
+
+            val dependencies = dependencyGraph[current]!!.map { getModuleDescriptor(it) }
+            md.setDependencies(listOf(md) + dependencies)
+            md
+        }
+
+        return dependencyGraph.keys.associateBy { klib -> getModuleDescriptor(klib) }
+    }
+
+    fun processJsIrLinker(dirtyFiles: Collection<String>?): Triple<JsIrLinker, IrModuleFragment, Collection<IrModuleFragment>> {
+        val loadedModules = loadModules()
+        val jsIrLinker = createLinker(loadedModules)
+        val irModules = ArrayList<Pair<IrModuleFragment, KotlinLibrary>>(loadedModules.size)
+
+        // TODO: modules deserialized here have to be reused for cache building further
+        for ((descriptor, loadedLibrary) in loadedModules) {
+            if (library == loadedLibrary) {
+                if (dirtyFiles != null) {
+                    irModules.add(jsIrLinker.deserializeDirtyFiles(descriptor, loadedLibrary, dirtyFiles) to loadedLibrary)
+                } else {
+                    irModules.add(jsIrLinker.deserializeFullModule(descriptor, loadedLibrary) to loadedLibrary)
+                }
+            } else {
+                irModules.add(jsIrLinker.deserializeHeadersWithInlineBodies(descriptor, loadedLibrary) to loadedLibrary)
+            }
+        }
+
+        jsIrLinker.init(null, emptyList())
+        ExternalDependenciesGenerator(jsIrLinker.symbolTable, listOf(jsIrLinker)).generateUnboundSymbolsAsDependencies()
+        jsIrLinker.postProcess()
+
+        val currentIrModule = irModules.find { it.second == library }?.first!!
+        return Triple(jsIrLinker, currentIrModule, irModules.map { it.first })
+    }
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/fileUtils.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2022 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.backend.js.ic
+
+import org.jetbrains.kotlin.protobuf.CodedInputStream
+import org.jetbrains.kotlin.protobuf.CodedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+
+internal inline fun <T> File.ifExists(f: File.() -> T): T? = if (exists()) f() else null
+
+internal fun File.recreate() {
+    if (exists()) {
+        delete()
+    }
+    createNewFile()
+}
+
+internal inline fun File.useCodedInputIfExists(f: CodedInputStream.() -> Unit) = ifExists {
+    CodedInputStream.newInstance(FileInputStream(this)).f()
+}
+
+internal inline fun File.useCodedOutput(f: CodedOutputStream.() -> Unit) {
+    parentFile?.mkdirs()
+    recreate()
+    FileOutputStream(this).use {
+        val out = CodedOutputStream.newInstance(it)
+        out.f()
+        out.flush()
+    }
+}

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/invalidation.kt

@@ -5,279 +5,20 @@
 
 package org.jetbrains.kotlin.ir.backend.js.ic
 
-import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.config.languageVersionSettings
-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.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.JsManglerDesc
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
-import org.jetbrains.kotlin.ir.descriptors.IrBuiltInsOverDescriptors
 import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.konan.properties.propertyList
 import org.jetbrains.kotlin.library.KLIB_PROPERTY_DEPENDS
 import org.jetbrains.kotlin.library.KotlinLibrary
-import org.jetbrains.kotlin.library.unresolvedDependencies
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import java.io.File
-import java.security.MessageDigest
-
-private fun KotlinLibrary.fingerprint(fileIndex: Int): Hash {
-    return ((((types(fileIndex).md5() * 31) + signatures(fileIndex).md5()) * 31 + strings(fileIndex).md5()) * 31 + declarations(fileIndex).md5()) * 31 + bodies(
-        fileIndex
-    ).md5()
-}
-
-private fun invalidateCacheForModule(
-    library: KotlinLibrary,
-    libraryFiles: List<String>,
-    externalHashes: Map<IdSignature, TransHash>,
-    cachedInlineHashesForFile: MutableMap<String, Map<IdSignature, TransHash>>,
-    cacheProvider: CacheLazyLoader,
-    cacheConsumer: PersistentCacheConsumer,
-    fileFingerPrints: MutableMap<String, Hash>
-): Pair<Set<String>, Collection<String>> {
-
-    val dirtyFiles = mutableSetOf<String>()
-
-    for ((index, file) in libraryFiles.withIndex()) {
-
-        // 1. get cached fingerprints
-        val fileOldFingerprint = cacheProvider.getFileFingerPrint(file)
-
-        // 2. calculate new fingerprints
-        val fileNewFingerprint = library.fingerprint(index)
-
-        if (fileOldFingerprint != fileNewFingerprint) {
-            fileFingerPrints[file] = fileNewFingerprint
-            cachedInlineHashesForFile.remove(file)
-
-            // 3. form initial dirty set
-            dirtyFiles.add(file)
-        }
-    }
-
-    // 4. extend dirty set with inline functions
-    do {
-        if (dirtyFiles.size == libraryFiles.size) break
-
-        val oldSize = dirtyFiles.size
-        for (file in libraryFiles) {
-
-            if (file in dirtyFiles) continue
-
-            // check for clean file
-            val inlineGraph = cacheProvider.getInlineGraphForFile(file)
-
-            for ((sig, oldHash) in inlineGraph) {
-                val actualHash = externalHashes[sig] ?: cachedInlineHashesForFile.values.firstNotNullOfOrNull { it[sig] }
-                // null means inline function is from dirty file, could be a bit more optimal
-                if (actualHash == null || oldHash != actualHash) {
-                    cachedInlineHashesForFile.remove(file)
-                    dirtyFiles.add(file)
-                    fileFingerPrints[file] = cacheProvider.getFileFingerPrint(file)
-                    break
-                }
-            }
-        }
-    } while (oldSize != dirtyFiles.size)
-
-    // 5. invalidate file caches
-    for (dirty in dirtyFiles) {
-        cacheConsumer.invalidateForFile(dirty)
-    }
-
-    val cachedFiles = cacheProvider.getFilePaths()
-    val deletedFiles = cachedFiles - libraryFiles.toSet()
-
-    for (deleted in deletedFiles) {
-        cacheConsumer.invalidateForFile(deleted)
-    }
-
-    cacheProvider.clearCaches()
-    return dirtyFiles to deletedFiles
-}
-
-private fun CacheInfo.commitLibraryInfo(cacheConsumer: PersistentCacheConsumer, newModuleName: String? = null) {
-    cacheConsumer.commitLibraryInfo(
-        libPath.toCanonicalPath(),
-        newModuleName ?: moduleName ?: error("Cannot find module name for $libPath module"),
-        flatHash,
-        transHash,
-        configHash
-    )
-}
-
-private fun buildCacheForModule(
-    configuration: CompilerConfiguration,
-    irModule: IrModuleFragment,
-    deserializer: JsIrLinker,
-    dependencies: Collection<IrModuleFragment>,
-    dirtyFiles: Collection<String>,
-    deletedFiles: Collection<String>,
-    cleanInlineHashes: Map<IdSignature, Hash>,
-    cacheConsumer: PersistentCacheConsumer,
-    signatureDeserializers: Map<FilePath, Map<IdSignature, Int>>,
-    fileFingerPrints: Map<String, Hash>,
-    mainArguments: List<String>?,
-    cacheExecutor: CacheExecutor
-) {
-    val dirtyIrFiles = irModule.files.filter { it.fileEntry.name in dirtyFiles }
-
-    val flatHasher = InlineFunctionFlatHashBuilder()
-
-    dirtyIrFiles.forEach { it.acceptVoid(flatHasher) }
-
-    val flatHashes = flatHasher.idToHashMap
-
-    val hashProvider = object : InlineFunctionHashProvider {
-        override fun hashForExternalFunction(declaration: IrSimpleFunction): TransHash? {
-            return declaration.symbol.signature?.let { cleanInlineHashes[it] }
-        }
-    }
-
-    val hashBuilder = InlineFunctionHashBuilder(hashProvider, flatHashes)
-
-    val hashes = hashBuilder.buildHashes(dirtyIrFiles)
-
-    val splitPerFiles =
-        hashes.entries.filter { !it.key.isFakeOverride && (it.key.symbol.signature?.visibleCrossFile ?: false) }.groupBy({ it.key.file }) {
-            val signature = it.key.symbol.signature ?: error("Unexpected private inline fun ${it.key.render()}")
-            signature to it.value
-        }
-
-    val inlineGraph = hashBuilder.buildInlineGraph(hashes)
-
-    dirtyIrFiles.forEach { irFile ->
-        val fileName = irFile.fileEntry.name
-        val sigToIndexMap = signatureDeserializers[fileName] ?: error("No sig2id mapping found for $fileName")
-        val indexResolver: (IdSignature) -> Int = { sigToIndexMap[it] ?: error("No index found for sig $it") }
-        val inlineHashes = splitPerFiles[irFile] ?: emptyList()
-        cacheConsumer.commitInlineFunctions(fileName, inlineHashes, indexResolver)
-        val fileInlineGraph = inlineGraph[irFile] ?: emptyList()
-        cacheConsumer.commitInlineGraph(fileName, fileInlineGraph, indexResolver)
-        cacheConsumer.commitFileFingerPrint(fileName, fileFingerPrints[fileName] ?: error("No fingerprint found for file $fileName"))
-    }
-
-    // TODO: actual way of building a cache could change in future
-
-    cacheExecutor.execute(
-        irModule,
-        dependencies,
-        deserializer,
-        configuration,
-        dirtyFiles,
-        deletedFiles,
-        cacheConsumer,
-        emptySet(),
-        mainArguments
-    )
-}
-
-private fun loadModules(
-    languageVersionSettings: LanguageVersionSettings,
-    dependencyGraph: Map<KotlinLibrary, Collection<KotlinLibrary>>
-): Map<ModuleDescriptor, KotlinLibrary> {
-    val descriptors = mutableMapOf<KotlinLibrary, ModuleDescriptorImpl>()
-
-    var runtimeModule: ModuleDescriptorImpl? = null
-
-    // TODO: deduplicate this code using part from klib.kt
-    fun getModuleDescriptor(current: KotlinLibrary): ModuleDescriptorImpl = descriptors.getOrPut(current) {
-        val isBuiltIns = current.unresolvedDependencies.isEmpty()
-
-        val lookupTracker = LookupTracker.DO_NOTHING
-        val md = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns(
-            current,
-            languageVersionSettings,
-            LockBasedStorageManager.NO_LOCKS,
-            runtimeModule?.builtIns,
-            packageAccessHandler = null, // TODO: This is a speed optimization used by Native. Don't bother for now.
-            lookupTracker = lookupTracker
-        )
-        if (isBuiltIns) runtimeModule = md
-
-        val dependencies = dependencyGraph[current]!!.map { getModuleDescriptor(it) }
-        md.setDependencies(listOf(md) + dependencies)
-        md
-    }
-
-
-    return dependencyGraph.keys.associateBy { klib -> getModuleDescriptor(klib) }
-}
-
-@OptIn(ObsoleteDescriptorBasedAPI::class)
-private fun createLinker(
-    configuration: CompilerConfiguration,
-    loadedModules: Map<ModuleDescriptor, KotlinLibrary>,
-    irFactory: IrFactory
-): JsIrLinker {
-    val logger = configuration[IrMessageLogger.IR_MESSAGE_LOGGER] ?: IrMessageLogger.None
-    val signaturer = IdSignatureDescriptor(JsManglerDesc)
-    val symbolTable = SymbolTable(signaturer, irFactory)
-    val moduleDescriptor = loadedModules.keys.last()
-    val typeTranslator = TypeTranslatorImpl(symbolTable, configuration.languageVersionSettings, moduleDescriptor)
-    val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
-    return JsIrLinker(null, logger, irBuiltIns, symbolTable, null)
-}
-
-
-fun Map<KotlinLibrary, Collection<KotlinLibrary>>.transitiveClosure(library: KotlinLibrary): Collection<KotlinLibrary> {
-    val visited = mutableSetOf<KotlinLibrary>()
-
-    fun walk(lib: KotlinLibrary) {
-        if (visited.add(lib)) {
-            get(lib)?.let { it.forEach { d -> walk(d) } }
-        }
-    }
-
-    walk(library)
-
-    return visited
-}
-
-private fun createCacheProvider(path: String): PersistentCacheProvider {
-    return PersistentCacheProviderImpl(path)
-}
-
-private fun createCacheConsumer(path: String): PersistentCacheConsumer {
-    return PersistentCacheConsumerImpl(path)
-}
-
-fun loadCacheInfo(cachePaths: Collection<String>): MutableMap<ModulePath, CacheInfo> {
-    val caches = cachePaths.map { CacheInfo.load(it) ?: error("Cannot load IC cache from $it") }
-    val result = mutableMapOf<ModulePath, CacheInfo>()
-    return caches.associateByTo(result) { it.libPath.toCanonicalPath() }
-}
-
-fun String.toCanonicalPath(): String = File(this).canonicalPath
-
-private fun KotlinLibrary.moduleCanonicalName() = libraryFile.path.toCanonicalPath()
-
-private fun loadLibraries(configuration: CompilerConfiguration, dependencies: Collection<String>): Map<ModulePath, KotlinLibrary> {
-    val allResolvedDependencies = jsResolveLibraries(
-        dependencies,
-        configuration[JSConfigurationKeys.REPOSITORIES] ?: emptyList(),
-        configuration[IrMessageLogger.IR_MESSAGE_LOGGER].toResolverLogger()
-    )
-
-    return allResolvedDependencies.getFullList().associateBy { it.moduleCanonicalName() }
-}
-
-typealias ModuleName = String
-typealias ModulePath = String
-typealias FilePath = String
 
 
 fun interface CacheExecutor {
@@ -287,345 +28,295 @@ fun interface CacheExecutor {
         deserializer: JsIrLinker,
         configuration: CompilerConfiguration,
         dirtyFiles: Collection<String>?, // if null consider the whole module dirty
-        deletedFiles: Collection<String>,
-        cacheConsumer: PersistentCacheConsumer,
+        artifactCache: ArtifactCache,
         exportedDeclarations: Set<FqName>,
         mainArguments: List<String>?,
     )
 }
 
-private fun calcMD5(feeder: (MessageDigest) -> Unit): ULong {
-    val md5 = MessageDigest.getInstance("MD5")
-    feeder(md5)
-
-    val d = md5.digest()
-    return ((d[0].toULong() and 0xFFUL)
-            or ((d[1].toULong() and 0xFFUL) shl 8)
-            or ((d[2].toULong() and 0xFFUL) shl 16)
-            or ((d[3].toULong() and 0xFFUL) shl 24)
-            or ((d[4].toULong() and 0xFFUL) shl 32)
-            or ((d[5].toULong() and 0xFFUL) shl 40)
-            or ((d[6].toULong() and 0xFFUL) shl 48)
-            or ((d[7].toULong() and 0xFFUL) shl 56)
-            )
+sealed class CacheUpdateStatus {
+    object FastPath : CacheUpdateStatus()
+    class NoDirtyFiles(val removed: Set<String>) : CacheUpdateStatus()
+    class Dirty(val removed: Set<String>, val updated: Set<String>, val updatedAll: Boolean) : CacheUpdateStatus()
 }
 
-private fun File.md5(): ULong {
-    fun File.process(md5: MessageDigest, prefix: String = "") {
-        if (isDirectory) {
-            this.listFiles()!!.sortedBy { it.name }.forEach {
-                md5.update((prefix + it.name).toByteArray())
-                it.process(md5, prefix + it.name + "/")
-            }
-        } else {
-            md5.update(readBytes())
-        }
-    }
-    return calcMD5 { this.process(it) }
-}
-
-private fun CompilerConfiguration.calcMD5(): ULong {
-    val importantBooleanSettingKeys = listOf(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION)
-    return calcMD5 {
-        for (key in importantBooleanSettingKeys) {
-            it.update(key.toString().toByteArray())
-            it.update(getBoolean(key).toString().toByteArray())
-        }
-    }
-}
-
-private fun checkLibrariesHash(
-    currentLib: KotlinLibrary,
-    dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>,
-    currentCache: CacheInfo,
-    icCacheMap: Map<ModulePath, CacheInfo>,
-    modulePath: ModulePath
-): Boolean {
-    val flatHash = File(modulePath).md5()
-
-    val dependencies = dependencyGraph[currentLib] ?: error("Cannot find dependencies for ${currentLib.libraryName}")
-
-    var transHash = flatHash
-
-    for (dep in dependencies) {
-        val depCache = icCacheMap[dep.libraryFile.canonicalPath] ?: error("Cannot cache info for ${dep.libraryName}")
-        transHash += depCache.transHash
-    }
-
-    if (currentCache.transHash != transHash) {
-        currentCache.flatHash = flatHash
-        currentCache.transHash = transHash
-        return false
-    }
-
-    return true
-}
-
-private fun CacheInfo.invalidateCacheForNewConfig(configMD5: ULong, cacheConsumer: PersistentCacheConsumer) {
-    if (configHash != configMD5) {
-        cacheConsumer.invalidate()
-        flatHash = 0UL
-        transHash = 0UL
-        configHash = configMD5
-    }
-}
-
-enum class CacheUpdateStatus(val upToDate: Boolean) {
-    DIRTY(upToDate = false),
-    NO_DIRTY_FILES(upToDate = true),
-    FAST_PATH(upToDate = true)
-}
-
-fun actualizeCaches(
-    includes: String,
-    compilerConfiguration: CompilerConfiguration,
-    dependencies: Collection<ModulePath>,
-    icCachePaths: Collection<String>,
-    irFactory: () -> IrFactory,
-    mainArguments: List<String>?,
-    executor: CacheExecutor,
-    callback: (CacheUpdateStatus, String) -> Unit
-): List<String> {
-    val (libraries, dependencyGraph, configMD5) = CacheConfiguration(dependencies, compilerConfiguration)
-    val cacheMap = libraries.values.zip(icCachePaths).toMap()
-
-    val icCacheMap = mutableMapOf<ModulePath, CacheInfo>()
-    val resultCaches = mutableListOf<String>()
-    val persistentCacheProviders = mutableMapOf<KotlinLibrary, CacheLazyLoader>()
-
-    val visitedLibraries = mutableSetOf<KotlinLibrary>()
-    fun visitDependency(library: KotlinLibrary) {
-        if (library in visitedLibraries) return
-        visitedLibraries.add(library)
-
-        val libraryDeps = dependencyGraph[library] ?: error("Unknown library ${library.libraryName}")
-        libraryDeps.forEach { visitDependency(it) }
-
-        val cachePath = cacheMap[library] ?: error("Unknown cache for library ${library.libraryName}")
-        resultCaches.add(cachePath)
-
-        val modulePath = library.moduleCanonicalName()
-        val cacheInfo = CacheInfo.loadOrCreate(cachePath, modulePath)
-        icCacheMap[modulePath] = cacheInfo
-
-        val cacheConsumer = createCacheConsumer(cachePath)
-        persistentCacheProviders[library] = CacheLazyLoader(createCacheProvider(cachePath), library)
-
-        cacheInfo.invalidateCacheForNewConfig(configMD5, cacheConsumer)
-        val updateStatus = when {
-            checkLibrariesHash(library, dependencyGraph, cacheInfo, icCacheMap, modulePath) -> CacheUpdateStatus.FAST_PATH
-            else -> actualizeCacheForModule(
-                library = library,
-                libraryInfo = cacheInfo,
-                configuration = compilerConfiguration,
-                dependencyGraph = getDependencySubGraphFor(library, dependencyGraph),
-                persistentCacheProviders = persistentCacheProviders,
-                persistentCacheConsumer = cacheConsumer,
-                irFactory = irFactory(),
-                mainArguments = mainArguments,
-                cacheExecutor = executor,
-            )
-        }
-
-        callback(updateStatus, modulePath)
-    }
-
-    val canonicalIncludes = includes.toCanonicalPath()
-    val mainLibrary = libraries[canonicalIncludes] ?: error("Main library not found in libraries: $canonicalIncludes")
-    visitDependency(mainLibrary)
-    return resultCaches
-}
-
-private fun getDependencySubGraphFor(
-    targetLib: KotlinLibrary,
-    dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>
-): Map<KotlinLibrary, List<KotlinLibrary>> {
-    val subGraph = mutableMapOf<KotlinLibrary, List<KotlinLibrary>>()
-
-    fun addDependsFor(library: KotlinLibrary) {
-        if (library in subGraph) {
-            return
-        }
-        val dependencies = dependencyGraph[library] ?: error("Cannot find dependencies for ${library.libraryName}")
-        subGraph[library] = dependencies
-        for (dependency in dependencies) {
-            addDependsFor(dependency)
-        }
-    }
-    addDependsFor(targetLib)
-    return subGraph
-}
-
-class CacheConfiguration(
-    private val dependencies: Collection<ModulePath>,
-    val compilerConfiguration: CompilerConfiguration
+class CacheUpdater(
+    private val rootModule: String,
+    private val allModules: Collection<String>,
+    private val compilerConfiguration: CompilerConfiguration,
+    private val icCachePaths: Collection<String>,
+    private val irFactory: () -> IrFactory,
+    private val mainArguments: List<String>?,
+    private val executor: CacheExecutor
 ) {
-    val libraries: Map<ModulePath, KotlinLibrary> = loadLibraries(compilerConfiguration, dependencies)
+    private fun KotlinLibrary.moduleCanonicalName() = libraryFile.canonicalPath
 
-    val dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>
-        get() {
-            val nameToKotlinLibrary: Map<ModuleName, KotlinLibrary> = libraries.values.associateBy { it.moduleName }
+    private inner class KLibCacheUpdater(
+        private val library: KotlinLibrary,
+        private val dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>,
+        private val incrementalCache: IncrementalCache,
+        private val klibIncrementalCaches: Map<KotlinLibrary, IncrementalCache>
+    ) {
+        private fun invalidateCacheForModule(externalHashes: Map<IdSignature, ICHash>): Pair<Set<String>, Map<String, ICHash>> {
+            val fileFingerPrints = mutableMapOf<String, ICHash>()
+            val dirtyFiles = mutableSetOf<String>()
 
-            return libraries.values.associateWith {
-                it.manifestProperties.propertyList(KLIB_PROPERTY_DEPENDS, escapeInQuotes = true).map { depName ->
-                    nameToKotlinLibrary[depName] ?: error("No Library found for $depName")
+            if (incrementalCache.klibUpdated) {
+                for ((index, file) in incrementalCache.srcFilesInOrderFromKLib.withIndex()) {
+                    // 1. get cached fingerprints
+                    val fileOldFingerprint = incrementalCache.srcFingerprints[file] ?: 0
+
+                    // 2. calculate new fingerprints
+                    val fileNewFingerprint = library.fingerprint(index)
+
+                    if (fileOldFingerprint != fileNewFingerprint) {
+                        fileFingerPrints[file] = fileNewFingerprint
+                        incrementalCache.invalidateForSrcFile(file)
+
+                        // 3. form initial dirty set
+                        dirtyFiles.add(file)
+                    }
                 }
             }
+
+            // 4. extend dirty set with inline functions
+            do {
+                if (dirtyFiles.size == incrementalCache.srcFilesInOrderFromKLib.size) break
+
+                val oldSize = dirtyFiles.size
+                for (file in incrementalCache.srcFilesInOrderFromKLib) {
+
+                    if (file in dirtyFiles) continue
+
+                    // check for clean file
+                    val usedInlineFunctions = incrementalCache.usedFunctions[file] ?: emptyMap()
+
+                    for ((sig, oldHash) in usedInlineFunctions) {
+                        val actualHash = externalHashes[sig] ?: incrementalCache.implementedFunctions.firstNotNullOfOrNull { it[sig] }
+                        // null means inline function is from dirty file, could be a bit more optimal
+                        if (actualHash == null || oldHash != actualHash) {
+                            fileFingerPrints[file] = incrementalCache.srcFingerprints[file] ?: error("Cannot find fingerprint for $file")
+                            incrementalCache.invalidateForSrcFile(file)
+                            dirtyFiles.add(file)
+                            break
+                        }
+                    }
+                }
+            } while (oldSize != dirtyFiles.size)
+
+            // 5. invalidate file caches
+            for (deleted in incrementalCache.deletedSrcFiles) {
+                incrementalCache.invalidateForSrcFile(deleted)
+            }
+
+            return dirtyFiles to fileFingerPrints
         }
 
-    val configMD5
-        get() = compilerConfiguration.calcMD5()
+        private fun getDependencySubGraph(): Map<KotlinLibrary, List<KotlinLibrary>> {
+            val subGraph = mutableMapOf<KotlinLibrary, List<KotlinLibrary>>()
 
-    operator fun component1() = libraries
-    operator fun component2() = dependencyGraph
-    operator fun component3() = configMD5
+            fun addDependsFor(library: KotlinLibrary) {
+                if (library in subGraph) {
+                    return
+                }
+                val dependencies = dependencyGraph[library] ?: error("Cannot find dependencies for ${library.libraryName}")
+                subGraph[library] = dependencies
+                for (dependency in dependencies) {
+                    addDependsFor(dependency)
+                }
+            }
+            addDependsFor(library)
+            return subGraph
+        }
+
+        private fun buildCacheForModule(
+            irModule: IrModuleFragment,
+            deserializer: JsIrLinker,
+            dependencies: Collection<IrModuleFragment>,
+            dirtyFiles: Collection<String>,
+            cleanInlineHashes: Map<IdSignature, ICHash>,
+            fileFingerPrints: Map<String, ICHash>
+        ) {
+            val dirtyIrFiles = irModule.files.filter { it.fileEntry.name in dirtyFiles }
+
+            val flatHashes = InlineFunctionFlatHashBuilder().apply {
+                dirtyIrFiles.forEach { it.acceptVoid(this) }
+            }.getFlatHashes()
+
+            val hashProvider = object : InlineFunctionHashProvider {
+                override fun hashForExternalFunction(declaration: IrSimpleFunction): ICHash? {
+                    return declaration.symbol.signature?.let { cleanInlineHashes[it] }
+                }
+            }
+
+            val hashBuilder = InlineFunctionHashBuilder(hashProvider, flatHashes)
+
+            val hashes = hashBuilder.buildHashes(dirtyIrFiles)
+
+            val splitPerFiles = hashes.entries.filter { !it.key.isFakeOverride && (it.key.symbol.signature?.visibleCrossFile ?: false) }
+                .groupBy({ it.key.file }) {
+                    val signature = it.key.symbol.signature ?: error("Unexpected private inline fun ${it.key.render()}")
+                    signature to it.value
+                }
+
+            val inlineGraph = hashBuilder.buildInlineGraph(hashes)
+
+            dirtyIrFiles.forEach { irFile ->
+                val fileName = irFile.fileEntry.name
+                incrementalCache.updateHashes(
+                    srcPath = fileName,
+                    fingerprint = fileFingerPrints[fileName] ?: error("No fingerprint found for file $fileName"),
+                    usedFunctions = inlineGraph[irFile],
+                    implementedFunctions = splitPerFiles[irFile]?.toMap()
+                )
+            }
+
+            // TODO: actual way of building a cache could change in future
+            executor.execute(
+                irModule, dependencies, deserializer, compilerConfiguration, dirtyFiles, incrementalCache, emptySet(), mainArguments
+            )
+        }
+
+        fun checkLibrariesHash(): Boolean {
+            val flatHash = File(library.moduleCanonicalName()).fileHashForIC()
+            val dependencies = dependencyGraph[library] ?: error("Cannot find dependencies for ${library.libraryName}")
+
+            var transHash = flatHash
+            for (dep in dependencies) {
+                val depCache = klibIncrementalCaches[dep] ?: error("Cannot cache info for ${dep.libraryName}")
+                transHash = transHash.combineWith(depCache.klibTransitiveHash)
+            }
+            return incrementalCache.checkAndUpdateCacheFastInfo(flatHash, transHash)
+        }
+
+        fun actualizeCacheForModule(): CacheUpdateStatus {
+            // 1. Invalidate
+            val dependencies = dependencyGraph[library]!!
+
+            val incrementalCache = klibIncrementalCaches[library] ?: error("No cache provider for $library")
+
+            val sigHashes = mutableMapOf<IdSignature, ICHash>()
+            dependencies.forEach { lib ->
+                klibIncrementalCaches[lib]?.let { libCache ->
+                    libCache.fetchCacheDataForDependency()
+                    libCache.implementedFunctions.forEach { sigHashes.putAll(it) }
+                }
+            }
+
+            incrementalCache.fetchFullCacheData()
+            val (dirtySet, fileFingerPrints) = invalidateCacheForModule(sigHashes)
+            val removed = incrementalCache.deletedSrcFiles
+
+            if (dirtySet.isEmpty()) {
+                // up-to-date
+                incrementalCache.commitCacheForRemovedSrcFiles()
+                return CacheUpdateStatus.NoDirtyFiles(removed)
+            }
+
+            // 2. Build
+            val jsIrLinkerProcessor = JsIrLinkerLoader(compilerConfiguration, library, getDependencySubGraph(), irFactory())
+            val (jsIrLinker, currentIrModule, irModules) = jsIrLinkerProcessor.processJsIrLinker(dirtySet)
+
+            val currentModuleDeserializer = jsIrLinker.moduleDeserializer(currentIrModule.descriptor)
+
+            incrementalCache.implementedFunctions.forEach { sigHashes.putAll(it) }
+
+            for (dirtySrcFile in dirtySet) {
+                val signatureMapping = currentModuleDeserializer.signatureDeserializerForFile(dirtySrcFile).signatureToIndexMapping()
+                incrementalCache.updateSignatureToIdMapping(dirtySrcFile, signatureMapping)
+            }
+
+            buildCacheForModule(currentIrModule, jsIrLinker, irModules, dirtySet, sigHashes, fileFingerPrints)
+
+            val updatedAll = dirtySet.size == incrementalCache.srcFilesInOrderFromKLib.size
+            incrementalCache.commitCacheForRebuiltSrcFiles(currentIrModule.name.asString())
+            // invalidated and re-built
+            return CacheUpdateStatus.Dirty(removed, dirtySet, updatedAll)
+        }
+    }
+
+    private fun loadLibraries(): Map<String, KotlinLibrary> {
+        val allResolvedDependencies = jsResolveLibraries(
+            allModules,
+            compilerConfiguration[JSConfigurationKeys.REPOSITORIES] ?: emptyList(),
+            compilerConfiguration[IrMessageLogger.IR_MESSAGE_LOGGER].toResolverLogger()
+        )
+
+        return allResolvedDependencies.getFullList().associateBy { it.moduleCanonicalName() }
+    }
+
+    private fun buildDependenciesGraph(libraries: Map<String, KotlinLibrary>): Map<KotlinLibrary, List<KotlinLibrary>> {
+        val nameToKotlinLibrary: Map<String, KotlinLibrary> = libraries.values.associateBy { it.moduleName }
+        return libraries.values.associateWith {
+            it.manifestProperties.propertyList(KLIB_PROPERTY_DEPENDS, escapeInQuotes = true).map { depName ->
+                nameToKotlinLibrary[depName] ?: error("No Library found for $depName")
+            }
+        }
+    }
+
+    fun actualizeCaches(callback: (CacheUpdateStatus, String) -> Unit): List<KLibArtifact> {
+        val libraries = loadLibraries()
+        val dependencyGraph = buildDependenciesGraph(libraries)
+        val configHash = compilerConfiguration.configHashForIC()
+
+        val cacheMap = libraries.values.zip(icCachePaths).toMap()
+
+        val klibIncrementalCaches = mutableMapOf<KotlinLibrary, IncrementalCache>()
+
+        val visitedLibraries = mutableSetOf<KotlinLibrary>()
+        fun visitDependency(library: KotlinLibrary) {
+            if (library in visitedLibraries) return
+            visitedLibraries.add(library)
+
+            val libraryDeps = dependencyGraph[library] ?: error("Unknown library ${library.libraryName}")
+            libraryDeps.forEach { visitDependency(it) }
+
+            val cachePath = cacheMap[library] ?: error("Unknown cache for library ${library.libraryName}")
+            val incrementalCache = IncrementalCache(library, cachePath)
+            klibIncrementalCaches[library] = incrementalCache
+
+            incrementalCache.invalidateCacheForNewConfig(configHash)
+            val cacheUpdater = KLibCacheUpdater(library, dependencyGraph, incrementalCache, klibIncrementalCaches)
+            val updateStatus = when {
+                cacheUpdater.checkLibrariesHash() -> CacheUpdateStatus.FastPath
+                else -> cacheUpdater.actualizeCacheForModule()
+            }
+            callback(updateStatus, library.libraryFile.path)
+        }
+
+        val rootModuleCanonical = File(rootModule).canonicalPath
+        val mainLibrary = libraries[rootModuleCanonical] ?: error("Main library not found in libraries: $rootModuleCanonical")
+        visitDependency(mainLibrary)
+        return klibIncrementalCaches.map { it.value.fetchArtifacts() }
+    }
 }
 
-private fun actualizeCacheForModule(
-    library: KotlinLibrary,
-    libraryInfo: CacheInfo,
-    configuration: CompilerConfiguration,
-    dependencyGraph: Map<KotlinLibrary, Collection<KotlinLibrary>>,
-    persistentCacheProviders: Map<KotlinLibrary, CacheLazyLoader>,
-    persistentCacheConsumer: PersistentCacheConsumer,
-    irFactory: IrFactory,
-    mainArguments: List<String>?,
-    cacheExecutor: CacheExecutor,
-): CacheUpdateStatus {
-    // 1. Invalidate
-    val dependencies = dependencyGraph[library]!!
-
-    val currentLibraryCacheProvider = persistentCacheProviders[library] ?: error("No cache provider for $library")
-    val libraryFiles = currentLibraryCacheProvider.signatureReadersList.map { it.first }
-
-    val sigHashes = mutableMapOf<IdSignature, TransHash>()
-    dependencies.forEach { lib ->
-        persistentCacheProviders[lib]?.let { provider ->
-            sigHashes.putAll(provider.allInlineFunctionHashes)
-        }
-    }
-
-    val fileFingerPrints = mutableMapOf<String, Hash>()
-    val fileCachedInlineHashes = currentLibraryCacheProvider.getInlineHashesByFile()
-
-    val (dirtySet, deletedFiles) = invalidateCacheForModule(
-        library,
-        libraryFiles,
-        sigHashes,
-        fileCachedInlineHashes,
-        currentLibraryCacheProvider,
-        persistentCacheConsumer,
-        fileFingerPrints
-    )
-
-    if (dirtySet.isEmpty()) {
-        // up-to-date
-        libraryInfo.commitLibraryInfo(persistentCacheConsumer)
-        return CacheUpdateStatus.NO_DIRTY_FILES
-    }
-
-    // 2. Build
-
-    val loadedModules = loadModules(configuration.languageVersionSettings, dependencyGraph)
-
-    val jsIrLinker = createLinker(configuration, loadedModules, irFactory)
-
-    val irModules = ArrayList<Pair<IrModuleFragment, KotlinLibrary>>(loadedModules.size)
-
-    // TODO: modules deserialized here have to be reused for cache building further
-    for ((descriptor, loadedLibrary) in loadedModules) {
-        if (library == loadedLibrary) {
-            irModules.add(jsIrLinker.deserializeDirtyFiles(descriptor, loadedLibrary, dirtySet) to loadedLibrary)
-        } else {
-            irModules.add(jsIrLinker.deserializeHeadersWithInlineBodies(descriptor, loadedLibrary) to loadedLibrary)
-        }
-    }
-
-    jsIrLinker.init(null, emptyList())
-
-    ExternalDependenciesGenerator(jsIrLinker.symbolTable, listOf(jsIrLinker)).generateUnboundSymbolsAsDependencies()
-
-    jsIrLinker.postProcess()
-
-    val currentIrModule = irModules.find { it.second == library }?.first!!
-    val currentModuleDeserializer = jsIrLinker.moduleDeserializer(currentIrModule.descriptor)
-
-    for (hashes in fileCachedInlineHashes.values) {
-        sigHashes.putAll(hashes)
-    }
-
-    val deserializers = dirtySet.associateWith { currentModuleDeserializer.signatureDeserializerForFile(it).signatureToIndexMapping() }
-
-    buildCacheForModule(
-        configuration,
-        currentIrModule,
-        jsIrLinker,
-        irModules.map { it.first },
-        dirtySet,
-        deletedFiles,
-        sigHashes,
-        persistentCacheConsumer,
-        deserializers,
-        fileFingerPrints,
-        mainArguments,
-        cacheExecutor
-    )
-
-    libraryInfo.commitLibraryInfo(persistentCacheConsumer, currentIrModule.name.asString())
-    return CacheUpdateStatus.DIRTY // invalidated and re-built
-}
 
 // Used for tests only
 fun rebuildCacheForDirtyFiles(
     library: KotlinLibrary,
     configuration: CompilerConfiguration,
-    dependencyGraph: Map<KotlinLibrary, Collection<KotlinLibrary>>,
+    dependencyGraph: Map<KotlinLibrary, List<KotlinLibrary>>,
     dirtyFiles: Collection<String>?,
-    cacheConsumer: PersistentCacheConsumer,
+    artifactCache: ArtifactCache,
     irFactory: IrFactory,
     exportedDeclarations: Set<FqName>,
     mainArguments: List<String>?,
-) {
-    val loadedModules = loadModules(configuration.languageVersionSettings, dependencyGraph)
-
-    val jsIrLinker = createLinker(configuration, loadedModules, irFactory)
-
-    val irModules = ArrayList<Pair<IrModuleFragment, KotlinLibrary>>(loadedModules.size)
-
-    // TODO: modules deserialized here have to be reused for cache building further
-    for ((descriptor, loadedLibrary) in loadedModules) {
-        if (library == loadedLibrary) {
-            if (dirtyFiles != null) {
-                irModules.add(jsIrLinker.deserializeDirtyFiles(descriptor, loadedLibrary, dirtyFiles) to loadedLibrary)
-            } else {
-                irModules.add(jsIrLinker.deserializeFullModule(descriptor, loadedLibrary) to loadedLibrary)
-            }
-        } else {
-            irModules.add(jsIrLinker.deserializeHeadersWithInlineBodies(descriptor, loadedLibrary) to loadedLibrary)
-        }
-    }
-
-    jsIrLinker.init(null, emptyList())
-
-    ExternalDependenciesGenerator(jsIrLinker.symbolTable, listOf(jsIrLinker)).generateUnboundSymbolsAsDependencies()
-
-    jsIrLinker.postProcess()
-
-    val currentIrModule = irModules.find { it.second == library }?.first!!
-
-    cacheConsumer.commitLibraryInfo(library.moduleCanonicalName(), currentIrModule.name.asString(), 0UL, 0UL, 0UL)
+): String {
+    val jsIrLinkerProcessor = JsIrLinkerLoader(configuration, library, dependencyGraph, irFactory)
+    val (jsIrLinker, currentIrModule, irModules) = jsIrLinkerProcessor.processJsIrLinker(dirtyFiles)
 
     buildCacheForModuleFiles(
         currentIrModule,
-        irModules.map { it.first },
+        irModules,
         jsIrLinker,
         configuration,
         dirtyFiles,
-        emptyList(),
-        cacheConsumer,
+        artifactCache,
         exportedDeclarations,
         mainArguments
     )
+    return currentIrModule.name.asString()
 }
 
 @Suppress("UNUSED_PARAMETER")
@@ -635,8 +326,7 @@ fun buildCacheForModuleFiles(
     deserializer: JsIrLinker,
     configuration: CompilerConfiguration,
     dirtyFiles: Collection<String>?, // if null consider the whole module dirty
-    deletedFiles: Collection<String>,
-    cacheConsumer: PersistentCacheConsumer,
+    artifactCache: ArtifactCache,
     exportedDeclarations: Set<FqName>,
     mainArguments: List<String>?,
 ) {
@@ -648,24 +338,6 @@ fun buildCacheForModuleFiles(
         mainArguments = mainArguments,
         exportedDeclarations = exportedDeclarations,
         filesToLower = dirtyFiles?.toSet(),
-        cacheConsumer = cacheConsumer,
+        artifactCache = artifactCache,
     )
-
-//    println("creating caches for module ${currentModule.name}")
-//    println("Store them into $cacheConsumer")
-//    val dirtyS = if (dirtyFiles == null) "[ALL]" else dirtyFiles.joinToString(",", "[", "]") { it }
-//    println("Dirty files -> $dirtyS")
-}
-
-
-fun loadModuleCaches(icCachePaths: Collection<String>): Map<String, ModuleCache> {
-    val icCacheMap: Map<ModulePath, CacheInfo> = loadCacheInfo(icCachePaths)
-
-    return icCacheMap.entries.associate { (lib, cache) ->
-        val provider = createCacheProvider(cache.path)
-        val files = provider.filePaths()
-        lib to ModuleCache(provider.moduleName(), files.associate { f ->
-            f to FileCache(f, provider.binaryAst(f), provider.dts(f), provider.sourceMap(f))
-        })
-    }
 }

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

@@ -506,7 +506,8 @@ class RenderIrElementVisitor(private val normalizeNames: Boolean = false, privat
         declaration.runTrimEnd {
             "TYPE_PARAMETER ${renderOriginIfNonTrivial()}" +
                     "name:$name index:$index variance:$variance " +
-                    "superTypes:[${superTypes.joinToString(separator = "; ") { it.render() }}]"
+                    "superTypes:[${superTypes.joinToString(separator = "; ") { it.render() }}] " +
+                    "reified:$isReified"
         }
 
     override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?): String =

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

@@ -1,350 +0,0 @@
-/*
- * 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.backend.js.ic
-
-import org.jetbrains.kotlin.ir.util.IdSignature
-import java.io.File
-import java.io.PrintWriter
-import java.security.MessageDigest
-
-
-private const val inlineGraphFile = "inline.graph"
-private const val inlineFunctionsFile = "inline.functions"
-private const val fileInfoFile = "file.info"
-private const val fileBinaryAst = "binary.ast"
-private const val fileBinaryDts = "binary.dst"
-private const val fileSourceMap = "source.map"
-
-typealias Hash = Long // Any long hash
-typealias FlatHash = Hash // Hash of inline function without its underlying inline call tree
-typealias TransHash = Hash // Hash of inline function including its underlying inline call tree
-
-private val md5 = MessageDigest.getInstance("MD5")
-
-private fun ByteArray.toHex(): String = joinToString(separator = "") { eachByte -> "%02x".format(eachByte) }
-
-private fun createFileCacheId(fileName: String): String = md5.digest(fileName.encodeToByteArray()).toHex()
-
-class ICCache()
-
-class FileCache(val name: String, var ast: ByteArray?, var dts: ByteArray?, var sourceMap: ByteArray?)
-class ModuleCache(val name: String, val asts: Map<String, FileCache>)
-
-interface PersistentCacheProvider {
-    fun fileFingerPrint(path: String): Hash
-
-    fun inlineGraphForFile(path: String, sigResolver: (Int) -> IdSignature): Collection<Pair<IdSignature, TransHash>>
-
-    fun inlineHashes(path: String, sigResolver: (Int) -> IdSignature): Map<IdSignature, TransHash>
-
-    fun allInlineHashes(sigResolver: (String, Int) -> IdSignature): Map<IdSignature, TransHash>
-
-    fun binaryAst(path: String): ByteArray?
-
-    fun dts(path: String): ByteArray?
-
-    fun sourceMap(path: String): ByteArray?
-
-    fun filePaths(): Iterable<String>
-
-    fun moduleName(): String
-
-    companion object {
-        val EMPTY = object : PersistentCacheProvider {
-            override fun fileFingerPrint(path: String): Hash {
-                return 0
-            }
-
-            override fun inlineGraphForFile(path: String, sigResolver: (Int) -> IdSignature): Collection<Pair<IdSignature, TransHash>> {
-                return emptyList()
-            }
-
-            override fun inlineHashes(path: String, sigResolver: (Int) -> IdSignature): Map<IdSignature, TransHash> {
-                return emptyMap()
-            }
-
-            override fun allInlineHashes(sigResolver: (String, Int) -> IdSignature): Map<IdSignature, TransHash> {
-                return emptyMap()
-            }
-
-            override fun binaryAst(path: String): ByteArray {
-                return ByteArray(0)
-            }
-
-            override fun dts(path: String): ByteArray? {
-                return null
-            }
-
-            override fun sourceMap(path: String): ByteArray? {
-                return null
-            }
-
-            override fun filePaths(): Iterable<String> = emptyList()
-
-            override fun moduleName(): String {
-                TODO("Not yet implemented")
-            }
-        }
-    }
-}
-
-
-class PersistentCacheProviderImpl(private val cachePath: String) : PersistentCacheProvider {
-
-    private val String.fileDir: File
-        get() {
-            val fileId = createFileCacheId(this)
-            return File(File(cachePath), fileId)
-        }
-
-    private fun String.parseHash(): Hash = java.lang.Long.parseUnsignedLong(this, 16)
-
-    override fun fileFingerPrint(path: String): Hash {
-        val dataFile = File(path.fileDir, fileInfoFile)
-        return if (dataFile.exists()) {
-            val hashLine = dataFile.readLines()[1]
-            hashLine.parseHash()
-        } else 0
-    }
-
-    private fun parseHashList(
-        fileDir: File,
-        fileName: String,
-        sigResolver: (Int) -> IdSignature
-    ): Collection<Pair<IdSignature, TransHash>> {
-        val inlineGraphFile = File(fileDir, fileName)
-
-        if (inlineGraphFile.exists()) {
-
-            return inlineGraphFile.readLines().mapNotNull { line ->
-                val (sigIdS, hashString) = line.split(":")
-                val sigId = Integer.parseInt(sigIdS)
-                try {
-                    val idSig = sigResolver(sigId)
-                    val tHash = hashString.parseHash()
-                    idSig to tHash
-                } catch (ex: IndexOutOfBoundsException) {
-                    // println("Signature [$sigId] has been removed")
-                    null
-                }
-            }
-        }
-
-        return emptyList()
-    }
-
-    override fun inlineGraphForFile(path: String, sigResolver: (Int) -> IdSignature): Collection<Pair<IdSignature, TransHash>> {
-        return parseHashList(path.fileDir, inlineGraphFile, sigResolver)
-    }
-
-    override fun inlineHashes(path: String, sigResolver: (Int) -> IdSignature): Map<IdSignature, TransHash> {
-        return parseHashList(path.fileDir, inlineFunctionsFile, sigResolver).toMap()
-    }
-
-    override fun allInlineHashes(sigResolver: (String, Int) -> IdSignature): Map<IdSignature, TransHash> {
-        val result = mutableMapOf<IdSignature, TransHash>()
-        val cachePath = File(cachePath)
-        cachePath.listFiles { file: File -> file.isDirectory }!!.forEach { f ->
-            val fileInfo = File(f, fileInfoFile)
-            if (fileInfo.exists()) {
-                val fileName = fileInfo.readLines()[0]
-                parseHashList(f, inlineFunctionsFile) { id -> sigResolver(fileName, id) }.forEach { (sig, hash) ->
-                    result[sig] = hash
-                }
-            }
-        }
-        return result
-    }
-
-    private fun readBytesFromCacheFile(fileName: String, cacheName: String): ByteArray? {
-        val cachePath = fileName.fileDir
-        val cacheFile = File(cachePath, cacheName)
-        if (cacheFile.exists()) return cacheFile.readBytes()
-        return null
-    }
-
-    override fun binaryAst(path: String): ByteArray? {
-        return readBytesFromCacheFile(path, fileBinaryAst)
-    }
-
-    override fun dts(path: String): ByteArray? {
-        return readBytesFromCacheFile(path, fileBinaryDts)
-    }
-
-    override fun sourceMap(path: String): ByteArray? {
-        return readBytesFromCacheFile(path, fileSourceMap)
-    }
-
-    override fun filePaths(): Iterable<String> {
-        val files = File(cachePath).listFiles() ?: return emptyList()
-        return files.filter { it.isDirectory }.mapNotNull { f ->
-            val fileInfo = File(f, fileInfoFile)
-            if (fileInfo.exists()) {
-                fileInfo.readLines()[0]
-            } else null
-        }
-    }
-
-    override fun moduleName(): String {
-        val infoFile = File(File(cachePath), "info")
-        return infoFile.readLines()[1]
-    }
-}
-
-interface PersistentCacheConsumer {
-    fun commitInlineFunctions(path: String, hashes: Collection<Pair<IdSignature, TransHash>>, sigResolver: (IdSignature) -> Int)
-    fun commitFileFingerPrint(path: String, fingerprint: Hash)
-    fun commitInlineGraph(path: String, hashes: Collection<Pair<IdSignature, TransHash>>, sigResolver: (IdSignature) -> Int)
-    fun commitBinaryAst(path: String, astData: ByteArray)
-    fun commitBinaryDts(path: String, dstData: ByteArray)
-    fun commitSourceMap(path: String, mapData: ByteArray)
-    fun invalidateForFile(path: String)
-    fun invalidate()
-
-    fun commitLibraryInfo(libraryPath: String, moduleName: String, flatHash: ULong, transHash: ULong, configHash: ULong)
-
-    companion object {
-        val EMPTY = object : PersistentCacheConsumer {
-            override fun commitInlineFunctions(
-                path: String,
-                hashes: Collection<Pair<IdSignature, TransHash>>,
-                sigResolver: (IdSignature) -> Int
-            ) {
-            }
-
-            override fun commitFileFingerPrint(path: String, fingerprint: Hash) {
-            }
-
-            override fun commitInlineGraph(
-                path: String,
-                hashes: Collection<Pair<IdSignature, TransHash>>,
-                sigResolver: (IdSignature) -> Int
-            ) {
-            }
-
-            override fun invalidateForFile(path: String) {
-            }
-
-            override fun invalidate() {
-            }
-
-            override fun commitBinaryAst(path: String, astData: ByteArray) {
-
-            }
-
-            override fun commitLibraryInfo(libraryPath: String, moduleName: String, flatHash: ULong, transHash: ULong, configHash: ULong) {
-
-            }
-
-            override fun commitBinaryDts(path: String, dstData: ByteArray) {
-
-            }
-
-            override fun commitSourceMap(path: String, mapData: ByteArray) {
-
-            }
-        }
-    }
-}
-
-
-class PersistentCacheConsumerImpl(private val cachePath: String) : PersistentCacheConsumer {
-
-    private fun commitFileHashMapping(
-        path: String,
-        cacheDst: String,
-        hashes: Collection<Pair<IdSignature, TransHash>>,
-        sigResolver: (IdSignature) -> Int
-    ) {
-        val fileId = createFileCacheId(path)
-        val fileDir = File(File(cachePath), fileId)
-        val destination = File(fileDir, cacheDst)
-        fileDir.mkdirs()
-        destination.createNewFile()
-        PrintWriter(destination).use {
-            for (hashData in hashes) {
-                val (sig, hash) = hashData
-                val sigId = sigResolver(sig)
-                val hashString = hash.toULong().toString(16)
-                it.println("$sigId:$hashString")
-            }
-        }
-    }
-
-    override fun commitInlineFunctions(path: String, hashes: Collection<Pair<IdSignature, TransHash>>, sigResolver: (IdSignature) -> Int) {
-        commitFileHashMapping(path, inlineFunctionsFile, hashes, sigResolver)
-    }
-
-    override fun commitFileFingerPrint(path: String, fingerprint: Hash) {
-        val fileId = createFileCacheId(path)
-        val fileDir = File(File(cachePath), fileId)
-        fileDir.mkdirs()
-        val infoFile = File(fileDir, fileInfoFile)
-        if (infoFile.exists()) infoFile.delete()
-        infoFile.createNewFile()
-        PrintWriter(infoFile).use {
-            it.println(path)
-            it.println(fingerprint.toULong().toString(16))
-        }
-    }
-
-    override fun commitInlineGraph(path: String, hashes: Collection<Pair<IdSignature, TransHash>>, sigResolver: (IdSignature) -> Int) {
-        commitFileHashMapping(path, inlineGraphFile, hashes, sigResolver)
-    }
-
-    override fun invalidateForFile(path: String) {
-        val fileId = createFileCacheId(path)
-        val cacheDir = File(cachePath)
-        val fileDir = File(cacheDir, fileId)
-        File(fileDir, inlineFunctionsFile).delete()
-        File(fileDir, inlineGraphFile).delete()
-        File(fileDir, fileInfoFile).delete()
-        File(fileDir, fileBinaryAst).delete()
-        // TODO: once per-file invalidation is integrated into IC delete the whole directory including PIR parts
-        //fileDir.deleteRecursively()
-    }
-
-    override fun invalidate() {
-        File(cachePath).deleteRecursively()
-    }
-
-    private fun commitByteArrayToCacheFile(fileName: String, cacheName: String, data: ByteArray) {
-        val fileId = createFileCacheId(fileName)
-        val cacheDir = File(File(cachePath), fileId)
-        val cacheFile = File(cacheDir, cacheName)
-        if (cacheFile.exists()) cacheFile.delete()
-        cacheFile.createNewFile()
-        cacheFile.writeBytes(data)
-    }
-
-    override fun commitBinaryAst(path: String, astData: ByteArray) {
-        commitByteArrayToCacheFile(path, fileBinaryAst, astData)
-    }
-
-    override fun commitBinaryDts(path: String, dstData: ByteArray) {
-        commitByteArrayToCacheFile(path, fileBinaryDts, dstData)
-    }
-
-    override fun commitSourceMap(path: String, mapData: ByteArray) {
-        commitByteArrayToCacheFile(path, fileSourceMap, mapData)
-    }
-
-    override fun commitLibraryInfo(libraryPath: String, moduleName: String, flatHash: ULong, transHash: ULong, configHash: ULong) {
-        val infoFile = File(File(cachePath), "info")
-        if (infoFile.exists()) {
-            infoFile.delete()
-        }
-        infoFile.createNewFile()
-
-        PrintWriter(infoFile).use {
-            it.println(libraryPath)
-            it.println(moduleName)
-            it.println(flatHash.toString(16))
-            it.println(transHash.toString(16))
-            it.println(configHash.toString(16))
-        }
-    }
-}

compiler/testData/codegen/box/smartCasts/kt44814.fir.ir.txt

@@ -375,7 +375,7 @@ FILE fqName:<root> fileName:/kt44814.kt
       CLASS CLASS name:FirPsiModifier modality:FINAL visibility:public superTypes:[<root>.FirModifier<<root>.ASTNode>]
       CLASS CLASS name:FirLightModifier modality:FINAL visibility:public superTypes:[<root>.FirModifier<<root>.LighterASTNode>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.FirModifier<Node of <root>.FirModifier>
-    TYPE_PARAMETER name:Node index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:Node index:0 variance: superTypes:[kotlin.Any] reified:false
     CONSTRUCTOR visibility:protected <> (node:Node of <root>.FirModifier, token:<root>.KtModifierKeywordToken) returnType:<root>.FirModifier<Node of <root>.FirModifier> [primary]
       VALUE_PARAMETER name:node index:0 type:Node of <root>.FirModifier
       VALUE_PARAMETER name:token index:1 type:<root>.KtModifierKeywordToken

compiler/testData/codegen/box/smartCasts/kt44814.ir.txt

@@ -375,7 +375,7 @@ FILE fqName:<root> fileName:/kt44814.kt
       CLASS CLASS name:FirPsiModifier modality:FINAL visibility:public superTypes:[<root>.FirModifier<<root>.ASTNode>]
       CLASS CLASS name:FirLightModifier modality:FINAL visibility:public superTypes:[<root>.FirModifier<<root>.LighterASTNode>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.FirModifier<Node of <root>.FirModifier>
-    TYPE_PARAMETER name:Node index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:Node index:0 variance: superTypes:[kotlin.Any] reified:false
     CONSTRUCTOR visibility:protected <> (node:Node of <root>.FirModifier, token:<root>.KtModifierKeywordToken) returnType:<root>.FirModifier<Node of <root>.FirModifier> [primary]
       VALUE_PARAMETER name:node index:0 type:Node of <root>.FirModifier
       VALUE_PARAMETER name:token index:1 type:<root>.KtModifierKeywordToken

compiler/testData/ir/irJsText/scripting/fun.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/fun.kts
   SCRIPT
     FUN name:test1 visibility:public modality:FINAL <T> ($this:<root>.Fun, i:kotlin.Int, j:T of <root>.Fun.test1) returnType:kotlin.Unit
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Fun
       VALUE_PARAMETER name:i index:0 type:kotlin.Int
       VALUE_PARAMETER name:j index:1 type:T of <root>.Fun.test1
@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/fun.kts
         VALUE_PARAMETER name:j index:1 type:kotlin.String
         BLOCK_BODY
       FUN name:testMembetExt2 visibility:public modality:FINAL <T> ($this:<root>.Fun.Host, $receiver:kotlin.String, i:kotlin.Int, j:T of <root>.Fun.Host.testMembetExt2) returnType:kotlin.Unit
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Fun.Host
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.String
         VALUE_PARAMETER name:i index:0 type:kotlin.Int

compiler/testData/ir/irText/classes/47424.ir.txt

@@ -16,7 +16,7 @@ FILE fqName:com.example fileName:/47424.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:Ab modality:ABSTRACT visibility:public superTypes:[com.example.Aa]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:com.example.Ab<T of com.example.Ab>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[com.example.Ab<T of com.example.Ab>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[com.example.Ab<T of com.example.Ab>] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in com.example.Aa
@@ -47,7 +47,7 @@ FILE fqName:com.example fileName:/47424.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:Bb modality:ABSTRACT visibility:public superTypes:[com.example.Ab<T of com.example.Bb>; com.example.Ba]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:com.example.Bb<T of com.example.Bb>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[com.example.Bb<T of com.example.Bb>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[com.example.Bb<T of com.example.Bb>] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in com.example.Ab

compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/clashingFakeOverrideSignatures.kt
   CLASS CLASS name:Base modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Base<T of <root>.Base>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Base<T of <root>.Base> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -163,8 +163,8 @@ FILE fqName:<root> fileName:/clashingFakeOverrideSignatures.kt
         y: CONST String type=kotlin.String value=""
   CLASS CLASS name:BaseXY modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.BaseXY<X of <root>.BaseXY, Y of <root>.BaseXY>
-    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:Y index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:Y index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.BaseXY<X of <root>.BaseXY, Y of <root>.BaseXY> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -229,7 +229,7 @@ FILE fqName:<root> fileName:/clashingFakeOverrideSignatures.kt
     BLOCK_BODY
       CLASS CLASS name:LocalBase modality:OPEN visibility:local superTypes:[kotlin.Any]
         $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.outerFun.LocalBase<T of <root>.outerFun.LocalBase>
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         CONSTRUCTOR visibility:public <> () returnType:<root>.outerFun.LocalBase<T of <root>.outerFun.LocalBase> [primary]
           BLOCK_BODY
             DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -391,7 +391,7 @@ FILE fqName:<root> fileName:/clashingFakeOverrideSignatures.kt
             y: CONST String type=kotlin.String value=""
   CLASS CLASS name:Outer modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Outer<T of <root>.Outer>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Outer<T of <root>.Outer> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/classes/dataClasses/dataClassWithArrayMembers.fir.ir.txt

@@ -461,7 +461,7 @@ FILE fqName:<root> fileName:/dataClassWithArrayMembers.kt
             CONST String type=kotlin.String value=")"
   CLASS CLASS name:Test2 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2<T of <root>.Test2>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (genericArray:kotlin.Array<T of <root>.Test2>) returnType:<root>.Test2<T of <root>.Test2> [primary]
       VALUE_PARAMETER name:genericArray index:0 type:kotlin.Array<T of <root>.Test2>
       BLOCK_BODY

compiler/testData/ir/irText/classes/dataClasses/dataClassWithArrayMembers.ir.txt

@@ -461,7 +461,7 @@ FILE fqName:<root> fileName:/dataClassWithArrayMembers.kt
           CONST Boolean type=kotlin.Boolean value=true
   CLASS CLASS name:Test2 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2<T of <root>.Test2>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (genericArray:kotlin.Array<T of <root>.Test2>) returnType:<root>.Test2<T of <root>.Test2> [primary]
       VALUE_PARAMETER name:genericArray index:0 type:kotlin.Array<T of <root>.Test2>
       BLOCK_BODY

compiler/testData/ir/irText/classes/dataClasses/dataClassesGeneric.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/dataClassesGeneric.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T of <root>.Test1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test1) returnType:<root>.Test1<T of <root>.Test1> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test1
       BLOCK_BODY
@@ -101,7 +101,7 @@ FILE fqName:<root> fileName:/dataClassesGeneric.kt
             CONST String type=kotlin.String value=")"
   CLASS CLASS name:Test2 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2<T of <root>.Test2>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test2) returnType:<root>.Test2<T of <root>.Test2> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test2
       BLOCK_BODY
@@ -192,7 +192,7 @@ FILE fqName:<root> fileName:/dataClassesGeneric.kt
             CONST String type=kotlin.String value=")"
   CLASS CLASS name:Test3 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test3<T of <root>.Test3>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.collections.List<T of <root>.Test3>) returnType:<root>.Test3<T of <root>.Test3> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.collections.List<T of <root>.Test3>
       BLOCK_BODY

compiler/testData/ir/irText/classes/dataClasses/dataClassesGeneric.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/dataClassesGeneric.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T of <root>.Test1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test1) returnType:<root>.Test1<T of <root>.Test1> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test1
       BLOCK_BODY
@@ -101,7 +101,7 @@ FILE fqName:<root> fileName:/dataClassesGeneric.kt
           CONST Boolean type=kotlin.Boolean value=true
   CLASS CLASS name:Test2 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2<T of <root>.Test2>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test2) returnType:<root>.Test2<T of <root>.Test2> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test2
       BLOCK_BODY
@@ -192,7 +192,7 @@ FILE fqName:<root> fileName:/dataClassesGeneric.kt
           CONST Boolean type=kotlin.Boolean value=true
   CLASS CLASS name:Test3 modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test3<T of <root>.Test3>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.collections.List<T of <root>.Test3>) returnType:<root>.Test3<T of <root>.Test3> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.collections.List<T of <root>.Test3>
       BLOCK_BODY

compiler/testData/ir/irText/classes/delegatedGenericImplementation.fir.ir.txt

@@ -1,27 +1,27 @@
 FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
   CLASS INTERFACE name:IBase modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IBase<A of <root>.IBase>
-    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:foo visibility:public modality:ABSTRACT <B> ($this:<root>.IBase<A of <root>.IBase>, a:A of <root>.IBase, b:B of <root>.IBase.foo) returnType:kotlin.Unit
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
       VALUE_PARAMETER name:a index:0 type:A of <root>.IBase
       VALUE_PARAMETER name:b index:1 type:B of <root>.IBase.foo
     PROPERTY name:id visibility:public modality:ABSTRACT [val]
       FUN DEFAULT_PROPERTY_ACCESSOR name:<get-id> visibility:public modality:ABSTRACT <C> ($this:<root>.IBase<A of <root>.IBase>, $receiver:C of <root>.IBase.<get-id>) returnType:kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>?
         correspondingProperty: PROPERTY name:id visibility:public modality:ABSTRACT [val]
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.IBase.<get-id>
     PROPERTY name:x visibility:public modality:ABSTRACT [var]
       FUN DEFAULT_PROPERTY_ACCESSOR name:<get-x> visibility:public modality:ABSTRACT <D> ($this:<root>.IBase<A of <root>.IBase>, $receiver:kotlin.collections.List<D of <root>.IBase.<get-x>>) returnType:D of <root>.IBase.<get-x>?
         correspondingProperty: PROPERTY name:x visibility:public modality:ABSTRACT [var]
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.IBase.<get-x>>
       FUN DEFAULT_PROPERTY_ACCESSOR name:<set-x> visibility:public modality:ABSTRACT <D> ($this:<root>.IBase<A of <root>.IBase>, $receiver:kotlin.collections.List<D of <root>.IBase.<set-x>>, <set-?>:D of <root>.IBase.<set-x>?) returnType:kotlin.Unit
         correspondingProperty: PROPERTY name:x visibility:public modality:ABSTRACT [var]
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.IBase.<set-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.IBase.<set-x>?
@@ -40,7 +40,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[<root>.IBase<E of <root>.Test1>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<E of <root>.Test1>
-    TYPE_PARAMETER name:E index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:E index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (i:<root>.IBase<E of <root>.Test1>) returnType:<root>.Test1<E of <root>.Test1> [primary]
       VALUE_PARAMETER name:i index:0 type:<root>.IBase<E of <root>.Test1>
       BLOCK_BODY
@@ -49,7 +49,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
     FUN DELEGATED_MEMBER name:foo visibility:public modality:OPEN <B> ($this:<root>.Test1<E of <root>.Test1>, a:E of <root>.Test1, b:B of <root>.Test1.foo) returnType:kotlin.Unit
       overridden:
         public abstract fun foo <B> (a: A of <root>.IBase, b: B of <root>.IBase.foo): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
       VALUE_PARAMETER name:a index:0 type:E of <root>.Test1
       VALUE_PARAMETER name:b index:1 type:B of <root>.Test1.foo
@@ -67,7 +67,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public abstract fun <get-id> <C> (): kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>? declared in <root>.IBase
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.Test1.<get-id>
         BLOCK_BODY
@@ -84,7 +84,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <get-x> <D> (): D of <root>.IBase.<get-x>? declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test1.<get-x>>
         BLOCK_BODY
@@ -98,7 +98,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <set-x> <D> (<set-?>: D of <root>.IBase.<set-x>?): kotlin.Unit declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test1.<get-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.Test1.<set-x>?
@@ -135,7 +135,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
     FUN DELEGATED_MEMBER name:foo visibility:public modality:OPEN <B> ($this:<root>.Test2, a:kotlin.String, b:B of <root>.Test2.foo) returnType:kotlin.Unit
       overridden:
         public abstract fun foo <B> (a: A of <root>.IBase, b: B of <root>.IBase.foo): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test2
       VALUE_PARAMETER name:a index:0 type:kotlin.String
       VALUE_PARAMETER name:b index:1 type:B of <root>.Test2.foo
@@ -153,7 +153,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public abstract fun <get-id> <C> (): kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>? declared in <root>.IBase
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.Test2.<get-id>
         BLOCK_BODY
@@ -170,7 +170,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <get-x> <D> (): D of <root>.IBase.<get-x>? declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test2.<get-x>>
         BLOCK_BODY
@@ -184,7 +184,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <set-x> <D> (<set-?>: D of <root>.IBase.<set-x>?): kotlin.Unit declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test2.<get-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.Test2.<set-x>?

compiler/testData/ir/irText/classes/delegatedGenericImplementation.ir.txt

@@ -1,27 +1,27 @@
 FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
   CLASS INTERFACE name:IBase modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IBase<A of <root>.IBase>
-    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:foo visibility:public modality:ABSTRACT <B> ($this:<root>.IBase<A of <root>.IBase>, a:A of <root>.IBase, b:B of <root>.IBase.foo) returnType:kotlin.Unit
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
       VALUE_PARAMETER name:a index:0 type:A of <root>.IBase
       VALUE_PARAMETER name:b index:1 type:B of <root>.IBase.foo
     PROPERTY name:id visibility:public modality:ABSTRACT [val]
       FUN DEFAULT_PROPERTY_ACCESSOR name:<get-id> visibility:public modality:ABSTRACT <C> ($this:<root>.IBase<A of <root>.IBase>, $receiver:C of <root>.IBase.<get-id>) returnType:kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>?
         correspondingProperty: PROPERTY name:id visibility:public modality:ABSTRACT [val]
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.IBase.<get-id>
     PROPERTY name:x visibility:public modality:ABSTRACT [var]
       FUN DEFAULT_PROPERTY_ACCESSOR name:<get-x> visibility:public modality:ABSTRACT <D> ($this:<root>.IBase<A of <root>.IBase>, $receiver:kotlin.collections.List<D of <root>.IBase.<get-x>>) returnType:D of <root>.IBase.<get-x>?
         correspondingProperty: PROPERTY name:x visibility:public modality:ABSTRACT [var]
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.IBase.<get-x>>
       FUN DEFAULT_PROPERTY_ACCESSOR name:<set-x> visibility:public modality:ABSTRACT <D> ($this:<root>.IBase<A of <root>.IBase>, $receiver:kotlin.collections.List<D of <root>.IBase.<set-x>>, <set-?>:D of <root>.IBase.<set-x>?) returnType:kotlin.Unit
         correspondingProperty: PROPERTY name:x visibility:public modality:ABSTRACT [var]
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<A of <root>.IBase>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.IBase.<set-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.IBase.<set-x>?
@@ -40,7 +40,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[<root>.IBase<E of <root>.Test1>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<E of <root>.Test1>
-    TYPE_PARAMETER name:E index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:E index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (i:<root>.IBase<E of <root>.Test1>) returnType:<root>.Test1<E of <root>.Test1> [primary]
       VALUE_PARAMETER name:i index:0 type:<root>.IBase<E of <root>.Test1>
       BLOCK_BODY
@@ -56,7 +56,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public abstract fun <get-id> <C> (): kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>? declared in <root>.IBase
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.Test1.<get-id>
         BLOCK_BODY
@@ -73,7 +73,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <get-x> <D> (): D of <root>.IBase.<get-x>? declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test1.<get-x>>
         BLOCK_BODY
@@ -87,7 +87,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <set-x> <D> (<set-?>: D of <root>.IBase.<set-x>?): kotlin.Unit declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test1.<set-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.Test1.<set-x>?
@@ -101,7 +101,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
     FUN DELEGATED_MEMBER name:foo visibility:public modality:OPEN <B> ($this:<root>.Test1<E of <root>.Test1>, a:E of <root>.Test1, b:B of <root>.Test1.foo) returnType:kotlin.Unit
       overridden:
         public abstract fun foo <B> (a: A of <root>.IBase, b: B of <root>.IBase.foo): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test1<E of <root>.Test1>
       VALUE_PARAMETER name:a index:0 type:E of <root>.Test1
       VALUE_PARAMETER name:b index:1 type:B of <root>.Test1.foo
@@ -161,7 +161,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public abstract fun <get-id> <C> (): kotlin.collections.Map<A of <root>.IBase, C of <root>.IBase.<get-id>>? declared in <root>.IBase
-        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:C index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:C of <root>.Test2.<get-id>
         BLOCK_BODY
@@ -178,7 +178,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <get-x> <D> (): D of <root>.IBase.<get-x>? declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test2.<get-x>>
         BLOCK_BODY
@@ -192,7 +192,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:x visibility:public modality:OPEN [var]
         overridden:
           public abstract fun <set-x> <D> (<set-?>: D of <root>.IBase.<set-x>?): kotlin.Unit declared in <root>.IBase
-        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:D index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Test2
         $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<D of <root>.Test2.<set-x>>
         VALUE_PARAMETER name:<set-?> index:0 type:D of <root>.Test2.<set-x>?
@@ -206,7 +206,7 @@ FILE fqName:<root> fileName:/delegatedGenericImplementation.kt
     FUN DELEGATED_MEMBER name:foo visibility:public modality:OPEN <B> ($this:<root>.Test2, a:kotlin.String, b:B of <root>.Test2.foo) returnType:kotlin.Unit
       overridden:
         public abstract fun foo <B> (a: A of <root>.IBase, b: B of <root>.IBase.foo): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:B index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test2
       VALUE_PARAMETER name:a index:0 type:kotlin.String
       VALUE_PARAMETER name:b index:1 type:B of <root>.Test2.foo

compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.fir.ir.txt

@@ -1,10 +1,10 @@
 FILE fqName:<root> fileName:/delegatingConstructorCallToTypeAliasConstructor.kt
   TYPEALIAS name:CT visibility:public expandedType:<root>.Cell<T of <root>.CT>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
   TYPEALIAS name:CStr visibility:public expandedType:<root>.Cell<kotlin.String>
   CLASS CLASS name:Cell modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Cell<T of <root>.Cell>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Cell) returnType:<root>.Cell<T of <root>.Cell> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Cell
       BLOCK_BODY

compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/delegatingConstructorCallToTypeAliasConstructor.kt
   CLASS CLASS name:Cell modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Cell<T of <root>.Cell>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Cell) returnType:<root>.Cell<T of <root>.Cell> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Cell
       BLOCK_BODY
@@ -32,7 +32,7 @@ FILE fqName:<root> fileName:/delegatingConstructorCallToTypeAliasConstructor.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   TYPEALIAS name:CT visibility:public expandedType:<root>.Cell<T of <root>.CT>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
   TYPEALIAS name:CStr visibility:public expandedType:<root>.Cell<kotlin.String>
   CLASS CLASS name:C1 modality:FINAL visibility:public superTypes:[<root>.Cell<kotlin.String>{ <root>.CT<kotlin.String> }]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.C1

compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/inlineClassSyntheticMethods.kt
   CLASS CLASS name:C modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.C<T of <root>.C>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (t:T of <root>.C) returnType:<root>.C<T of <root>.C> [primary]
       VALUE_PARAMETER name:t index:0 type:T of <root>.C
       BLOCK_BODY
@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/inlineClassSyntheticMethods.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:IC modality:FINAL visibility:public [value] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IC<TT of <root>.IC>
-    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (c:<root>.C<TT of <root>.IC>) returnType:<root>.IC<TT of <root>.IC> [primary]
       VALUE_PARAMETER name:c index:0 type:<root>.C<TT of <root>.IC>
       BLOCK_BODY

compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/inlineClassSyntheticMethods.kt
   CLASS CLASS name:C modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.C<T of <root>.C>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (t:T of <root>.C) returnType:<root>.C<T of <root>.C> [primary]
       VALUE_PARAMETER name:t index:0 type:T of <root>.C
       BLOCK_BODY
@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/inlineClassSyntheticMethods.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:IC modality:FINAL visibility:public [value] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IC<TT of <root>.IC>
-    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (c:<root>.C<TT of <root>.IC>) returnType:<root>.IC<TT of <root>.IC> [primary]
       VALUE_PARAMETER name:c index:0 type:<root>.C<TT of <root>.IC>
       BLOCK_BODY

compiler/testData/ir/irText/classes/kt45934.fir.ir.txt

@@ -9,7 +9,7 @@ FILE fqName:<root> fileName:/kt45934.kt
     FUN DELEGATED_MEMBER name:foo visibility:public modality:OPEN <C> ($this:<root>.C) returnType:@[FlexibleNullability] kotlin.collections.List<@[FlexibleNullability] C of <root>.C.foo?>?
       overridden:
         public abstract fun foo <C> (): @[FlexibleNullability] kotlin.collections.List<@[FlexibleNullability] C of <root>.I.foo?>? declared in <root>.I
-      TYPE_PARAMETER name:C index:0 variance: superTypes:[@[FlexibleNullability] kotlin.Any?]
+      TYPE_PARAMETER name:C index:0 variance: superTypes:[@[FlexibleNullability] kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.C
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public open fun foo <C> (): @[FlexibleNullability] kotlin.collections.List<@[FlexibleNullability] C of <root>.C.foo?>? declared in <root>.C'

compiler/testData/ir/irText/declarations/annotations/genericAnnotationClasses.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:ann fileName:/genericAnnotationClasses.kt
   CLASS ANNOTATION_CLASS name:Test1 modality:OPEN visibility:public superTypes:[kotlin.Annotation]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.Test1<T of ann.Test1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.Int) returnType:ann.Test1<T of ann.Test1> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
       BLOCK_BODY
@@ -33,8 +33,8 @@ FILE fqName:ann fileName:/genericAnnotationClasses.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS ANNOTATION_CLASS name:Test2 modality:OPEN visibility:public superTypes:[kotlin.Annotation]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.Test2<T1 of ann.Test2, T2 of ann.Test2>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.Int) returnType:ann.Test2<T1 of ann.Test2, T2 of ann.Test2> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
         EXPRESSION_BODY
@@ -68,7 +68,7 @@ FILE fqName:ann fileName:/genericAnnotationClasses.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:I modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.I<T of ann.I>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -84,8 +84,8 @@ FILE fqName:ann fileName:/genericAnnotationClasses.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS ANNOTATION_CLASS name:Test3 modality:OPEN visibility:public superTypes:[kotlin.Annotation]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.Test3<T1 of ann.Test3, T2 of ann.Test3>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[ann.I<T1 of ann.Test3>]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[ann.I<T1 of ann.Test3>] reified:false
     CONSTRUCTOR visibility:public <> (x:ann.Test1<ann.I<T2 of ann.Test3>>) returnType:ann.Test3<T1 of ann.Test3, T2 of ann.Test3> [primary]
       VALUE_PARAMETER name:x index:0 type:ann.Test1<ann.I<T2 of ann.Test3>>
       BLOCK_BODY
@@ -117,7 +117,7 @@ FILE fqName:ann fileName:/genericAnnotationClasses.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:C modality:FINAL visibility:public superTypes:[ann.I<T of ann.C>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.C<T of ann.C>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:ann.C<T of ann.C> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -187,7 +187,7 @@ FILE fqName:ann fileName:/genericAnnotationClasses.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS ANNOTATION_CLASS name:Test5 modality:OPEN visibility:public superTypes:[kotlin.Annotation]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:ann.Test5<T of ann.Test5>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (xs:kotlin.Array<out ann.Test3<T of ann.Test5, ann.C<T of ann.Test5>>>) returnType:ann.Test5<T of ann.Test5> [primary]
       VALUE_PARAMETER name:xs index:0 type:kotlin.Array<out ann.Test3<T of ann.Test5, ann.C<T of ann.Test5>>> varargElementType:ann.Test3<T of ann.Test5, ann.C<T of ann.Test5>> [vararg]
       BLOCK_BODY

compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.ir.txt

@@ -21,7 +21,7 @@ FILE fqName:<root> fileName:/typeParametersWithAnnotations.kt
         public open fun toString (): kotlin.String [fake_override] declared in kotlin.Annotation
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:foo visibility:public modality:FINAL <T> () returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       annotations:
         Anno
     BLOCK_BODY

compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/compareTo.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/compareTo.kt
   CLASS CLASS name:Pair modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Pair<A of <root>.Pair, B of <root>.Pair>
-    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:B index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:B index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (first:A of <root>.Pair, second:B of <root>.Pair) returnType:<root>.Pair<A of <root>.Pair, B of <root>.Pair> [primary]
       VALUE_PARAMETER name:first index:0 type:A of <root>.Pair
       VALUE_PARAMETER name:second index:1 type:B of <root>.Pair
@@ -158,7 +158,7 @@ FILE fqName:<root> fileName:/compareTo.kt
         RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in <root>.Pair'
           CONST Boolean type=kotlin.Boolean value=true
   FUN name:compareTo visibility:public modality:FINAL <T> ($receiver:T of <root>.compareTo, <this>:java.util.Comparator<T of <root>.compareTo>{ kotlin.TypeAliasesKt.Comparator<T of <root>.compareTo> }, other:T of <root>.compareTo) returnType:kotlin.Int [operator,infix]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     $receiver: VALUE_PARAMETER name:<this> type:T of <root>.compareTo
     VALUE_PARAMETER name:<this> index:0 type:java.util.Comparator<T of <root>.compareTo>{ kotlin.TypeAliasesKt.Comparator<T of <root>.compareTo> }
@@ -172,7 +172,7 @@ FILE fqName:<root> fileName:/compareTo.kt
   PROPERTY name:min visibility:public modality:FINAL [val]
     FUN name:<get-min> visibility:public modality:FINAL <T> ($receiver:<root>.Pair<T of <root>.<get-min>, T of <root>.<get-min>>, <this>:java.util.Comparator<T of <root>.<get-min>>{ kotlin.TypeAliasesKt.Comparator<T of <root>.<get-min>> }) returnType:T of <root>.<get-min>
       correspondingProperty: PROPERTY name:min visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       contextReceiverParametersCount: 1
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Pair<T of <root>.<get-min>, T of <root>.<get-min>>
       VALUE_PARAMETER name:<this> index:0 type:java.util.Comparator<T of <root>.<get-min>>{ kotlin.TypeAliasesKt.Comparator<T of <root>.<get-min>> }

compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/functionalType.ir.txt

@@ -79,7 +79,7 @@ FILE fqName:<root> fileName:/functionalType.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:f visibility:public modality:FINAL <T> ($receiver:<root>.K, <this>:<root>.O, g:@[ExtensionFunctionType] @[ContextFunctionTypeParams(count = '1')] kotlin.Function3<<root>.O, <root>.K, <root>.Param, T of <root>.f>) returnType:T of <root>.f
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     $receiver: VALUE_PARAMETER name:<this> type:<root>.K
     VALUE_PARAMETER name:<this> index:0 type:<root>.O

compiler/testData/ir/irText/declarations/contextReceivers/fromKEEP/monoidSum.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/monoidSum.kt
   CLASS INTERFACE name:Semigroup modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Semigroup<T of <root>.Semigroup>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:combine visibility:public modality:ABSTRACT <> ($this:<root>.Semigroup<T of <root>.Semigroup>, $receiver:T of <root>.Semigroup, other:T of <root>.Semigroup) returnType:T of <root>.Semigroup [infix]
       $this: VALUE_PARAMETER name:<this> type:<root>.Semigroup<T of <root>.Semigroup>
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.Semigroup
@@ -21,7 +21,7 @@ FILE fqName:<root> fileName:/monoidSum.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:Monoid modality:ABSTRACT visibility:public superTypes:[<root>.Semigroup<T of <root>.Monoid>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Monoid<T of <root>.Monoid>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     PROPERTY name:unit visibility:public modality:ABSTRACT [val]
       FUN DEFAULT_PROPERTY_ACCESSOR name:<get-unit> visibility:public modality:ABSTRACT <> ($this:<root>.Monoid<T of <root>.Monoid>) returnType:T of <root>.Monoid
         correspondingProperty: PROPERTY name:unit visibility:public modality:ABSTRACT [val]
@@ -136,7 +136,7 @@ FILE fqName:<root> fileName:/monoidSum.kt
         public open fun toString (): kotlin.String [fake_override] declared in <root>.Monoid
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:sum visibility:public modality:FINAL <T> ($receiver:kotlin.collections.List<T of <root>.sum>, <this>:<root>.Monoid<T of <root>.sum>) returnType:T of <root>.sum
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     $receiver: VALUE_PARAMETER name:<this> type:kotlin.collections.List<T of <root>.sum>
     VALUE_PARAMETER name:<this> index:0 type:<root>.Monoid<T of <root>.sum>

compiler/testData/ir/irText/declarations/contextReceivers/genericOuterClass.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericOuterClass.kt
   CLASS CLASS name:A modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.A<T of <root>.A>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.A<T of <root>.A> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -21,7 +21,7 @@ FILE fqName:<root> fileName:/genericOuterClass.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:B modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.B<P of <root>.B>
-    TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.B<P of <root>.B> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/declarations/contextReceivers/genericOuterClass.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericOuterClass.kt
   CLASS CLASS name:A modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.A<T of <root>.A>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FIELD FIELD_FOR_CLASS_CONTEXT_RECEIVER name:contextReceiverField0 type:T of <root>.A visibility:private [final]
     CONSTRUCTOR visibility:public <> (<this>:T of <root>.A) returnType:<root>.A<T of <root>.A> [primary]
       VALUE_PARAMETER name:<this> index:0 type:T of <root>.A
@@ -26,7 +26,7 @@ FILE fqName:<root> fileName:/genericOuterClass.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:B modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.B<P of <root>.B>
-    TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?] reified:false
     FIELD FIELD_FOR_CLASS_CONTEXT_RECEIVER name:contextReceiverField0 type:kotlin.collections.Collection<P of <root>.B> visibility:private [final]
     CONSTRUCTOR visibility:public <> (<this>:kotlin.collections.Collection<P of <root>.B>) returnType:<root>.B<P of <root>.B> [primary]
       VALUE_PARAMETER name:<this> index:0 type:kotlin.collections.Collection<P of <root>.B>

compiler/testData/ir/irText/declarations/contextReceivers/lazy.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/lazy.kt
   CLASS INTERFACE name:Lazy modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Lazy<T of <root>.Lazy>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -21,19 +21,19 @@ FILE fqName:<root> fileName:/lazy.kt
     VALUE_PARAMETER name:<this> index:1 type:<root>.Lazy<kotlin.CharSequence>
     BLOCK_BODY
   FUN name:test2 visibility:public modality:FINAL <T> ($receiver:<root>.Lazy<kotlin.Int>, <this>:<root>.Lazy<T of <root>.test2>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     $receiver: VALUE_PARAMETER name:<this> type:<root>.Lazy<kotlin.Int>
     VALUE_PARAMETER name:<this> index:0 type:<root>.Lazy<T of <root>.test2>
     BLOCK_BODY
   FUN name:test3 visibility:public modality:FINAL <T> ($receiver:<root>.Lazy<kotlin.Int>, <this>:<root>.Lazy<<root>.Lazy<T of <root>.test3>>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     $receiver: VALUE_PARAMETER name:<this> type:<root>.Lazy<kotlin.Int>
     VALUE_PARAMETER name:<this> index:0 type:<root>.Lazy<<root>.Lazy<T of <root>.test3>>
     BLOCK_BODY
   FUN name:f visibility:public modality:FINAL <T> (lazy1:<root>.Lazy<kotlin.Int>, lazy2:<root>.Lazy<kotlin.CharSequence>, lazyT:<root>.Lazy<T of <root>.f>, lazyLazyT:<root>.Lazy<<root>.Lazy<T of <root>.f>>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:lazy1 index:0 type:<root>.Lazy<kotlin.Int>
     VALUE_PARAMETER name:lazy2 index:1 type:<root>.Lazy<kotlin.CharSequence>
     VALUE_PARAMETER name:lazyT index:2 type:<root>.Lazy<T of <root>.f>

compiler/testData/ir/irText/declarations/contextReceivers/thisWithCustomLabel.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/thisWithCustomLabel.kt
   CLASS CLASS name:A modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.A<T of <root>.A>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (a:T of <root>.A) returnType:<root>.A<T of <root>.A> [primary]
       VALUE_PARAMETER name:a index:0 type:T of <root>.A
       BLOCK_BODY

compiler/testData/ir/irText/declarations/contextReceivers/typeParameterAsContextReceiver.fir.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/typeParameterAsContextReceiver.kt
   FUN name:useContext visibility:public modality:FINAL <T> (block:kotlin.Function1<T of <root>.useContext, kotlin.Unit>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:block index:0 type:kotlin.Function1<T of <root>.useContext, kotlin.Unit>
     BLOCK_BODY
   FUN name:test visibility:public modality:FINAL <> () returnType:kotlin.Unit

compiler/testData/ir/irText/declarations/contextReceivers/typeParameterAsContextReceiver.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/typeParameterAsContextReceiver.kt
   FUN name:useContext visibility:public modality:FINAL <T> (<this>:T of <root>.useContext, block:kotlin.Function1<T of <root>.useContext, kotlin.Unit>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     contextReceiverParametersCount: 1
     VALUE_PARAMETER name:<this> index:0 type:T of <root>.useContext
     VALUE_PARAMETER name:block index:1 type:kotlin.Function1<T of <root>.useContext, kotlin.Unit>

compiler/testData/ir/irText/declarations/fakeOverrides.fir.ir.txt

@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/fakeOverrides.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:CFoo modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CFoo<T of <root>.CFoo>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.CFoo<T of <root>.CFoo> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/declarations/fakeOverrides.ir.txt

@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/fakeOverrides.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:CFoo modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CFoo<T of <root>.CFoo>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.CFoo<T of <root>.CFoo> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.ir.txt

@@ -1,3 +1,3 @@
 FILE fqName:<root> fileName:/fileWithTypeAliasesOnly.kt
   TYPEALIAS name:Bar visibility:public expandedType:kotlin.Function1<T of <root>.Bar, kotlin.String>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false

compiler/testData/ir/irText/declarations/genericDelegatedProperty.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericDelegatedProperty.kt
   CLASS CLASS name:C modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.C<T of <root>.C>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.C<T of <root>.C> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -57,7 +57,7 @@ FILE fqName:<root> fileName:/genericDelegatedProperty.kt
         GET_OBJECT 'CLASS OBJECT name:Delegate modality:FINAL visibility:public superTypes:[kotlin.Any]' type=<root>.Delegate
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-genericDelegatedProperty> visibility:public modality:FINAL <T> ($receiver:<root>.C<T of <root>.<get-genericDelegatedProperty>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:genericDelegatedProperty visibility:public modality:FINAL [delegated,var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.C<T of <root>.<get-genericDelegatedProperty>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-genericDelegatedProperty> <T> (): kotlin.Int declared in <root>'
@@ -68,7 +68,7 @@ FILE fqName:<root> fileName:/genericDelegatedProperty.kt
               <1>: <none>
     FUN DELEGATED_PROPERTY_ACCESSOR name:<set-genericDelegatedProperty> visibility:public modality:FINAL <T> ($receiver:<root>.C<T of <root>.<set-genericDelegatedProperty>>, <set-?>:kotlin.Int) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:genericDelegatedProperty visibility:public modality:FINAL [delegated,var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.C<T of <root>.<set-genericDelegatedProperty>>
       VALUE_PARAMETER name:<set-?> index:0 type:kotlin.Int
       BLOCK_BODY

compiler/testData/ir/irText/declarations/genericDelegatedProperty.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericDelegatedProperty.kt
   CLASS CLASS name:C modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.C<T of <root>.C>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.C<T of <root>.C> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -57,7 +57,7 @@ FILE fqName:<root> fileName:/genericDelegatedProperty.kt
         GET_OBJECT 'CLASS OBJECT name:Delegate modality:FINAL visibility:public superTypes:[kotlin.Any]' type=<root>.Delegate
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-genericDelegatedProperty> visibility:public modality:FINAL <T> ($receiver:<root>.C<T of <root>.<get-genericDelegatedProperty>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:genericDelegatedProperty visibility:public modality:FINAL [delegated,var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.C<T of <root>.<get-genericDelegatedProperty>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-genericDelegatedProperty> <T> (): kotlin.Int declared in <root>'
@@ -68,7 +68,7 @@ FILE fqName:<root> fileName:/genericDelegatedProperty.kt
               <1>: T of <root>.<get-genericDelegatedProperty>
     FUN DELEGATED_PROPERTY_ACCESSOR name:<set-genericDelegatedProperty> visibility:public modality:FINAL <T> ($receiver:<root>.C<T of <root>.<set-genericDelegatedProperty>>, <set-?>:kotlin.Int) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:genericDelegatedProperty visibility:public modality:FINAL [delegated,var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.C<T of <root>.<set-genericDelegatedProperty>>
       VALUE_PARAMETER name:<set-?> index:0 type:kotlin.Int
       BLOCK_BODY

compiler/testData/ir/irText/declarations/kt27005.ir.txt

@@ -10,6 +10,6 @@ FILE fqName:<root> fileName:/kt27005.kt
         CALL 'public final fun baz <T> (): T of <root>.baz [suspend] declared in <root>' type=kotlin.Any origin=null
           <T>: kotlin.Any
   FUN name:baz visibility:public modality:FINAL <T> () returnType:T of <root>.baz [suspend]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
       CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin.StandardKt' type=kotlin.Nothing origin=null

compiler/testData/ir/irText/declarations/kt35550.fir.ir.txt

@@ -4,7 +4,7 @@ FILE fqName:<root> fileName:/kt35550.kt
     PROPERTY name:id visibility:public modality:OPEN [val]
       FUN name:<get-id> visibility:public modality:OPEN <T> ($this:<root>.I, $receiver:T of <root>.I.<get-id>) returnType:T of <root>.I.<get-id>
         correspondingProperty: PROPERTY name:id visibility:public modality:OPEN [val]
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.I
         $receiver: VALUE_PARAMETER name:<this> type:T of <root>.I.<get-id>
         BLOCK_BODY
@@ -37,7 +37,7 @@ FILE fqName:<root> fileName:/kt35550.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public open fun <get-id> <T> (): T of <root>.I.<get-id> declared in <root>.I
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.A
         $receiver: VALUE_PARAMETER name:<this> type:T of <root>.A.<get-id>
         BLOCK_BODY

compiler/testData/ir/irText/declarations/kt35550.ir.txt

@@ -4,7 +4,7 @@ FILE fqName:<root> fileName:/kt35550.kt
     PROPERTY name:id visibility:public modality:OPEN [val]
       FUN name:<get-id> visibility:public modality:OPEN <T> ($this:<root>.I, $receiver:T of <root>.I.<get-id>) returnType:T of <root>.I.<get-id>
         correspondingProperty: PROPERTY name:id visibility:public modality:OPEN [val]
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.I
         $receiver: VALUE_PARAMETER name:<this> type:T of <root>.I.<get-id>
         BLOCK_BODY
@@ -40,7 +40,7 @@ FILE fqName:<root> fileName:/kt35550.kt
         correspondingProperty: PROPERTY DELEGATED_MEMBER name:id visibility:public modality:OPEN [val]
         overridden:
           public open fun <get-id> <T> (): T of <root>.I.<get-id> declared in <root>.I
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.A
         $receiver: VALUE_PARAMETER name:<this> type:T of <root>.A.<get-id>
         BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/class.ir.txt

@@ -1,10 +1,10 @@
 FILE fqName:<root> fileName:/class.kt
   CLASS INTERFACE name:TestInterface modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.TestInterface<T of <root>.TestInterface>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CLASS INTERFACE name:TestNestedInterface modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.TestInterface.TestNestedInterface<TT of <root>.TestInterface.TestNestedInterface>
-      TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
       FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
         overridden:
           public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -33,14 +33,14 @@ FILE fqName:<root> fileName:/class.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test<T0 of <root>.Test>
-    TYPE_PARAMETER name:T0 index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T0 index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Test<T0 of <root>.Test> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Test modality:FINAL visibility:public superTypes:[kotlin.Any]'
     CLASS CLASS name:TestNested modality:FINAL visibility:public superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test.TestNested<T1 of <root>.Test.TestNested>
-      TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> () returnType:<root>.Test.TestNested<T1 of <root>.Test.TestNested> [primary]
         BLOCK_BODY
           DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -60,7 +60,7 @@ FILE fqName:<root> fileName:/class.kt
         $this: VALUE_PARAMETER name:<this> type:kotlin.Any
     CLASS CLASS name:TestInner modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test.TestInner<T2 of <root>.Test.TestInner, T0 of <root>.Test>
-      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.Test<T0 of <root>.Test>) returnType:<root>.Test.TestInner<T2 of <root>.Test.TestInner, T0 of <root>.Test> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.Test<T0 of <root>.Test>
         BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/constructor.fir.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/constructor.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T1 of <root>.Test1, T2 of <root>.Test1>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T1 of <root>.Test1, y:T2 of <root>.Test1) returnType:<root>.Test1<T1 of <root>.Test1, T2 of <root>.Test1> [primary]
       VALUE_PARAMETER name:x index:0 type:T1 of <root>.Test1
       VALUE_PARAMETER name:y index:1 type:T2 of <root>.Test1
@@ -65,7 +65,7 @@ FILE fqName:<root> fileName:/constructor.kt
               receiver: GET_VAR '<this>: <root>.Test2 declared in <root>.Test2.<get-y>' type=<root>.Test2 origin=null
     CLASS CLASS name:TestInner modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2.TestInner<Z of <root>.Test2.TestInner>
-      TYPE_PARAMETER name:Z index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:Z index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.Test2, z:Z of <root>.Test2.TestInner) returnType:<root>.Test2.TestInner<Z of <root>.Test2.TestInner> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.Test2
         VALUE_PARAMETER name:z index:0 type:Z of <root>.Test2.TestInner
@@ -165,7 +165,7 @@ FILE fqName:<root> fileName:/constructor.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test4 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test4<T of <root>.Test4>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.Int) returnType:<root>.Test4<T of <root>.Test4> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
       BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/constructor.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/constructor.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T1 of <root>.Test1, T2 of <root>.Test1>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T1 of <root>.Test1, y:T2 of <root>.Test1) returnType:<root>.Test1<T1 of <root>.Test1, T2 of <root>.Test1> [primary]
       VALUE_PARAMETER name:x index:0 type:T1 of <root>.Test1
       VALUE_PARAMETER name:y index:1 type:T2 of <root>.Test1
@@ -65,7 +65,7 @@ FILE fqName:<root> fileName:/constructor.kt
               receiver: GET_VAR '<this>: <root>.Test2 declared in <root>.Test2.<get-y>' type=<root>.Test2 origin=null
     CLASS CLASS name:TestInner modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test2.TestInner<Z of <root>.Test2.TestInner>
-      TYPE_PARAMETER name:Z index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:Z index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.Test2, z:Z of <root>.Test2.TestInner) returnType:<root>.Test2.TestInner<Z of <root>.Test2.TestInner> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.Test2
         VALUE_PARAMETER name:z index:0 type:Z of <root>.Test2.TestInner
@@ -165,7 +165,7 @@ FILE fqName:<root> fileName:/constructor.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test4 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test4<T of <root>.Test4>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:kotlin.Int) returnType:<root>.Test4<T of <root>.Test4> [primary]
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
       BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/dataClassMembers.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/dataClassMembers.kt
   CLASS CLASS name:Test modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test<T of <root>.Test>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test, y:kotlin.String) returnType:<root>.Test<T of <root>.Test> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test
       VALUE_PARAMETER name:y index:1 type:kotlin.String

compiler/testData/ir/irText/declarations/parameters/dataClassMembers.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/dataClassMembers.kt
   CLASS CLASS name:Test modality:FINAL visibility:public [data] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test<T of <root>.Test>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (x:T of <root>.Test, y:kotlin.String) returnType:<root>.Test<T of <root>.Test> [primary]
       VALUE_PARAMETER name:x index:0 type:T of <root>.Test
       VALUE_PARAMETER name:y index:1 type:kotlin.String

compiler/testData/ir/irText/declarations/parameters/defaultPropertyAccessors.ir.txt

@@ -74,7 +74,7 @@ FILE fqName:<root> fileName:/defaultPropertyAccessors.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:InPrimaryCtor modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.InPrimaryCtor<T of <root>.InPrimaryCtor>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (testInPrimaryCtor1:T of <root>.InPrimaryCtor, testInPrimaryCtor2:kotlin.Int) returnType:<root>.InPrimaryCtor<T of <root>.InPrimaryCtor> [primary]
       VALUE_PARAMETER name:testInPrimaryCtor1 index:0 type:T of <root>.InPrimaryCtor
       VALUE_PARAMETER name:testInPrimaryCtor2 index:1 type:kotlin.Int

compiler/testData/ir/irText/declarations/parameters/delegatedMembers.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/delegatedMembers.kt
   CLASS INTERFACE name:IBase modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IBase<T of <root>.IBase>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:foo visibility:public modality:ABSTRACT <> ($this:<root>.IBase<T of <root>.IBase>, x:kotlin.Int) returnType:kotlin.Unit
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
@@ -10,7 +10,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
         correspondingProperty: PROPERTY name:bar visibility:public modality:ABSTRACT [val]
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
     FUN name:qux visibility:public modality:ABSTRACT <X> ($this:<root>.IBase<T of <root>.IBase>, t:T of <root>.IBase, x:X of <root>.IBase.qux) returnType:kotlin.Unit
-      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
       VALUE_PARAMETER name:t index:0 type:T of <root>.IBase
       VALUE_PARAMETER name:x index:1 type:X of <root>.IBase.qux
@@ -29,7 +29,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test modality:FINAL visibility:public superTypes:[<root>.IBase<TT of <root>.Test>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test<TT of <root>.Test>
-    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (impl:<root>.IBase<TT of <root>.Test>) returnType:<root>.Test<TT of <root>.Test> [primary]
       VALUE_PARAMETER name:impl index:0 type:<root>.IBase<TT of <root>.Test>
       BLOCK_BODY
@@ -48,7 +48,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
     FUN DELEGATED_MEMBER name:qux visibility:public modality:OPEN <X> ($this:<root>.Test<TT of <root>.Test>, t:TT of <root>.Test, x:X of <root>.Test.qux) returnType:kotlin.Unit
       overridden:
         public abstract fun qux <X> (t: T of <root>.IBase, x: X of <root>.IBase.qux): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test<TT of <root>.Test>
       VALUE_PARAMETER name:t index:0 type:TT of <root>.Test
       VALUE_PARAMETER name:x index:1 type:X of <root>.Test.qux

compiler/testData/ir/irText/declarations/parameters/delegatedMembers.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/delegatedMembers.kt
   CLASS INTERFACE name:IBase modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.IBase<T of <root>.IBase>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:foo visibility:public modality:ABSTRACT <> ($this:<root>.IBase<T of <root>.IBase>, x:kotlin.Int) returnType:kotlin.Unit
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
       VALUE_PARAMETER name:x index:0 type:kotlin.Int
@@ -10,7 +10,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
         correspondingProperty: PROPERTY name:bar visibility:public modality:ABSTRACT [val]
         $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
     FUN name:qux visibility:public modality:ABSTRACT <X> ($this:<root>.IBase<T of <root>.IBase>, t:T of <root>.IBase, x:X of <root>.IBase.qux) returnType:kotlin.Unit
-      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.IBase<T of <root>.IBase>
       VALUE_PARAMETER name:t index:0 type:T of <root>.IBase
       VALUE_PARAMETER name:x index:1 type:X of <root>.IBase.qux
@@ -29,7 +29,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Test modality:FINAL visibility:public superTypes:[<root>.IBase<TT of <root>.Test>]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test<TT of <root>.Test>
-    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (impl:<root>.IBase<TT of <root>.Test>) returnType:<root>.Test<TT of <root>.Test> [primary]
       VALUE_PARAMETER name:impl index:0 type:<root>.IBase<TT of <root>.Test>
       BLOCK_BODY
@@ -64,7 +64,7 @@ FILE fqName:<root> fileName:/delegatedMembers.kt
     FUN DELEGATED_MEMBER name:qux visibility:public modality:OPEN <X> ($this:<root>.Test<TT of <root>.Test>, t:TT of <root>.Test, x:X of <root>.Test.qux) returnType:kotlin.Unit
       overridden:
         public abstract fun qux <X> (t: T of <root>.IBase, x: X of <root>.IBase.qux): kotlin.Unit declared in <root>.IBase
-      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Test<TT of <root>.Test>
       VALUE_PARAMETER name:t index:0 type:TT of <root>.Test
       VALUE_PARAMETER name:x index:1 type:X of <root>.Test.qux

compiler/testData/ir/irText/declarations/parameters/fun.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/fun.kt
   FUN name:test1 visibility:public modality:FINAL <T> (i:kotlin.Int, j:T of <root>.test1) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:i index:0 type:kotlin.Int
     VALUE_PARAMETER name:j index:1 type:T of <root>.test1
     BLOCK_BODY
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/fun.kt
       VALUE_PARAMETER name:j index:1 type:kotlin.String
       BLOCK_BODY
     FUN name:testMembetExt2 visibility:public modality:FINAL <T> ($this:<root>.Host, $receiver:kotlin.String, i:kotlin.Int, j:T of <root>.Host.testMembetExt2) returnType:kotlin.Unit
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Host
       $receiver: VALUE_PARAMETER name:<this> type:kotlin.String
       VALUE_PARAMETER name:i index:0 type:kotlin.Int

compiler/testData/ir/irText/declarations/parameters/genericInnerClass.ir.txt

@@ -1,14 +1,14 @@
 FILE fqName:<root> fileName:/genericInnerClass.kt
   CLASS CLASS name:Outer modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Outer<T1 of <root>.Outer>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Outer<T1 of <root>.Outer> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Outer modality:FINAL visibility:public superTypes:[kotlin.Any]'
     CLASS CLASS name:Inner modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Outer.Inner<T2 of <root>.Outer.Inner, T1 of <root>.Outer>
-      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.Outer<T1 of <root>.Outer>) returnType:<root>.Outer.Inner<T2 of <root>.Outer.Inner, T1 of <root>.Outer> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.Outer<T1 of <root>.Outer>
         BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/localFun.ir.txt

@@ -1,9 +1,9 @@
 FILE fqName:<root> fileName:/localFun.kt
   FUN name:outer visibility:public modality:FINAL <TT> () returnType:kotlin.Unit
-    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
       FUN LOCAL_FUNCTION name:test1 visibility:local modality:FINAL <T> (i:kotlin.Int, j:T of <root>.outer.test1) returnType:kotlin.Unit
-        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
         VALUE_PARAMETER name:i index:0 type:kotlin.Int
         VALUE_PARAMETER name:j index:1 type:T of <root>.outer.test1
         BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/propertyAccessors.ir.txt

@@ -37,7 +37,7 @@ FILE fqName:<root> fileName:/propertyAccessors.kt
   PROPERTY name:testExt3 visibility:public modality:FINAL [val]
     FUN name:<get-testExt3> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-testExt3>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:testExt3 visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-testExt3>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-testExt3> <T> (): kotlin.Int declared in <root>'
@@ -45,20 +45,20 @@ FILE fqName:<root> fileName:/propertyAccessors.kt
   PROPERTY name:testExt4 visibility:public modality:FINAL [var]
     FUN name:<get-testExt4> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-testExt4>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:testExt4 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-testExt4>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-testExt4> <T> (): kotlin.Int declared in <root>'
           CONST Int type=kotlin.Int value=42
     FUN name:<set-testExt4> visibility:public modality:FINAL <T> ($receiver:T of <root>.<set-testExt4>, value:kotlin.Int) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:testExt4 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<set-testExt4>
       VALUE_PARAMETER name:value index:0 type:kotlin.Int
       BLOCK_BODY
   CLASS CLASS name:Host modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Host<T of <root>.Host>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Host<T of <root>.Host> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -107,7 +107,7 @@ FILE fqName:<root> fileName:/propertyAccessors.kt
     PROPERTY name:testMemExt3 visibility:public modality:FINAL [val]
       FUN name:<get-testMemExt3> visibility:public modality:FINAL <TT> ($this:<root>.Host<T of <root>.Host>, $receiver:TT of <root>.Host.<get-testMemExt3>) returnType:kotlin.Int
         correspondingProperty: PROPERTY name:testMemExt3 visibility:public modality:FINAL [val]
-        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
         $receiver: VALUE_PARAMETER name:<this> type:TT of <root>.Host.<get-testMemExt3>
         BLOCK_BODY
@@ -116,7 +116,7 @@ FILE fqName:<root> fileName:/propertyAccessors.kt
     PROPERTY name:testMemExt4 visibility:public modality:FINAL [var]
       FUN name:<get-testMemExt4> visibility:public modality:FINAL <TT> ($this:<root>.Host<T of <root>.Host>, $receiver:TT of <root>.Host.<get-testMemExt4>) returnType:kotlin.Int
         correspondingProperty: PROPERTY name:testMemExt4 visibility:public modality:FINAL [var]
-        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
         $receiver: VALUE_PARAMETER name:<this> type:TT of <root>.Host.<get-testMemExt4>
         BLOCK_BODY
@@ -124,7 +124,7 @@ FILE fqName:<root> fileName:/propertyAccessors.kt
             CONST Int type=kotlin.Int value=42
       FUN name:<set-testMemExt4> visibility:public modality:FINAL <TT> ($this:<root>.Host<T of <root>.Host>, $receiver:TT of <root>.Host.<set-testMemExt4>, value:kotlin.Int) returnType:kotlin.Unit
         correspondingProperty: PROPERTY name:testMemExt4 visibility:public modality:FINAL [var]
-        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:TT index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
         $receiver: VALUE_PARAMETER name:<this> type:TT of <root>.Host.<set-testMemExt4>
         VALUE_PARAMETER name:value index:0 type:kotlin.Int

compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.fir.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/typeParameterBeforeBound.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T of <root>.Test1, U of <root>.Test1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.Test1]
-    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.Test1] reified:false
+    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Test1<T of <root>.Test1, U of <root>.Test1> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -21,20 +21,20 @@ FILE fqName:<root> fileName:/typeParameterBeforeBound.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:test2 visibility:public modality:FINAL <T, U> () returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.test2]
-    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.test2] reified:false
+    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
   PROPERTY name:test3 visibility:public modality:FINAL [var]
     FUN name:<get-test3> visibility:public modality:FINAL <T, U> ($receiver:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:test3 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>]
-      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>] reified:false
+      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>
       BLOCK_BODY
     FUN name:<set-test3> visibility:public modality:FINAL <T, U> ($receiver:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>, value:kotlin.Unit) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:test3 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>]
-      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>] reified:false
+      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>
       VALUE_PARAMETER name:value index:0 type:kotlin.Unit
       BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/typeParameterBeforeBound.kt
   CLASS CLASS name:Test1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Test1<T of <root>.Test1, U of <root>.Test1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.Test1]
-    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.Test1] reified:false
+    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Test1<T of <root>.Test1, U of <root>.Test1> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -21,20 +21,20 @@ FILE fqName:<root> fileName:/typeParameterBeforeBound.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:test2 visibility:public modality:FINAL <T, U> () returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.test2]
-    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.test2] reified:false
+    TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
   PROPERTY name:test3 visibility:public modality:FINAL [var]
     FUN name:<get-test3> visibility:public modality:FINAL <T, U> ($receiver:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:test3 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>]
-      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<get-test3>] reified:false
+      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Test1<T of <root>.<get-test3>, U of <root>.<get-test3>>
       BLOCK_BODY
     FUN name:<set-test3> visibility:public modality:FINAL <T, U> ($receiver:<root>.Test1<T of <root>.<set-test3>, U of <root>.<set-test3>>, value:kotlin.Unit) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:test3 visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<set-test3>]
-      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[U of <root>.<set-test3>] reified:false
+      TYPE_PARAMETER name:U index:1 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Test1<T of <root>.<set-test3>, U of <root>.<set-test3>>
       VALUE_PARAMETER name:value index:0 type:kotlin.Unit
       BLOCK_BODY

compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/typeParameterBoundedBySubclass.kt
   CLASS CLASS name:Base1 modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Base1<T of <root>.Base1>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived1]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived1] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Base1<T of <root>.Base1> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -46,7 +46,7 @@ FILE fqName:<root> fileName:/typeParameterBoundedBySubclass.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Base2 modality:ABSTRACT visibility:public superTypes:[kotlin.Any]'
     FUN name:foo visibility:public modality:FINAL <T> ($this:<root>.Base2, x:T of <root>.Base2.foo) returnType:kotlin.Unit
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived2]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived2] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Base2
       VALUE_PARAMETER name:x index:0 type:T of <root>.Base2.foo
       BLOCK_BODY
@@ -72,7 +72,7 @@ FILE fqName:<root> fileName:/typeParameterBoundedBySubclass.kt
     FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <T> ($this:<root>.Base2, x:T of <root>.Derived2.foo) returnType:kotlin.Unit [fake_override]
       overridden:
         public final fun foo <T> (x: T of <root>.Base2.foo): kotlin.Unit declared in <root>.Base2
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived2]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Derived2] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Base2
       VALUE_PARAMETER name:x index:0 type:T of <root>.Derived2.foo
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]

compiler/testData/ir/irText/expressions/argumentMappedWithError.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/argumentMappedWithError.kt
   FUN name:convert visibility:public modality:FINAL <R> ($receiver:kotlin.Number) returnType:R of <root>.convert
-    TYPE_PARAMETER name:R index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:R index:0 variance: superTypes:[kotlin.Number] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:kotlin.Number
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun convert <R> (): R of <root>.convert declared in <root>'

compiler/testData/ir/irText/expressions/bangbang.fir.ir.txt

@@ -26,7 +26,7 @@ FILE fqName:<root> fileName:/bangbang.kt
                 then: CALL 'public open fun hashCode (): kotlin.Int declared in kotlin.Any' type=kotlin.Int origin=null
                   $this: GET_VAR 'val tmp_0: kotlin.Any? [val] declared in <root>.test2' type=kotlin.Any? origin=null
   FUN name:test3 visibility:public modality:FINAL <X> (a:X of <root>.test3) returnType:{X of <root>.test3 & Any}
-    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:X of <root>.test3
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test3 <X> (a: X of <root>.test3): {X of <root>.test3 & Any} declared in <root>'
@@ -37,7 +37,7 @@ FILE fqName:<root> fileName:/bangbang.kt
     VALUE_PARAMETER name:s index:0 type:kotlin.String
     BLOCK_BODY
   FUN name:test4 visibility:public modality:FINAL <X> (a:X of <root>.test4) returnType:kotlin.Unit
-    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:X of <root>.test4
     BLOCK_BODY
       WHEN type=kotlin.Unit origin=IF

compiler/testData/ir/irText/expressions/bangbang.ir.txt

@@ -26,7 +26,7 @@ FILE fqName:<root> fileName:/bangbang.kt
                 then: CALL 'public open fun hashCode (): kotlin.Int declared in kotlin.Any' type=kotlin.Int origin=null
                   $this: GET_VAR 'val tmp_0: kotlin.Any? [val] declared in <root>.test2' type=kotlin.Any? origin=null
   FUN name:test3 visibility:public modality:FINAL <X> (a:X of <root>.test3) returnType:{X of <root>.test3 & Any}
-    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:X of <root>.test3
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test3 <X> (a: X of <root>.test3): {X of <root>.test3 & Any} declared in <root>'
@@ -37,7 +37,7 @@ FILE fqName:<root> fileName:/bangbang.kt
     VALUE_PARAMETER name:s index:0 type:kotlin.String
     BLOCK_BODY
   FUN name:test4 visibility:public modality:FINAL <X> (a:X of <root>.test4) returnType:kotlin.Unit
-    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:X of <root>.test4
     BLOCK_BODY
       WHEN type=kotlin.Unit origin=IF

compiler/testData/ir/irText/expressions/callableReferences/boundInnerGenericConstructor.ir.txt

@@ -1,14 +1,14 @@
 FILE fqName:test fileName:/boundInnerGenericConstructor.kt
   CLASS CLASS name:Foo modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:test.Foo<T of test.Foo>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:test.Foo<T of test.Foo> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Foo modality:FINAL visibility:public superTypes:[kotlin.Any]'
     CLASS CLASS name:Inner modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:test.Foo.Inner<P of test.Foo.Inner, T of test.Foo>
-      TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:P index:0 variance: superTypes:[kotlin.Any?] reified:false
       CONSTRUCTOR visibility:public <> ($this:test.Foo<T of test.Foo>, a:T of test.Foo, b:P of test.Foo.Inner) returnType:test.Foo.Inner<P of test.Foo.Inner, T of test.Foo> [primary]
         $outer: VALUE_PARAMETER name:<this> type:test.Foo<T of test.Foo>
         VALUE_PARAMETER name:a index:0 type:T of test.Foo
@@ -65,8 +65,8 @@ FILE fqName:test fileName:/boundInnerGenericConstructor.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:foo visibility:public modality:FINAL <A, B> (a:A of test.foo, b:B of test.foo, x:kotlin.Function2<A of test.foo, B of test.foo, test.Foo.Inner<B of test.foo, A of test.foo>>) returnType:test.Foo.Inner<B of test.foo, A of test.foo> [inline]
-    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:B index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:A index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:B index:1 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:A of test.foo
     VALUE_PARAMETER name:b index:1 type:B of test.foo
     VALUE_PARAMETER name:x index:2 type:kotlin.Function2<A of test.foo, B of test.foo, test.Foo.Inner<B of test.foo, A of test.foo>>

compiler/testData/ir/irText/expressions/callableReferences/genericLocalClassConstructorReference.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
   CLASS CLASS name:L modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.L<LL of <root>.L>
-    TYPE_PARAMETER name:LL index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:LL index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (ll:LL of <root>.L) returnType:<root>.L<LL of <root>.L> [primary]
       VALUE_PARAMETER name:ll index:0 type:LL of <root>.L
       BLOCK_BODY
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Rec modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Rec<T of <root>.Rec>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (rt:T of <root>.Rec) returnType:<root>.Rec<T of <root>.Rec> [primary]
       VALUE_PARAMETER name:rt index:0 type:T of <root>.Rec
       BLOCK_BODY
@@ -66,12 +66,12 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
   PROPERTY name:p visibility:public modality:FINAL [val]
     FUN name:<get-p> visibility:public modality:FINAL <PT> ($receiver:<root>.Rec<PT of <root>.<get-p>>) returnType:<root>.L<PT of <root>.<get-p>>
       correspondingProperty: PROPERTY name:p visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:PT index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:PT index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Rec<PT of <root>.<get-p>>
       BLOCK_BODY
         CLASS CLASS name:PLocal modality:FINAL visibility:local superTypes:[<root>.L<LT of <root>.<get-p>.PLocal>]
           $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.<get-p>.PLocal<LT of <root>.<get-p>.PLocal, PT of <root>.<get-p>>
-          TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?]
+          TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?] reified:false
           CONSTRUCTOR visibility:public <> (lt:LT of <root>.<get-p>.PLocal, pt:PT of <root>.<get-p>) returnType:<root>.<get-p>.PLocal<LT of <root>.<get-p>.PLocal, PT of <root>.<get-p>> [primary]
             VALUE_PARAMETER name:lt index:0 type:LT of <root>.<get-p>.PLocal
             VALUE_PARAMETER name:pt index:1 type:PT of <root>.<get-p>
@@ -124,12 +124,12 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
             bb: FUNCTION_REFERENCE 'public constructor <init> (lt: LT of <root>.<get-p>.PLocal, pt: PT of <root>.<get-p>) [primary] declared in <root>.<get-p>.PLocal' type=kotlin.reflect.KFunction2<PT of <root>.<get-p>, PT of <root>.<get-p>, <root>.<get-p>.PLocal<PT of <root>.<get-p>, PT of <root>.<get-p>>> origin=null reflectionTarget=<same>
               <LT>: PT of <root>.<get-p>
   FUN name:fn visibility:public modality:FINAL <FT> ($receiver:<root>.Rec<FT of <root>.fn>) returnType:<root>.L<FT of <root>.fn>
-    TYPE_PARAMETER name:FT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:FT index:0 variance: superTypes:[kotlin.Any?] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:<root>.Rec<FT of <root>.fn>
     BLOCK_BODY
       CLASS CLASS name:FLocal modality:FINAL visibility:local superTypes:[<root>.L<LT of <root>.fn.FLocal>]
         $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.fn.FLocal<LT of <root>.fn.FLocal, FT of <root>.fn>
-        TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?] reified:false
         CONSTRUCTOR visibility:public <> (lt:LT of <root>.fn.FLocal, pt:FT of <root>.fn) returnType:<root>.fn.FLocal<LT of <root>.fn.FLocal, FT of <root>.fn> [primary]
           VALUE_PARAMETER name:lt index:0 type:LT of <root>.fn.FLocal
           VALUE_PARAMETER name:pt index:1 type:FT of <root>.fn
@@ -182,9 +182,9 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
           bb: FUNCTION_REFERENCE 'public constructor <init> (lt: LT of <root>.fn.FLocal, pt: FT of <root>.fn) [primary] declared in <root>.fn.FLocal' type=kotlin.reflect.KFunction2<FT of <root>.fn, FT of <root>.fn, <root>.fn.FLocal<FT of <root>.fn, FT of <root>.fn>> origin=null reflectionTarget=<same>
             <LT>: FT of <root>.fn
   FUN name:foo2 visibility:public modality:FINAL <T1, T2, R> (t1:T1 of <root>.foo2, t2:T2 of <root>.foo2, bb:kotlin.Function2<T1 of <root>.foo2, T2 of <root>.foo2, R of <root>.foo2>) returnType:R of <root>.foo2
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:R index:2 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:R index:2 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:t1 index:0 type:T1 of <root>.foo2
     VALUE_PARAMETER name:t2 index:1 type:T2 of <root>.foo2
     VALUE_PARAMETER name:bb index:2 type:kotlin.Function2<T1 of <root>.foo2, T2 of <root>.foo2, R of <root>.foo2>

compiler/testData/ir/irText/expressions/callableReferences/genericLocalClassConstructorReference.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
   CLASS CLASS name:L modality:OPEN visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.L<LL of <root>.L>
-    TYPE_PARAMETER name:LL index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:LL index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (ll:LL of <root>.L) returnType:<root>.L<LL of <root>.L> [primary]
       VALUE_PARAMETER name:ll index:0 type:LL of <root>.L
       BLOCK_BODY
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS CLASS name:Rec modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Rec<T of <root>.Rec>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (rt:T of <root>.Rec) returnType:<root>.Rec<T of <root>.Rec> [primary]
       VALUE_PARAMETER name:rt index:0 type:T of <root>.Rec
       BLOCK_BODY
@@ -66,12 +66,12 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
   PROPERTY name:p visibility:public modality:FINAL [val]
     FUN name:<get-p> visibility:public modality:FINAL <PT> ($receiver:<root>.Rec<PT of <root>.<get-p>>) returnType:<root>.L<PT of <root>.<get-p>>
       correspondingProperty: PROPERTY name:p visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:PT index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:PT index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Rec<PT of <root>.<get-p>>
       BLOCK_BODY
         CLASS CLASS name:PLocal modality:FINAL visibility:local superTypes:[<root>.L<LT of <root>.<get-p>.PLocal>]
           $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.<get-p>.PLocal<LT of <root>.<get-p>.PLocal>
-          TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?]
+          TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?] reified:false
           CONSTRUCTOR visibility:public <> (lt:LT of <root>.<get-p>.PLocal, pt:PT of <root>.<get-p>) returnType:<root>.<get-p>.PLocal<LT of <root>.<get-p>.PLocal> [primary]
             VALUE_PARAMETER name:lt index:0 type:LT of <root>.<get-p>.PLocal
             VALUE_PARAMETER name:pt index:1 type:PT of <root>.<get-p>
@@ -124,12 +124,12 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
             bb: FUNCTION_REFERENCE 'public constructor <init> (lt: LT of <root>.<get-p>.PLocal, pt: PT of <root>.<get-p>) [primary] declared in <root>.<get-p>.PLocal' type=kotlin.reflect.KFunction2<PT of <root>.<get-p>, PT of <root>.<get-p>, <root>.<get-p>.PLocal<PT of <root>.<get-p>>> origin=null reflectionTarget=<same>
               <LT>: PT of <root>.<get-p>
   FUN name:fn visibility:public modality:FINAL <FT> ($receiver:<root>.Rec<FT of <root>.fn>) returnType:<root>.L<FT of <root>.fn>
-    TYPE_PARAMETER name:FT index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:FT index:0 variance: superTypes:[kotlin.Any?] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:<root>.Rec<FT of <root>.fn>
     BLOCK_BODY
       CLASS CLASS name:FLocal modality:FINAL visibility:local superTypes:[<root>.L<LT of <root>.fn.FLocal>]
         $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.fn.FLocal<LT of <root>.fn.FLocal, FT of <root>.fn>
-        TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:LT index:0 variance: superTypes:[kotlin.Any?] reified:false
         CONSTRUCTOR visibility:public <> (lt:LT of <root>.fn.FLocal, pt:FT of <root>.fn) returnType:<root>.fn.FLocal<LT of <root>.fn.FLocal, FT of <root>.fn> [primary]
           VALUE_PARAMETER name:lt index:0 type:LT of <root>.fn.FLocal
           VALUE_PARAMETER name:pt index:1 type:FT of <root>.fn
@@ -182,9 +182,9 @@ FILE fqName:<root> fileName:/genericLocalClassConstructorReference.kt
           bb: FUNCTION_REFERENCE 'public constructor <init> (lt: LT of <root>.fn.FLocal, pt: FT of <root>.fn) [primary] declared in <root>.fn.FLocal' type=kotlin.reflect.KFunction2<FT of <root>.fn, FT of <root>.fn, <root>.fn.FLocal<FT of <root>.fn, FT of <root>.fn>> origin=null reflectionTarget=<same>
             <LT>: FT of <root>.fn
   FUN name:foo2 visibility:public modality:FINAL <T1, T2, R> (t1:T1 of <root>.foo2, t2:T2 of <root>.foo2, bb:kotlin.Function2<T1 of <root>.foo2, T2 of <root>.foo2, R of <root>.foo2>) returnType:R of <root>.foo2
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:R index:2 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:T2 index:1 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:R index:2 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:t1 index:0 type:T1 of <root>.foo2
     VALUE_PARAMETER name:t2 index:1 type:T2 of <root>.foo2
     VALUE_PARAMETER name:bb index:2 type:kotlin.Function2<T1 of <root>.foo2, T2 of <root>.foo2, R of <root>.foo2>

compiler/testData/ir/irText/expressions/callableReferences/genericMember.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericMember.kt
   CLASS CLASS name:A modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.A<T of <root>.A>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.A<T of <root>.A> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/expressions/callableReferences/kt46069.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/kt46069.kt
   CLASS CLASS name:ObjectAssert modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.ObjectAssert<ACTUAL of <root>.ObjectAssert>
-    TYPE_PARAMETER name:ACTUAL index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:ACTUAL index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.ObjectAssert<ACTUAL of <root>.ObjectAssert> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/kt46069.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Assertions modality:FINAL visibility:public superTypes:[kotlin.Any]'
     FUN name:assertThat visibility:public modality:FINAL <S> ($this:<root>.Assertions, actual:S of <root>.Assertions.assertThat) returnType:<root>.ObjectAssert<S of <root>.Assertions.assertThat>
-      TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Assertions
       VALUE_PARAMETER name:actual index:0 type:S of <root>.Assertions.assertThat
       BLOCK_BODY
@@ -54,7 +54,7 @@ FILE fqName:<root> fileName:/kt46069.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:assertNotNull visibility:public modality:FINAL <T> ($receiver:T of <root>.assertNotNull?, description:kotlin.String?) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:T of <root>.assertNotNull?
     VALUE_PARAMETER name:description index:0 type:kotlin.String?
       EXPRESSION_BODY

compiler/testData/ir/irText/expressions/callableReferences/kt46069.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/kt46069.kt
   CLASS CLASS name:ObjectAssert modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.ObjectAssert<ACTUAL of <root>.ObjectAssert>
-    TYPE_PARAMETER name:ACTUAL index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:ACTUAL index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.ObjectAssert<ACTUAL of <root>.ObjectAssert> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/kt46069.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Assertions modality:FINAL visibility:public superTypes:[kotlin.Any]'
     FUN name:assertThat visibility:public modality:FINAL <S> ($this:<root>.Assertions, actual:S of <root>.Assertions.assertThat) returnType:<root>.ObjectAssert<S of <root>.Assertions.assertThat>
-      TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Assertions
       VALUE_PARAMETER name:actual index:0 type:S of <root>.Assertions.assertThat
       BLOCK_BODY
@@ -54,7 +54,7 @@ FILE fqName:<root> fileName:/kt46069.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:assertNotNull visibility:public modality:FINAL <T> ($receiver:T of <root>.assertNotNull?, description:kotlin.String?) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:T of <root>.assertNotNull?
     VALUE_PARAMETER name:description index:0 type:kotlin.String?
       EXPRESSION_BODY

compiler/testData/ir/irText/expressions/callableReferences/typeArguments.fir.ir.txt

@@ -6,7 +6,7 @@ FILE fqName:<root> fileName:/typeArguments.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Host modality:FINAL visibility:public superTypes:[kotlin.Any]'
     FUN name:objectMember visibility:public modality:FINAL <T> ($this:<root>.Host, x:T of <root>.Host.objectMember) returnType:kotlin.Unit [inline]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
       $this: VALUE_PARAMETER name:<this> type:<root>.Host
       VALUE_PARAMETER name:x index:0 type:T of <root>.Host.objectMember
       BLOCK_BODY
@@ -24,11 +24,11 @@ FILE fqName:<root> fileName:/typeArguments.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:topLevel1 visibility:public modality:FINAL <T> (x:T of <root>.topLevel1) returnType:kotlin.Unit [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:x index:0 type:T of <root>.topLevel1
     BLOCK_BODY
   FUN name:topLevel2 visibility:public modality:FINAL <T> (x:kotlin.collections.List<T of <root>.topLevel2>) returnType:kotlin.Unit [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:x index:0 type:kotlin.collections.List<T of <root>.topLevel2>
     BLOCK_BODY
   PROPERTY name:test1 visibility:public modality:FINAL [val]

compiler/testData/ir/irText/expressions/callableReferences/typeArguments.ir.txt

@@ -6,7 +6,7 @@ FILE fqName:<root> fileName:/typeArguments.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Host modality:FINAL visibility:public superTypes:[kotlin.Any]'
     FUN name:objectMember visibility:public modality:FINAL <T> ($this:<root>.Host, x:T of <root>.Host.objectMember) returnType:kotlin.Unit [inline]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
       $this: VALUE_PARAMETER name:<this> type:<root>.Host
       VALUE_PARAMETER name:x index:0 type:T of <root>.Host.objectMember
       BLOCK_BODY
@@ -24,11 +24,11 @@ FILE fqName:<root> fileName:/typeArguments.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:topLevel1 visibility:public modality:FINAL <T> (x:T of <root>.topLevel1) returnType:kotlin.Unit [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:x index:0 type:T of <root>.topLevel1
     BLOCK_BODY
   FUN name:topLevel2 visibility:public modality:FINAL <T> (x:kotlin.collections.List<T of <root>.topLevel2>) returnType:kotlin.Unit [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:x index:0 type:kotlin.collections.List<T of <root>.topLevel2>
     BLOCK_BODY
   PROPERTY name:test1 visibility:public modality:FINAL [val]

compiler/testData/ir/irText/expressions/castToTypeParameter.ir.txt

@@ -1,13 +1,13 @@
 FILE fqName:<root> fileName:/castToTypeParameter.kt
   FUN name:castFun visibility:public modality:FINAL <T> (x:kotlin.Any) returnType:T of <root>.castFun
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun castFun <T> (x: kotlin.Any): T of <root>.castFun declared in <root>'
         TYPE_OP type=T of <root>.castFun origin=CAST typeOperand=T of <root>.castFun
           GET_VAR 'x: kotlin.Any declared in <root>.castFun' type=kotlin.Any origin=null
   FUN name:castExtFun visibility:public modality:FINAL <T> ($receiver:kotlin.Any) returnType:T of <root>.castExtFun
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     $receiver: VALUE_PARAMETER name:<this> type:kotlin.Any
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun castExtFun <T> (): T of <root>.castExtFun declared in <root>'
@@ -16,7 +16,7 @@ FILE fqName:<root> fileName:/castToTypeParameter.kt
   PROPERTY name:castExtVal visibility:public modality:FINAL [val]
     FUN name:<get-castExtVal> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-castExtVal>) returnType:T of <root>.<get-castExtVal>
       correspondingProperty: PROPERTY name:castExtVal visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-castExtVal>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-castExtVal> <T> (): T of <root>.<get-castExtVal> declared in <root>'
@@ -24,7 +24,7 @@ FILE fqName:<root> fileName:/castToTypeParameter.kt
             GET_VAR '<this>: T of <root>.<get-castExtVal> declared in <root>.<get-castExtVal>' type=T of <root>.<get-castExtVal> origin=null
   CLASS CLASS name:Host modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Host<T of <root>.Host>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Host<T of <root>.Host> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
@@ -37,7 +37,7 @@ FILE fqName:<root> fileName:/castToTypeParameter.kt
           TYPE_OP type=T of <root>.Host origin=CAST typeOperand=T of <root>.Host
             GET_VAR 'x: kotlin.Any declared in <root>.Host.castMemberFun' type=kotlin.Any origin=null
     FUN name:castGenericMemberFun visibility:public modality:FINAL <TF> ($this:<root>.Host<T of <root>.Host>, x:kotlin.Any) returnType:TF of <root>.Host.castGenericMemberFun
-      TYPE_PARAMETER name:TF index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:TF index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
       VALUE_PARAMETER name:x index:0 type:kotlin.Any
       BLOCK_BODY
@@ -52,7 +52,7 @@ FILE fqName:<root> fileName:/castToTypeParameter.kt
           TYPE_OP type=T of <root>.Host origin=CAST typeOperand=T of <root>.Host
             GET_VAR '<this>: kotlin.Any declared in <root>.Host.castMemberExtFun' type=kotlin.Any origin=null
     FUN name:castGenericMemberExtFun visibility:public modality:FINAL <TF> ($this:<root>.Host<T of <root>.Host>, $receiver:kotlin.Any) returnType:TF of <root>.Host.castGenericMemberExtFun
-      TYPE_PARAMETER name:TF index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:TF index:0 variance: superTypes:[kotlin.Any?] reified:false
       $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
       $receiver: VALUE_PARAMETER name:<this> type:kotlin.Any
       BLOCK_BODY
@@ -71,7 +71,7 @@ FILE fqName:<root> fileName:/castToTypeParameter.kt
     PROPERTY name:castGenericMemberExtVal visibility:public modality:FINAL [val]
       FUN name:<get-castGenericMemberExtVal> visibility:public modality:FINAL <TV> ($this:<root>.Host<T of <root>.Host>, $receiver:TV of <root>.Host.<get-castGenericMemberExtVal>) returnType:TV of <root>.Host.<get-castGenericMemberExtVal>
         correspondingProperty: PROPERTY name:castGenericMemberExtVal visibility:public modality:FINAL [val]
-        TYPE_PARAMETER name:TV index:0 variance: superTypes:[kotlin.Any?]
+        TYPE_PARAMETER name:TV index:0 variance: superTypes:[kotlin.Any?] reified:false
         $this: VALUE_PARAMETER name:<this> type:<root>.Host<T of <root>.Host>
         $receiver: VALUE_PARAMETER name:<this> type:TV of <root>.Host.<get-castGenericMemberExtVal>
         BLOCK_BODY

compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.fir.ir.txt

@@ -17,14 +17,14 @@ FILE fqName:<root> fileName:/constructorWithOwnTypeParametersCall.kt
             <Y1>: @[FlexibleNullability] kotlin.String?
   CLASS CLASS name:K1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.K1<T1 of <root>.K1>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Number] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.K1<T1 of <root>.K1> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:K1 modality:FINAL visibility:public superTypes:[kotlin.Any]'
     CLASS CLASS name:K2 modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.K1.K2<T2 of <root>.K1.K2, T1 of <root>.K1>
-      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.CharSequence]
+      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.CharSequence] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.K1<T1 of <root>.K1>) returnType:<root>.K1.K2<T2 of <root>.K1.K2, T1 of <root>.K1> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.K1<T1 of <root>.K1>
         BLOCK_BODY

compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.ir.txt

@@ -17,14 +17,14 @@ FILE fqName:<root> fileName:/constructorWithOwnTypeParametersCall.kt
             <Y1>: @[FlexibleNullability] kotlin.String?
   CLASS CLASS name:K1 modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.K1<T1 of <root>.K1>
-    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:T1 index:0 variance: superTypes:[kotlin.Number] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.K1<T1 of <root>.K1> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:K1 modality:FINAL visibility:public superTypes:[kotlin.Any]'
     CLASS CLASS name:K2 modality:FINAL visibility:public [inner] superTypes:[kotlin.Any]
       $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.K1.K2<T2 of <root>.K1.K2, T1 of <root>.K1>
-      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.CharSequence]
+      TYPE_PARAMETER name:T2 index:0 variance: superTypes:[kotlin.CharSequence] reified:false
       CONSTRUCTOR visibility:public <> ($this:<root>.K1<T1 of <root>.K1>) returnType:<root>.K1.K2<T2 of <root>.K1.K2, T1 of <root>.K1> [primary]
         $outer: VALUE_PARAMETER name:<this> type:<root>.K1<T1 of <root>.K1>
         BLOCK_BODY

compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall__J1.ir.txt

@@ -1,13 +1,13 @@
 CLASS IR_EXTERNAL_DECLARATION_STUB CLASS name:J1 modality:OPEN visibility:public superTypes:[<unbound IrClassPublicSymbolImpl>]
   $this: VALUE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:<this> type:<root>.J1<X1 of <root>.J1>
-  TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:X1 index:0 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?]
+  TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:X1 index:0 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?] reified:false
   CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB visibility:public <Y1> () returnType:<root>.J1<X1 of <root>.J1>
-    TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:Y1 index:1 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?]
+    TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:Y1 index:1 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?] reified:false
   CLASS IR_EXTERNAL_DECLARATION_STUB CLASS name:J2 modality:OPEN visibility:public [inner] superTypes:[<unbound IrClassPublicSymbolImpl>]
     $this: VALUE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:<this> type:<root>.J1.J2<X2 of <root>.J1.J2, X1 of <root>.J1>
-    TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:X2 index:0 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?]
+    TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:X2 index:0 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?] reified:false
     CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB visibility:public <Y2> ($this:<root>.J1<X1 of <root>.J1>) returnType:<root>.J1.J2<X2 of <root>.J1.J2, X1 of <root>.J1>
-      TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:Y2 index:1 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?]
+      TYPE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:Y2 index:1 variance: superTypes:[<unbound IrClassPublicSymbolImpl>?] reified:false
       $outer: VALUE_PARAMETER IR_EXTERNAL_DECLARATION_STUB name:<this> type:<root>.J1<X1 of <root>.J1>
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:<unbound IrClassPublicSymbolImpl>, other:<unbound IrClassPublicSymbolImpl>?) returnType:<unbound IrClassPublicSymbolImpl> [fake_override,operator]
       overridden:

compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
   FUN name:test0 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test0) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test0
     BLOCK_BODY
@@ -16,7 +16,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test1 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test1) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test1
     BLOCK_BODY
@@ -33,7 +33,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test2 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test2) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Double]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Double] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test2
     BLOCK_BODY
@@ -51,7 +51,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test3 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test3) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test3
     BLOCK_BODY
@@ -69,7 +69,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test4 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test4) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float?] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test4
     BLOCK_BODY
@@ -87,8 +87,8 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test5 visibility:public modality:FINAL <T, R> (x:kotlin.Any, y:R of <root>.test5) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float?]
-    TYPE_PARAMETER name:R index:1 variance: superTypes:[T of <root>.test5]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float?] reified:false
+    TYPE_PARAMETER name:R index:1 variance: superTypes:[T of <root>.test5] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:R of <root>.test5
     BLOCK_BODY
@@ -106,7 +106,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             if: CONST Boolean type=kotlin.Boolean value=true
             then: CONST Boolean type=kotlin.Boolean value=false
   FUN name:test6 visibility:public modality:FINAL <T> (x:kotlin.Any, y:T of <root>.test6) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Number] reified:false
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     VALUE_PARAMETER name:y index:1 type:T of <root>.test6
     BLOCK_BODY
@@ -123,7 +123,7 @@ FILE fqName:<root> fileName:/typeParameterWithPrimitiveNumericSupertype.kt
             then: CONST Boolean type=kotlin.Boolean value=false
   CLASS CLASS name:F modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.F<T of <root>.F>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Float] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.F<T of <root>.F> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/expressions/funImportedFromObject.ir.txt

@@ -6,7 +6,7 @@ FILE fqName:test fileName:/funImportedFromObject.kt
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
         INSTANCE_INITIALIZER_CALL classDescriptor='CLASS OBJECT name:Host modality:FINAL visibility:public superTypes:[kotlin.Any]'
     FUN name:foo visibility:public modality:FINAL <T> ($this:test.Host) returnType:kotlin.String [inline]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
       $this: VALUE_PARAMETER name:<this> type:test.Host
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun foo <T> (): kotlin.String [inline] declared in test.Host'

compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/partialSam.kt
   CLASS INTERFACE name:Fn modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Fn<T of <root>.Fn, R of <root>.Fn>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:R index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:R index:1 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:run visibility:public modality:ABSTRACT <> ($this:<root>.Fn<T of <root>.Fn, R of <root>.Fn>, s:kotlin.String, i:kotlin.Int, t:T of <root>.Fn) returnType:R of <root>.Fn
       $this: VALUE_PARAMETER name:<this> type:<root>.Fn<T of <root>.Fn, R of <root>.Fn>
       VALUE_PARAMETER name:s index:0 type:kotlin.String

compiler/testData/ir/irText/expressions/funInterface/partialSam.ir.txt

@@ -1,8 +1,8 @@
 FILE fqName:<root> fileName:/partialSam.kt
   CLASS INTERFACE name:Fn modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Fn<T of <root>.Fn, R of <root>.Fn>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
-    TYPE_PARAMETER name:R index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
+    TYPE_PARAMETER name:R index:1 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:run visibility:public modality:ABSTRACT <> ($this:<root>.Fn<T of <root>.Fn, R of <root>.Fn>, s:kotlin.String, i:kotlin.Int, t:T of <root>.Fn) returnType:R of <root>.Fn
       $this: VALUE_PARAMETER name:<this> type:<root>.Fn<T of <root>.Fn, R of <root>.Fn>
       VALUE_PARAMETER name:s index:0 type:kotlin.String

compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.fir.ir.txt

@@ -17,7 +17,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:id visibility:public modality:FINAL <T> (x:T of <root>.id) returnType:T of <root>.id
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:x index:0 type:T of <root>.id
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun id <T> (x: T of <root>.id): T of <root>.id declared in <root>'
@@ -30,7 +30,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
     VALUE_PARAMETER name:r2 index:1 type:<root>.KRunnable
     BLOCK_BODY
   FUN name:test0 visibility:public modality:FINAL <T> (a:T of <root>.test0) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.KRunnable; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.KRunnable; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test0
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null
@@ -125,7 +125,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
           TYPE_OP type=kotlin.Function0<kotlin.Unit> origin=IMPLICIT_CAST typeOperand=kotlin.Function0<kotlin.Unit>
             GET_VAR 'a: kotlin.Function1<kotlin.Int, kotlin.Int> declared in <root>.test7' type=kotlin.Function1<kotlin.Int, kotlin.Int> origin=null
   FUN name:test7a visibility:public modality:FINAL <T> (a:T of <root>.test7a) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Int>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Int>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7a
     BLOCK_BODY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit
@@ -136,7 +136,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
           TYPE_OP type=kotlin.Function0<kotlin.Unit> origin=IMPLICIT_CAST typeOperand=kotlin.Function0<kotlin.Unit>
             GET_VAR 'a: T of <root>.test7a declared in <root>.test7a' type=T of <root>.test7a origin=null
   FUN name:test7b visibility:public modality:FINAL <T> (a:T of <root>.test7b) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Unit>; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Unit>; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7b
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null
@@ -158,7 +158,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:test7c visibility:public modality:FINAL <T> (a:T of <root>.test7c) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Unrelated; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Unrelated; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7c
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null

compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.ir.txt

@@ -17,7 +17,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:id visibility:public modality:FINAL <T> (x:T of <root>.id) returnType:T of <root>.id
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:x index:0 type:T of <root>.id
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun id <T> (x: T of <root>.id): T of <root>.id declared in <root>'
@@ -30,7 +30,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
     VALUE_PARAMETER name:r2 index:1 type:<root>.KRunnable
     BLOCK_BODY
   FUN name:test0 visibility:public modality:FINAL <T> (a:T of <root>.test0) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.KRunnable; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.KRunnable; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test0
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null
@@ -127,7 +127,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
           TYPE_OP type=kotlin.Function0<kotlin.Unit> origin=IMPLICIT_CAST typeOperand=kotlin.Function0<kotlin.Unit>
             GET_VAR 'a: kotlin.Function1<kotlin.Int, kotlin.Int> declared in <root>.test7' type=kotlin.Function1<kotlin.Int, kotlin.Int> origin=null
   FUN name:test7a visibility:public modality:FINAL <T> (a:T of <root>.test7a) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Int>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Int>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7a
     BLOCK_BODY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit
@@ -138,7 +138,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
           TYPE_OP type=kotlin.Function0<kotlin.Unit> origin=IMPLICIT_CAST typeOperand=kotlin.Function0<kotlin.Unit>
             GET_VAR 'a: T of <root>.test7a declared in <root>.test7a' type=T of <root>.test7a origin=null
   FUN name:test7b visibility:public modality:FINAL <T> (a:T of <root>.test7b) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Unit>; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Function1<kotlin.Int, kotlin.Unit>; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7b
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null
@@ -160,7 +160,7 @@ FILE fqName:<root> fileName:/samConversionsWithSmartCasts.kt
         public open fun toString (): kotlin.String declared in kotlin.Any
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   FUN name:test7c visibility:public modality:FINAL <T> (a:T of <root>.test7c) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Unrelated; kotlin.Function0<kotlin.Unit>]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[<root>.Unrelated; kotlin.Function0<kotlin.Unit>] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test7c
     BLOCK_BODY
       CALL 'public final fun run1 (r: <root>.KRunnable): kotlin.Unit declared in <root>' type=kotlin.Unit origin=null

compiler/testData/ir/irText/expressions/funInterfaceConstructorReference.fir.ir.txt

@@ -21,7 +21,7 @@ FILE fqName:<root> fileName:/funInterfaceConstructorReference.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:KSupplier modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.KSupplier<T of <root>.KSupplier>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:get visibility:public modality:ABSTRACT <> ($this:<root>.KSupplier<T of <root>.KSupplier>) returnType:T of <root>.KSupplier
       $this: VALUE_PARAMETER name:<this> type:<root>.KSupplier<T of <root>.KSupplier>
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
@@ -39,7 +39,7 @@ FILE fqName:<root> fileName:/funInterfaceConstructorReference.kt
       $this: VALUE_PARAMETER name:<this> type:kotlin.Any
   CLASS INTERFACE name:KConsumer modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.KConsumer<T of <root>.KConsumer>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:accept visibility:public modality:ABSTRACT <> ($this:<root>.KConsumer<T of <root>.KConsumer>, x:T of <root>.KConsumer) returnType:kotlin.Unit
       $this: VALUE_PARAMETER name:<this> type:<root>.KConsumer<T of <root>.KConsumer>
       VALUE_PARAMETER name:x index:0 type:T of <root>.KConsumer

compiler/testData/ir/irText/expressions/funInterfaceConstructorReference.ir.txt

@@ -19,7 +19,7 @@ FILE fqName:<root> fileName:/funInterfaceConstructorReference.kt
   TYPEALIAS name:KR visibility:public expandedType:<root>.KRunnable
   CLASS INTERFACE name:KSupplier modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.KSupplier<T of <root>.KSupplier>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:get visibility:public modality:ABSTRACT <> ($this:<root>.KSupplier<T of <root>.KSupplier>) returnType:T of <root>.KSupplier
       $this: VALUE_PARAMETER name:<this> type:<root>.KSupplier<T of <root>.KSupplier>
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
@@ -38,7 +38,7 @@ FILE fqName:<root> fileName:/funInterfaceConstructorReference.kt
   TYPEALIAS name:KSS visibility:public expandedType:<root>.KSupplier<kotlin.String>
   CLASS INTERFACE name:KConsumer modality:ABSTRACT visibility:public [fun] superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.KConsumer<T of <root>.KConsumer>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN name:accept visibility:public modality:ABSTRACT <> ($this:<root>.KConsumer<T of <root>.KConsumer>, x:T of <root>.KConsumer) returnType:kotlin.Unit
       $this: VALUE_PARAMETER name:<this> type:<root>.KConsumer<T of <root>.KConsumer>
       VALUE_PARAMETER name:x index:0 type:T of <root>.KConsumer

compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.fir.ir.txt

@@ -6,7 +6,7 @@ FILE fqName:<root> fileName:/genericConstructorCallWithTypeArguments.kt
           <class: T>: kotlin.Long
           value: CONST Long type=kotlin.Long value=6
   FUN name:testArray visibility:public modality:FINAL <T> (n:kotlin.Int, block:kotlin.Function0<T of <root>.testArray>) returnType:kotlin.Array<T of <root>.testArray> [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:n index:0 type:kotlin.Int
     VALUE_PARAMETER name:block index:1 type:kotlin.Function0<T of <root>.testArray> [crossinline]
     BLOCK_BODY
@@ -23,7 +23,7 @@ FILE fqName:<root> fileName:/genericConstructorCallWithTypeArguments.kt
                     $this: GET_VAR 'block: kotlin.Function0<T of <root>.testArray> [crossinline] declared in <root>.testArray' type=kotlin.Function0<T of <root>.testArray> origin=VARIABLE_AS_FUNCTION
   CLASS CLASS name:Box modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Box<T of <root>.Box>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Box) returnType:<root>.Box<T of <root>.Box> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Box
       BLOCK_BODY

compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.ir.txt

@@ -8,7 +8,7 @@ FILE fqName:<root> fileName:/genericConstructorCallWithTypeArguments.kt
             $this: CONST Long type=kotlin.Long value=2
             other: CONST Int type=kotlin.Int value=3
   FUN name:testArray visibility:public modality:FINAL <T> (n:kotlin.Int, block:kotlin.Function0<T of <root>.testArray>) returnType:kotlin.Array<T of <root>.testArray> [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:true
     VALUE_PARAMETER name:n index:0 type:kotlin.Int
     VALUE_PARAMETER name:block index:1 type:kotlin.Function0<T of <root>.testArray> [crossinline]
     BLOCK_BODY
@@ -25,7 +25,7 @@ FILE fqName:<root> fileName:/genericConstructorCallWithTypeArguments.kt
                     $this: GET_VAR 'block: kotlin.Function0<T of <root>.testArray> [crossinline] declared in <root>.testArray' type=kotlin.Function0<T of <root>.testArray> origin=VARIABLE_AS_FUNCTION
   CLASS CLASS name:Box modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Box<T of <root>.Box>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Box) returnType:<root>.Box<T of <root>.Box> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Box
       BLOCK_BODY

compiler/testData/ir/irText/expressions/genericPropertyCall.ir.txt

@@ -2,7 +2,7 @@ FILE fqName:<root> fileName:/genericPropertyCall.kt
   PROPERTY name:id visibility:public modality:FINAL [val]
     FUN name:<get-id> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-id>) returnType:T of <root>.<get-id>
       correspondingProperty: PROPERTY name:id visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-id>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-id> <T> (): T of <root>.<get-id> declared in <root>'

compiler/testData/ir/irText/expressions/genericPropertyRef.fir.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericPropertyRef.kt
   CLASS CLASS name:Value modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Value<T of <root>.Value>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Value, text:kotlin.String?) returnType:<root>.Value<T of <root>.Value> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Value
         EXPRESSION_BODY
@@ -71,7 +71,7 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
           kmember: PROPERTY_REFERENCE 'public final text: kotlin.String? [var]' field=null getter='public final fun <get-text> (): kotlin.String? declared in <root>.Value' setter='public final fun <set-text> (<set-?>: kotlin.String?): kotlin.Unit declared in <root>.Value' type=kotlin.reflect.KMutableProperty1<<root>.Value<T of <root>.<get-additionalText>>, kotlin.String?> origin=null
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-additionalText> visibility:public modality:FINAL <T> ($receiver:<root>.Value<T of <root>.<get-additionalText>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:additionalText visibility:public modality:FINAL [delegated,val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalText>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-additionalText> <T> (): kotlin.Int declared in <root>'
@@ -87,7 +87,7 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
           kmember: PROPERTY_REFERENCE 'public final value: T of <root>.Value [var]' field=null getter='public final fun <get-value> (): T of <root>.Value declared in <root>.Value' setter='public final fun <set-value> (<set-?>: T of <root>.Value): kotlin.Unit declared in <root>.Value' type=kotlin.reflect.KMutableProperty1<<root>.Value<T of <root>.<get-additionalValue>>, T of <root>.<get-additionalValue>> origin=null
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-additionalValue> visibility:public modality:FINAL <T> ($receiver:<root>.Value<T of <root>.<get-additionalValue>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:additionalValue visibility:public modality:FINAL [delegated,val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalValue>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-additionalValue> <T> (): kotlin.Int declared in <root>'
@@ -167,14 +167,14 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
   PROPERTY name:bar visibility:public modality:FINAL [var]
     FUN name:<get-bar> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-bar>) returnType:T of <root>.<get-bar>
       correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-bar>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-bar> <T> (): T of <root>.<get-bar> declared in <root>'
           GET_VAR '<this>: T of <root>.<get-bar> declared in <root>.<get-bar>' type=T of <root>.<get-bar> origin=null
     FUN name:<set-bar> visibility:public modality:FINAL <T> ($receiver:T of <root>.<set-bar>, value:T of <root>.<get-bar>) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<set-bar>
       VALUE_PARAMETER name:value index:0 type:T of <root>.<get-bar>
       BLOCK_BODY

compiler/testData/ir/irText/expressions/genericPropertyRef.ir.txt

@@ -1,7 +1,7 @@
 FILE fqName:<root> fileName:/genericPropertyRef.kt
   CLASS CLASS name:Value modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Value<T of <root>.Value>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> (value:T of <root>.Value, text:kotlin.String?) returnType:<root>.Value<T of <root>.Value> [primary]
       VALUE_PARAMETER name:value index:0 type:T of <root>.Value
         EXPRESSION_BODY
@@ -71,7 +71,7 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
           kmember: PROPERTY_REFERENCE 'public final text: kotlin.String? [var]' field=null getter='public final fun <get-text> (): kotlin.String? declared in <root>.Value' setter='public final fun <set-text> (<set-?>: kotlin.String?): kotlin.Unit declared in <root>.Value' type=kotlin.reflect.KMutableProperty1<<root>.Value<kotlin.Any?>, kotlin.String?> origin=null
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-additionalText> visibility:public modality:FINAL <T> ($receiver:<root>.Value<T of <root>.<get-additionalText>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:additionalText visibility:public modality:FINAL [delegated,val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalText>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-additionalText> <T> (): kotlin.Int declared in <root>'
@@ -87,7 +87,7 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
           kmember: PROPERTY_REFERENCE 'public final value: T of <root>.Value [var]' field=null getter='public final fun <get-value> (): T of <root>.Value declared in <root>.Value' setter='public final fun <set-value> (<set-?>: T of <root>.Value): kotlin.Unit declared in <root>.Value' type=kotlin.reflect.KMutableProperty1<<root>.Value<kotlin.Any?>, kotlin.Any?> origin=null
     FUN DELEGATED_PROPERTY_ACCESSOR name:<get-additionalValue> visibility:public modality:FINAL <T> ($receiver:<root>.Value<T of <root>.<get-additionalValue>>) returnType:kotlin.Int
       correspondingProperty: PROPERTY name:additionalValue visibility:public modality:FINAL [delegated,val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Value<T of <root>.<get-additionalValue>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-additionalValue> <T> (): kotlin.Int declared in <root>'
@@ -167,14 +167,14 @@ FILE fqName:<root> fileName:/genericPropertyRef.kt
   PROPERTY name:bar visibility:public modality:FINAL [var]
     FUN name:<get-bar> visibility:public modality:FINAL <T> ($receiver:T of <root>.<get-bar>) returnType:T of <root>.<get-bar>
       correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<get-bar>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-bar> <T> (): T of <root>.<get-bar> declared in <root>'
           GET_VAR '<this>: T of <root>.<get-bar> declared in <root>.<get-bar>' type=T of <root>.<get-bar> origin=null
     FUN name:<set-bar> visibility:public modality:FINAL <T> ($receiver:T of <root>.<set-bar>, value:T of <root>.<set-bar>) returnType:kotlin.Unit
       correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [var]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
       $receiver: VALUE_PARAMETER name:<this> type:T of <root>.<set-bar>
       VALUE_PARAMETER name:value index:0 type:T of <root>.<set-bar>
       BLOCK_BODY

compiler/testData/ir/irText/expressions/implicitCastToNonNull.ir.txt

@@ -14,7 +14,7 @@ FILE fqName:<root> fileName:/implicitCastToNonNull.kt
             then: CALL 'public open fun <get-length> (): kotlin.Int declared in kotlin.String' type=kotlin.Int origin=GET_PROPERTY
               $this: GET_VAR 'x: kotlin.String? declared in <root>.test1' type=kotlin.String? origin=null
   FUN name:test2 visibility:public modality:FINAL <T> (x:T of <root>.test2) returnType:kotlin.Int
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence?] reified:false
     VALUE_PARAMETER name:x index:0 type:T of <root>.test2
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test2 <T> (x: T of <root>.test2): kotlin.Int declared in <root>'
@@ -29,7 +29,7 @@ FILE fqName:<root> fileName:/implicitCastToNonNull.kt
             then: CALL 'public abstract fun <get-length> (): kotlin.Int declared in kotlin.CharSequence' type=kotlin.Int origin=GET_PROPERTY
               $this: GET_VAR 'x: T of <root>.test2 declared in <root>.test2' type=T of <root>.test2 origin=null
   FUN name:test3 visibility:public modality:FINAL <T> (x:kotlin.Any) returnType:kotlin.Int [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence?] reified:true
     VALUE_PARAMETER name:x index:0 type:kotlin.Any
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test3 <T> (x: kotlin.Any): kotlin.Int [inline] declared in <root>'
@@ -44,7 +44,7 @@ FILE fqName:<root> fileName:/implicitCastToNonNull.kt
               $this: TYPE_OP type={T of <root>.test3 & Any} origin=IMPLICIT_CAST typeOperand={T of <root>.test3 & Any}
                 GET_VAR 'x: kotlin.Any declared in <root>.test3' type=kotlin.Any origin=null
   FUN name:test4 visibility:public modality:FINAL <T> (x:kotlin.Any?) returnType:kotlin.Int [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.CharSequence] reified:true
     VALUE_PARAMETER name:x index:0 type:kotlin.Any?
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test4 <T> (x: kotlin.Any?): kotlin.Int [inline] declared in <root>'
@@ -59,8 +59,8 @@ FILE fqName:<root> fileName:/implicitCastToNonNull.kt
               $this: TYPE_OP type=T of <root>.test4 origin=IMPLICIT_CAST typeOperand=T of <root>.test4
                 GET_VAR 'x: kotlin.Any? declared in <root>.test4' type=kotlin.Any? origin=null
   FUN name:test5 visibility:public modality:FINAL <T, S> (x:T of <root>.test5, fn:kotlin.Function1<S of <root>.test5, kotlin.Unit>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[S of <root>.test5?]
-    TYPE_PARAMETER name:S index:1 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[S of <root>.test5?] reified:false
+    TYPE_PARAMETER name:S index:1 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:x index:0 type:T of <root>.test5
     VALUE_PARAMETER name:fn index:1 type:kotlin.Function1<S of <root>.test5, kotlin.Unit>
     BLOCK_BODY

compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.fir.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
   FUN name:test1 visibility:public modality:FINAL <T> ($receiver:kotlin.Any) returnType:T of <root>.test1? [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:true
     $receiver: VALUE_PARAMETER name:<this> type:kotlin.Any
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test1 <T> (): T of <root>.test1? [inline] declared in <root>'
@@ -15,7 +15,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
             then: CONST Null type=kotlin.Nothing? value=null
   CLASS INTERFACE name:Foo modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Foo<T of <root>.Foo>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -32,7 +32,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
   PROPERTY name:asT visibility:public modality:FINAL [val]
     FUN name:<get-asT> visibility:public modality:FINAL <T> ($receiver:<root>.Foo<T of <root>.<get-asT>>) returnType:T of <root>.<get-asT>? [inline]
       correspondingProperty: PROPERTY name:asT visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:true
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Foo<T of <root>.<get-asT>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-asT> <T> (): T of <root>.<get-asT>? [inline] declared in <root>'
@@ -47,7 +47,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
               then: CONST Null type=kotlin.Nothing? value=null
   CLASS CLASS name:Bar modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Bar<T of <root>.Bar>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Bar<T of <root>.Bar> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
   FUN name:test1 visibility:public modality:FINAL <T> ($receiver:kotlin.Any) returnType:T of <root>.test1? [inline]
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:true
     $receiver: VALUE_PARAMETER name:<this> type:kotlin.Any
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun test1 <T> (): T of <root>.test1? [inline] declared in <root>'
@@ -15,7 +15,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
             then: CONST Null type=kotlin.Nothing? value=null
   CLASS INTERFACE name:Foo modality:ABSTRACT visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Foo<T of <root>.Foo>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator]
       overridden:
         public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any
@@ -32,7 +32,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
   PROPERTY name:asT visibility:public modality:FINAL [val]
     FUN name:<get-asT> visibility:public modality:FINAL <T> ($receiver:<root>.Foo<T of <root>.<get-asT>>) returnType:T of <root>.<get-asT>? [inline]
       correspondingProperty: PROPERTY name:asT visibility:public modality:FINAL [val]
-      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any]
+      TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any] reified:true
       $receiver: VALUE_PARAMETER name:<this> type:<root>.Foo<T of <root>.<get-asT>>
       BLOCK_BODY
         RETURN type=kotlin.Nothing from='public final fun <get-asT> <T> (): T of <root>.<get-asT>? [inline] declared in <root>'
@@ -47,7 +47,7 @@ FILE fqName:<root> fileName:/implicitCastToTypeParameter.kt
               then: CONST Null type=kotlin.Nothing? value=null
   CLASS CLASS name:Bar modality:FINAL visibility:public superTypes:[kotlin.Any]
     $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.Bar<T of <root>.Bar>
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     CONSTRUCTOR visibility:public <> () returnType:<root>.Bar<T of <root>.Bar> [primary]
       BLOCK_BODY
         DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'

compiler/testData/ir/irText/expressions/in.fir.ir.txt

@@ -17,7 +17,7 @@ FILE fqName:<root> fileName:/in.kt
             $this: GET_VAR 'x: kotlin.collections.Collection<kotlin.Any> declared in <root>.test2' type=kotlin.collections.Collection<kotlin.Any> origin=null
             element: GET_VAR 'a: kotlin.Any declared in <root>.test2' type=kotlin.Any origin=null
   FUN name:test3 visibility:public modality:FINAL <T> (a:T of <root>.test3, x:kotlin.collections.Collection<T of <root>.test3>) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test3
     VALUE_PARAMETER name:x index:1 type:kotlin.collections.Collection<T of <root>.test3>
     BLOCK_BODY
@@ -26,7 +26,7 @@ FILE fqName:<root> fileName:/in.kt
           $this: GET_VAR 'x: kotlin.collections.Collection<T of <root>.test3> declared in <root>.test3' type=kotlin.collections.Collection<T of <root>.test3> origin=null
           element: GET_VAR 'a: T of <root>.test3 declared in <root>.test3' type=T of <root>.test3 origin=null
   FUN name:test4 visibility:public modality:FINAL <T> (a:T of <root>.test4, x:kotlin.collections.Collection<T of <root>.test4>) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test4
     VALUE_PARAMETER name:x index:1 type:kotlin.collections.Collection<T of <root>.test4>
     BLOCK_BODY

compiler/testData/ir/irText/expressions/in.ir.txt

@@ -17,7 +17,7 @@ FILE fqName:<root> fileName:/in.kt
             $this: GET_VAR 'x: kotlin.collections.Collection<kotlin.Any> declared in <root>.test2' type=kotlin.collections.Collection<kotlin.Any> origin=null
             element: GET_VAR 'a: kotlin.Any declared in <root>.test2' type=kotlin.Any origin=null
   FUN name:test3 visibility:public modality:FINAL <T> (a:T of <root>.test3, x:kotlin.collections.Collection<T of <root>.test3>) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test3
     VALUE_PARAMETER name:x index:1 type:kotlin.collections.Collection<T of <root>.test3>
     BLOCK_BODY
@@ -26,7 +26,7 @@ FILE fqName:<root> fileName:/in.kt
           $this: GET_VAR 'x: kotlin.collections.Collection<T of <root>.test3> declared in <root>.test3' type=kotlin.collections.Collection<T of <root>.test3> origin=null
           element: GET_VAR 'a: T of <root>.test3 declared in <root>.test3' type=T of <root>.test3 origin=null
   FUN name:test4 visibility:public modality:FINAL <T> (a:T of <root>.test4, x:kotlin.collections.Collection<T of <root>.test4>) returnType:kotlin.Boolean
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:a index:0 type:T of <root>.test4
     VALUE_PARAMETER name:x index:1 type:kotlin.collections.Collection<T of <root>.test4>
     BLOCK_BODY

compiler/testData/ir/irText/expressions/javaSyntheticGenericPropretyAccess.fir.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/javaSyntheticGenericPropertyAccess.kt
   FUN name:test visibility:public modality:FINAL <F> (j:<root>.J<F of <root>.test>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:F index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:F index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:j index:0 type:<root>.J<F of <root>.test>
     BLOCK_BODY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit

compiler/testData/ir/irText/expressions/javaSyntheticGenericPropretyAccess.ir.txt

@@ -1,6 +1,6 @@
 FILE fqName:<root> fileName:/javaSyntheticGenericPropertyAccess.kt
   FUN name:test visibility:public modality:FINAL <F> (j:<root>.J<F of <root>.test>) returnType:kotlin.Unit
-    TYPE_PARAMETER name:F index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:F index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:j index:0 type:<root>.J<F of <root>.test>
     BLOCK_BODY
       TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit

compiler/testData/ir/irText/expressions/kt30796.fir.ir.txt

@@ -1,12 +1,12 @@
 FILE fqName:<root> fileName:/kt30796.kt
   FUN name:magic visibility:public modality:FINAL <T> () returnType:T of <root>.magic
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
       RETURN type=kotlin.Nothing from='public final fun magic <T> (): T of <root>.magic declared in <root>'
         THROW type=kotlin.Nothing
           CONSTRUCTOR_CALL 'public constructor <init> () declared in java.lang.Exception' type=java.lang.Exception origin=null
   FUN name:test visibility:public modality:FINAL <T> (value:T of <root>.test, value2:T of <root>.test) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:value index:0 type:T of <root>.test
     VALUE_PARAMETER name:value2 index:1 type:T of <root>.test
     BLOCK_BODY

compiler/testData/ir/irText/expressions/kt30796.ir.txt

@@ -1,11 +1,11 @@
 FILE fqName:<root> fileName:/kt30796.kt
   FUN name:magic visibility:public modality:FINAL <T> () returnType:T of <root>.magic
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     BLOCK_BODY
       THROW type=kotlin.Nothing
         CONSTRUCTOR_CALL 'public constructor <init> () declared in java.lang.Exception' type=java.lang.Exception origin=null
   FUN name:test visibility:public modality:FINAL <T> (value:T of <root>.test, value2:T of <root>.test) returnType:kotlin.Unit
-    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?]
+    TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] reified:false
     VALUE_PARAMETER name:value index:0 type:T of <root>.test
     VALUE_PARAMETER name:value2 index:1 type:T of <root>.test
     BLOCK_BODY