From 5b70d39bd0e36a427683ef0bc56e68fa22d7a376 Mon Sep 17 00:00:00 2001 From: Alexander Korepanov Date: Fri, 28 Oct 2022 23:50:32 +0200 Subject: [PATCH] [JS IR] Move id signature functions into a separate file --- .../kotlin/ir/backend/js/ic/CacheUpdater.kt | 97 +------------------ .../js/ic/IdSignatureHashCalculator.kt | 10 +- .../ir/backend/js/ic/IdSignatureSource.kt | 93 ++++++++++++++++++ 3 files changed, 104 insertions(+), 96 deletions(-) create mode 100644 compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureSource.kt diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt index be14413a5ac..54bf602122b 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt @@ -251,100 +251,13 @@ class CacheUpdater( return exportedSymbols } - private fun resolveFakeOverrideFunction(symbol: IrSymbol): IdSignature? { - return (symbol.owner as? IrSimpleFunction)?.let { overridable -> - if (overridable.isFakeOverride) { - overridable.resolveFakeOverride()?.symbol?.signature - } else { - null - } - } - } - - private fun collectImplementedSymbol(deserializedSymbols: Map): Map { - return HashMap(deserializedSymbols.size).apply { - for ((signature, symbol) in deserializedSymbols) { - put(signature, symbol) - - fun addSymbol(decl: T): Boolean where T : IrDeclarationWithVisibility, T : IrSymbolOwner { - when (decl.visibility) { - DescriptorVisibilities.LOCAL -> return false - DescriptorVisibilities.PRIVATE -> return false - DescriptorVisibilities.PRIVATE_TO_THIS -> return false - } - - val sig = decl.symbol.signature - if (sig != null && sig !in deserializedSymbols) { - return put(sig, decl.symbol) == null - } - return false - } - - fun addNestedDeclarations(irClass: IrClass) { - for (decl in irClass.declarations) { - when (decl) { - is IrSimpleFunction -> addSymbol(decl) - is IrProperty -> { - decl.getter?.let(::addSymbol) - decl.setter?.let(::addSymbol) - } - - is IrClass -> { - if (addSymbol(decl)) { - addNestedDeclarations(decl) - } - } - } - } - } - - (symbol.owner as? IrClass)?.let(::addNestedDeclarations) - } - } - } - - private data class SignatureSource(val lib: KotlinLibraryFile, val src: KotlinSourceFile, val symbol: IrSymbol) - - private fun addParentSignatures( - signatures: Collection, - idSignatureToFile: Map, - importerLibFile: KotlinLibraryFile, - importerSrcFile: KotlinSourceFile - ): Set { - val allSignatures = HashSet(signatures.size) - - fun addAllParents(sig: IdSignature) { - val signatureSrc = idSignatureToFile[sig] ?: return - if (signatureSrc.lib == importerLibFile && signatureSrc.src == importerSrcFile) { - return - } - if (allSignatures.add(sig)) { - (signatureSrc.symbol.owner as? IrDeclaration)?.let { declaration -> - (declaration.parent as? IrSymbolOwner)?.let { parent -> - parent.symbol.signature?.let(::addAllParents) - } - } - } - } - - signatures.forEach(::addAllParents) - - return allSignatures - } - - private fun IdSignatureHashCalculator.addAllSignatureSymbols(idSignatureToFile: Map) { - for ((signature, signatureSrc) in idSignatureToFile) { - addHashForSignatureIfNotExist(signature, signatureSrc.symbol) - } - } - private fun KotlinSourceFileMutableMap.getExportedSignaturesAndAddMetadata( jsIrLinker: JsIrLinker, irModule: IrModuleFragment, libFile: KotlinLibraryFile, dirtySrcFiles: Set - ): Map { - val idSignatureToFile = hashMapOf() + ): Map { + val idSignatureToFile = hashMapOf() val moduleDeserializer = jsIrLinker.moduleDeserializer(irModule.descriptor) val incrementalCache = getLibIncrementalCache(libFile) for (fileDeserializer in moduleDeserializer.fileDeserializers()) { @@ -360,7 +273,7 @@ class CacheUpdater( symbolCanBeExported = true } if (symbolCanBeExported) { - idSignatureToFile[signature] = SignatureSource(libFile, KotlinSourceFile(fileDeserializer.file), symbol) + idSignatureToFile[signature] = IdSignatureSource(libFile, KotlinSourceFile(fileDeserializer.file), symbol) } } @@ -375,7 +288,7 @@ class CacheUpdater( private fun DirtyFileMetadata.setAllDependencies( signatureHashCalculator: IdSignatureHashCalculator, - idSignatureToFile: Map, + idSignatureToFile: Map, updatedMetadata: KotlinSourceFileMap, libFile: KotlinLibraryFile, srcFile: KotlinSourceFile @@ -399,7 +312,7 @@ class CacheUpdater( loadedFragments: Map, dirtySrcFiles: KotlinSourceFileMap, ): KotlinSourceFileMap { - val idSignatureToFile = hashMapOf() + val idSignatureToFile = hashMapOf() val updatedMetadata = KotlinSourceFileMutableMap() for ((lib, irModule) in loadedFragments) { diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt index 3712cd0da1d..0e67655d82e 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureHashCalculator.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.ir.visitors.acceptVoid -class IdSignatureHashCalculator { +internal class IdSignatureHashCalculator { private val flatHashes = hashMapOf() private val inlineFunctionCallGraph = hashMapOf>() private val processingFunctions = hashSetOf() @@ -124,9 +124,11 @@ class IdSignatureHashCalculator { updateTransitiveHashesByCallGraph() } - fun addHashForSignatureIfNotExist(signature: IdSignature, symbol: IrSymbol) { - if (signature !in allIdSignatureHashes) { - allIdSignatureHashes[signature] = symbol.irSymbolHashForIC() + fun addAllSignatureSymbols(idSignatureToFile: Map) { + for ((signature, signatureSrc) in idSignatureToFile) { + if (signature !in allIdSignatureHashes) { + allIdSignatureHashes[signature] = signatureSrc.symbol.irSymbolHashForIC() + } } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureSource.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureSource.kt new file mode 100644 index 00000000000..39fcd2619d1 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IdSignatureSource.kt @@ -0,0 +1,93 @@ +/* + * 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.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.util.IdSignature +import org.jetbrains.kotlin.ir.util.resolveFakeOverride + +internal data class IdSignatureSource(val lib: KotlinLibraryFile, val src: KotlinSourceFile, val symbol: IrSymbol) + +internal fun addParentSignatures( + signatures: Collection, + idSignatureToFile: Map, + importerLibFile: KotlinLibraryFile, + importerSrcFile: KotlinSourceFile +): Set { + val allSignatures = HashSet(signatures.size) + + fun addAllParents(sig: IdSignature) { + val signatureSrc = idSignatureToFile[sig] ?: return + if (signatureSrc.lib == importerLibFile && signatureSrc.src == importerSrcFile) { + return + } + if (allSignatures.add(sig)) { + (signatureSrc.symbol.owner as? IrDeclaration)?.let { declaration -> + (declaration.parent as? IrSymbolOwner)?.let { parent -> + parent.symbol.signature?.let(::addAllParents) + } + } + } + } + + signatures.forEach(::addAllParents) + + return allSignatures +} + +internal fun resolveFakeOverrideFunction(symbol: IrSymbol): IdSignature? { + return (symbol.owner as? IrSimpleFunction)?.let { overridable -> + if (overridable.isFakeOverride) { + overridable.resolveFakeOverride()?.symbol?.signature + } else { + null + } + } +} + +internal fun collectImplementedSymbol(deserializedSymbols: Map): Map { + return HashMap(deserializedSymbols.size).apply { + for ((signature, symbol) in deserializedSymbols) { + put(signature, symbol) + + fun addSymbol(decl: T): Boolean where T : IrDeclarationWithVisibility, T : IrSymbolOwner { + when (decl.visibility) { + DescriptorVisibilities.LOCAL -> return false + DescriptorVisibilities.PRIVATE -> return false + DescriptorVisibilities.PRIVATE_TO_THIS -> return false + } + + val sig = decl.symbol.signature + if (sig != null && sig !in deserializedSymbols) { + return put(sig, decl.symbol) == null + } + return false + } + + fun addNestedDeclarations(irClass: IrClass) { + for (decl in irClass.declarations) { + when (decl) { + is IrSimpleFunction -> addSymbol(decl) + is IrProperty -> { + decl.getter?.let(::addSymbol) + decl.setter?.let(::addSymbol) + } + + is IrClass -> { + if (addSymbol(decl)) { + addNestedDeclarations(decl) + } + } + } + } + } + + (symbol.owner as? IrClass)?.let(::addNestedDeclarations) + } + } +}