diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt index c018295def0..928ac465959 100644 --- a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt +++ b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt @@ -213,43 +213,42 @@ class K2JsIrCompiler : CLICompiler() { messageCollector.report(INFO, arguments.cacheDirectories ?: "") messageCollector.report(INFO, libraries.toString()) - val includes = arguments.includes!! - - var start = System.currentTimeMillis() + val start = System.currentTimeMillis() val cacheUpdater = CacheUpdater( - includes, - libraries, - configurationJs, - cacheDirectories, - { IrFactoryImplForJsIC(WholeWorldStageController()) }, - mainCallArguments, - ::buildCacheForModuleFiles + mainModule = arguments.includes!!, + allModules = libraries, + icCachePaths = cacheDirectories, + compilerConfiguration = configurationJs, + irFactory = { IrFactoryImplForJsIC(WholeWorldStageController()) }, + mainArguments = mainCallArguments, + executor = ::buildCacheForModuleFiles ) - cacheUpdater.actualizeCaches { updateStatus, updatedModule -> + + var tp = System.currentTimeMillis() + messageCollector.report(INFO, "IC cache updater initialization: ${tp - start}ms") + + val artifacts = cacheUpdater.actualizeCaches { val now = System.currentTimeMillis() - fun reportCacheStatus(status: String, removed: Set = emptySet(), updated: Set = 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 $it: ${now - tp}ms") + tp = now + } + + messageCollector.report(INFO, "IC rebuilt overall time: ${System.currentTimeMillis() - start}ms") + + for ((libFile, srcFiles) in cacheUpdater.getDirtyFileStats()) { + val isCleanBuild = srcFiles.values.all { it.contains(DirtyFileState.ADDED_FILE) } + val msg = if (isCleanBuild) "fully rebuilt" else "partially rebuilt" + messageCollector.report(INFO, "module [${File(libFile.path).name}] was $msg") + if (!isCleanBuild) { + for ((srcFile, stat) in srcFiles) { + val statStr = stat.joinToString { it.str } + messageCollector.report(INFO, " file [${File(srcFile.path).name}]: ($statStr)") } } - start = now } + + artifacts } else emptyList() // Run analysis if main module is sources diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt index 5f10ea98b1c..3a8334704f4 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsIrBackendContext.kt @@ -50,6 +50,12 @@ import org.jetbrains.kotlin.types.isNullable import org.jetbrains.kotlin.util.collectionUtils.filterIsInstanceMapNotNull import org.jetbrains.kotlin.utils.addToStdlib.cast +enum class IcCompatibleIr2Js(val isCompatible: Boolean, val incrementalCacheEnabled: Boolean) { + DISABLED(false, false), + COMPATIBLE(true, false), + IC_MODE(true, true) +} + class JsIrBackendContext( val module: ModuleDescriptor, override val irBuiltIns: IrBuiltIns, @@ -65,7 +71,7 @@ class JsIrBackendContext( val safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null, override val mapping: JsMapping = JsMapping(), val granularity: JsGenerationGranularity = JsGenerationGranularity.WHOLE_PROGRAM, - val icCompatibleIr2Js: Boolean = false, + val icCompatibleIr2Js: IcCompatibleIr2Js = IcCompatibleIr2Js.DISABLED, ) : JsCommonBackendContext { val polyfills = JsPolyfills() val fieldToInitializer: MutableMap = mutableMapOf() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt index 0a13b40eeaf..673f815c9f7 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt @@ -128,7 +128,7 @@ fun compileIr( safeExternalBoolean = safeExternalBoolean, safeExternalBooleanDiagnostic = safeExternalBooleanDiagnostic, granularity = granularity, - icCompatibleIr2Js = icCompatibleIr2Js, + icCompatibleIr2Js = if (icCompatibleIr2Js) IcCompatibleIr2Js.COMPATIBLE else IcCompatibleIr2Js.DISABLED ) // Load declarations referenced during `context` initialization @@ -166,4 +166,4 @@ fun generateJsCode( val transformer = IrModuleToJsTransformer(context, null, true, nameTables) return transformer.generateModule(listOf(moduleFragment)).outputs[TranslationMode.FULL]!!.jsCode -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compilerWithIC.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compilerWithIC.kt index 9efe2265333..faf602e78a9 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compilerWithIC.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compilerWithIC.kt @@ -9,29 +9,27 @@ 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.ArtifactCache -import org.jetbrains.kotlin.ir.backend.js.ic.JsMultiModuleCache -import org.jetbrains.kotlin.ir.backend.js.ic.ModuleArtifact 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 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.* +import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.util.ExternalDependenciesGenerator import org.jetbrains.kotlin.ir.util.noUnboundLeft import org.jetbrains.kotlin.js.config.RuntimeDiagnostic import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi2ir.descriptors.IrBuiltInsOverDescriptors -import org.jetbrains.kotlin.serialization.js.ModuleKind @Suppress("UNUSED_PARAMETER") @OptIn(ObsoleteDescriptorBasedAPI::class) fun compileWithIC( - module: IrModuleFragment, + mainModule: IrModuleFragment, configuration: CompilerConfiguration, deserializer: JsIrLinker, - dependencies: Collection, + allModules: Collection, + filesToLower: Collection, mainArguments: List? = null, exportedDeclarations: Set = emptySet(), generateFullJs: Boolean = true, @@ -45,22 +43,16 @@ fun compileWithIC( baseClassIntoMetadata: Boolean = false, lowerPerModule: Boolean = false, safeExternalBoolean: Boolean = false, - safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null, - filesToLower: Set?, - artifactCache: ArtifactCache, -) { - - val mainModule = module - val allModules = dependencies - val moduleDescriptor = module.descriptor - val irBuiltIns = module.irBuiltins + safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null +): List { + val irBuiltIns = mainModule.irBuiltins val symbolTable = (irBuiltIns as IrBuiltInsOverDescriptors).symbolTable val context = JsIrBackendContext( - moduleDescriptor, + mainModule.descriptor, irBuiltIns, symbolTable, - module, + mainModule, exportedDeclarations, configuration, es6mode = es6mode, @@ -68,7 +60,7 @@ fun compileWithIC( baseClassIntoMetadata = baseClassIntoMetadata, safeExternalBoolean = safeExternalBoolean, safeExternalBooleanDiagnostic = safeExternalBooleanDiagnostic, - icCompatibleIr2Js = true, + icCompatibleIr2Js = IcCompatibleIr2Js.IC_MODE ) // Load declarations referenced during `context` initialization @@ -79,7 +71,7 @@ fun compileWithIC( symbolTable.noUnboundLeft("Unbound symbols at the end of linker") allModules.forEach { - collectNativeImplementations(context, module) + collectNativeImplementations(context, it) moveBodilessDeclarationsToSeparatePlace(context, it) } @@ -93,18 +85,15 @@ fun compileWithIC( relativeRequirePath = relativeRequirePath, ) - val dirtyFiles = filesToLower?.let { dirties -> - module.files.filter { it.fileEntry.name in dirties } - } ?: module.files - - val astAndFragments = transformer.generateBinaryAst(dirtyFiles, allModules) - astAndFragments.forEach { - artifactCache.saveFragment(it.srcPath, it.fragment) - artifactCache.saveBinaryAst(it.srcPath, it.binaryAst) - } + return transformer.generateBinaryAst(filesToLower, allModules) } -fun lowerPreservingTags(modules: Iterable, context: JsIrBackendContext, phaseConfig: PhaseConfig, controller: WholeWorldStageController) { +fun lowerPreservingTags( + modules: Iterable, + context: JsIrBackendContext, + phaseConfig: PhaseConfig, + controller: WholeWorldStageController +) { // Lower all the things controller.currentStage = 0 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 new file mode 100644 index 00000000000..64531be943b --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/CacheUpdater.kt @@ -0,0 +1,579 @@ +/* * 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.config.CompilerConfiguration +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.transformers.irToJs.JsIrFragmentAndBinaryAst +import org.jetbrains.kotlin.ir.declarations.IrFactory +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.util.* +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.name.FqName +import java.io.File +import java.util.EnumSet + + +fun interface CacheExecutor { + fun execute( + mainModule: IrModuleFragment, + allModules: Collection, + deserializer: JsIrLinker, + configuration: CompilerConfiguration, + dirtyFiles: Collection, + exportedDeclarations: Set, + mainArguments: List? + ): List +} + +enum class DirtyFileState(val str: String) { + ADDED_FILE("added file"), + MODIFIED_IR("modified ir"), + UPDATED_EXPORTS("updated exports"), + UPDATED_INLINE_IMPORTS("updated inline imports"), + REMOVED_INVERSE_DEPENDS("removed inverse depends"), + REMOVED_DIRECT_DEPENDS("removed direct depends"), + REMOVED_FILE("removed file") +} + +class CacheUpdater( + mainModule: String, + allModules: Collection, + icCachePaths: Collection, + private val compilerConfiguration: CompilerConfiguration, + private val irFactory: () -> IrFactory, + private val mainArguments: List?, + private val executor: CacheExecutor +) { + private val hashCalculator = InlineFunctionTransitiveHashCalculator() + private val transitiveHashes + get() = hashCalculator.transitiveHashes + + private val libraries = loadLibraries(allModules) + private val dependencyGraph = buildDependenciesGraph(libraries) + private val configHash = compilerConfiguration.configHashForIC() + + private val cacheMap = libraries.values.zip(icCachePaths).toMap() + + private val mainLibraryFile = KotlinLibraryFile(File(mainModule).canonicalPath) + private val mainLibrary = libraries[mainLibraryFile] ?: notFoundIcError("main library", mainLibraryFile) + + private val incrementalCaches = libraries.entries.associate { (libFile, lib) -> + val cachePath = cacheMap[lib] ?: notFoundIcError("cache path", KotlinLibraryFile(lib)) + libFile to IncrementalCache(lib, cachePath) + } + + private val dirtyFileStats = KotlinSourceFileMutableMap>() + + fun getDirtyFileStats(): KotlinSourceFileMap> = dirtyFileStats + + private fun MutableMap>.addDirtFileStat(srcFile: KotlinSourceFile, state: DirtyFileState) { + when (val stats = this[srcFile]) { + null -> this[srcFile] = EnumSet.of(state) + else -> stats.add(state) + } + } + + private fun getLibIncrementalCache(libFile: KotlinLibraryFile) = + incrementalCaches[libFile] ?: notFoundIcError("incremental cache", libFile) + + private fun loadLibraries(allModules: Collection): Map { + val allResolvedDependencies = jsResolveLibraries( + allModules, + compilerConfiguration[JSConfigurationKeys.REPOSITORIES] ?: emptyList(), + compilerConfiguration[IrMessageLogger.IR_MESSAGE_LOGGER].toResolverLogger() + ) + + return allResolvedDependencies.getFullList().associateBy { KotlinLibraryFile(it) } + } + + private fun buildDependenciesGraph(libraries: Map): Map> { + val nameToKotlinLibrary = libraries.values.associateBy { it.moduleName } + return libraries.values.associateWith { + it.manifestProperties.propertyList(KLIB_PROPERTY_DEPENDS, escapeInQuotes = true).map { depName -> + nameToKotlinLibrary[depName] ?: notFoundIcError("library $depName") + } + } + } + + private class DirtyFileExports( + override val inverseDependencies: KotlinSourceFileMutableMap> = KotlinSourceFileMutableMap() + ) : KotlinSourceFileExports() { + override fun getExportedSignatures(): Set = allExportedSignatures + + val allExportedSignatures = mutableSetOf() + } + + private class DirtyFileMetadata( + val maybeImportedSignatures: Collection, + + val oldDirectDependencies: KotlinSourceFileMap<*>, + + override val inverseDependencies: KotlinSourceFileMutableMap> = KotlinSourceFileMutableMap(), + override val directDependencies: KotlinSourceFileMutableMap> = KotlinSourceFileMutableMap(), + + override val importedInlineFunctions: MutableMap = mutableMapOf() + ) : KotlinSourceFileMetadata() { + fun addInverseDependency(lib: KotlinLibraryFile, src: KotlinSourceFile, signature: IdSignature) = + inverseDependencies.addSignature(lib, src, signature) + + fun addDirectDependency(lib: KotlinLibraryFile, src: KotlinSourceFile, signature: IdSignature) = + directDependencies.addSignature(lib, src, signature) + } + + private class UpdatedDependenciesMetadata(oldMetadata: KotlinSourceFileMetadata) : KotlinSourceFileMetadata() { + private val oldInverseDependencies = oldMetadata.inverseDependencies + private val newExportedSignatures: Set by lazy { inverseDependencies.flatSignatures() } + + var importedInlineFunctionsModified = false + + override val inverseDependencies = oldMetadata.inverseDependencies.toMutable() + override val directDependencies = oldMetadata.directDependencies.toMutable() + override val importedInlineFunctions = oldMetadata.importedInlineFunctions + + override fun getExportedSignatures(): Set = newExportedSignatures + + fun isExportedSignaturesUpdated() = newExportedSignatures != oldInverseDependencies.flatSignatures() + } + + private fun addFilesWithRemovedDependencies( + modifiedFiles: KotlinSourceFileMap, removedFiles: KotlinSourceFileMap + ): KotlinSourceFileMap { + val extraModifiedLibFiles = KotlinSourceFileMutableMap() + + fun addDependenciesToExtraModifiedFiles(dependencies: KotlinSourceFileMap<*>, dirtyState: DirtyFileState) { + for ((dependentLib, dependentFiles) in dependencies) { + val dependentCache = incrementalCaches[dependentLib] ?: continue + val alreadyModifiedFiles = modifiedFiles[dependentLib] ?: emptyMap() + val alreadyRemovedFiles = removedFiles[dependentLib] ?: emptyMap() + val extraModifiedFiles by lazy(LazyThreadSafetyMode.NONE) { extraModifiedLibFiles.getOrPutFiles(dependentLib) } + val fileStats by lazy(LazyThreadSafetyMode.NONE) { dirtyFileStats.getOrPutFiles(dependentLib) } + for (dependentFile in dependentFiles.keys) { + when (dependentFile) { + in alreadyModifiedFiles -> continue + in alreadyRemovedFiles -> continue + in extraModifiedFiles -> continue + else -> { + val dependentMetadata = dependentCache.fetchSourceFileFullMetadata(dependentFile) + extraModifiedFiles[dependentFile] = dependentMetadata + fileStats.addDirtFileStat(dependentFile, dirtyState) + } + } + } + } + } + + removedFiles.forEachFile { _, _, removedFileMetadata -> + addDependenciesToExtraModifiedFiles(removedFileMetadata.directDependencies, DirtyFileState.REMOVED_INVERSE_DEPENDS) + addDependenciesToExtraModifiedFiles(removedFileMetadata.inverseDependencies, DirtyFileState.REMOVED_DIRECT_DEPENDS) + } + + if (extraModifiedLibFiles.isNotEmpty()) { + extraModifiedLibFiles.copyFilesFrom(modifiedFiles) + return extraModifiedLibFiles + } + return modifiedFiles + } + + private fun loadModifiedFiles(): KotlinSourceFileMap { + val removedFilesMetadata = mutableMapOf>() + + val modifiedFiles = KotlinSourceFileMap(incrementalCaches.entries.associate { (lib, cache) -> + val (dirtyFiles, removedFiles, newFiles) = cache.collectModifiedFiles(configHash) + + val fileStats by lazy(LazyThreadSafetyMode.NONE) { dirtyFileStats.getOrPutFiles(lib) } + newFiles.forEach { fileStats.addDirtFileStat(it, DirtyFileState.ADDED_FILE) } + removedFiles.forEach { fileStats.addDirtFileStat(it.key, DirtyFileState.REMOVED_FILE) } + dirtyFiles.forEach { + if (it.key !in newFiles) { + fileStats.addDirtFileStat(it.key, DirtyFileState.MODIFIED_IR) + } + } + + if (removedFiles.isNotEmpty()) { + removedFilesMetadata[lib] = removedFiles + } + + lib to dirtyFiles + }) + + return addFilesWithRemovedDependencies(modifiedFiles, KotlinSourceFileMap(removedFilesMetadata)) + } + + private fun collectExportedSymbolsForDirtyFiles( + dirtyFiles: KotlinSourceFileMap + ): KotlinSourceFileMutableMap { + val exportedSymbols = KotlinSourceFileMutableMap() + + for ((libFile, srcFiles) in dirtyFiles) { + val exportedSymbolFiles = mutableMapOf() + for ((srcFile, srcFileMetadata) in srcFiles) { + val loadingFileExports = DirtyFileExports() + for ((dependentLib, dependentFiles) in srcFileMetadata.inverseDependencies) { + val dependentCache = incrementalCaches[dependentLib] ?: continue + val dirtyLibFiles = dirtyFiles[dependentLib] ?: emptyMap() + for (dependentFile in dependentFiles.keys) { + if (dependentFile !in dirtyLibFiles) { + val dependentSrcFileMetadata = dependentCache.fetchSourceFileFullMetadata(dependentFile) + dependentSrcFileMetadata.directDependencies[libFile, srcFile]?.let { + loadingFileExports.inverseDependencies[dependentLib, dependentFile] = it + loadingFileExports.allExportedSignatures += it + } + } + } + } + exportedSymbolFiles[srcFile] = loadingFileExports + } + if (exportedSymbolFiles.isNotEmpty()) { + exportedSymbols[libFile] = exportedSymbolFiles + } + } + return exportedSymbols + } + + private fun rebuildDirtySourceMetadata( + jsIrLinker: JsIrLinker, + loadedFragments: Map, + dirtySrcFiles: KotlinSourceFileMap, + ): KotlinSourceFileMap { + val idSignatureToFile = mutableMapOf>() + val updatedMetadata = KotlinSourceFileMutableMap() + + for ((lib, irModule) in loadedFragments) { + val moduleDeserializer = jsIrLinker.moduleDeserializer(irModule.descriptor) + val incrementalCache = getLibIncrementalCache(lib) + for (fileDeserializer in moduleDeserializer.fileDeserializers()) { + val libSrcFile = KotlinSourceFile(fileDeserializer.file) + + val reachableSignatures = fileDeserializer.symbolDeserializer.signatureDeserializer.signatureToIndexMapping() + val allImplementedSignatures = fileDeserializer.symbolDeserializer.deserializedSymbols.keys + val maybeImportedSignatures = reachableSignatures.keys.toMutableSet() + for (signature in allImplementedSignatures) { + if (signature in reachableSignatures) { + idSignatureToFile[signature] = lib to libSrcFile + maybeImportedSignatures.remove(signature) + } + } + + val metadata = incrementalCache.fetchSourceFileFullMetadata(libSrcFile) + updatedMetadata[lib, libSrcFile] = DirtyFileMetadata(maybeImportedSignatures, metadata.directDependencies) + } + } + + for ((libFile, srcFiles) in updatedMetadata) { + val libDirtySrcFiles = dirtySrcFiles[libFile] ?: continue + for ((srcFile, internalHeader) in srcFiles) { + val dirtySrcFile = libDirtySrcFiles[srcFile] ?: continue + dirtySrcFile.inverseDependencies.forEachFile { dependentLibFile, dependentSrcFile, signatures -> + signatures.forEach { + val (dependencyLib, dependencyFile) = idSignatureToFile[it] ?: (libFile to srcFile) + updatedMetadata[dependencyLib, dependencyFile]?.also { dependencyMetadata -> + dependencyMetadata.addInverseDependency(dependentLibFile, dependentSrcFile, it) + } ?: notFoundIcError("metadata", dependencyLib, dependencyFile) + } + } + + for (importedSignature in internalHeader.maybeImportedSignatures) { + val (dependencyLib, dependencyFile) = idSignatureToFile[importedSignature] ?: continue + internalHeader.addDirectDependency(dependencyLib, dependencyFile, importedSignature) + transitiveHashes[importedSignature]?.let { internalHeader.importedInlineFunctions[importedSignature] = it } + + updatedMetadata[dependencyLib, dependencyFile]?.also { dependencyMetadata -> + dependencyMetadata.addInverseDependency(libFile, srcFile, importedSignature) + } ?: notFoundIcError("metadata", dependencyLib, dependencyFile) + } + } + } + + val result = KotlinSourceFileMutableMap() + + for ((libFile, sourceFiles) in dirtySrcFiles) { + val incrementalCache = getLibIncrementalCache(libFile) + val srcFileUpdatedMetadata = updatedMetadata[libFile] ?: notFoundIcError("metadata", libFile) + for (srcFile in sourceFiles.keys) { + val srcMetadata = srcFileUpdatedMetadata[srcFile] ?: notFoundIcError("metadata", libFile, srcFile) + incrementalCache.updateSourceFileMetadata(srcFile, srcMetadata) + result[libFile, srcFile] = srcMetadata + } + } + + return result + } + + private fun KotlinSourceFileMutableMap.addNewMetadata( + libFile: KotlinLibraryFile, srcFile: KotlinSourceFile, oldMetadata: KotlinSourceFileMetadata + ) = this[libFile, srcFile] ?: UpdatedDependenciesMetadata(oldMetadata).also { + this[libFile, srcFile] = it + } + + private fun KotlinSourceFileMutableMap.addDependenciesWithUpdatedSignatures( + libFile: KotlinLibraryFile, srcFile: KotlinSourceFile, srcFileMetadata: DirtyFileMetadata + ) { + // go through dependencies and collect dependencies with updated signatures + for ((dependencyLibFile, dependencySrcFiles) in srcFileMetadata.directDependencies) { + val dependencyCache = getLibIncrementalCache(dependencyLibFile) + for ((dependencySrcFile, newSignatures) in dependencySrcFiles) { + val dependencySrcMetadata = dependencyCache.fetchSourceFileFullMetadata(dependencySrcFile) + val oldSignatures = dependencySrcMetadata.inverseDependencies[libFile, srcFile] ?: emptySet() + if (oldSignatures == newSignatures) { + continue + } + val newMetadata = addNewMetadata(dependencyLibFile, dependencySrcFile, dependencySrcMetadata) + newMetadata.inverseDependencies[libFile, srcFile] = newSignatures + } + } + } + + private fun KotlinSourceFileMutableMap.addDependenciesWithRemovedInverseDependencies( + libFile: KotlinLibraryFile, srcFile: KotlinSourceFile, srcFileMetadata: DirtyFileMetadata + ) { + // go through old dependencies and look for removed dependencies + for ((oldDependencyLibFile, oldDependencySrcFiles) in srcFileMetadata.oldDirectDependencies) { + val dependencyCache = incrementalCaches[oldDependencyLibFile] ?: continue + val newDirectDependencyFiles = srcFileMetadata.directDependencies[oldDependencyLibFile] ?: emptyMap() + for (oldDependencySrcFile in oldDependencySrcFiles.keys) { + if (oldDependencySrcFile in newDirectDependencyFiles) { + continue + } + val dependencySrcMetadata = dependencyCache.fetchSourceFileFullMetadata(oldDependencySrcFile) + if (dependencySrcMetadata.inverseDependencies[libFile, srcFile] != null) { + val newMetadata = addNewMetadata(oldDependencyLibFile, oldDependencySrcFile, dependencySrcMetadata) + newMetadata.inverseDependencies.removeFile(libFile, srcFile) + } + } + } + } + + private fun KotlinSourceFileMutableMap.addDependentsWithUpdatedImports( + libFile: KotlinLibraryFile, srcFile: KotlinSourceFile, srcFileMetadata: DirtyFileMetadata + ) { + // go through dependent files and check if their inline imports were modified + for ((dependentLibFile, dependentSrcFiles) in srcFileMetadata.inverseDependencies) { + val dependentCache = incrementalCaches[dependentLibFile] ?: continue + for ((dependentSrcFile, newSignatures) in dependentSrcFiles) { + val dependentSrcMetadata = dependentCache.fetchSourceFileFullMetadata(dependentSrcFile) + val dependentSignatures = dependentSrcMetadata.directDependencies[libFile, srcFile] ?: emptySet() + val importedInlineModified = dependentSrcMetadata.importedInlineFunctions.any { + transitiveHashes[it.key]?.let { newHash -> newHash != it.value } ?: (it.key in dependentSignatures) + } + if (importedInlineModified) { + val newMetadata = addNewMetadata(dependentLibFile, dependentSrcFile, dependentSrcMetadata) + newMetadata.importedInlineFunctionsModified = true + } else if (dependentSignatures != newSignatures) { + val newMetadata = addNewMetadata(dependentLibFile, dependentSrcFile, dependentSrcMetadata) + newMetadata.directDependencies[libFile, srcFile] = newSignatures + } + } + } + } + + private fun collectFilesWithModifiedExportsOrInlineImports( + loadedDirtyFiles: KotlinSourceFileMap + ): KotlinSourceFileMap { + val filesWithModifiedExports = KotlinSourceFileMutableMap() + + loadedDirtyFiles.forEachFile { libFile, srcFile, srcFileMetadata -> + filesWithModifiedExports.addDependenciesWithUpdatedSignatures(libFile, srcFile, srcFileMetadata) + filesWithModifiedExports.addDependenciesWithRemovedInverseDependencies(libFile, srcFile, srcFileMetadata) + filesWithModifiedExports.addDependentsWithUpdatedImports(libFile, srcFile, srcFileMetadata) + } + + return filesWithModifiedExports + } + + private fun collectFilesToRebuildSignatures( + filesWithModifiedExports: KotlinSourceFileMap + ): KotlinSourceFileMap { + val libFilesToRebuild = KotlinSourceFileMutableMap() + + for ((libFile, srcFiles) in filesWithModifiedExports) { + val filesToRebuild by lazy(LazyThreadSafetyMode.NONE) { libFilesToRebuild.getOrPutFiles(libFile) } + val fileStats by lazy(LazyThreadSafetyMode.NONE) { dirtyFileStats.getOrPutFiles(libFile) } + val cache = getLibIncrementalCache(libFile) + + for ((srcFile, srcFileMetadata) in srcFiles) { + val isSignatureUpdated = srcFileMetadata.isExportedSignaturesUpdated() + if (isSignatureUpdated || srcFileMetadata.importedInlineFunctionsModified) { + // if exported signatures or imported inline functions were modified - rebuild + filesToRebuild[srcFile] = srcFileMetadata + if (isSignatureUpdated) { + fileStats.addDirtFileStat(srcFile, DirtyFileState.UPDATED_EXPORTS) + } + if (srcFileMetadata.importedInlineFunctionsModified) { + fileStats.addDirtFileStat(srcFile, DirtyFileState.UPDATED_INLINE_IMPORTS) + } + } else { + // if signatures and inline functions are the same - just update cache metadata + cache.updateSourceFileMetadata(srcFile, srcFileMetadata) + } + } + } + + return libFilesToRebuild + } + + private fun buildModuleArtifactsAndCommitCache( + jsIrLinker: JsIrLinker, + loadedFragments: Map, + rebuiltFileFragments: List + ): List { + val fragmentToLibName = loadedFragments.entries.associate { it.value to it.key } + + val rebuiltSrcFiles = rebuiltFileFragments.groupBy { + fragmentToLibName[it.irFile.module] ?: notFoundIcError("loaded fragment lib name", srcFile = KotlinSourceFile(it.irFile)) + } + + val visited = mutableSetOf() + val artifacts = mutableListOf() + fun addArtifact(lib: KotlinLibrary) { + if (visited.add(lib)) { + dependencyGraph[lib]?.forEach(::addArtifact) + + val libFile = KotlinLibraryFile(lib) + val incrementalCache = getLibIncrementalCache(libFile) + val libFragment = loadedFragments[libFile] ?: notFoundIcError("loaded fragment", libFile) + val libRebuiltFiles = rebuiltSrcFiles[libFile]?.associateBy { KotlinSourceFile(it.irFile) } ?: emptyMap() + val moduleDeserializer = jsIrLinker.moduleDeserializer(libFragment.descriptor) + + val signatureToIndexMapping = moduleDeserializer.fileDeserializers().associate { + KotlinSourceFile(it.file) to it.symbolDeserializer.signatureDeserializer.signatureToIndexMapping() + } + artifacts += incrementalCache.buildModuleArtifactAndCommitCache( + moduleName = libFragment.name.asString(), + rebuiltFileFragments = libRebuiltFiles, + signatureToIndexMapping = signatureToIndexMapping + ) + } + } + + addArtifact(mainLibrary) + + return artifacts + } + + fun actualizeCaches(eventCallback: (String) -> Unit = {}): List { + dirtyFileStats.clear() + + val modifiedFiles = loadModifiedFiles() + val dirtyFileExports = collectExportedSymbolsForDirtyFiles(modifiedFiles) + + val jsIrLinkerLoader = JsIrLinkerLoader(compilerConfiguration, mainLibrary, dependencyGraph, irFactory()) + var loadedIr = jsIrLinkerLoader.loadIr(dirtyFileExports) + + eventCallback("initial loading of updated files") + + var iterations = 0 + var lastDirtyFiles: KotlinSourceFileMap = dirtyFileExports + + while (true) { + hashCalculator.updateTransitiveHashes(loadedIr.loadedFragments.values) + + val dirtyHeaders = rebuildDirtySourceMetadata(loadedIr.linker, loadedIr.loadedFragments, lastDirtyFiles) + + val filesWithModifiedExportsOrImports = collectFilesWithModifiedExportsOrInlineImports(dirtyHeaders) + + val filesToRebuild = collectFilesToRebuildSignatures(filesWithModifiedExportsOrImports) + + eventCallback("actualization iteration $iterations") + if (filesToRebuild.isEmpty()) { + break + } + + loadedIr = jsIrLinkerLoader.loadIr(filesToRebuild) + iterations++ + + lastDirtyFiles = filesToRebuild + dirtyFileExports.copyFilesFrom(filesToRebuild) + } + + if (iterations != 0) { + loadedIr = jsIrLinkerLoader.loadIr(dirtyFileExports) + eventCallback("final loading of updated files") + } + + val rebuiltFragments = executor.execute( + mainModule = loadedIr.loadedFragments[mainLibraryFile] ?: notFoundIcError("main lib loaded fragment", mainLibraryFile), + allModules = loadedIr.loadedFragments.values, + deserializer = loadedIr.linker, + configuration = compilerConfiguration, + dirtyFiles = loadedIr.loadedFragments.flatMap { (libFile, libFragment) -> + dirtyFileExports[libFile]?.let { libDirtyFiles -> + libFragment.files.filter { file -> KotlinSourceFile(file) in libDirtyFiles } + } ?: emptyList() + }, + exportedDeclarations = emptySet(), + mainArguments = mainArguments + ) + eventCallback("updated files processing (lowering)") + + val artifacts = buildModuleArtifactsAndCommitCache(loadedIr.linker, loadedIr.loadedFragments, rebuiltFragments) + eventCallback("cache committing") + + return artifacts + } +} + +// Used for tests only +fun rebuildCacheForDirtyFiles( + library: KotlinLibrary, + configuration: CompilerConfiguration, + dependencyGraph: Map>, + dirtyFiles: Collection?, + irFactory: IrFactory, + exportedDeclarations: Set, + mainArguments: List?, +): Pair> { + val emptyMetadata = object : KotlinSourceFileExports() { + override val inverseDependencies = KotlinSourceFileMap>(emptyMap()) + } + + val libFile = KotlinLibraryFile(library) + val dirtySrcFiles = dirtyFiles?.map { KotlinSourceFile(it) } ?: KotlinLibraryHeader(library).sourceFiles + val modifiedFiles = mapOf(libFile to dirtySrcFiles.associateWith { emptyMetadata }) + + val jsIrLoader = JsIrLinkerLoader(configuration, library, dependencyGraph, irFactory) + val (jsIrLinker, irModules) = jsIrLoader.loadIr(KotlinSourceFileMap(modifiedFiles), true) + + val currentIrModule = irModules[libFile] ?: notFoundIcError("loaded fragment", libFile) + val dirtyIrFiles = dirtyFiles?.let { + val files = it.toSet() + currentIrModule.files.filter { irFile -> irFile.fileEntry.name in files } + } ?: currentIrModule.files + + return currentIrModule to buildCacheForModuleFiles( + mainModule = currentIrModule, + allModules = irModules.values, + deserializer = jsIrLinker, + configuration = configuration, + dirtyFiles = dirtyIrFiles, + exportedDeclarations = exportedDeclarations, + mainArguments = mainArguments + ) +} + +fun buildCacheForModuleFiles( + mainModule: IrModuleFragment, + allModules: Collection, + deserializer: JsIrLinker, + configuration: CompilerConfiguration, + dirtyFiles: Collection, + exportedDeclarations: Set, + mainArguments: List? +): List { + return compileWithIC( + mainModule = mainModule, + allModules = allModules, + filesToLower = dirtyFiles, + configuration = configuration, + deserializer = deserializer, + mainArguments = mainArguments, + exportedDeclarations = exportedDeclarations, + ) +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/fileUtils.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ICUtils.kt similarity index 52% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/fileUtils.kt rename to compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ICUtils.kt index b83cf0d98dd..f1d4add8601 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/fileUtils.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ICUtils.kt @@ -16,6 +16,8 @@ internal inline fun File.ifExists(f: File.() -> T): T? = if (exists()) f() e internal fun File.recreate() { if (exists()) { delete() + } else { + parentFile?.mkdirs() } createNewFile() } @@ -35,3 +37,23 @@ internal inline fun File.useCodedOutput(f: CodedOutputStream.() -> Unit) { out.flush() } } + +internal fun icError(msg: String): Nothing = error("IC internal error: $msg") + +internal fun notFoundIcError(what: String, libFile: KotlinLibraryFile? = null, srcFile: KotlinSourceFile? = null): Nothing { + val filePath = listOfNotNull(libFile?.path, srcFile?.path).joinToString(":") { File(it).name } + val msg = if (filePath.isEmpty()) what else "$what for $filePath" + icError("can not find $msg") +} + +internal inline fun buildListUntil(to: Int, builderAction: MutableList.(Int) -> Unit): List { + return buildList(to) { repeat(to) { builderAction(it) } } +} + +internal inline fun buildSetUntil(to: Int, builderAction: MutableSet.(Int) -> Unit): Set { + return buildSet(to) { repeat(to) { builderAction(it) } } +} + +internal inline fun buildMapUntil(to: Int, builderAction: MutableMap.(Int) -> Unit): Map { + return buildMap(to) { repeat(to) { builderAction(it) } } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IncrementalCache.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IncrementalCache.kt index a3ed3248643..f678d2f4fc5 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IncrementalCache.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/IncrementalCache.kt @@ -6,311 +6,249 @@ 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.backend.js.transformers.irToJs.JsIrFragmentAndBinaryAst import org.jetbrains.kotlin.ir.util.IdSignature import org.jetbrains.kotlin.library.KotlinLibrary +import org.jetbrains.kotlin.library.impl.javaFile 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() { +class IncrementalCache(private val library: KotlinLibrary, cachePath: String) { companion object { - private const val cacheFullInfoFile = "cache.full.info" - private const val cacheFastInfoFile = "cache.fast.info" - private const val binaryAstSuffix = "binary.ast" + private const val CACHE_HEADER = "ic.header.bin" + + private const val BINARY_AST_SUFFIX = "ast.bin" + private const val METADATA_SUFFIX = "metadata.bin" } - 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 var forceRebuildJs = false - private val cacheDir = File(cachePath) - private val signatureToIdMapping = mutableMapOf>() + private val signatureToIndexMappingFromMetadata = mutableMapOf>() - private val fingerprints = mutableMapOf() - private val usedInlineFunctions = mutableMapOf>() - private val implementedInlineFunctions = mutableMapOf>() + private val libraryFile = KotlinLibraryFile(library) - private var cacheFastInfo = CacheFastInfo().apply { - File(cacheDir, cacheFastInfoFile).useCodedInputIfExists { - moduleName = readString() - flatHash = ICHash.fromProtoStream(this) - transHash = ICHash.fromProtoStream(this) - configHash = ICHash.fromProtoStream(this) + class CacheHeader(val klibFileHash: ICHash = ICHash(), val configHash: ICHash = ICHash()) { + fun toProtoStream(out: CodedOutputStream) { + klibFileHash.toProtoStream(out) + configHash.toProtoStream(out) } - initialFlatHash = flatHash - } - val srcFingerprints: Map get() = fingerprints - val usedFunctions: Map> get() = usedInlineFunctions - val implementedFunctions: Collection> get() = implementedInlineFunctions.values - - val klibUpdated: Boolean get() = cacheFastInfo.run { initialFlatHash == ICHash() || initialFlatHash != flatHash } - - val klibTransitiveHash: ICHash get() = cacheFastInfo.transHash - - var srcFilesInOrderFromKLib: List = emptyList() - private set - - var deletedSrcFiles: Set = emptySet() - private set - - fun updateSignatureToIdMapping(srcPath: String, mapping: Map) { - signatureToIdMapping[srcPath] = mapping - } - - fun updateHashes( - srcPath: String, fingerprint: ICHash, usedFunctions: Map?, implementedFunctions: Map? - ) { - 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? = null - ): Map? { - val functions = readInt32() - if (functions == 0) { - return null - } - val result = mutableMapOf() - 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 + companion object { + fun fromProtoStream(input: CodedInputStream): CacheHeader { + val klibFileHash = ICHash.fromProtoStream(input) + val configHash = ICHash.fromProtoStream(input) + return CacheHeader(klibFileHash, configHash) } } - 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 } + private var cacheHeader = File(cacheDir, CACHE_HEADER).useCodedInputIfExists { + CacheHeader.fromProtoStream(this) + } ?: CacheHeader() - File(cacheDir, cacheFullInfoFile).useCodedInputIfExists { - val deleted = mutableSetOf() + private fun loadCachedFingerprints() = File(cacheDir, CACHE_HEADER).useCodedInputIfExists { + // skip cache header + CacheHeader.fromProtoStream(this@useCodedInputIfExists) + buildMapUntil(readInt32()) { + val file = KotlinSourceFile.fromProtoStream(this@useCodedInputIfExists) + put(file, ICHash.fromProtoStream(this@useCodedInputIfExists)) + } + } ?: emptyMap() - val signatureReadersMap = signatureReaders.toMap() - val srcFiles = readInt32() - for (srcIndex in 0 until srcFiles) { - val srcPath = readString() - val fingerprint = ICHash.fromProtoStream(this) + private val kotlinLibraryHeader: KotlinLibraryHeader by lazy { KotlinLibraryHeader(library) } - val deserializer = signatureReadersMap[srcPath] - if (deserializer != null) { - fingerprints[srcPath] = fingerprint - val signatureToId = mutableMapOf() - readFunctionHashes(deserializer, signatureToId)?.let { implementedInlineFunctions[srcPath] = it } - readFunctionHashes(deserializer, signatureToId)?.let { usedInlineFunctions[srcPath] = it } - if (signatureToId.isNotEmpty()) { - signatureToIdMapping[srcPath] = signatureToId - } + private class KotlinSourceFileMetadataFromDisk( + override val inverseDependencies: KotlinSourceFileMap>, + override val directDependencies: KotlinSourceFileMap>, + + override val importedInlineFunctions: Map + ) : KotlinSourceFileMetadata() + + private object KotlinSourceFileMetadataNotExist : KotlinSourceFileMetadata() { + override val inverseDependencies = KotlinSourceFileMap>(emptyMap()) + override val directDependencies = KotlinSourceFileMap>(emptyMap()) + + override val importedInlineFunctions = emptyMap() + } + + private val kotlinLibrarySourceFileMetadata = mutableMapOf() + + private fun KotlinSourceFile.getCacheFile(suffix: String) = File(cacheDir, "${File(path).name}.${path.stringHashForIC()}.$suffix") + + private fun commitCacheHeader(fingerprints: List>) = File(cacheDir, CACHE_HEADER).useCodedOutput { + cacheHeader.toProtoStream(this) + writeInt32NoTag(fingerprints.size) + for ((srcFile, fingerprint) in fingerprints) { + srcFile.toProtoStream(this) + fingerprint.toProtoStream(this) + } + } + + fun buildModuleArtifactAndCommitCache( + moduleName: String, + rebuiltFileFragments: Map, + signatureToIndexMapping: Map> + ): ModuleArtifact { + val fileArtifacts = kotlinLibraryHeader.sourceFiles.map { srcFile -> + val binaryAstFile = srcFile.getCacheFile(BINARY_AST_SUFFIX) + val rebuiltFileFragment = rebuiltFileFragments[srcFile] + if (rebuiltFileFragment != null) { + binaryAstFile.apply { recreate() }.writeBytes(rebuiltFileFragment.binaryAst) + } + + commitSourceFileMetadata(srcFile, signatureToIndexMapping[srcFile] ?: emptyMap()) + SrcFileArtifact(srcFile.path, rebuiltFileFragment?.fragment, binaryAstFile) + } + + return ModuleArtifact(moduleName, fileArtifacts, cacheDir, forceRebuildJs) + } + + data class ModifiedFiles( + val modified: Map = emptyMap(), + val removed: Map = emptyMap(), + val newFiles: Set = emptySet() + ) + + fun collectModifiedFiles(configHash: ICHash): ModifiedFiles { + val klibFileHash = library.libraryFile.javaFile().fileHashForIC() + cacheHeader = when { + cacheHeader.configHash != configHash -> { + cacheDir.deleteRecursively() + CacheHeader(klibFileHash, configHash) + } + cacheHeader.klibFileHash != klibFileHash -> CacheHeader(klibFileHash, configHash) + else -> return ModifiedFiles() + } + + val cachedFingerprints = loadCachedFingerprints() + val deletedFiles = cachedFingerprints.keys.toMutableSet() + val newFiles = mutableSetOf() + + val newFingerprints = kotlinLibraryHeader.sourceFiles.mapIndexed { index, file -> file to library.fingerprint(index) } + val modifiedFiles = buildMap(newFingerprints.size) { + for ((file, fileNewFingerprint) in newFingerprints) { + val oldFingerprint = cachedFingerprints[file] + if (oldFingerprint == null) { + newFiles += file + } + if (oldFingerprint != fileNewFingerprint) { + val metadata = fetchSourceFileMetadata(file, false) + put(file, metadata) + } + deletedFiles.remove(file) + } + } + + val removedFilesMetadata = deletedFiles.associateWith { + val metadata = fetchSourceFileMetadata(it, false) + it.getCacheFile(BINARY_AST_SUFFIX).delete() + it.getCacheFile(METADATA_SUFFIX).delete() + metadata + } + + forceRebuildJs = deletedFiles.isNotEmpty() + commitCacheHeader(newFingerprints) + + return ModifiedFiles(modifiedFiles, removedFilesMetadata, newFiles) + } + + fun fetchSourceFileFullMetadata(srcFile: KotlinSourceFile): KotlinSourceFileMetadata { + return fetchSourceFileMetadata(srcFile, true) + } + + fun updateSourceFileMetadata(srcFile: KotlinSourceFile, sourceFileMetadata: KotlinSourceFileMetadata) { + kotlinLibrarySourceFileMetadata[srcFile] = sourceFileMetadata + } + + private fun fetchSourceFileMetadata(srcFile: KotlinSourceFile, loadSignatures: Boolean) = + kotlinLibrarySourceFileMetadata.getOrPut(srcFile) { + val signatureToIndexMapping = signatureToIndexMappingFromMetadata.getOrPut(srcFile) { mutableMapOf() } + fun IdSignatureDeserializer.deserializeIdSignatureAndSave(index: Int): IdSignature { + val signature = deserializeIdSignature(index) + signatureToIndexMapping[signature] = index + return signature + } + + val deserializer: IdSignatureDeserializer by lazy { + kotlinLibraryHeader.signatureDeserializers[srcFile] ?: notFoundIcError("signature deserializer", libraryFile, srcFile) + } + + srcFile.getCacheFile(METADATA_SUFFIX).useCodedInputIfExists { + fun readDependencies() = buildMapUntil(readInt32()) { + val libraryFile = KotlinLibraryFile.fromProtoStream(this@useCodedInputIfExists) + val depends = buildMapUntil(readInt32()) { + val dependencySrcFile = KotlinSourceFile.fromProtoStream(this@useCodedInputIfExists) + val dependencySignatures = if (loadSignatures) { + buildSetUntil(readInt32()) { add(deserializer.deserializeIdSignatureAndSave(readInt32())) } } else { - deleted.add(srcPath) - skipFunctionHashes() - skipFunctionHashes() + repeat(readInt32()) { readInt32() } + emptySet() + } + put(dependencySrcFile, dependencySignatures) + } + put(libraryFile, depends) + } + + val directDependencies = KotlinSourceFileMap(readDependencies()) + val reverseDependencies = KotlinSourceFileMap(readDependencies()) + + val importedInlineFunctions = if (loadSignatures) { + buildMapUntil(readInt32()) { + val signature = deserializer.deserializeIdSignatureAndSave(readInt32()) + val transitiveHash = ICHash.fromProtoStream(this@useCodedInputIfExists) + put(signature, transitiveHash) + } + } else { + emptyMap() + } + + KotlinSourceFileMetadataFromDisk(reverseDependencies, directDependencies, importedInlineFunctions) + } ?: KotlinSourceFileMetadataNotExist + } + + private fun commitSourceFileMetadata(srcFile: KotlinSourceFile, signatureToIndexMapping: Map) { + val headerCacheFile = srcFile.getCacheFile(METADATA_SUFFIX) + val sourceFileMetadata = kotlinLibrarySourceFileMetadata[srcFile] ?: notFoundIcError("metadata", libraryFile, srcFile) + if (sourceFileMetadata.isEmpty()) { + headerCacheFile.delete() + return + } + if (sourceFileMetadata is KotlinSourceFileMetadataFromDisk) { + return + } + + val signatureToIndexMappingSaved = signatureToIndexMappingFromMetadata[srcFile] ?: emptyMap() + fun serializeSignature(signature: IdSignature): Int { + val index = signatureToIndexMapping[signature] ?: signatureToIndexMappingSaved[signature] + return index ?: notFoundIcError("signature $signature", libraryFile, srcFile) + } + + headerCacheFile.useCodedOutput { + fun writeDepends(depends: KotlinSourceFileMap>) { + writeInt32NoTag(depends.size) + for ((dependencyLibFile, dependencySrcFiles) in depends) { + dependencyLibFile.toProtoStream(this) + writeInt32NoTag(dependencySrcFiles.size) + for ((dependencySrcFile, signatures) in dependencySrcFiles) { + dependencySrcFile.toProtoStream(this) + writeInt32NoTag(signatures.size) + for (signature in signatures) { + writeInt32NoTag(serializeSignature(signature)) } } - - deletedSrcFiles = deleted } } - } - } - private fun CodedInputStream.skipFunctionHashes() { - val functions = readInt32() - for (funIndex in 0 until functions) { - readInt32() // skip sigid - readFixed64() // skip hash - } - } + writeDepends(sourceFileMetadata.directDependencies) + writeDepends(sourceFileMetadata.inverseDependencies) - 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() + writeInt32NoTag(sourceFileMetadata.importedInlineFunctions.size) + for ((signature, transitiveHash) in sourceFileMetadata.importedInlineFunctions) { + writeInt32NoTag(serializeSignature(signature)) + transitiveHash.toProtoStream(this) } } } - - private fun getBinaryAstPath(srcFile: String): File { - val binaryAstFileName = "${File(srcFile).name}.${srcFile.stringHashForIC()}.$binaryAstSuffix" - return File(cacheDir, binaryAstFileName) - } - - private fun CodedOutputStream.writeFunctionHashes(sigToIndexMap: Map, hashes: Map) { - 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 - forceRebuildJs = deletedSrcFiles.isNotEmpty() - signatureToIdMapping.clear() - usedInlineFunctions.clear() - srcFilesInOrderFromKLib = emptyList() - deletedSrcFiles = emptySet() - binaryAsts.clear() - } - - 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() = ModuleArtifact( - moduleName = cacheFastInfo.moduleName ?: error("Internal error: missing module name"), - fileArtifacts = fingerprints.keys.map { - SrcFileArtifact(it, fragments[it], getBinaryAstPath(it)) - }, - artifactsDir = cacheDir, - forceRebuildJs = forceRebuildJs - ) - - fun invalidate() { - cacheDir.deleteRecursively() - signatureToIdMapping.clear() - implementedInlineFunctions.clear() - usedInlineFunctions.clear() - fingerprints.clear() - binaryAsts.clear() - fragments.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) - fragments.remove(srcPath) - } - - private fun KotlinLibrary.filesAndSigReaders(): List> { - val fileSize = fileCount() - val result = ArrayList>(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 - } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineFunctionTransitiveHashCalculator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineFunctionTransitiveHashCalculator.kt new file mode 100644 index 00000000000..c50296fc7ed --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineFunctionTransitiveHashCalculator.kt @@ -0,0 +1,121 @@ +/* + * 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.ir.IrElement +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.ir.expressions.IrCall +import org.jetbrains.kotlin.ir.expressions.IrFunctionReference +import org.jetbrains.kotlin.ir.util.IdSignature +import org.jetbrains.kotlin.ir.util.isFakeOverride +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.ir.visitors.acceptVoid + + +class InlineFunctionTransitiveHashCalculator { + private val flatHashes = mutableMapOf() + private val inlineFunctionCallGraph: MutableMap> = mutableMapOf() + private val processingFunctions = mutableSetOf() + private val functionTransitiveHashes = mutableMapOf() + private val idSignatureTransitiveHashes = mutableMapOf() + + val transitiveHashes: Map + get() = idSignatureTransitiveHashes + + private inner class FlatHashCalculator : IrElementVisitorVoid { + override fun visitElement(element: IrElement) = element.acceptChildren(this, null) + + override fun visitSimpleFunction(declaration: IrSimpleFunction) { + if (declaration.isInline) { + if (declaration in flatHashes) { + return + } + flatHashes[declaration] = declaration.irElementHashForIC() + } + // go deeper since local inline special declarations (like a reference adaptor) may appear + declaration.acceptChildren(this, null) + } + } + + private inner class CallGraphBuilder : IrElementVisitor> { + var inlineFunctionCallDepth: Int = 0 + + override fun visitElement(element: IrElement, data: MutableSet) = element.acceptChildren(this, data) + + override fun visitSimpleFunction(declaration: IrSimpleFunction, data: MutableSet) { + if (declaration in inlineFunctionCallGraph) { + return + } + val newGraph = mutableSetOf() + inlineFunctionCallGraph[declaration] = newGraph + declaration.acceptChildren(this, newGraph) + } + + override fun visitCall(expression: IrCall, data: MutableSet) { + val callee = expression.symbol.owner + if (callee.isInline) { + // TODO: do not ignore fake overrides after KT-51896 + if (!callee.isFakeOverride) { + data += callee + } + inlineFunctionCallDepth += 1 + } + expression.acceptChildren(this, data) + if (callee.isInline) { + inlineFunctionCallDepth -= 1 + if (inlineFunctionCallDepth < 0) { + icError("inline function calls depth inconsistent") + } + } + } + + override fun visitFunctionReference(expression: IrFunctionReference, data: MutableSet) { + val reference = expression.symbol.owner + if (inlineFunctionCallDepth > 0 && reference.isInline) { + // this if is fine, because fake overrides are not inlined as function reference calls even as inline function args + if (!reference.isFakeOverride) { + data += reference + } + } + expression.acceptChildren(this, data) + } + } + + private fun getInlineFunctionTransitiveHash(f: IrFunction): ICHash = functionTransitiveHashes.getOrPut(f) { + if (!processingFunctions.add(f)) { + icError("inline circle through function ${f.render()} detected") + } + val callees = inlineFunctionCallGraph[f] ?: icError("inline function is missed in inline graph ${f.render()}") + val flatHash = flatHashes[f] ?: icError("no flat hash for ${f.render()}") + var functionInlineHash = flatHash + for (callee in callees) { + functionInlineHash = functionInlineHash.combineWith(getInlineFunctionTransitiveHash(callee)) + } + processingFunctions.remove(f) + f.symbol.signature?.let { idSignatureTransitiveHashes[it] = functionInlineHash } + functionInlineHash + } + + private fun updateTransitiveHashesByCallGraph() { + for ((f, callees) in inlineFunctionCallGraph.entries) { + if (f.isInline) { + getInlineFunctionTransitiveHash(f) + } else { + callees.forEach(::getInlineFunctionTransitiveHash) + } + } + } + + fun updateTransitiveHashes(fragments: Collection) { + fragments.forEach { it.acceptVoid(FlatHashCalculator()) } + fragments.forEach { it.acceptChildren(CallGraphBuilder(), mutableSetOf()) } + updateTransitiveHashesByCallGraph() + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineGraphTracker.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineGraphTracker.kt deleted file mode 100644 index eb6127249fe..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/InlineGraphTracker.kt +++ /dev/null @@ -1,159 +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.IrElement -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -import org.jetbrains.kotlin.ir.expressions.IrCall -import org.jetbrains.kotlin.ir.expressions.IrFunctionReference -import org.jetbrains.kotlin.ir.util.IdSignature -import org.jetbrains.kotlin.ir.util.file -import org.jetbrains.kotlin.ir.util.isFakeOverride -import org.jetbrains.kotlin.ir.util.render -import org.jetbrains.kotlin.ir.visitors.IrElementVisitor -import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid - - -class InlineFunctionFlatHashBuilder : IrElementVisitorVoid { - override fun visitElement(element: IrElement) { - element.acceptChildren(this, null) - } - - override fun visitSimpleFunction(declaration: IrSimpleFunction) { - if (declaration.isInline) { - flatHashes[declaration] = declaration.irElementHashForIC() - } - // go deeper since local inline special declarations (like a reference adaptor) may appear - declaration.acceptChildren(this, null) - } - - private val flatHashes = mutableMapOf() - - fun getFlatHashes() = flatHashes -} - -interface InlineFunctionHashProvider { - fun hashForExternalFunction(declaration: IrFunction): ICHash? -} - -class InlineFunctionHashBuilder( - private val hashProvider: InlineFunctionHashProvider, - private val flatHashes: Map -) { - private val inlineFunctionCallGraph: MutableMap> = mutableMapOf() - - private inner class GraphBuilder : IrElementVisitor> { - var inlineFunctionCallDepth: Int = 0 - - override fun visitElement(element: IrElement, data: MutableSet) { - element.acceptChildren(this, data) - } - - override fun visitSimpleFunction(declaration: IrSimpleFunction, data: MutableSet) { - val newGraph = mutableSetOf() - inlineFunctionCallGraph[declaration] = newGraph - declaration.acceptChildren(this, newGraph) - } - - override fun visitCall(expression: IrCall, data: MutableSet) { - val callee = expression.symbol.owner - if (callee.isInline) { - // TODO: do not ignore fake overides after KT-51896 - if (!callee.isFakeOverride) { - data += callee - } - inlineFunctionCallDepth += 1 - } - expression.acceptChildren(this, data) - if (callee.isInline) { - inlineFunctionCallDepth -= 1 - if (inlineFunctionCallDepth < 0) { - error("Internal error: inline function calls depth inconsistency") - } - } - } - - override fun visitFunctionReference(expression: IrFunctionReference, data: MutableSet) { - val reference = expression.symbol.owner - if (inlineFunctionCallDepth > 0 && reference.isInline) { - // this if is fine, because fake overrides are not inlined as function reference calls even as inline function args - if (!reference.isFakeOverride) { - data += reference - } - } - expression.acceptChildren(this, data) - } - } - - private inner class InlineFunctionHashProcessor { - private val computedHashes = mutableMapOf() - private val processingFunctions = mutableSetOf() - - private fun processInlineFunction(f: IrFunction): 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: IrFunction): ICHash { - if (callee in flatHashes) { - return processInlineFunction(callee) - } - return hashProvider.hashForExternalFunction(callee) ?: error("Internal error: No hash found for ${callee.render()}") - } - - fun process(): Map { - for ((f, callees) in inlineFunctionCallGraph.entries) { - if (f.isInline) { - processInlineFunction(f) - } else { - callees.forEach(::processCallee) - } - } - return computedHashes - } - } - - fun buildHashes(dirtyFiles: Collection): Map { - dirtyFiles.forEach { it.acceptChildren(GraphBuilder(), mutableSetOf()) } - return InlineFunctionHashProcessor().process() - } - - fun buildInlineGraph(computedHashed: Map): Map> { - val perFileInlineGraph = inlineFunctionCallGraph.entries.groupBy({ it.key.file }) { - it.value - } - - return perFileInlineGraph.entries.associate { - val usedInlineFunctions = mutableMapOf() - it.value.forEach { edges -> - edges.forEach { callee -> - // TODO: do not ignore fake overides after KT-51896 - if (!callee.isFakeOverride) { - val signature = callee.symbol.signature - if (signature?.visibleCrossFile == true) { - val calleeHash = computedHashed[callee] - ?: hashProvider.hashForExternalFunction(callee) - ?: error("Internal error: No hash found for ${callee.render()}") - usedInlineFunctions[signature] = calleeHash - } - } - } - } - it.key to usedInlineFunctions - } - } -} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsExecutableProducer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsExecutableProducer.kt index 1426ad7d1b8..c6cd2082e5e 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsExecutableProducer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsExecutableProducer.kt @@ -53,8 +53,8 @@ class JsExecutableProducer( } jsIrHeader.associatedModule = artifact.loadJsIrModule() } - val associatedModule = jsIrHeader.associatedModule ?: error("Internal error: cannot load module $moduleName") - val crossRef = crossModuleReferences[jsIrHeader] ?: error("Internal error: cannot find cross references for module $moduleName") + val associatedModule = jsIrHeader.associatedModule ?: icError("can not load module $moduleName") + val crossRef = crossModuleReferences[jsIrHeader] ?: icError("can not find cross references for module $moduleName") crossRef.initJsImportsForModule(associatedModule) val compiledModule = generateSingleWrappedModuleBody( diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsIrLinkerLoader.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsIrLinkerLoader.kt index c67bd79668b..d365deccc6d 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsIrLinkerLoader.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsIrLinkerLoader.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.ir.backend.js.ic +import org.jetbrains.kotlin.backend.common.serialization.DeserializationStrategy import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.languageVersionSettings @@ -71,29 +72,46 @@ internal class JsIrLinkerLoader( return dependencyGraph.keys.associateBy { klib -> getModuleDescriptor(klib) } } - fun processJsIrLinker(dirtyFiles: Collection?): Triple> { + data class LoadedJsIr(val linker: JsIrLinker, val loadedFragments: Map) + + fun loadIr(modifiedFiles: KotlinSourceFileMap, loadAllIr: Boolean = false): LoadedJsIr { val loadedModules = loadModules() val jsIrLinker = createLinker(loadedModules) - val irModules = ArrayList>(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) + val irModules = loadedModules.entries.associate { (descriptor, module) -> + val libraryFile = KotlinLibraryFile(module) + val modifiedStrategy = when { + loadAllIr -> DeserializationStrategy.ALL + module == library -> DeserializationStrategy.ALL + else -> DeserializationStrategy.EXPLICITLY_EXPORTED } + val modified = modifiedFiles[libraryFile] ?: emptyMap() + libraryFile to jsIrLinker.deserializeIrModuleHeader(descriptor, module, { + when (KotlinSourceFile(it)) { + in modified -> modifiedStrategy + else -> DeserializationStrategy.WITH_INLINE_BODIES + } + }) } jsIrLinker.init(null, emptyList()) + + if (!loadAllIr) { + for ((loadingLibFile, loadingSrcFiles) in modifiedFiles) { + val loadingIrModule = irModules[loadingLibFile] ?: notFoundIcError("loading fragment", loadingLibFile) + val moduleDeserializer = jsIrLinker.moduleDeserializer(loadingIrModule.descriptor) + for (loadingSrcFileSignatures in loadingSrcFiles.values) { + for (loadingSignature in loadingSrcFileSignatures.getExportedSignatures()) { + if (loadingSignature in moduleDeserializer) { + moduleDeserializer.addModuleReachableTopLevel(loadingSignature) + } + } + } + } + } + ExternalDependenciesGenerator(jsIrLinker.symbolTable, listOf(jsIrLinker)).generateUnboundSymbolsAsDependencies() jsIrLinker.postProcess() - - val currentIrModule = irModules.find { it.second == library }?.first!! - return Triple(jsIrLinker, currentIrModule, irModules.map { it.first }) + return LoadedJsIr(jsIrLinker, irModules) } } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsMultiModuleCache.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsMultiModuleCache.kt index 3e5c62a9ffd..21a1ca9b4ba 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsMultiModuleCache.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/JsMultiModuleCache.kt @@ -12,9 +12,9 @@ import java.io.File class JsMultiModuleCache(private val moduleArtifacts: List) { companion object { - private const val cacheModuleHeader = "cache.module.header.info" - private const val cacheJsModuleFile = "cache.module.js" - private const val cacheJsMapModuleFile = "cache.module.js.map" + private const val JS_MODULE_HEADER = "js.module.header.bin" + private const val CACHED_MODULE_JS = "module.js" + private const val CACHED_MODULE_JS_MAP = "module.js.map" } private enum class NameType(val typeMask: Int) { @@ -25,7 +25,7 @@ class JsMultiModuleCache(private val moduleArtifacts: List) { private val headerToCachedInfo = mutableMapOf() - private fun ModuleArtifact.fetchModuleInfo() = File(artifactsDir, cacheModuleHeader).useCodedInputIfExists { + private fun ModuleArtifact.fetchModuleInfo() = File(artifactsDir, JS_MODULE_HEADER).useCodedInputIfExists { val definitions = mutableSetOf() val nameBindings = mutableMapOf() @@ -49,7 +49,7 @@ class JsMultiModuleCache(private val moduleArtifacts: List) { } private fun CachedModuleInfo.commitModuleInfo() = artifact.artifactsDir?.let { cacheDir -> - File(cacheDir, cacheModuleHeader).useCodedOutput { + File(cacheDir, JS_MODULE_HEADER).useCodedOutput { val names = mutableMapOf>() for ((tag, name) in jsIrHeader.nameBindings) { names[tag] = NameType.NAME_BINDINGS.typeMask to name @@ -72,15 +72,15 @@ class JsMultiModuleCache(private val moduleArtifacts: List) { } fun fetchCompiledJsCode(artifact: ModuleArtifact) = artifact.artifactsDir?.let { cacheDir -> - val jsCode = File(cacheDir, cacheJsModuleFile).ifExists { readText() } - val sourceMap = File(cacheDir, cacheJsMapModuleFile).ifExists { readText() } + val jsCode = File(cacheDir, CACHED_MODULE_JS).ifExists { readText() } + val sourceMap = File(cacheDir, CACHED_MODULE_JS_MAP).ifExists { readText() } jsCode?.let { CompilationOutputs(it, null, sourceMap) } } fun commitCompiledJsCode(artifact: ModuleArtifact, compilationOutputs: CompilationOutputs) = artifact.artifactsDir?.let { cacheDir -> - val jsCodeCache = File(cacheDir, cacheJsModuleFile).apply { recreate() } + val jsCodeCache = File(cacheDir, CACHED_MODULE_JS).apply { recreate() } jsCodeCache.writeText(compilationOutputs.jsCode) - val jsMapCache = File(cacheDir, cacheJsMapModuleFile) + val jsMapCache = File(cacheDir, CACHED_MODULE_JS_MAP) if (compilationOutputs.sourceMap != null) { jsMapCache.recreate() jsMapCache.writeText(compilationOutputs.sourceMap) @@ -104,7 +104,7 @@ class JsMultiModuleCache(private val moduleArtifacts: List) { fun loadRequiredJsIrModules(crossModuleReferences: Map) { for ((header, references) in crossModuleReferences) { - val cachedInfo = headerToCachedInfo[header] ?: error("Internal error: cannot find artifact for module ${header.moduleName}") + val cachedInfo = headerToCachedInfo[header] ?: notFoundIcError("artifact for module ${header.moduleName}") val actualCrossModuleHash = references.crossModuleReferencesHashForIC() if (header.associatedModule == null && cachedInfo.crossModuleReferencesHash != actualCrossModuleHash) { header.associatedModule = cachedInfo.artifact.loadJsIrModule() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinLibraryHeader.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinLibraryHeader.kt new file mode 100644 index 00000000000..9f1064e90c2 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinLibraryHeader.kt @@ -0,0 +1,43 @@ +/* + * 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.library.KotlinLibrary +import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite + +internal class KotlinLibraryHeader(library: KotlinLibrary) { + val sourceFiles: List + val signatureDeserializers: Map + + init { + val filesCount = library.fileCount() + val extReg = ExtensionRegistryLite.newInstance() + val files = buildListUntil(filesCount) { + val fileProto = IrFile.parseFrom(library.file(it).codedInputStream, extReg) + add(KotlinSourceFile(fileProto.fileEntry.name)) + } + + val deserializers = buildMapUntil(filesCount) { + put(files[it], IdSignatureDeserializer(IrLibraryFileFromBytes(object : IrLibraryBytesSource() { + private fun err(): Nothing = icError("Not supported") + override fun irDeclaration(index: Int): ByteArray = err() + override fun type(index: Int): ByteArray = err() + override fun signature(index: Int): ByteArray = library.signature(index, it) + override fun string(index: Int): ByteArray = library.string(index, it) + override fun body(index: Int): ByteArray = err() + override fun debugInfo(index: Int): ByteArray? = null + }), null)) + } + + sourceFiles = files + signatureDeserializers = deserializers + } +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinSourceFileMetadata.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinSourceFileMetadata.kt new file mode 100644 index 00000000000..6332e78b2c7 --- /dev/null +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/KotlinSourceFileMetadata.kt @@ -0,0 +1,102 @@ +/* + * 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.ir.declarations.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 + +@JvmInline +value class KotlinLibraryFile(val path: String) { + constructor(lib: KotlinLibrary) : this(lib.libraryFile.canonicalPath) + + fun toProtoStream(out: CodedOutputStream) = out.writeStringNoTag(path) + + companion object { + fun fromProtoStream(input: CodedInputStream) = KotlinLibraryFile(input.readString()) + } +} + +@JvmInline +value class KotlinSourceFile(val path: String) { + constructor(irFile: IrFile) : this(irFile.fileEntry.name) + + fun toProtoStream(out: CodedOutputStream) = out.writeStringNoTag(path) + + companion object { + fun fromProtoStream(input: CodedInputStream) = KotlinSourceFile(input.readString()) + } +} + +open class KotlinSourceFileMap(files: Map>) : + Map> by files { + + inline fun forEachFile(f: (KotlinLibraryFile, KotlinSourceFile, T) -> Unit) = + forEach { (lib, files) -> files.forEach { (file, data) -> f(lib, file, data) } } + + operator fun get(libFile: KotlinLibraryFile, sourceFile: KotlinSourceFile): T? = get(libFile)?.get(sourceFile) +} + +class KotlinSourceFileMutableMap( + private val files: MutableMap> = mutableMapOf() +) : KotlinSourceFileMap(files) { + + operator fun set(libFile: KotlinLibraryFile, sourceFile: KotlinSourceFile, data: T) = getOrPutFiles(libFile).put(sourceFile, data) + operator fun set(libFile: KotlinLibraryFile, sourceFiles: MutableMap) = files.put(libFile, sourceFiles) + + fun getOrPutFiles(libFile: KotlinLibraryFile) = files.getOrPut(libFile) { mutableMapOf() } + + fun copyFilesFrom(other: KotlinSourceFileMap) { + for ((libFile, srcFiles) in other) { + files.getOrPut(libFile) { mutableMapOf() } += srcFiles + } + } + + fun removeFile(libFile: KotlinLibraryFile, sourceFile: KotlinSourceFile) { + val libFiles = files[libFile] + if (libFiles != null) { + libFiles.remove(sourceFile) + if (libFiles.isEmpty()) { + files.remove(libFile) + } + } + } + + fun clear() = files.clear() +} + +fun KotlinSourceFileMap.toMutable(): KotlinSourceFileMutableMap { + return KotlinSourceFileMutableMap(entries.associateTo(mutableMapOf()) { it.key to it.value.toMutableMap() }) +} + +fun KotlinSourceFileMap>.flatSignatures(): Set { + val allSignatures = mutableSetOf() + forEachFile { _, _, signatures -> allSignatures += signatures } + return allSignatures +} + +fun KotlinSourceFileMutableMap>.addSignature( + lib: KotlinLibraryFile, src: KotlinSourceFile, signature: IdSignature +) = when (val signatures = this[lib, src]) { + null -> this[lib, src] = mutableSetOf(signature) + else -> signatures += signature +} + +abstract class KotlinSourceFileExports { + abstract val inverseDependencies: KotlinSourceFileMap> + + open fun getExportedSignatures(): Set = inverseDependencies.flatSignatures() +} + +abstract class KotlinSourceFileMetadata : KotlinSourceFileExports() { + abstract val directDependencies: KotlinSourceFileMap> + + abstract val importedInlineFunctions: Map +} + +fun KotlinSourceFileMetadata.isEmpty() = inverseDependencies.isEmpty() && directDependencies.isEmpty() && importedInlineFunctions.isEmpty() diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ArtifactCache.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ModuleArtifact.kt similarity index 78% rename from compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ArtifactCache.kt rename to compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ModuleArtifact.kt index 1fad8780d21..407f0507754 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ArtifactCache.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ModuleArtifact.kt @@ -41,18 +41,3 @@ class ModuleArtifact( return JsIrModule(moduleSafeName, moduleSafeName, fragments) } } - -abstract class ArtifactCache { - protected val binaryAsts = mutableMapOf() - protected val fragments = mutableMapOf() - - fun saveBinaryAst(srcPath: String, binaryAst: ByteArray) { - binaryAsts[srcPath] = binaryAst - } - - fun saveFragment(srcPath: String, fragment: JsIrProgramFragment) { - fragments[srcPath] = fragment - } - - abstract fun fetchArtifacts(): ModuleArtifact -} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/invalidation.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/invalidation.kt deleted file mode 100644 index 8d0ffa70ff9..00000000000 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/invalidation.kt +++ /dev/null @@ -1,348 +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.config.CompilerConfiguration -import org.jetbrains.kotlin.ir.backend.js.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker -import org.jetbrains.kotlin.ir.declarations.IrFactory -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrModuleFragment -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction -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.name.FqName -import org.jetbrains.kotlin.protobuf.ExtensionRegistryLite -import org.jetbrains.kotlin.psi2ir.descriptors.IrBuiltInsOverDescriptors -import org.jetbrains.kotlin.psi2ir.generators.TypeTranslatorImpl -import org.jetbrains.kotlin.storage.LockBasedStorageManager -import java.io.File - - -fun interface CacheExecutor { - fun execute( - currentModule: IrModuleFragment, - dependencies: Collection, - deserializer: JsIrLinker, - configuration: CompilerConfiguration, - dirtyFiles: Collection?, // if null consider the whole module dirty - artifactCache: ArtifactCache, - exportedDeclarations: Set, - mainArguments: List?, - ) -} - -sealed class CacheUpdateStatus { - object FastPath : CacheUpdateStatus() - class NoDirtyFiles(val removed: Set) : CacheUpdateStatus() - class Dirty(val removed: Set, val updated: Set, val updatedAll: Boolean) : CacheUpdateStatus() -} - -class CacheUpdater( - private val rootModule: String, - private val allModules: Collection, - private val compilerConfiguration: CompilerConfiguration, - private val icCachePaths: Collection, - private val irFactory: () -> IrFactory, - private val mainArguments: List?, - private val executor: CacheExecutor -) { - private fun KotlinLibrary.moduleCanonicalName() = libraryFile.canonicalPath - - private inner class KLibCacheUpdater( - private val library: KotlinLibrary, - private val dependencyGraph: Map>, - private val incrementalCache: IncrementalCache, - private val klibIncrementalCaches: Map - ) { - private fun invalidateCacheForModule(externalHashes: Map): Pair, Map> { - val fileFingerPrints = mutableMapOf() - val dirtyFiles = mutableSetOf() - - 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 - } - - private fun getDependencySubGraph(): Map> { - val subGraph = mutableMapOf>() - - 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, - dirtyFiles: Collection, - cleanInlineHashes: Map, - fileFingerPrints: Map - ) { - 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: IrFunction): 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() - 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 { - 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): Map> { - val nameToKotlinLibrary: Map = 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 { - val libraries = loadLibraries() - val dependencyGraph = buildDependenciesGraph(libraries) - val configHash = compilerConfiguration.configHashForIC() - - val cacheMap = libraries.values.zip(icCachePaths).toMap() - - val klibIncrementalCaches = mutableMapOf() - - val visitedLibraries = mutableSetOf() - 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() } - } -} - - -// Used for tests only -fun rebuildCacheForDirtyFiles( - library: KotlinLibrary, - configuration: CompilerConfiguration, - dependencyGraph: Map>, - dirtyFiles: Collection?, - artifactCache: ArtifactCache, - irFactory: IrFactory, - exportedDeclarations: Set, - mainArguments: List?, -): String { - val jsIrLinkerProcessor = JsIrLinkerLoader(configuration, library, dependencyGraph, irFactory) - val (jsIrLinker, currentIrModule, irModules) = jsIrLinkerProcessor.processJsIrLinker(dirtyFiles) - - buildCacheForModuleFiles( - currentIrModule, - irModules, - jsIrLinker, - configuration, - dirtyFiles, - artifactCache, - exportedDeclarations, - mainArguments - ) - return currentIrModule.name.asString() -} - -@Suppress("UNUSED_PARAMETER") -fun buildCacheForModuleFiles( - currentModule: IrModuleFragment, - dependencies: Collection, - deserializer: JsIrLinker, - configuration: CompilerConfiguration, - dirtyFiles: Collection?, // if null consider the whole module dirty - artifactCache: ArtifactCache, - exportedDeclarations: Set, - mainArguments: List?, -) { - compileWithIC( - currentModule, - configuration = configuration, - deserializer = deserializer, - dependencies = dependencies, - mainArguments = mainArguments, - exportedDeclarations = exportedDeclarations, - filesToLower = dirtyFiles?.toSet(), - artifactCache = artifactCache, - ) -} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsPropertyAccessorInlineLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsPropertyAccessorInlineLowering.kt index d3182b39a7e..165d6628d86 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsPropertyAccessorInlineLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsPropertyAccessorInlineLowering.kt @@ -21,10 +21,11 @@ class JsPropertyAccessorInlineLowering( return false // Member properties could be safely inlined, because initialization processed via parent declaration - if (!isTopLevel) return true + if (!isTopLevel && !context.icCompatibleIr2Js.incrementalCacheEnabled) + return true // TODO: teach the deserializer to load constant property initializers - if (context.icCompatibleIr2Js) { + if (context.icCompatibleIr2Js.isCompatible) { val accessFile = accessContainer.fileOrNull ?: return false val file = fileOrNull ?: return false @@ -49,4 +50,4 @@ class JsPropertyAccessorInlineLowering( false } } -} \ No newline at end of file +} diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformerTmp.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformerTmp.kt index 16bdbc9ffe6..0670580a63f 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformerTmp.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformerTmp.kt @@ -62,6 +62,8 @@ enum class TranslationMode( } } +class JsIrFragmentAndBinaryAst(val irFile: IrFile, val fragment: JsIrProgramFragment, val binaryAst: ByteArray) + class IrModuleToJsTransformerTmp( private val backendContext: JsIrBackendContext, private val mainArguments: List?, @@ -125,14 +127,10 @@ class IrModuleToJsTransformerTmp( return CompilerResult(result, dts) } - class SrcFileFragmentAndBinaryAst(val srcPath: String, val fragment: JsIrProgramFragment, val binaryAst: ByteArray) - - fun generateBinaryAst(files: Iterable, allModules: Iterable): List { + fun generateBinaryAst(files: Collection, allModules: Collection): List { val exportModelGenerator = ExportModelGenerator(backendContext, generateNamespacesForPackages = true) - val exportData = files.associate { file -> - file to exportModelGenerator.generateExportWithExternals(file) - } + val exportData = files.map { it to exportModelGenerator.generateExportWithExternals(it) } allModules.forEach { it.files.forEach { @@ -141,13 +139,12 @@ class IrModuleToJsTransformerTmp( } val serializer = JsIrAstSerializer() - return files.map { f -> - val exports = exportData[f]!! // TODO - val fragment = generateProgramFragment(f, exports, minimizedMemberNames = false) + return exportData.map { (file, exports) -> + val fragment = generateProgramFragment(file, exports, minimizedMemberNames = false) val output = ByteArrayOutputStream() serializer.serialize(fragment, output) val binaryAst = output.toByteArray() - SrcFileFragmentAndBinaryAst(f.fileEntry.name, fragment, binaryAst) + JsIrFragmentAndBinaryAst(file, fragment, binaryAst) } } diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/TestModel.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/TestModel.kt index 4036a557492..e1588692944 100644 --- a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/TestModel.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/TestModel.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.codegen +import org.jetbrains.kotlin.ir.backend.js.ic.DirtyFileState import java.io.File import java.util.regex.Pattern @@ -43,19 +44,13 @@ class ModuleInfo(val moduleName: String) { class ModuleStep( val id: Int, val dependencies: Collection, - val dirtyFiles: Collection, val modifications: List, - val directives: Set + val expectedFileStats: Map> ) val steps = mutableListOf() } -enum class StepDirectives(val mnemonic: String) { - FAST_PATH_UPDATE("FP"), - UNUSED_MODULE("UNUSED") -} - const val MODULES_LIST = "MODULES" const val PROJECT_INFO_FILE = "project.info" const val MODULE_INFO_FILE = "module.info" @@ -203,18 +198,10 @@ class ModuleInfoParser(infoFile: File) : InfoParser(infoFile) { return modifications } - private fun MutableSet.parseStepFlags(flags: String) { - val tokens = flags.trim().split(" ").map { it.trim() } - for (directive in StepDirectives.values()) { - if (directive.mnemonic in tokens) add(directive) - } - } - private fun parseSteps(firstId: Int, lastId: Int): List { + val expectedFileStats = mutableMapOf>() val dependencies = mutableSetOf() - val dirtyFiles = mutableSetOf() val modifications = mutableListOf() - val directives = mutableSetOf() loop { line -> if (line.matches(STEP_PATTERN.toRegex())) @@ -225,17 +212,30 @@ class ModuleInfoParser(infoFile: File) : InfoParser(infoFile) { if (opIndex < 0) throwSyntaxError(line) val op = line.substring(0, opIndex) - when (op) { - "dependencies" -> line.substring(opIndex + 1).split(",").filter { it.isNotBlank() }.forEach { dependencies.add(it.trim()) } - "dirty" -> line.substring(opIndex + 1).split(",").filter { it.isNotBlank() }.forEach { dirtyFiles.add(it.trim()) } - "modifications" -> modifications.addAll(parseModifications()) - "flags" -> directives.parseStepFlags(line.substring(opIndex + 1)) - else -> println(diagnosticMessage("Unknown op $op", line)) + fun getOpArgs() = line.substring(opIndex + 1).splitAndTrim() + + val expectedState = DirtyFileState.values().find { it.str == op } + if (expectedState != null) { + expectedFileStats[expectedState.str] = getOpArgs().toSet() + } else { + when (op) { + "dependencies" -> getOpArgs().forEach { dependencies.add(it) } + "modifications" -> modifications.addAll(parseModifications()) + else -> println(diagnosticMessage("Unknown op $op", line)) + } } + false } - return (firstId..lastId).map { ModuleInfo.ModuleStep(it, dependencies, dirtyFiles, modifications, directives) } + return (firstId..lastId).map { + ModuleInfo.ModuleStep( + id = it, + dependencies = dependencies, + modifications = modifications, + expectedFileStats = expectedFileStats + ) + } } override fun parse(entryName: String): ModuleInfo { diff --git a/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt b/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt index b211f6a2998..32f7c390011 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt @@ -19,8 +19,10 @@ import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.ir.backend.js.* import org.jetbrains.kotlin.ir.backend.js.ic.* import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker +import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsIrFragmentAndBinaryAst import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.SourceMapsInfo import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.safeModuleName +import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC @@ -33,18 +35,18 @@ import org.jetbrains.kotlin.test.KotlinTestWithEnvironment import org.jetbrains.kotlin.test.util.JUnit4Assertions import org.junit.ComparisonFailure import java.io.File -import kotlin.io.path.createTempDirectory +import java.util.EnumSet abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { companion object { private const val TEST_DATA_DIR_PATH = "js/js.translator/testData/" + private const val BOX_FUNCTION_NAME = "box" + private const val STDLIB_ALIAS = "stdlib" - private const val stdlibAlias = "stdlib" - private const val stdlibModuleName = "kotlin" - private val stdlibKlibPath = File(System.getProperty("kotlin.js.stdlib.klib.path") ?: error("Please set stdlib path")).canonicalPath - private var stdlibCacheDir: File? = null + private val STDLIB_MODULE_NAME = "kotlin".safeModuleName + private val STDLIB_KLIB = File(System.getProperty("kotlin.js.stdlib.klib.path") ?: error("Please set stdlib path")).canonicalPath - private const val boxFunctionName = "box" + private val KT_FILE_IGNORE_PATTERN = Regex("^.*\\..+\\.kt$") } override fun createEnvironment(): KotlinCoreEnvironment { @@ -59,28 +61,6 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { return ModuleInfoParser(infoFile).parse(moduleName) } - private fun initializeStdlibCache() { - if (stdlibCacheDir != null) return - val cacheDir = createTempDirectory().toFile() - cacheDir.deleteOnExit() - - val cacheUpdater = CacheUpdater( - stdlibKlibPath, - listOf(stdlibKlibPath), - createConfiguration(stdlibAlias), - listOf(cacheDir.canonicalPath), - { IrFactoryImplForJsIC(WholeWorldStageController()) }, - null, - ::buildCacheForModuleFiles - ) - cacheUpdater.actualizeCaches { updateStatus, updatedModule -> - JUnit4Assertions.assertEquals(stdlibKlibPath, updatedModule) { "incorrect std klib path" } - JUnit4Assertions.assertTrue(updateStatus is CacheUpdateStatus.Dirty) { "std klib should be rebuilt" } - } - - stdlibCacheDir = cacheDir - } - protected fun doTest(testPath: String) { val testDirectory = File(testPath) val testName = testDirectory.name @@ -96,8 +76,6 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { modulesInfos[module] = parseModuleInfo(module, moduleInfo) } - initializeStdlibCache() - val workingDir = testWorkingDir(projectInfo.name) val sourceDir = File(workingDir, "sources").also { it.invalidateDir() } val buildDir = File(workingDir, "build").also { it.invalidateDir() } @@ -108,12 +86,10 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { } private fun resolveModuleArtifact(moduleName: String, buildDir: File): File { - if (moduleName == stdlibAlias) return File(stdlibKlibPath) return File(File(buildDir, moduleName), "$moduleName.klib") } private fun resolveModuleCache(moduleName: String, buildDir: File): File { - if (moduleName == stdlibAlias) return stdlibCacheDir ?: error("stdlib cache corruption") return File(File(buildDir, moduleName), "cache") } @@ -121,6 +97,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { val copy = environment.configuration.copy() copy.put(CommonConfigurationKeys.MODULE_NAME, moduleName) copy.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN) + copy.put(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION, true) return copy } @@ -135,9 +112,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { val moduleName: String, val modulePath: String, val icCacheDir: String, - val directives: Set, - val dirtyFiles: List = emptyList(), - val deletedFiles: List = emptyList() + val expectedFileStats: Map> ) private fun setupTestStep(projStepId: Int, module: String): TestStepInfo { @@ -145,67 +120,64 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { val moduleSourceDir = File(sourceDir, module) val moduleInfo = moduleInfos[module] ?: error("No module info found for $module") val moduleStep = moduleInfo.steps[projStepId] - val deletedFiles = mutableListOf() + val deletedFiles = mutableSetOf() for (modification in moduleStep.modifications) { - modification.execute(moduleTestDir, moduleSourceDir) { deletedFiles.add(it) } + modification.execute(moduleTestDir, moduleSourceDir) { deletedFiles.add(it.name) } } - val dependencies = moduleStep.dependencies.map { resolveModuleArtifact(it, buildDir) } + val dependencies = moduleStep.dependencies.mapTo(mutableListOf(File(STDLIB_KLIB))) { resolveModuleArtifact(it, buildDir) } val outputKlibFile = resolveModuleArtifact(module, buildDir) val configuration = createConfiguration(module) buildArtifact(configuration, module, moduleSourceDir, dependencies, outputKlibFile) + val expectedFileStats = if (deletedFiles.isEmpty()) { + moduleStep.expectedFileStats + } else { + moduleStep.expectedFileStats + (DirtyFileState.REMOVED_FILE.str to deletedFiles) + } return TestStepInfo( module.safeModuleName, outputKlibFile.canonicalPath, resolveModuleCache(module, buildDir).canonicalPath, - moduleStep.directives, - moduleStep.dirtyFiles.map { File(moduleSourceDir, it).canonicalPath }, - deletedFiles.map { it.canonicalPath } + expectedFileStats ) } - private fun verifyCacheUpdateStatus(stepId: Int, statuses: Map, testInfo: List) { - val expectedInfo = testInfo.filter { StepDirectives.UNUSED_MODULE !in it.directives } + private fun verifyCacheUpdateStats( + stepId: Int, stats: KotlinSourceFileMap>, testInfo: List + ) { + val gotStats = stats.filter { it.key.path != STDLIB_KLIB } - JUnit4Assertions.assertEquals(statuses.size, expectedInfo.size) { - "Mismatched updated modules count at step $stepId" + val checkedLibs = mutableSetOf() + + for (info in testInfo) { + val libFile = KotlinLibraryFile(info.modulePath) + val updateStatus = gotStats[libFile] ?: emptyMap() + checkedLibs += libFile + + val got = mutableMapOf>() + for ((srcFile, dirtyStats) in updateStatus) { + for (dirtyStat in dirtyStats) { + got.getOrPut(dirtyStat.str) { mutableSetOf() }.add(File(srcFile.path).name) + } + } + + JUnit4Assertions.assertSameElements(got.entries, info.expectedFileStats.entries) { + "Mismatched file stats for module [${info.moduleName}] at step $stepId" + } } - for (info in expectedInfo) { - JUnit4Assertions.assertTrue(info.modulePath in statuses) { - "Status is missed for ${info.modulePath} at step $stepId" - } - val updateStatus = statuses[info.modulePath]!! - if (StepDirectives.FAST_PATH_UPDATE in info.directives) { - JUnit4Assertions.assertEquals(CacheUpdateStatus.FastPath, updateStatus) { - "Cache has to be checked by fast path, instead it $updateStatus at step $stepId" - } - } else { - JUnit4Assertions.assertNotEquals(CacheUpdateStatus.FastPath, updateStatus) { - "Cache has not to be checked by fast path, but it is at step $stepId" - } - } - - val (updated, removed) = when (updateStatus) { - is CacheUpdateStatus.FastPath -> emptySet() to emptySet() - is CacheUpdateStatus.NoDirtyFiles -> emptySet() to updateStatus.removed - is CacheUpdateStatus.Dirty -> updateStatus.updated to updateStatus.removed - } - - JUnit4Assertions.assertSameElements(info.dirtyFiles, updated.map { File(it).canonicalPath }) { - "Mismatched DIRTY files for module ${info.moduleName} at step $stepId" - } - - JUnit4Assertions.assertSameElements(info.deletedFiles, removed.map { File(it).canonicalPath }) { - "Mismatched DELETED files for module ${info.moduleName} at step $stepId" + for (libFile in gotStats.keys) { + JUnit4Assertions.assertTrue(libFile in checkedLibs) { + "Got unexpected stats for module [${libFile.path}] at step $stepId" } } } private fun verifyJsExecutableProducerBuildModules(stepId: Int, gotRebuilt: Set, expectedRebuilt: List) { - val expected = expectedRebuilt.map { if (it == stdlibAlias) stdlibModuleName.safeModuleName else it.safeModuleName } - JUnit4Assertions.assertSameElements(expected, gotRebuilt) { + val expected = expectedRebuilt.map { it.safeModuleName } + val got = gotRebuilt.filter { it != STDLIB_MODULE_NAME } + JUnit4Assertions.assertSameElements(got, expected) { "Mismatched rebuilt modules at step $stepId" } } @@ -226,7 +198,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { files = files, testModuleName = mainModuleName, testPackageName = null, - testFunctionName = boxFunctionName, + testFunctionName = BOX_FUNCTION_NAME, testFunctionArgs = "$stepId", expectedResult = "OK", withModuleSystem = false @@ -240,64 +212,42 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { fun executorWithBoxExport( currentModule: IrModuleFragment, - dependencies: Collection, + allModules: Collection, deserializer: JsIrLinker, configuration: CompilerConfiguration, - dirtyFiles: Collection?, - artifactCache: ArtifactCache, + dirtyFiles: Collection, exportedDeclarations: Set, mainArguments: List? - ) { - buildCacheForModuleFiles( - currentModule = currentModule, - dependencies = dependencies, + ): List { + return buildCacheForModuleFiles( + mainModule = currentModule, + allModules = allModules, deserializer = deserializer, configuration = configuration, dirtyFiles = dirtyFiles, - artifactCache = artifactCache, - exportedDeclarations = exportedDeclarations + FqName(boxFunctionName), + exportedDeclarations = exportedDeclarations + FqName(BOX_FUNCTION_NAME), mainArguments = mainArguments, ) } fun execute() { - val stdlibInfo = TestStepInfo( - moduleName = stdlibModuleName.safeModuleName, - modulePath = stdlibKlibPath, - icCacheDir = stdlibCacheDir!!.canonicalPath, - directives = setOf(StepDirectives.FAST_PATH_UPDATE) - ) + val stdlibCacheDir = resolveModuleCache(STDLIB_ALIAS, buildDir).canonicalPath for (projStep in projectInfo.steps) { - val testInfo = projStep.order.mapTo(mutableListOf(stdlibInfo)) { setupTestStep(projStep.id, it) } + val testInfo = projStep.order.map { setupTestStep(projStep.id, it) } val configuration = createConfiguration(projStep.order.last()) val cacheUpdater = CacheUpdater( - rootModule = testInfo.last().modulePath, - testInfo.map { it.modulePath }, - configuration, - testInfo.map { it.icCacheDir }, - { IrFactoryImplForJsIC(WholeWorldStageController()) }, - null, - ::executorWithBoxExport + mainModule = testInfo.last().modulePath, + allModules = testInfo.mapTo(mutableListOf(STDLIB_KLIB)) { it.modulePath }, + icCachePaths = testInfo.mapTo(mutableListOf(stdlibCacheDir)) { it.icCacheDir }, + compilerConfiguration = configuration, + irFactory = { IrFactoryImplForJsIC(WholeWorldStageController()) }, + mainArguments = null, + executor = ::executorWithBoxExport ) - val updateStatuses = mutableMapOf() - var icCaches = cacheUpdater.actualizeCaches { updateStatus, updatedModule -> updateStatuses[updatedModule] = updateStatus } - verifyCacheUpdateStatus(projStep.id, updateStatuses, testInfo) - - val mainModuleCacheDir = icCaches.last().artifactsDir!! - // tests use one stdlib artifact for all cases, patching stdlib cache path here: - // - enable using cached js (stdlib) file through all steps in a test case - // - disable using cached js (stdlib) file through test cases - icCaches = icCaches.map { - when (it.moduleSafeName) { - stdlibModuleName.safeModuleName -> { - val stdlibDir = File(mainModuleCacheDir, stdlibAlias).apply { mkdirs() } - ModuleArtifact(stdlibModuleName, it.fileArtifacts, stdlibDir, it.forceRebuildJs) - } - else -> it - } - } + val icCaches = cacheUpdater.actualizeCaches() + verifyCacheUpdateStats(projStep.id, cacheUpdater.getDirtyFileStats(), testInfo) val jsExecutableProducer = JsExecutableProducer( mainModuleName = testInfo.last().moduleName, @@ -315,9 +265,11 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { } } + private fun String.isAllowedKtFile() = endsWith(".kt") && !KT_FILE_IGNORE_PATTERN.matches(this) + private fun File.filteredKtFiles(): Collection { assert(isDirectory && exists()) - return listFiles { _, name -> name.endsWith(".kt") }!!.toList() + return listFiles { _, name -> name.isAllowedKtFile() }!!.toList() } private fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile { @@ -332,11 +284,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { } private fun buildArtifact( - configuration: CompilerConfiguration, - moduleName: String, - sourceDir: File, - dependencies: Collection, - outputKlibFile: File + configuration: CompilerConfiguration, moduleName: String, sourceDir: File, dependencies: Collection, outputKlibFile: File ) { if (outputKlibFile.exists()) outputKlibFile.delete() @@ -345,11 +293,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) } val sourceModule = prepareAnalyzedSourceModule( - projectJs, - sourceFiles, - configuration, - dependencies.map { it.canonicalPath }, - emptyList(), // TODO + projectJs, sourceFiles, configuration, dependencies.map { it.canonicalPath }, emptyList(), // TODO AnalyzerWithCompilerReport(configuration) ) @@ -362,7 +306,7 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() { File(buildDir, module).invalidateDir() val testModuleDir = File(testDir, module) - testModuleDir.listFiles { _, fileName -> fileName.endsWith(".kt") }!!.forEach { file -> + testModuleDir.listFiles { _, fileName -> fileName.isAllowedKtFile() }!!.forEach { file -> assert(!file.isDirectory) val fileName = file.name val workingFile = File(moduleSourceDir, fileName) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsIrIncrementalDataProvider.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsIrIncrementalDataProvider.kt index 9a47fc08b82..d3e72e6311f 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsIrIncrementalDataProvider.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/utils/JsIrIncrementalDataProvider.kt @@ -26,15 +26,15 @@ import org.jetbrains.kotlin.test.services.jsLibraryProvider import java.io.ByteArrayInputStream import java.io.File -private class TestArtifactCache(var moduleName: String? = null) : ArtifactCache() { - override fun fetchArtifacts(): ModuleArtifact { +private class TestArtifactCache(val moduleName: String, val binaryAsts: MutableMap = mutableMapOf()) { + fun fetchArtifacts(): ModuleArtifact { val deserializer = JsIrAstDeserializer() return ModuleArtifact( - moduleName = moduleName ?: error("Module name is not set"), + moduleName = moduleName, fileArtifacts = binaryAsts.entries.map { SrcFileArtifact( srcFilePath = it.key, - // TODO: It will be better to use saved fragments (this.fragments), but it doesn't work + // TODO: It will be better to use saved fragments (from JsIrFragmentAndBinaryAst), but it doesn't work // Merger.merge() + JsNode.resolveTemporaryNames() modify fragments, // therefore the sequential calls produce different results fragment = deserializer.deserialize(ByteArrayInputStream(it.value)) @@ -42,13 +42,6 @@ private class TestArtifactCache(var moduleName: String? = null) : ArtifactCache( } ) } - - fun invalidateForFile(srcPath: String) { - binaryAsts.remove(srcPath) - fragments.remove(srcPath) - } - - fun getAst(srcPath: String) = binaryAsts[srcPath] } class JsIrIncrementalDataProvider(private val testServices: TestServices) : TestService { @@ -76,8 +69,8 @@ class JsIrIncrementalDataProvider(private val testServices: TestServices) : Test for (testFile in module.files) { if (JsEnvironmentConfigurationDirectives.RECOMPILE in testFile.directives) { val fileName = "/${testFile.name}" - oldBinaryAsts[fileName] = moduleCache.getAst(fileName) ?: error("No AST found for $fileName") - moduleCache.invalidateForFile(fileName) + oldBinaryAsts[fileName] = moduleCache.binaryAsts[fileName] ?: error("No AST found for $fileName") + moduleCache.binaryAsts.remove(fileName) } } @@ -122,43 +115,50 @@ class JsIrIncrementalDataProvider(private val testServices: TestServices) : Test mainArguments: List? ) { val canonicalPath = File(path).canonicalPath - var moduleCache = predefinedKlibHasIcCache[canonicalPath] + val predefinedModuleCache = predefinedKlibHasIcCache[canonicalPath] + if (predefinedModuleCache != null) { + icCache[canonicalPath] = predefinedModuleCache + return + } - if (moduleCache == null) { - moduleCache = icCache[canonicalPath] ?: TestArtifactCache() + val libs = allDependencies.associateBy { File(it.libraryFile.path).canonicalPath } - val libs = allDependencies.associateBy { File(it.libraryFile.path).canonicalPath } + val nameToKotlinLibrary: Map = libs.values.associateBy { it.moduleName } - val nameToKotlinLibrary: Map = libs.values.associateBy { it.moduleName } - - val dependencyGraph = libs.values.associateWith { - it.manifestProperties.propertyList(KLIB_PROPERTY_DEPENDS, escapeInQuotes = true).map { depName -> - nameToKotlinLibrary[depName] ?: error("No Library found for $depName") - } + val dependencyGraph = libs.values.associateWith { + it.manifestProperties.propertyList(KLIB_PROPERTY_DEPENDS, escapeInQuotes = true).map { depName -> + nameToKotlinLibrary[depName] ?: error("No Library found for $depName") } + } - val currentLib = libs[File(canonicalPath).canonicalPath] ?: error("Expected library at $canonicalPath") + val currentLib = libs[File(canonicalPath).canonicalPath] ?: error("Expected library at $canonicalPath") - val testPackage = extractTestPackage(testServices) + val testPackage = extractTestPackage(testServices) - moduleCache.moduleName = rebuildCacheForDirtyFiles( - currentLib, - configuration, - dependencyGraph, - dirtyFiles, - moduleCache, - IrFactoryImplForJsIC(WholeWorldStageController()), - setOf(FqName.fromSegments(listOfNotNull(testPackage, JsBoxRunner.TEST_FUNCTION))), - mainArguments, - ) + val (mainModuleIr, rebuiltFiles) = rebuildCacheForDirtyFiles( + currentLib, + configuration, + dependencyGraph, + dirtyFiles, + IrFactoryImplForJsIC(WholeWorldStageController()), + setOf(FqName.fromSegments(listOfNotNull(testPackage, JsBoxRunner.TEST_FUNCTION))), + mainArguments, + ) - if (canonicalPath in predefinedKlibHasIcCache) { - predefinedKlibHasIcCache[canonicalPath] = moduleCache + val moduleCache = icCache[canonicalPath] ?: TestArtifactCache(mainModuleIr.name.asString()) + for (rebuiltFile in rebuiltFiles) { + if (rebuiltFile.irFile.module == mainModuleIr) { + moduleCache.binaryAsts[rebuiltFile.irFile.fileEntry.name] = rebuiltFile.binaryAst } } + if (canonicalPath in predefinedKlibHasIcCache) { + predefinedKlibHasIcCache[canonicalPath] = moduleCache + } + icCache[canonicalPath] = moduleCache } } val TestServices.jsIrIncrementalDataProvider: JsIrIncrementalDataProvider by TestServices.testServiceAccessor() + diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java index 5e33f45f26d..459ea4aa6ef 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java @@ -26,10 +26,30 @@ public class InvalidationTestGenerated extends AbstractInvalidationTest { KotlinTestUtils.runTest(this::doTest, TargetBackend.JS_IR, testDataFilePath); } + @TestMetadata("addUpdateRemoveDependentFile") + public void testAddUpdateRemoveDependentFile() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/"); + } + + @TestMetadata("addUpdateRemoveDependentModule") + public void testAddUpdateRemoveDependentModule() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/"); + } + public void testAllFilesPresentInInvalidation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/incremental/invalidation"), Pattern.compile("^([^_](.+))$"), null, TargetBackend.JS_IR, false); } + @TestMetadata("circleExportsUpdate") + public void testCircleExportsUpdate() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/circleExportsUpdate/"); + } + + @TestMetadata("circleInlineImportsUpdate") + public void testCircleInlineImportsUpdate() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/"); + } + @TestMetadata("class") public void testClass() throws Exception { runTest("js/js.translator/testData/incremental/invalidation/class/"); @@ -50,6 +70,16 @@ public class InvalidationTestGenerated extends AbstractInvalidationTest { runTest("js/js.translator/testData/incremental/invalidation/crossModuleReferences/"); } + @TestMetadata("eagerInitialization") + public void testEagerInitialization() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/eagerInitialization/"); + } + + @TestMetadata("exportsThroughInlineFunction") + public void testExportsThroughInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/"); + } + @TestMetadata("fakeOverride") public void testFakeOverride() throws Exception { runTest("js/js.translator/testData/incremental/invalidation/fakeOverride/"); @@ -180,6 +210,16 @@ public class InvalidationTestGenerated extends AbstractInvalidationTest { runTest("js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/"); } + @TestMetadata("updateExports") + public void testUpdateExports() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/updateExports/"); + } + + @TestMetadata("updateExportsAndInlineImports") + public void testUpdateExportsAndInlineImports() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/"); + } + @TestMetadata("variance") public void testVariance() throws Exception { runTest("js/js.translator/testData/incremental/invalidation/variance/"); diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1a.0.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1a.0.kt new file mode 100644 index 00000000000..69bfebf4346 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1a.0.kt @@ -0,0 +1,3 @@ +fun foo0() = 42 + +fun foo0_1() = 78 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.1.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.1.kt new file mode 100644 index 00000000000..64a1e71af81 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.1.kt @@ -0,0 +1 @@ +fun foo1() = foo0_1() / 2 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.2.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.2.kt new file mode 100644 index 00000000000..25c152e588f --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/l1b.2.kt @@ -0,0 +1 @@ +fun foo1() = 123 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/module.info new file mode 100644 index 00000000000..f9ab121586a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib1/module.info @@ -0,0 +1,29 @@ +STEP 0: + modifications: + U : l1a.0.kt -> l1a.kt + added file: l1a.kt +STEP 1: + modifications: + U : l1b.1.kt -> l1b.kt + added file: l1b.kt + updated exports: l1a.kt +STEP 2: + modifications: + U : l1b.2.kt -> l1b.kt + modified ir: l1b.kt + updated exports: l1a.kt +STEP 3: + updated exports: l1a.kt, l1b.kt +STEP 4: + updated exports: l1a.kt, l1b.kt +STEP 5: + modifications: + U : l1b.1.kt -> l1b.kt + modified ir: l1b.kt + updated exports: l1a.kt +STEP 6: + modifications: + D : l1b.kt + removed inverse depends: l1a.kt +STEP 7: + updated exports: l1a.kt diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.0.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.0.kt new file mode 100644 index 00000000000..83926fef175 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.0.kt @@ -0,0 +1 @@ +inline fun qux() = foo0() diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.1.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.1.kt new file mode 100644 index 00000000000..d91f8299f8a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.1.kt @@ -0,0 +1 @@ +inline fun qux() = foo0() + foo1() diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.3.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.3.kt new file mode 100644 index 00000000000..67dbcfe93e0 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/l2.3.kt @@ -0,0 +1 @@ +inline fun qux() = foo0() + foo0_1() diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/module.info new file mode 100644 index 00000000000..9e4cd052a68 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/lib2/module.info @@ -0,0 +1,34 @@ +STEP 0: + dependencies: lib1 + modifications: + U : l2.0.kt -> l2.kt + added file: l2.kt +STEP 1: + dependencies: lib1 + modifications: + U : l2.1.kt -> l2.kt + modified ir: l2.kt +STEP 2: + dependencies: lib1 +STEP 3: + dependencies: lib1 + modifications: + U : l2.3.kt -> l2.kt + modified ir: l2.kt +STEP 4: + dependencies: lib1 + modifications: + U : l2.1.kt -> l2.kt + modified ir: l2.kt +STEP 5: + dependencies: lib1 +STEP 6: + dependencies: lib1 + modifications: + U : l2.0.kt -> l2.kt + modified ir: l2.kt +STEP 7: + dependencies: lib1 + modifications: + U : l2.3.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/m.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/m.kt new file mode 100644 index 00000000000..010638ff113 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/m.kt @@ -0,0 +1,10 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 6 -> if (qux() != 42) return "Fail" + 1, 5 -> if (qux() != 42 + 78 / 2) return "Fail" + 2, 4 -> if (qux() != 42 + 123) return "Fail" + 3, 7 -> if (qux() != 42 + 78) return "Fail" + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/module.info new file mode 100644 index 00000000000..2f0924d3a9e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/main/module.info @@ -0,0 +1,19 @@ +STEP 0: + dependencies: lib1, lib2 + added file: m.kt +STEP 1: + dependencies: lib1, lib2 + updated inline imports: m.kt +STEP 2: + dependencies: lib1, lib2 +STEP 3..4: + dependencies: lib1, lib2 + updated inline imports: m.kt +STEP 5: + dependencies: lib1, lib2 +STEP 6: + dependencies: lib1, lib2 + updated inline imports: m.kt +STEP 7: + dependencies: lib1, lib2 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/project.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/project.info new file mode 100644 index 00000000000..30679d73bc6 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentFile/project.info @@ -0,0 +1,17 @@ +MODULES: lib1, lib2, main + +STEP 0..1: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 2: + libs: lib1, lib2, main + dirty js: lib1 +STEP 3..4: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 5: + libs: lib1, lib2, main + dirty js: lib1 +STEP 6..7: + libs: lib1, lib2, main + dirty js: lib1, lib2, main diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.4.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.4.kt new file mode 100644 index 00000000000..d5b95d29c70 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.4.kt @@ -0,0 +1 @@ +fun qux1() = 42 + foo() * 8 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.kt new file mode 100644 index 00000000000..7fa05a69903 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1a.kt @@ -0,0 +1 @@ +fun qux1() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1b.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1b.kt new file mode 100644 index 00000000000..faaf2b85f10 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/l1b.kt @@ -0,0 +1 @@ +fun foo() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/module.info new file mode 100644 index 00000000000..c29e358ef9d --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib1/module.info @@ -0,0 +1,11 @@ +STEP 0: + added file: l1a.kt, l1b.kt +STEP 1: + updated exports: l1b.kt, l1a.kt +STEP 2: + updated exports: l1a.kt +STEP 3: +STEP 4: + modifications: + U : l1a.4.kt -> l1a.kt + modified ir: l1a.kt diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.1.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.1.kt new file mode 100644 index 00000000000..41aafede801 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.1.kt @@ -0,0 +1 @@ +inline fun qux2() = foo() + 32 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.2.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.2.kt new file mode 100644 index 00000000000..837031f59e0 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/l2.2.kt @@ -0,0 +1 @@ +inline fun qux2() = foo() + 32 + qux1() diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/module.info new file mode 100644 index 00000000000..551c2f0d50e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/lib2/module.info @@ -0,0 +1,15 @@ +STEP 0: +STEP 1: + dependencies: lib1 + modifications: + U : l2.1.kt -> l2.kt + added file: l2.kt +STEP 2: + dependencies: lib1 + modifications: + U : l2.2.kt -> l2.kt + modified ir: l2.kt +STEP 3: + modifications: + D : l2.kt +STEP 4: diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.0.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.0.kt new file mode 100644 index 00000000000..3aa15cfe485 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.0.kt @@ -0,0 +1,8 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 3 -> if (qux1() != 42) return "Fail" + 4 -> if (qux1() != 42 + 99 * 8) return "Fail" + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.1.kt b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.1.kt new file mode 100644 index 00000000000..d91821e622c --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/m.1.kt @@ -0,0 +1,8 @@ +fun box(stepId: Int): String { + when (stepId) { + 1 -> if (qux2() != 99 + 32) return "Fail" + 2 -> if (qux2() != 99 + 32 + 42) return "Fail" + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/module.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/module.info new file mode 100644 index 00000000000..858e97280c8 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/main/module.info @@ -0,0 +1,20 @@ +STEP 0: + dependencies: lib1 + modifications: + U : m.0.kt -> m.kt + added file: m.kt +STEP 1: + dependencies: lib1, lib2 + modifications: + U : m.1.kt -> m.kt + modified ir: m.kt +STEP 2: + dependencies: lib1, lib2 + updated inline imports: m.kt +STEP 3: + dependencies: lib1 + modifications: + U : m.0.kt -> m.kt + modified ir: m.kt +STEP 4: + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/project.info b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/project.info new file mode 100644 index 00000000000..7ee2b46e3d5 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/addUpdateRemoveDependentModule/project.info @@ -0,0 +1,14 @@ +MODULES: lib1, lib2, main + +STEP 0: + libs: lib1, main + dirty js: lib1, main +STEP 1..2: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 3: + libs: lib1, main + dirty js: lib1, main +STEP 4: + libs: lib1, main + dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.0.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.0.kt new file mode 100644 index 00000000000..89a0e484b55 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.0.kt @@ -0,0 +1,3 @@ +fun f1() = "${f1_1()} ${f2_1()} ${f3_1()}" + +fun f2() = "empty" diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.1.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.1.kt new file mode 100644 index 00000000000..6a30a04c1d0 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f.1.kt @@ -0,0 +1,3 @@ +fun f1() = "${f1_1()} ${f2_1()} ${f3_1()}" + +fun f2() = f1_2() diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f1.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f1.kt new file mode 100644 index 00000000000..c3fb089ac1e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f1.kt @@ -0,0 +1,7 @@ +fun f1_1() = "f1_1" + +fun f1_2() = f2_2() + +fun f1_3() = f2_3() + +fun f1_4() = "something" diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f2.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f2.kt new file mode 100644 index 00000000000..991b1df2d57 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f2.kt @@ -0,0 +1,5 @@ +fun f2_1() = "f2_1" + +fun f2_2() = f3_2() + +fun f2_3() = f3_3() diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f3.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f3.kt new file mode 100644 index 00000000000..b3eb8ad5808 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/f3.kt @@ -0,0 +1,5 @@ +fun f3_1() = "f3_1" + +fun f3_2() = f1_3() + +fun f3_3() = f1_4() diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/module.info b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/module.info new file mode 100644 index 00000000000..1c518fbcb2c --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/lib1/module.info @@ -0,0 +1,19 @@ +STEP 0: + modifications: + U : f.0.kt -> f.kt + added file: f.kt, f1.kt, f2.kt, f3.kt +STEP 1: + modifications: + U : f.1.kt -> f.kt + modified ir: f.kt + updated exports: f1.kt, f2.kt, f3.kt +STEP 2: + modifications: + U : f.0.kt -> f.kt + modified ir: f.kt + updated exports: f1.kt, f2.kt, f3.kt +STEP 3: + modifications: + U : f.1.kt -> f.kt + modified ir: f.kt + updated exports: f1.kt, f2.kt, f3.kt diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/m.kt b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/m.kt new file mode 100644 index 00000000000..2554b407246 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/m.kt @@ -0,0 +1,14 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 2 -> { + if (f1() != "f1_1 f2_1 f3_1") return "Fail f1" + if (f2() != "empty") return "Fail f2" + } + 1, 3 -> { + if (f1() != "f1_1 f2_1 f3_1") return "Fail f1" + if (f2() != "something") return "Fail f2" + } + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/module.info b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/module.info new file mode 100644 index 00000000000..7d5eef3e8a1 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/main/module.info @@ -0,0 +1,5 @@ +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..3: + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/project.info b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/project.info new file mode 100644 index 00000000000..0b4e2109318 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleExportsUpdate/project.info @@ -0,0 +1,8 @@ +MODULES: lib1, main + +STEP 0: + libs: lib1, main + dirty js: lib1, main +STEP 1..3: + libs: lib1, main + dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f.kt new file mode 100644 index 00000000000..11520988d78 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f.kt @@ -0,0 +1 @@ +inline fun f1() = f1_2() diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.0.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.0.kt new file mode 100644 index 00000000000..75e72c613e9 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.0.kt @@ -0,0 +1,5 @@ +inline fun f1_2() = "f1_2 -> ${f2_2()}" + +inline fun f1_3() = "f1_3 -> ${f2_3()}" + +inline fun f1_4() = "f1_4 -> stop" diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.1.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.1.kt new file mode 100644 index 00000000000..12154232926 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f1.1.kt @@ -0,0 +1,5 @@ +inline fun f1_2() = "f1_2 -> ${f2_2()}" + +inline fun f1_3() = "f1_3 -> ${f2_3()}" + +inline fun f1_4() = "f1_4 -> end" diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f2.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f2.kt new file mode 100644 index 00000000000..1fe6b10e74c --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f2.kt @@ -0,0 +1,3 @@ +inline fun f2_2() = "f2_2 -> ${f3_2()}" + +inline fun f2_3() = "f2_3 -> ${f3_3()}" diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f3.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f3.kt new file mode 100644 index 00000000000..00ea68f2944 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/f3.kt @@ -0,0 +1,3 @@ +inline fun f3_2() = "f3_2 -> ${f1_3()}" + +inline fun f3_3() = "f3_3 -> ${f1_4()}" diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/module.info b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/module.info new file mode 100644 index 00000000000..4eb41d5495e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/lib1/module.info @@ -0,0 +1,14 @@ +STEP 0: + modifications: + U : f1.0.kt -> f1.kt + added file: f.kt, f1.kt, f2.kt, f3.kt +STEP 1: + modifications: + U : f1.1.kt -> f1.kt + modified ir: f1.kt + updated inline imports: f.kt, f2.kt, f3.kt +STEP 2: + modifications: + U : f1.0.kt -> f1.kt + modified ir: f1.kt + updated inline imports: f.kt, f2.kt, f3.kt diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/m.kt b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/m.kt new file mode 100644 index 00000000000..1c72f45433c --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/m.kt @@ -0,0 +1,12 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 2 -> { + if (f1() != "f1_2 -> f2_2 -> f3_2 -> f1_3 -> f2_3 -> f3_3 -> f1_4 -> stop") return "Fail" + } + 1 -> { + if (f1() != "f1_2 -> f2_2 -> f3_2 -> f1_3 -> f2_3 -> f3_3 -> f1_4 -> end") return "Fail" + } + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/module.info b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/module.info new file mode 100644 index 00000000000..2796e2311c8 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/main/module.info @@ -0,0 +1,6 @@ +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..2: + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/project.info b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/project.info new file mode 100644 index 00000000000..912abf292a5 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/circleInlineImportsUpdate/project.info @@ -0,0 +1,5 @@ +MODULES: lib1, main + +STEP 0..2: + libs: lib1, main + dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.0_simple_class.txt b/js/js.translator/testData/incremental/invalidation/class/lib1/l1.0_simple_class.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.0_simple_class.txt rename to js/js.translator/testData/incremental/invalidation/class/lib1/l1.0_simple_class.kt diff --git a/js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.1_data_class.txt b/js/js.translator/testData/incremental/invalidation/class/lib1/l1.1_data_class.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.1_data_class.txt rename to js/js.translator/testData/incremental/invalidation/class/lib1/l1.1_data_class.kt diff --git a/js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.2_inline_class.txt b/js/js.translator/testData/incremental/invalidation/class/lib1/l1.2_inline_class.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/class/lib1/l1.kt.2_inline_class.txt rename to js/js.translator/testData/incremental/invalidation/class/lib1/l1.2_inline_class.kt diff --git a/js/js.translator/testData/incremental/invalidation/class/lib1/module.info b/js/js.translator/testData/incremental/invalidation/class/lib1/module.info index b45eaacceef..edb9ce6d80a 100644 --- a/js/js.translator/testData/incremental/invalidation/class/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/class/lib1/module.info @@ -1,20 +1,16 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0_simple_class.txt -> l1.kt - dirty: l1.kt + U : l1.0_simple_class.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1_data_class.txt -> l1.kt - dirty: l1.kt + U : l1.1_data_class.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.0_simple_class.txt -> l1.kt - dirty: l1.kt + U : l1.0_simple_class.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.2_inline_class.txt -> l1.kt - dirty: l1.kt + U : l1.2_inline_class.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/class/main/m.kt b/js/js.translator/testData/incremental/invalidation/class/main/m.kt index e21ce7b27b4..d77b0982007 100644 --- a/js/js.translator/testData/incremental/invalidation/class/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/class/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0, 2 -> if (Demo(15) == Demo(15)) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/class/main/module.info b/js/js.translator/testData/incremental/invalidation/class/main/module.info index 161216424f1..7d5eef3e8a1 100644 --- a/js/js.translator/testData/incremental/invalidation/class/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/class/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1..3: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/class/project.info b/js/js.translator/testData/incremental/invalidation/class/project.info index e640d924b4f..0b4e2109318 100644 --- a/js/js.translator/testData/incremental/invalidation/class/project.info +++ b/js/js.translator/testData/incremental/invalidation/class/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1..3: libs: lib1, main - dirty js: stdlib, lib1 + dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.0_init.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.0_init.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.0_init.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.0_init.kt index c57883c8580..7b9d830e54c 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.0_init.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.0_init.kt @@ -1,4 +1,3 @@ - class Demo(val x: String) { fun foo() = "foo $x" inline fun foo_inline() = "inline foo $x" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.10_update_field_type.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.10_update_field_type.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.10_update_field_type.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.10_update_field_type.kt index 5a69dd69fc1..ec017204964 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.10_update_field_type.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.10_update_field_type.kt @@ -1,4 +1,3 @@ - interface DemoInterface { fun foo(): Any } diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.11_update_field_type.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.11_update_field_type.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.11_update_field_type.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.11_update_field_type.kt index 0fb3e6b4cd1..12eb883d98c 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.11_update_field_type.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.11_update_field_type.kt @@ -1,4 +1,3 @@ - interface DemoInterface { fun foo(): Any } diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.1_update_fun.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.1_update_fun.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.1_update_fun.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.1_update_fun.kt index 4f3ee15c48c..bf3740f62a2 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.1_update_fun.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.1_update_fun.kt @@ -1,4 +1,3 @@ - class Demo(val x: String) { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.2_update_inline_fun.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.2_update_inline_fun.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.2_update_inline_fun.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.2_update_inline_fun.kt index a2dda9fc0a0..8819a493b79 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.2_update_inline_fun.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.2_update_inline_fun.kt @@ -1,4 +1,3 @@ - class Demo(val x: String) { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x update" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.3_add_param.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.3_add_param.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.3_add_param.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.3_add_param.kt index 43e4a9ca9cd..b7406e087d7 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.3_add_param.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.3_add_param.kt @@ -1,4 +1,3 @@ - class Demo(val x: String, val y: String = "default") { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x update" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.4_add_field.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.4_add_field.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.4_add_field.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.4_add_field.kt index d99422c7a92..69b0a7a30a3 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.4_add_field.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.4_add_field.kt @@ -1,4 +1,3 @@ - class Demo(val x: String, val y: String = "default") { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x update" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.5_update_field.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.5_update_field.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.5_update_field.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.5_update_field.kt index 1f4cc37f46a..a00b56faa35 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.5_update_field.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.5_update_field.kt @@ -1,4 +1,3 @@ - class Demo(val x: String, val y: String = "default") { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x update" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.6_update_unused_inline.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.6_update_unused_inline.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.6_update_unused_inline.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.6_update_unused_inline.kt index 8e67d145b9f..44d6bd2fc2c 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.6_update_unused_inline.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.6_update_unused_inline.kt @@ -1,4 +1,3 @@ - class Demo(val x: String, val y: String = "default") { fun foo() = "foo $x update" inline fun foo_inline() = "inline foo $x update" diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.7_add_unused_interface.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.7_add_unused_interface.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.7_add_unused_interface.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.7_add_unused_interface.kt index 8509a75ce14..26216e241a6 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.7_add_unused_interface.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.7_add_unused_interface.kt @@ -1,4 +1,3 @@ - interface DemoInterface { fun foo(): String } diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.8_use_interface.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.8_use_interface.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.8_use_interface.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.8_use_interface.kt index 1202cc67a23..d2e516edb84 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.8_use_interface.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.8_use_interface.kt @@ -1,4 +1,3 @@ - interface DemoInterface { fun foo(): String } diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.9_update_interface.txt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.9_update_interface.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.9_update_interface.txt rename to js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.9_update_interface.kt index 2c8c8fd2e28..5d13fa3e074 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.kt.9_update_interface.txt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/l1.9_update_interface.kt @@ -1,4 +1,3 @@ - interface DemoInterface { fun foo(): Any } diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/module.info b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/module.info index 544b137f03e..3beeb9a98c9 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/lib1/module.info @@ -1,60 +1,48 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0_init.txt -> l1.kt - dirty: l1.kt + U : l1.0_init.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1_update_fun.txt -> l1.kt - dirty: l1.kt + U : l1.1_update_fun.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2_update_inline_fun.txt -> l1.kt - dirty: l1.kt + U : l1.2_update_inline_fun.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3_add_param.txt -> l1.kt - dirty: l1.kt + U : l1.3_add_param.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.kt.4_add_field.txt -> l1.kt - dirty: l1.kt + U : l1.4_add_field.kt -> l1.kt + modified ir: l1.kt STEP 5: - dependencies: stdlib modifications: - U : l1.kt.5_update_field.txt -> l1.kt - dirty: l1.kt + U : l1.5_update_field.kt -> l1.kt + modified ir: l1.kt STEP 6: - dependencies: stdlib modifications: - U : l1.kt.6_update_unused_inline.txt -> l1.kt - dirty: l1.kt + U : l1.6_update_unused_inline.kt -> l1.kt + modified ir: l1.kt STEP 7: - dependencies: stdlib modifications: - U : l1.kt.7_add_unused_interface.txt -> l1.kt - dirty: l1.kt + U : l1.7_add_unused_interface.kt -> l1.kt + modified ir: l1.kt STEP 8: - dependencies: stdlib modifications: - U : l1.kt.8_use_interface.txt -> l1.kt - dirty: l1.kt + U : l1.8_use_interface.kt -> l1.kt + modified ir: l1.kt STEP 9: - dependencies: stdlib modifications: - U : l1.kt.9_update_interface.txt -> l1.kt - dirty: l1.kt + U : l1.9_update_interface.kt -> l1.kt + modified ir: l1.kt STEP 10: - dependencies: stdlib modifications: - U : l1.kt.10_update_field_type.txt -> l1.kt - dirty: l1.kt + U : l1.10_update_field_type.kt -> l1.kt + modified ir: l1.kt STEP 11: - dependencies: stdlib modifications: - U : l1.kt.11_update_field_type.txt -> l1.kt - dirty: l1.kt + U : l1.11_update_field_type.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/m.kt b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/m.kt index 878d717417a..ff059e3b23b 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/m.kt @@ -1,4 +1,3 @@ - fun isEqual(l: Any?, r: Any?) = if (l == r) true else null fun box(stepId: Int): String { diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/module.info b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/module.info index c0857570346..cc0a1a54084 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/module.info @@ -1,13 +1,16 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1: - dependencies: stdlib, lib1 -STEP 2..3: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 +STEP 2: + dependencies: lib1 + updated inline imports: m.kt +STEP 3: + dependencies: lib1 + modified ir: m.kt STEP 4..9: - dependencies: stdlib, lib1 + dependencies: lib1 STEP 10..11: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + modified ir: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/project.info b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/project.info index 08a53dfd524..f89e79b0d80 100644 --- a/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/project.info +++ b/js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1: libs: lib1, main dirty js: lib1 @@ -14,7 +14,7 @@ STEP 4..6: dirty js: lib1 STEP 7: libs: lib1, main - dirty js: stdlib, lib1 + dirty js: lib1 STEP 8..9: libs: lib1, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.1.kt b/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.1.kt new file mode 100644 index 00000000000..9da912615f1 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.1.kt @@ -0,0 +1 @@ +const val FOO = "BAR" diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt index 38c71062899..5abc52412e4 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt @@ -1 +1 @@ -const val FOO = "FOO" \ No newline at end of file +const val FOO = "FOO" diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt.1 b/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt.1 deleted file mode 100644 index 278ecf533ab..00000000000 --- a/js/js.translator/testData/incremental/invalidation/constVals/lib1/l1.kt.1 +++ /dev/null @@ -1 +0,0 @@ -const val FOO = "BAR" \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib1/module.info b/js/js.translator/testData/incremental/invalidation/constVals/lib1/module.info index 5963605a540..b00df4e0597 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/constVals/lib1/module.info @@ -1,8 +1,6 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1 -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/constVals/lib2/l2.kt index 152363f55d7..7590c8419fb 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/constVals/lib2/l2.kt @@ -1,3 +1,2 @@ - fun qux() = FOO inline fun bar() = FOO diff --git a/js/js.translator/testData/incremental/invalidation/constVals/lib2/module.info b/js/js.translator/testData/incremental/invalidation/constVals/lib2/module.info index c1c7c4b5a69..d1d31ca5618 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/constVals/lib2/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/constVals/main/m.kt b/js/js.translator/testData/incremental/invalidation/constVals/main/m.kt index dd74a3d1a3f..80750527285 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/constVals/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> { diff --git a/js/js.translator/testData/incremental/invalidation/constVals/main/module.info b/js/js.translator/testData/incremental/invalidation/constVals/main/module.info index a2d4e3c24e6..406ec8bd244 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/constVals/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/constVals/project.info b/js/js.translator/testData/incremental/invalidation/constVals/project.info index ca17baa143e..3a84c058f4e 100644 --- a/js/js.translator/testData/incremental/invalidation/constVals/project.info +++ b/js/js.translator/testData/incremental/invalidation/constVals/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/module.info b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/module.info index 5ed945b9908..fe303dcfe1e 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/module.info @@ -1,6 +1,4 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1..6: - dependencies: stdlib - flags: FP + updated exports: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.1.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.1.kt similarity index 96% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.1.kt index 232ffb94add..78400adfc5e 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.1.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.1.kt @@ -1,2 +1 @@ - fun qux() = foo() + bar() diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.2.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.2.kt similarity index 95% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.2.kt index f667b9c9e8d..c566e291773 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.2.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.2.kt @@ -1,2 +1 @@ - fun qux() = foo() - 2 diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.3.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.3.kt similarity index 97% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.3.kt index 063d3566c94..3dd486279b0 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.3.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.3.kt @@ -1,2 +1 @@ - fun qux() = baz(2) + baz("test") + baz(true) diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.4.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.4.kt similarity index 97% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.4.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.4.kt index 7501f18d5a6..de7c7befdd7 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.4.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.4.kt @@ -1,2 +1 @@ - fun qux() = baz("test") + baz(true) diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.6.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.6.kt similarity index 96% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.6.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.6.kt index 555a0ce8658..d4712d7ea4b 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.6.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.6.kt @@ -1,2 +1 @@ - fun qux() = baz("test") + 100 diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt index 534fdd6be64..c7bcb429947 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt @@ -1,2 +1 @@ - fun qux() = foo() + 2 diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/module.info b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/module.info index 0841185099f..4e54b1b5901 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/module.info @@ -1,31 +1,30 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.1.txt -> l2.kt - dirty: l2.kt + U : l2.1.kt -> l2.kt + modified ir: l2.kt STEP 2: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.2.txt -> l2.kt - dirty: l2.kt + U : l2.2.kt -> l2.kt + modified ir: l2.kt STEP 3: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.3.txt -> l2.kt - dirty: l2.kt + U : l2.3.kt -> l2.kt + modified ir: l2.kt STEP 4: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.4.txt -> l2.kt - dirty: l2.kt + U : l2.4.kt -> l2.kt + modified ir: l2.kt STEP 5: - dependencies: stdlib, lib1 - flags: FP + dependencies: lib1 STEP 6: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.6.txt -> l2.kt - dirty: l2.kt + U : l2.6.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt.5.txt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.5.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt.5.txt rename to js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.5.kt index 44714ea1f9f..7646916ce66 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt.5.txt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.5.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 5 -> if (qux() != 14) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt index 9b55d4ffa5d..d6ce6908359 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux() != 44) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/module.info b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/module.info index 96afcf54ec7..e2cd2c69ecf 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/module.info @@ -1,12 +1,12 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1..4: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 STEP 5: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 modifications: - U : m.kt.5.txt -> m.kt - dirty: m.kt + U : m.5.kt -> m.kt + modified ir: m.kt STEP 6: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/project.info b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/project.info index be7d9c3ce73..ad98b79cbef 100644 --- a/js/js.translator/testData/incremental/invalidation/crossModuleReferences/project.info +++ b/js/js.translator/testData/incremental/invalidation/crossModuleReferences/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1..4: libs: lib1, lib2, main dirty js: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l1.kt new file mode 100644 index 00000000000..6d827cf376e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l1.kt @@ -0,0 +1,2 @@ +var z1 = false +var z2 = false diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.0.kt b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.0.kt new file mode 100644 index 00000000000..e8ff970c025 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.0.kt @@ -0,0 +1,7 @@ +//@OptIn(kotlin.ExperimentalStdlibApi::class) +//@EagerInitialization +val x = run { z1 = true; 42 } + +//@OptIn(kotlin.ExperimentalStdlibApi::class) +//@EagerInitialization +val y = run { z2 = true; 117 } diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.1.kt b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.1.kt new file mode 100644 index 00000000000..cf1ccc55ac2 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.1.kt @@ -0,0 +1,7 @@ +@OptIn(kotlin.ExperimentalStdlibApi::class) +@EagerInitialization +val x = run { z1 = true; 42 } + +//@OptIn(kotlin.ExperimentalStdlibApi::class) +//@EagerInitialization +val y = run { z2 = true; 117 } diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.2.kt b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.2.kt new file mode 100644 index 00000000000..3bffcf888e4 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/l2.2.kt @@ -0,0 +1,7 @@ +@OptIn(kotlin.ExperimentalStdlibApi::class) +@EagerInitialization +val x = run { z1 = true; 42 } + +@OptIn(kotlin.ExperimentalStdlibApi::class) +@EagerInitialization +val y = run { z2 = true; 117 } diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/module.info b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/module.info new file mode 100644 index 00000000000..562966ede03 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/lib1/module.info @@ -0,0 +1,16 @@ +STEP 0: + modifications: + U : l2.0.kt -> l2.kt + added file: l1.kt, l2.kt +STEP 1: + modifications: + U : l2.1.kt -> l2.kt + modified ir: l2.kt +STEP 2: + modifications: + U : l2.2.kt -> l2.kt + modified ir: l2.kt +STEP 3: + modifications: + U : l2.0.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/m.kt b/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/m.kt new file mode 100644 index 00000000000..7e17fe8e292 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/m.kt @@ -0,0 +1,18 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 3 -> { + if (z1) return "Fail z1" + if (z2) return "Fail z2" + } + 1 -> { + if (!z1) return "Fail z1" + if (z2) return "Fail z2" + } + 2 -> { + if (!z1) return "Fail z1" + if (!z2) return "Fail z2" + } + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/module.info b/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/module.info new file mode 100644 index 00000000000..7d5eef3e8a1 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/main/module.info @@ -0,0 +1,5 @@ +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..3: + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/eagerInitialization/project.info b/js/js.translator/testData/incremental/invalidation/eagerInitialization/project.info new file mode 100644 index 00000000000..0b4e2109318 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/eagerInitialization/project.info @@ -0,0 +1,8 @@ +MODULES: lib1, main + +STEP 0: + libs: lib1, main + dirty js: lib1, main +STEP 1..3: + libs: lib1, main + dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.0.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.0.kt new file mode 100644 index 00000000000..665b0e5d891 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.0.kt @@ -0,0 +1,3 @@ +fun foo() = "hello" + +inline fun fooInline() = "hello inline 0" diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.3.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.3.kt new file mode 100644 index 00000000000..5fd36846215 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.3.kt @@ -0,0 +1,3 @@ +fun foo() = "hello" + +inline fun fooInline() = "hello inline 3" diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.5.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.5.kt new file mode 100644 index 00000000000..2d1edfd80c0 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.5.kt @@ -0,0 +1,6 @@ +fun foo(): String { + if (false) lib1Foo() + return "hello 5" +} + +inline fun fooInline() = "hello inline 3" diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.6.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.6.kt new file mode 100644 index 00000000000..0d3471b3b75 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l1.6.kt @@ -0,0 +1,6 @@ +fun foo(flag: Boolean = false): String { + if (flag) lib1Foo() + return "hello 6" +} + +inline fun fooInline() = "hello inline 3" diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.0.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.0.kt new file mode 100644 index 00000000000..9db26de3658 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.0.kt @@ -0,0 +1 @@ +inline fun lib1Foo() = "empty" diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.1.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.1.kt new file mode 100644 index 00000000000..5ae45001f7d --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.1.kt @@ -0,0 +1 @@ +inline fun lib1Foo() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.2.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.2.kt new file mode 100644 index 00000000000..7e12df38707 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/l2.2.kt @@ -0,0 +1 @@ +inline fun lib1Foo() = fooInline() diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/module.info b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/module.info new file mode 100644 index 00000000000..17860c84248 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/lib1/module.info @@ -0,0 +1,39 @@ +STEP 0: + modifications: + U : l1.0.kt -> l1.kt + U : l2.0.kt -> l2.kt + added file: l1.kt, l2.kt +STEP 1: + modifications: + U : l2.1.kt -> l2.kt + modified ir: l2.kt + updated exports: l1.kt +STEP 2: + modifications: + U : l2.2.kt -> l2.kt + modified ir: l2.kt + updated exports: l1.kt +STEP 3: + modifications: + U : l1.3.kt -> l1.kt + modified ir: l1.kt + updated inline imports: l2.kt +STEP 4: + modifications: + U : l2.1.kt -> l2.kt + modified ir: l2.kt + updated exports: l1.kt +STEP 5: + modifications: + U : l1.5.kt -> l1.kt + modified ir: l1.kt +STEP 6: + modifications: + U : l1.6.kt -> l1.kt + modified ir: l1.kt, l2.kt +STEP 7: + modifications: + U : l2.0.kt -> l2.kt + modified ir: l2.kt + updated inline imports: l1.kt + updated exports: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/m.kt b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/m.kt new file mode 100644 index 00000000000..7c58f3f06a7 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/m.kt @@ -0,0 +1,12 @@ +fun box(stepId: Int): String { + when (stepId) { + 0, 7 -> if (lib1Foo() != "empty") return "Fail" + 1, 4 -> if (lib1Foo() != "hello") return "Fail" + 2 -> if (lib1Foo() != "hello inline 0") return "Fail" + 3 -> if (lib1Foo() != "hello inline 3") return "Fail" + 5 -> if (lib1Foo() != "hello 5") return "Fail" + 6 -> if (lib1Foo() != "hello 6") return "Fail" + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/module.info b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/module.info new file mode 100644 index 00000000000..988a74f3734 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/main/module.info @@ -0,0 +1,11 @@ +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..4: + dependencies: lib1 + updated inline imports: m.kt +STEP 5: + dependencies: lib1 +STEP 6..7: + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/project.info b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/project.info new file mode 100644 index 00000000000..6856f99a874 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/project.info @@ -0,0 +1,11 @@ +MODULES: lib1, main + +STEP 0..4: + libs: lib1, main + dirty js: lib1, main +STEP 5: + libs: lib1, main + dirty js: lib1 +STEP 6..7: + libs: lib1, main + dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/module.info b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/module.info index 3f9847a3248..fff993e24a7 100644 --- a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib1/module.info @@ -1,13 +1,10 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib2/module.info b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib2/module.info index df048187d3b..b6251b6e3d7 100644 --- a/js/js.translator/testData/incremental/invalidation/fakeOverride/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/fakeOverride/lib2/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1..2: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/main/module.info b/js/js.translator/testData/incremental/invalidation/fakeOverride/main/module.info index 370aa51ea53..9fbc8ef145a 100644 --- a/js/js.translator/testData/incremental/invalidation/fakeOverride/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/fakeOverride/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1..2: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/fakeOverride/project.info b/js/js.translator/testData/incremental/invalidation/fakeOverride/project.info index df4f6445441..2b1cc8467ee 100644 --- a/js/js.translator/testData/incremental/invalidation/fakeOverride/project.info +++ b/js/js.translator/testData/incremental/invalidation/fakeOverride/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1..2: libs: lib1, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/l1.kt index 859b384ad7f..9d198400fd7 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/l1.kt @@ -1 +1 @@ -fun foo() = 42 \ No newline at end of file +fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/module.info b/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/module.info index f500435de26..bfbe4ca58d0 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/lib1/module.info @@ -1,6 +1,3 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib - flags: FP diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.1.kt b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.1.kt new file mode 100644 index 00000000000..c7bcb429947 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.1.kt @@ -0,0 +1 @@ +fun qux() = foo() + 2 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt index baeaa737440..3c096ceace6 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt @@ -1,2 +1 @@ - -fun qux() = foo() \ No newline at end of file +fun qux() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt.1 b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt.1 deleted file mode 100644 index 3aee91a2674..00000000000 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/l2.kt.1 +++ /dev/null @@ -1 +0,0 @@ -fun qux() = foo() + 2 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/module.info b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/module.info index 34b5a84bf72..bb223664052 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/lib2/module.info @@ -1,8 +1,8 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.1 -> l2.kt - dirty: l2.kt + U : l2.1.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/main/m.kt b/js/js.translator/testData/incremental/invalidation/fastPath1/main/m.kt index d55814a4cd9..adb52d8ed28 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/main/module.info b/js/js.translator/testData/incremental/invalidation/fastPath1/main/module.info index a2d4e3c24e6..406ec8bd244 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath1/project.info b/js/js.translator/testData/incremental/invalidation/fastPath1/project.info index 9ddce48f7c0..ec60a5cb1eb 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath1/project.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath1/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main dirty js: lib2 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/l1.kt index 859b384ad7f..9d198400fd7 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/l1.kt @@ -1 +1 @@ -fun foo() = 42 \ No newline at end of file +fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/module.info b/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/module.info index f500435de26..bfbe4ca58d0 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/lib1/module.info @@ -1,6 +1,3 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib - flags: FP diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/l2.kt index baeaa737440..3c096ceace6 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/l2.kt @@ -1,2 +1 @@ - -fun qux() = foo() \ No newline at end of file +fun qux() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/module.info b/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/module.info index a6323a2b98f..d1d31ca5618 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/lib2/module.info @@ -1,6 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 - flags: FP + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/main/m.kt b/js/js.translator/testData/incremental/invalidation/fastPath2/main/m.kt index dd7574e87da..ca02ac8c08c 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/main/m.kt @@ -1,2 +1 @@ - fun box() = if (qux() == 42) "OK" else "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/main/module.info b/js/js.translator/testData/incremental/invalidation/fastPath2/main/module.info index cad654e4af7..406ec8bd244 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/main/module.info @@ -1,6 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 - flags: FP + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/fastPath2/project.info b/js/js.translator/testData/incremental/invalidation/fastPath2/project.info index ffc4ef83f29..ce9a1155f6b 100644 --- a/js/js.translator/testData/incremental/invalidation/fastPath2/project.info +++ b/js/js.translator/testData/incremental/invalidation/fastPath2/project.info @@ -2,6 +2,6 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/module.info b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/module.info index e575c74de97..c88eac8998e 100644 --- a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/lib1/module.info @@ -1,20 +1,16 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/m.kt b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/m.kt index 23ef41f6090..d5b955dbc1d 100644 --- a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (foo() != (42 + 77)) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/module.info b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/module.info index 3b6a621cc77..2af0cb06542 100644 --- a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/module.info @@ -1,10 +1,10 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 STEP 2: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + modified ir: m.kt STEP 3: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/project.info b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/project.info index 0c19fd8a2e7..86a27e2ae08 100644 --- a/js/js.translator/testData/incremental/invalidation/functionDefaultParams/project.info +++ b/js/js.translator/testData/incremental/invalidation/functionDefaultParams/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1: libs: lib1, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt new file mode 100644 index 00000000000..30e49c752ce --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt @@ -0,0 +1 @@ +fun foo(x: Any = 99): Any = x diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt.txt deleted file mode 100644 index 3f316181c0d..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any.out.any.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(x: Any = 99): Any = x \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any_or_null.out.any.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any_or_null.out.any.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any_or_null.out.any.kt.txt rename to js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.any_or_null.out.any.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt new file mode 100644 index 00000000000..b80f70fb4f5 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt @@ -0,0 +1 @@ +fun foo(x: Int = 77): Int = 42 + x diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt.txt deleted file mode 100644 index c2ba8342630..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.out.int.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(x: Int = 77): Int = 42 + x \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt new file mode 100644 index 00000000000..7700cc70105 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt @@ -0,0 +1 @@ +fun foo(x: Int = 98, y: String = "s"): Int = 42 + x + y.length diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt.txt deleted file mode 100644 index e02ca6058fd..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string.out.int.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(x: Int = 98, y: String = "s"): Int = 42 + x + y.length \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string_or_null.out.int.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string_or_null.out.int.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string_or_null.out.int.kt.txt rename to js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.int.string_or_null.out.int.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt new file mode 100644 index 00000000000..876597cd717 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt @@ -0,0 +1 @@ +fun foo(vararg x: Int): Int = 42 diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt.txt deleted file mode 100644 index f60d17c7064..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.in.vararg_int.out.int.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(vararg x: Int): Int = 42 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt new file mode 100644 index 00000000000..da0ee23a40b --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt @@ -0,0 +1 @@ +fun foo(): Any = "string" diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt.txt deleted file mode 100644 index cb9fb1686f4..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): Any = "string" \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt new file mode 100644 index 00000000000..ba49e18c411 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt @@ -0,0 +1 @@ +fun foo(): Any? = "string" diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt.txt deleted file mode 100644 index 99a397be544..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.any_or_null.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): Any? = "string" \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt new file mode 100644 index 00000000000..f8e7e030ea5 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt @@ -0,0 +1 @@ +fun foo(): Boolean = false diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt.txt deleted file mode 100644 index c1ff594735d..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.bool.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): Boolean = false \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt new file mode 100644 index 00000000000..887472b1842 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt @@ -0,0 +1 @@ +fun foo(): Double = 3.14 diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt.txt deleted file mode 100644 index a54f036453d..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.double.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): Double = 3.14 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt new file mode 100644 index 00000000000..9165e7ec1b0 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt @@ -0,0 +1 @@ +fun foo(): Int = 42 diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt.txt deleted file mode 100644 index 5730b06eda6..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.int.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): Int = 42 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt new file mode 100644 index 00000000000..2d4fc73b3ca --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt @@ -0,0 +1 @@ +fun foo(): String = "string" diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt.txt deleted file mode 100644 index 3bb9d414992..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): String = "string" \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt new file mode 100644 index 00000000000..a3292f722ac --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt @@ -0,0 +1 @@ +fun foo(): String? = null diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt.txt deleted file mode 100644 index 67a2c37f317..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.string_or_null.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo(): String? = null \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt new file mode 100644 index 00000000000..4279b041761 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt @@ -0,0 +1 @@ +fun foo() : Unit {} diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt.txt b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt.txt deleted file mode 100644 index 9cc35fc2b12..00000000000 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/l1.out.unit.kt.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo() : Unit {} \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/module.info b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/module.info index dbd9bd1f6d9..ad447a3b08a 100644 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/lib1/module.info @@ -1,85 +1,68 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.int.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.out.bool.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.bool.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.out.double.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.double.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.out.string.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.string.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.out.string_or_null.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.string_or_null.kt -> l1.kt + modified ir: l1.kt STEP 5: - dependencies: stdlib modifications: - U : l1.out.any.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.any.kt -> l1.kt + modified ir: l1.kt STEP 6: - dependencies: stdlib modifications: - U : l1.out.any_or_null.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.any_or_null.kt -> l1.kt + modified ir: l1.kt STEP 7: - dependencies: stdlib modifications: - U : l1.out.unit.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.unit.kt -> l1.kt + modified ir: l1.kt STEP 8: - dependencies: stdlib modifications: - U : l1.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.int.kt -> l1.kt + modified ir: l1.kt STEP 9: - dependencies: stdlib modifications: - U : l1.in.int.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.int.out.int.kt -> l1.kt + modified ir: l1.kt STEP 10: - dependencies: stdlib modifications: - U : l1.in.int.string.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.int.string.out.int.kt -> l1.kt + modified ir: l1.kt STEP 11: - dependencies: stdlib modifications: - U : l1.in.int.string_or_null.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.int.string_or_null.out.int.kt -> l1.kt + modified ir: l1.kt STEP 12: - dependencies: stdlib modifications: - U : l1.out.any.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.any.kt -> l1.kt + modified ir: l1.kt STEP 13: - dependencies: stdlib modifications: - U : l1.in.any.out.any.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.any.out.any.kt -> l1.kt + modified ir: l1.kt STEP 14: - dependencies: stdlib modifications: - U : l1.in.any_or_null.out.any.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.any_or_null.out.any.kt -> l1.kt + modified ir: l1.kt STEP 15: - dependencies: stdlib modifications: - U : l1.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.out.int.kt -> l1.kt + modified ir: l1.kt STEP 16: - dependencies: stdlib modifications: - U : l1.in.vararg_int.out.int.kt.txt -> l1.kt - dirty: l1.kt + U : l1.in.vararg_int.out.int.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/main/m.kt b/js/js.translator/testData/incremental/invalidation/functionSignature/main/m.kt index ec53e2d1bb7..951d8d07f0b 100644 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/main/m.kt @@ -1,4 +1,3 @@ - fun isEqual(l: Any?, r: Any?) = if (l == r) true else null fun box(stepId: Int): String { diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/main/module.info b/js/js.translator/testData/incremental/invalidation/functionSignature/main/module.info index 8bed6a33ca2..25f89ee4795 100644 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/main/module.info @@ -1,3 +1,6 @@ -STEP 0..16: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..16: + dependencies: lib1 + modified ir: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/functionSignature/project.info b/js/js.translator/testData/incremental/invalidation/functionSignature/project.info index 2ed43c2129b..0991bcba6cb 100644 --- a/js/js.translator/testData/incremental/invalidation/functionSignature/project.info +++ b/js/js.translator/testData/incremental/invalidation/functionSignature/project.info @@ -2,13 +2,13 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1..6: libs: lib1, main dirty js: lib1, main STEP 7..8: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 9..16: libs: lib1, main dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.4.txt b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.4.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.kt.4.txt rename to js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/l1.4.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/module.info b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/module.info index 901f2b2e7ac..e7cd35d3035 100644 --- a/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/genericFunctions/lib1/module.info @@ -1,25 +1,20 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/main/m.kt b/js/js.translator/testData/incremental/invalidation/genericFunctions/main/m.kt index c505af058d9..cacc5a25f26 100644 --- a/js/js.translator/testData/incremental/invalidation/genericFunctions/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/genericFunctions/main/m.kt @@ -1,2 +1 @@ - fun box() = foo("OK") diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/main/module.info b/js/js.translator/testData/incremental/invalidation/genericFunctions/main/module.info index e1041e7b7f8..120870fb813 100644 --- a/js/js.translator/testData/incremental/invalidation/genericFunctions/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/genericFunctions/main/module.info @@ -1,3 +1,6 @@ -STEP 0..4: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..4: + dependencies: lib1 + modified ir: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericFunctions/project.info b/js/js.translator/testData/incremental/invalidation/genericFunctions/project.info index 7910d40726d..1733e265b51 100644 --- a/js/js.translator/testData/incremental/invalidation/genericFunctions/project.info +++ b/js/js.translator/testData/incremental/invalidation/genericFunctions/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1..4: libs: lib1, main dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.4.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.4.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.4.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.4.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.5.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.5.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.5.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.5.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.6.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.6.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.6.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.6.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.7.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.7.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.kt.7.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/l1.7.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/module.info b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/module.info index 486eefcd56a..dec40c07058 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/lib1/module.info @@ -1,120 +1,96 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt STEP 5: - dependencies: stdlib modifications: - U : l1.kt.5.txt -> l1.kt - dirty: l1.kt + U : l1.5.kt -> l1.kt + modified ir: l1.kt STEP 6: - dependencies: stdlib modifications: - U : l1.kt.6.txt -> l1.kt - dirty: l1.kt + U : l1.6.kt -> l1.kt + modified ir: l1.kt STEP 7: - dependencies: stdlib modifications: - U : l1.kt.7.txt -> l1.kt - dirty: l1.kt + U : l1.7.kt -> l1.kt + modified ir: l1.kt STEP 8: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + modified ir: l1.kt STEP 9: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 10: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 11: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 12: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt STEP 13: - dependencies: stdlib modifications: - U : l1.kt.5.txt -> l1.kt - dirty: l1.kt + U : l1.5.kt -> l1.kt + modified ir: l1.kt STEP 14: - dependencies: stdlib modifications: - U : l1.kt.6.txt -> l1.kt - dirty: l1.kt + U : l1.6.kt -> l1.kt + modified ir: l1.kt STEP 15: - dependencies: stdlib modifications: - U : l1.kt.7.txt -> l1.kt - dirty: l1.kt + U : l1.7.kt -> l1.kt + modified ir: l1.kt STEP 16: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + modified ir: l1.kt STEP 17: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 18: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 19: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 20: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt STEP 21: - dependencies: stdlib modifications: - U : l1.kt.5.txt -> l1.kt - dirty: l1.kt + U : l1.5.kt -> l1.kt + modified ir: l1.kt STEP 22: - dependencies: stdlib modifications: - U : l1.kt.6.txt -> l1.kt - dirty: l1.kt + U : l1.6.kt -> l1.kt + modified ir: l1.kt STEP 23: - dependencies: stdlib modifications: - U : l1.kt.7.txt -> l1.kt - dirty: l1.kt + U : l1.7.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/module.info b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/module.info index 9cf39fde8b3..01c973ba59c 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/module.info +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/module.info @@ -1,24 +1,33 @@ STEP 0: - dependencies: stdlib modifications: - U : proxy.kt.0.txt -> proxy.kt - dirty: proxy.kt + U : proxy.0.kt -> proxy.kt + added file: proxy.kt STEP 1..7: - dependencies: stdlib - flags: FP STEP 8: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : proxy.kt.1.txt -> proxy.kt - dirty: proxy.kt -STEP 9..15: - dependencies: stdlib, lib1 - dirty: proxy.kt + U : proxy.1.kt -> proxy.kt + added file: proxy.kt +STEP 9: + dependencies: lib1 + updated inline imports: proxy.kt +STEP 10..14: + dependencies: lib1 + modified ir: proxy.kt +STEP 15: + dependencies: lib1 + updated inline imports: proxy.kt STEP 16: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : proxy.kt.2.txt -> proxy.kt - dirty: proxy.kt -STEP 17..23: - dependencies: stdlib, lib1 - dirty: proxy.kt + U : proxy.2.kt -> proxy.kt + modified ir: proxy.kt +STEP 17: + dependencies: lib1 + updated inline imports: proxy.kt +STEP 18..22: + dependencies: lib1 + modified ir: proxy.kt +STEP 23: + dependencies: lib1 + updated inline imports: proxy.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.0.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.1.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.2.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/proxy.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.kt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.kt index 0379a8048cf..7887c484386 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.kt @@ -1,4 +1,3 @@ - fun isEqual(l: Any?, r: Any?) = if (l == r) true else null fun box(stepId: Int): String { diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt.txt b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt similarity index 99% rename from js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt.txt rename to js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt index 034e10ee879..3a7389b65a2 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt.txt +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt @@ -1,4 +1,3 @@ - fun isEqual(l: Any?, r: Any?) = if (l == r) true else null fun box(stepId: Int): String { diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/module.info b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/module.info index e8127ccfeb8..7f5adab02cf 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/module.info @@ -1,11 +1,38 @@ -STEP 0..7: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1: + dependencies: lib1 + updated inline imports: m.kt +STEP 2..6: + dependencies: lib1 + modified ir: m.kt +STEP 7: + dependencies: lib1 + updated inline imports: m.kt STEP 8: - dependencies: stdlib, lib1, libProxy + dependencies: lib1, libProxy modifications: - U : m.proxy.kt.txt -> m.kt - dirty: m.kt -STEP 9..23: - dependencies: stdlib, lib1, libProxy - dirty: m.kt + U : m.proxy.kt -> m.kt + modified ir: m.kt +STEP 9..13: + dependencies: lib1, libProxy + updated inline imports: m.kt +STEP 14: + dependencies: lib1, libProxy + modified ir: m.kt +STEP 15: + dependencies: lib1, libProxy + updated inline imports: m.kt +STEP 16: + dependencies: lib1, libProxy + modified ir: m.kt +STEP 17..21: + dependencies: lib1, libProxy + updated inline imports: m.kt +STEP 22: + dependencies: lib1, libProxy + modified ir: m.kt +STEP 23: + dependencies: lib1, libProxy + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/project.info b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/project.info index 345bfe6ad4f..eece1761265 100644 --- a/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/project.info +++ b/js/js.translator/testData/incremental/invalidation/genericInlineFunctions/project.info @@ -1,23 +1,8 @@ MODULES: lib1, main, libProxy -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1..5: +STEP 0..7: libs: lib1, main dirty js: lib1, main -STEP 6..7: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 8..13: +STEP 8..23: libs: lib1, libProxy, main dirty js: lib1, libProxy, main -STEP 14..16: - libs: lib1, libProxy, main - dirty js: stdlib, lib1, libProxy, main -STEP 17..21: - libs: lib1, libProxy, main - dirty js: lib1, libProxy, main -STEP 22..23: - libs: lib1, libProxy, main - dirty js: stdlib, lib1, libProxy, main diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.1.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.1.kt new file mode 100644 index 00000000000..19732b898b7 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.1.kt @@ -0,0 +1,3 @@ +open class Parent(open var objectName: String) { + val isValid = true +} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.2.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.2.kt new file mode 100644 index 00000000000..d4b1721ee2d --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.2.kt @@ -0,0 +1,13 @@ +open class Parent(objectName: String) { + var objectName: String + get() = _name + set(objectName) { + isValid = true + _name = objectName + } + + var isValid = false + private set + + private var _name: String = objectName; +} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.3.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.3.kt new file mode 100644 index 00000000000..68a760e0b94 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.3.kt @@ -0,0 +1,3 @@ +open class Parent(open var objectName: String) { + open val isValid = true +} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt index 979e04a0a11..4ed6b3df4bf 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt @@ -1,3 +1,3 @@ -open class Parent(var name: String) { +open class Parent(var objectName: String) { val isValid = true -} \ No newline at end of file +} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.1.txt deleted file mode 100644 index d29fafc929c..00000000000 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.1.txt +++ /dev/null @@ -1,3 +0,0 @@ -open class Parent(open var name: String) { - val isValid = true -} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.2.txt deleted file mode 100644 index 4325f82e4b6..00000000000 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.2.txt +++ /dev/null @@ -1,13 +0,0 @@ -open class Parent(name: String) { - var name: String - get() = _name - set(name) { - isValid = true - _name = name - } - - var isValid = false - private set - - private var _name: String = name; -} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.3.txt deleted file mode 100644 index 0f261df53d0..00000000000 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/l1.kt.3.txt +++ /dev/null @@ -1,3 +0,0 @@ -open class Parent(open var name: String) { - open val isValid = true -} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/module.info b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/module.info index 255a6787d26..c4aa429951f 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib1/module.info @@ -1,21 +1,15 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib - flags: FP diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.4.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.4.kt new file mode 100644 index 00000000000..1e0952a6a49 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.4.kt @@ -0,0 +1,13 @@ +class Child(objectName: String) : Parent(objectName) { + override var objectName: String + get() = _name + set(objectName) { + _name = objectName + isValid = true + } + + private var _name: String = objectName + + override var isValid = false + private set +} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt index a4a85f78982..fefe632cad8 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt @@ -1 +1 @@ -class Child(name: String) : Parent(name) \ No newline at end of file +class Child(objectName: String) : Parent(objectName) diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt.4.txt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt.4.txt deleted file mode 100644 index 11f315076e3..00000000000 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/l2.kt.4.txt +++ /dev/null @@ -1,13 +0,0 @@ -class Child(name: String) : Parent(name) { - override var name: String - get() = _name - set(name) { - _name = name - isValid = true - } - - private var _name: String = name - - override var isValid = false - private set -} diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/module.info b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/module.info index 5b4fea5ac4a..9cb2309a5ee 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/lib2/module.info @@ -1,10 +1,10 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1..3: - dependencies: stdlib, lib1 + dependencies: lib1 STEP 4: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l2.kt.4.txt -> l2.kt - dirty: l2.kt + U : l2.4.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/m.kt b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/m.kt index 16f39da7041..cdb6516d35e 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/m.kt @@ -2,16 +2,16 @@ fun box(stepId: Int): String { val parent = Parent("parent") val child = Child("child") - if (parent.name != "parent") return "fail: initial parent name at step $stepId" - if (child.name != "child") return "fail: initial child name at step $stepId" + if (parent.objectName != "parent") return "fail: initial parent objectName at step $stepId" + if (child.objectName != "child") return "fail: initial child objectName at step $stepId" - parent.name = "updated parent" + parent.objectName = "updated parent" - if (parent.name != "updated parent") return "fail: updated parent name at step $stepId" + if (parent.objectName != "updated parent") return "fail: updated parent objectName at step $stepId" - child.name = "updated child" + child.objectName = "updated child" - if (child.name != "updated child") return "fail: updated child name at step $stepId" + if (child.objectName != "updated child") return "fail: updated child objectName at step $stepId" if (!parent.isValid) return "fail: parent is invalid at step $stepId" if (!child.isValid) return "fail: child is invalid at step $stepId" diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/module.info b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/module.info index 699d71982d0..d871ce55474 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1..4: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/project.info b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/project.info index 1a8af8d6f10..9e273f83145 100644 --- a/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/project.info +++ b/js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1..3: libs: lib1, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/module.info b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/module.info index 47593b4c4fe..4ae641e95be 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/lib1/module.info @@ -1,15 +1,12 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/m.kt b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/m.kt index 49f9547009b..fb51e16d988 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when(stepId) { 0, 1 -> if (foo() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/module.info b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/module.info index b19c6e2819d..5e24890d7f7 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/module.info @@ -1,5 +1,8 @@ -STEP 0..1: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1: + dependencies: lib1 + updated inline imports: m.kt STEP 2: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/project.info b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/project.info index 46365fc78a2..48eccd6bfa0 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/project.info +++ b/js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0..1: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 2: libs: lib1, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.4.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.4.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.4.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.4.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.5.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.5.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.5.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.5.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.6.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.6.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.6.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.6.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.7.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.7.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.7.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.7.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.8.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.8.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.8.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.8.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.9.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.9.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.kt.9.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/l1.9.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/module.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/module.info index f81a6b4c027..2b68e67f88d 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/lib1/module.info @@ -1,50 +1,40 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt STEP 5: - dependencies: stdlib modifications: - U : l1.kt.5.txt -> l1.kt - dirty: l1.kt + U : l1.5.kt -> l1.kt + modified ir: l1.kt STEP 6: - dependencies: stdlib modifications: - U : l1.kt.6.txt -> l1.kt - dirty: l1.kt + U : l1.6.kt -> l1.kt + modified ir: l1.kt STEP 7: - dependencies: stdlib modifications: - U : l1.kt.7.txt -> l1.kt - dirty: l1.kt + U : l1.7.kt -> l1.kt + modified ir: l1.kt STEP 8: - dependencies: stdlib modifications: - U : l1.kt.8.txt -> l1.kt - dirty: l1.kt + U : l1.8.kt -> l1.kt + modified ir: l1.kt STEP 9: - dependencies: stdlib modifications: - U : l1.kt.9.txt -> l1.kt - dirty: l1.kt + U : l1.9.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/m.kt b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/m.kt index 464db1f7f2f..8f8cddedf92 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/m.kt @@ -1,4 +1,3 @@ - fun isEqual(l: Any?, r: Any?) = if (l == r) true else null inline fun test1(x: () -> Any) = x() diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/module.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/module.info index ae53c73c164..2f886d64980 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/module.info @@ -1,8 +1,24 @@ -STEP 0..1: - dependencies: stdlib, lib1 - dirty: m.kt -STEP 2: - dependencies: stdlib, lib1 -STEP 3..9: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..2: + dependencies: lib1 + updated inline imports: m.kt +STEP 3..4: + dependencies: lib1 + modified ir: m.kt +STEP 5: + dependencies: lib1 + updated inline imports: m.kt +STEP 6: + dependencies: lib1 + modified ir: m.kt +STEP 7: + dependencies: lib1 + updated inline imports: m.kt +STEP 8: + dependencies: lib1 + modified ir: m.kt +STEP 9: + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/project.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/project.info index b59592e5040..a9a8e91b8e5 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/project.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/project.info @@ -1,14 +1,5 @@ MODULES: lib1, main -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1: - libs: lib1, main - dirty js: lib1, main -STEP 2: - libs: lib1, main - dirty js: lib1 -STEP 3..9: +STEP 0..9: libs: lib1, main dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/module.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/module.info index e575c74de97..c88eac8998e 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/lib1/module.info @@ -1,20 +1,16 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/m.kt b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/m.kt index beb64c009e5..b3924c968c8 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (foo() != (42 + 77)) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/module.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/module.info index 157458fc2d5..308b6d5e10b 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/module.info @@ -1,3 +1,12 @@ -STEP 0..3: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1: + dependencies: lib1 + updated inline imports: m.kt +STEP 2: + dependencies: lib1 + modified ir: m.kt +STEP 3: + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/project.info b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/project.info index 797d907ee4a..c8d9369c64b 100644 --- a/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/project.info +++ b/js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/project.info @@ -1,8 +1,5 @@ MODULES: lib1, main -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1..3: +STEP 0..3: libs: lib1, main dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.3.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.3.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/module.info b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/module.info index e575c74de97..c88eac8998e 100644 --- a/js/js.translator/testData/incremental/invalidation/jsCode/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/jsCode/lib1/module.info @@ -1,20 +1,16 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/main/m.kt b/js/js.translator/testData/incremental/invalidation/jsCode/main/m.kt index a2579cf9ac0..129144a3d64 100644 --- a/js/js.translator/testData/incremental/invalidation/jsCode/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/jsCode/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (foo() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/main/module.info b/js/js.translator/testData/incremental/invalidation/jsCode/main/module.info index 157458fc2d5..c8905bb5d62 100644 --- a/js/js.translator/testData/incremental/invalidation/jsCode/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/jsCode/main/module.info @@ -1,3 +1,6 @@ -STEP 0..3: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..3: + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsCode/project.info b/js/js.translator/testData/incremental/invalidation/jsCode/project.info index 797d907ee4a..c8d9369c64b 100644 --- a/js/js.translator/testData/incremental/invalidation/jsCode/project.info +++ b/js/js.translator/testData/incremental/invalidation/jsCode/project.info @@ -1,8 +1,5 @@ MODULES: lib1, main -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1..3: +STEP 0..3: libs: lib1, main dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.0.kt similarity index 97% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.0.kt index 507e2e17065..d794e64f297 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.0.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.0.kt @@ -1,3 +1,2 @@ - inline fun foo() = 77 fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.1.kt similarity index 97% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.1.kt index 370e26b5f4b..a0ef41311f5 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.1.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.1.kt @@ -1,3 +1,2 @@ - @JsExport inline fun foo() = 77 fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.2.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.2.kt index 4fd32424f59..82d4868a2e6 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.2.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.2.kt @@ -1,3 +1,2 @@ - @JsName("bar") @JsExport inline fun foo() = 77 fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.3.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.3.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.3.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.3.kt index eda58a2a529..f89192dfaeb 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.3.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.3.kt @@ -1,3 +1,2 @@ - @JsName("baz") @JsExport inline fun foo() = 77 fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.4.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.4.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.4.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.4.kt index 7ac56da6b1f..4c8ec3e246c 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.4.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.4.kt @@ -1,3 +1,2 @@ - @JsName("baz") @JsExport inline fun foo() = 77 @JsExport fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.5.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.5.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.5.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.5.kt index d8ed79f5ef7..a0436163b3d 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.5.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.5.kt @@ -1,3 +1,2 @@ - @JsName("baz") @JsExport inline fun foo() = 77 @JsName("gaz77") @JsExport fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.6.txt b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.6.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.6.txt rename to js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.6.kt index ce227534883..64e06a6f9a2 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.kt.6.txt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/l1.6.kt @@ -1,3 +1,2 @@ - @JsName("baz") @JsExport inline fun foo() = 77 @JsName("gaz99") @JsExport fun gaz() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/module.info b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/module.info index 7f8892bb8be..68c1c49f240 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/jsExport/lib1/module.info @@ -1,35 +1,28 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt STEP 3: - dependencies: stdlib modifications: - U : l1.kt.3.txt -> l1.kt - dirty: l1.kt + U : l1.3.kt -> l1.kt + modified ir: l1.kt STEP 4: - dependencies: stdlib modifications: - U : l1.kt.4.txt -> l1.kt - dirty: l1.kt + U : l1.4.kt -> l1.kt + modified ir: l1.kt STEP 5: - dependencies: stdlib modifications: - U : l1.kt.5.txt -> l1.kt - dirty: l1.kt + U : l1.5.kt -> l1.kt + modified ir: l1.kt STEP 6: - dependencies: stdlib modifications: - U : l1.kt.6.txt -> l1.kt - dirty: l1.kt + U : l1.6.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/main/m.kt b/js/js.translator/testData/incremental/invalidation/jsExport/main/m.kt index 987163500ec..d712d560dd0 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/jsExport/main/m.kt @@ -1,4 +1,3 @@ - fun box(): String { if (foo() != 77) return "Fail foo" if (gaz() != 99) return "Fail gaz" diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/main/module.info b/js/js.translator/testData/incremental/invalidation/jsExport/main/module.info index eb6ad02059d..8e24e7e9cbf 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/jsExport/main/module.info @@ -1,5 +1,8 @@ -STEP 0..3: - dependencies: stdlib, lib1 - dirty: m.kt +STEP 0: + dependencies: lib1 + added file: m.kt +STEP 1..3: + dependencies: lib1 + updated inline imports: m.kt STEP 4..6: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/jsExport/project.info b/js/js.translator/testData/incremental/invalidation/jsExport/project.info index ce0e42b37cf..5856e82f68d 100644 --- a/js/js.translator/testData/incremental/invalidation/jsExport/project.info +++ b/js/js.translator/testData/incremental/invalidation/jsExport/project.info @@ -1,9 +1,6 @@ MODULES: lib1, main -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1..3: +STEP 0..3: libs: lib1, main dirty js: lib1, main STEP 4..6: diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/lib1/module.info b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/lib1/module.info index f500435de26..bfbe4ca58d0 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/lib1/module.info @@ -1,6 +1,3 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib - flags: FP diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt.1.txt b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.1.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.1.kt index f5b6a11ce80..91469e8a8e3 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt.1.txt +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.1.kt @@ -1,4 +1,3 @@ - fun box(): String { if (qux() != 42) return "Fail qux" return "OK" diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt index c87f1720e2a..79976c980f2 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt @@ -1,4 +1,3 @@ - fun box(): String { if (qux() != 42) return "Fail" return "OK" diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m0.kt b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m0.kt index 7baa4f3169c..de73bb0cd8c 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m0.kt +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m0.kt @@ -1,2 +1 @@ - fun box0() = qux() diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m1.kt b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m1.kt index 6ff5fd2197b..90924cc4935 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m1.kt +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m1.kt @@ -1,2 +1 @@ - fun box1() = qux() diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/module.info b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/module.info index 05e0b6e092a..c92039ca9a3 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/module.info @@ -1,8 +1,8 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt, m0.kt, m1.kt + dependencies: lib1 + added file: m.kt, m0.kt, m1.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : m.kt.1.txt -> m.kt - dirty: m.kt + U : m.1.kt -> m.kt + modified ir: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/project.info b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/project.info index 00f537587ac..5b92e0e5472 100644 --- a/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/project.info +++ b/js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1: libs: lib1, main dirty js: main diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l11.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l11.kt index 2947ecd8ceb..6efca34b025 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l11.kt +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l11.kt @@ -1,2 +1 @@ - inline fun foo(a: Int) = a * 2 diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12.kt index cbd3599212b..7a486e179cf 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12.kt +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12.kt @@ -1,2 +1 @@ - -inline fun bar(b: Int) = b - 3 \ No newline at end of file +inline fun bar(b: Int) = b - 3 diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.2.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.2.kt new file mode 100644 index 00000000000..a4b0c99b059 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.2.kt @@ -0,0 +1 @@ +inline fun bar(b: Int) = b - 5 diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.kt.2 b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.kt.2 deleted file mode 100644 index dd0d39079dc..00000000000 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/l12_n.kt.2 +++ /dev/null @@ -1,2 +0,0 @@ - -inline fun bar(b: Int) = b - 5 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/module.info b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/module.info index 2f11be99f45..e22d3ecff6f 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/module.info @@ -1,13 +1,10 @@ STEP 0: - dependencies: stdlib - dirty: l11.kt, l12.kt + added file: l11.kt, l12.kt STEP 1: - dependencies: stdlib modifications: D : l12.kt STEP 2: - dependencies: stdlib modifications: - U : l12_n.kt.2 -> l12_n.kt - dirty: l12_n.kt + U : l12_n.2.kt -> l12_n.kt + added file: l12_n.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l21.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l21.kt index 77d5cd44425..6f4ceebf1f2 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l21.kt +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l21.kt @@ -1,2 +1 @@ - -inline fun qux(x: Int, y: Int) = foo(x) + bar(y) \ No newline at end of file +inline fun qux(x: Int, y: Int) = foo(x) + bar(y) diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.1.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.1.kt new file mode 100644 index 00000000000..a8c47766467 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.1.kt @@ -0,0 +1 @@ +inline fun bar(b: Int) = b - 4 diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.kt.1 b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.kt.1 deleted file mode 100644 index 35768eb7ae2..00000000000 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/l22.kt.1 +++ /dev/null @@ -1,2 +0,0 @@ - -inline fun bar(b: Int) = b - 4 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/module.info b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/module.info index 8466549fe50..07eadf09ad4 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/module.info @@ -1,13 +1,14 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l21.kt + dependencies: lib1 + added file: l21.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l22.kt.1 -> l22.kt - dirty: l21.kt, l22.kt + U : l22.1.kt -> l22.kt + added file: l22.kt + removed direct depends: l21.kt STEP 2: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: D : l22.kt - dirty: l21.kt + removed direct depends: l21.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/l3.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/l3.kt index adaa018e630..110a30af407 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/l3.kt +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/l3.kt @@ -1,2 +1 @@ - -inline fun dex(x: Int, y: Int) = qux(x * y, y - x) \ No newline at end of file +inline fun dex(x: Int, y: Int) = qux(x * y, y - x) diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/module.info b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/module.info index 9c530561fe8..d2aed7dbaf9 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/module.info @@ -1,3 +1,6 @@ -STEP 0..2: - dependencies: stdlib, lib1, lib2 - dirty: l3.kt +STEP 0: + dependencies: lib1, lib2 + added file: l3.kt +STEP 1..2: + dependencies: lib1, lib2 + updated inline imports: l3.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/m.kt b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/m.kt index fc86ce1af14..c7de70049f2 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (dex(4, 2) != 11) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/module.info b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/module.info index 0aa6e1d3601..ce57004340c 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/module.info @@ -1,3 +1,6 @@ -STEP 0..2: - dependencies: stdlib, lib1, lib2, lib3 - dirty: m.kt +STEP 0: + dependencies: lib1, lib2, lib3 + added file: m.kt +STEP 1..2: + dependencies: lib1, lib2, lib3 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/project.info b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/project.info index 0b9247734a4..f9e75d15662 100644 --- a/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/project.info +++ b/js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/project.info @@ -1,8 +1,5 @@ MODULES: lib1, lib2, lib3, main -STEP 0: - libs: lib1, lib2, lib3, main - dirty js: stdlib, lib1, lib2, lib3, main -STEP 1..2: +STEP 0..2: libs: lib1, lib2, lib3, main dirty js: lib1, lib2, lib3, main diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt.1 b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.1.kt similarity index 96% rename from js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt.1 rename to js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.1.kt index 68f9b70e81f..b08d4e0346e 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt.1 +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.1.kt @@ -1,2 +1 @@ - inline fun foo(a: Int) = a * 3 diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt index 2f65a3a72ca..e26e69a75eb 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/l1.kt @@ -1,4 +1,3 @@ - inline fun foo(a: Int) = a * 2 inline fun bar(b: Int) = b - 3 diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/module.info b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/module.info index 5963605a540..31f2aae17f9 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib1/module.info @@ -1,8 +1,7 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1 -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt + updated exports: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l2.kt index 77d5cd44425..6f4ceebf1f2 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l2.kt @@ -1,2 +1 @@ - -inline fun qux(x: Int, y: Int) = foo(x) + bar(y) \ No newline at end of file +inline fun qux(x: Int, y: Int) = foo(x) + bar(y) diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.1.kt b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.1.kt new file mode 100644 index 00000000000..a8c47766467 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.1.kt @@ -0,0 +1 @@ +inline fun bar(b: Int) = b - 4 diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.kt.1 b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.kt.1 deleted file mode 100644 index 35768eb7ae2..00000000000 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/l22.kt.1 +++ /dev/null @@ -1,2 +0,0 @@ - -inline fun bar(b: Int) = b - 4 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/module.info b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/module.info index a82f8cfa072..666b7c50620 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/module.info @@ -1,8 +1,10 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: - U : l22.kt.1 -> l22.kt - dirty: l2.kt, l22.kt + U : l22.1.kt -> l22.kt + added file: l22.kt + updated exports: l22.kt + updated inline imports: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/l3.kt b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/l3.kt index adaa018e630..110a30af407 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/l3.kt +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/l3.kt @@ -1,2 +1 @@ - -inline fun dex(x: Int, y: Int) = qux(x * y, y - x) \ No newline at end of file +inline fun dex(x: Int, y: Int) = qux(x * y, y - x) diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/module.info b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/module.info index c0e16b77a1f..231b4fdf915 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/module.info @@ -1,3 +1,6 @@ -STEP 0..1: - dependencies: stdlib, lib1, lib2 - dirty: l3.kt +STEP 0: + dependencies: lib1, lib2 + added file: l3.kt +STEP 1: + dependencies: lib1, lib2 + updated inline imports: l3.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/m.kt b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/m.kt index 9c493a1e3a7..1c80268ded7 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (dex(4, 2) != 11) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/module.info b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/module.info index 0a863e696d5..8e0c882cfd8 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/module.info @@ -1,3 +1,6 @@ -STEP 0..1: - dependencies: stdlib, lib1, lib2, lib3 - dirty: m.kt +STEP 0: + dependencies: lib1, lib2, lib3 + added file: m.kt +STEP 1: + dependencies: lib1, lib2, lib3 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/project.info b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/project.info index 194818478f6..3469cfa7088 100644 --- a/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/project.info +++ b/js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/project.info @@ -1,8 +1,5 @@ MODULES: lib1, lib2, lib3, main -STEP 0: - libs: lib1, lib2, lib3, main - dirty js: stdlib, lib1, lib2, lib3, main -STEP 1: +STEP 0..1: libs: lib1, lib2, lib3, main dirty js: lib1, lib2, lib3, main diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.0.kt b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.0.kt new file mode 100644 index 00000000000..9d198400fd7 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.0.kt @@ -0,0 +1 @@ +fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.0.txt deleted file mode 100644 index 859b384ad7f..00000000000 --- a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/l1.kt.0.txt +++ /dev/null @@ -1 +0,0 @@ -fun foo() = 42 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/module.info b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/module.info index 47593b4c4fe..4ae641e95be 100644 --- a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/lib1/module.info @@ -1,15 +1,12 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/m.kt b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/m.kt index 9f53a0f22d1..bb295676f9d 100644 --- a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (foo() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/module.info b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/module.info index 63fcbf11b28..549c56cad93 100644 --- a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1..2: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/project.info b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/project.info index 4c2690d8461..9af68d0168a 100644 --- a/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/project.info +++ b/js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1..2: libs: lib1, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt.1 b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.1.kt similarity index 74% rename from js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt.1 rename to js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.1.kt index 2b74aeb0fb1..ced6dce9f90 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt.1 +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.1.kt @@ -1,8 +1,7 @@ - private inline fun privateBar(z: Int, l: (Int) -> Int) = l(z - 5) private inline fun privateFoo(x: Int, l: (Int) -> Int): Int { return privateBar(x * 2, l) } -fun foo(x: Int, y: Int) = y - privateFoo(x) { it + it } \ No newline at end of file +fun foo(x: Int, y: Int) = y - privateFoo(x) { it + it } diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt index 838fd19d461..2cce1a647db 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/l1.kt @@ -1,4 +1,3 @@ - private inline fun privateBar(z: Int, l: (Int) -> Int) = l(z - 3) private inline fun privateFoo(x: Int, l: (Int) -> Int): Int { diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/module.info b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/module.info index 5963605a540..b00df4e0597 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib1/module.info @@ -1,8 +1,6 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1 -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/l2.kt index b2fb080ee75..935a75a0a69 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/l2.kt @@ -1,2 +1 @@ - -inline fun qux(x: Int, y: Int) = foo(x, y) \ No newline at end of file +inline fun qux(x: Int, y: Int) = foo(x, y) diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/module.info b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/module.info index c1c7c4b5a69..d1d31ca5618 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/m.kt b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/m.kt index ab906368e18..47c54cb7050 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux(4, 2) != -8) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/module.info b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/module.info index a2d4e3c24e6..406ec8bd244 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/project.info b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/project.info index ca17baa143e..3a84c058f4e 100644 --- a/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/project.info +++ b/js/js.translator/testData/incremental/invalidation/privateInlineFunction1/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_0.kt b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_0.kt index 38e164c8a68..986cae72471 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_0.kt +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_0.kt @@ -1 +1 @@ -fun foo0() = 42 \ No newline at end of file +fun foo0() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_1.kt b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_1.kt index 6bbac8b1257..fcb4be972d4 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_1.kt +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/l1_1.kt @@ -1 +1 @@ -fun foo1() = 24 \ No newline at end of file +fun foo1() = 24 diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/module.info b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/module.info index afee833fa34..da49635626b 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib1/module.info @@ -1,7 +1,5 @@ STEP 0: - dependencies: stdlib - dirty: l1_0.kt, l1_1.kt + added file: l1_0.kt, l1_1.kt STEP 1: - dependencies: stdlib modifications: D : l1_1.kt diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_0.kt b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_0.kt index d559a3b094c..46c4de48bc6 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_0.kt +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_0.kt @@ -1,2 +1 @@ - -fun qux0() = foo0() \ No newline at end of file +fun qux0() = foo0() diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_1.kt b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_1.kt index 5b9fb75300e..074a99e7d5c 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_1.kt +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/l2_1.kt @@ -1,2 +1 @@ - -fun qux1() = foo1() \ No newline at end of file +fun qux1() = foo1() diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/module.info b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/module.info index eadd9138e8f..6f226a866d5 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeFile/lib2/module.info @@ -1,7 +1,7 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2_0.kt, l2_1.kt + dependencies: lib1 + added file: l2_0.kt, l2_1.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 modifications: D : l2_1.kt diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt b/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt index 824d10871af..8ced45d3900 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt @@ -1,4 +1,3 @@ - fun box(): String { if (qux0() != 42) return "Fail" if (qux1() != 24) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt.new b/js/js.translator/testData/incremental/invalidation/removeFile/main/m.new.kt similarity index 98% rename from js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt.new rename to js/js.translator/testData/incremental/invalidation/removeFile/main/m.new.kt index 84f8a228a26..daae8059c4d 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt.new +++ b/js/js.translator/testData/incremental/invalidation/removeFile/main/m.new.kt @@ -1,4 +1,3 @@ - fun box(): String { if (qux0() != 42) return "Fail" return "OK" diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/main/module.info b/js/js.translator/testData/incremental/invalidation/removeFile/main/module.info index aaf8b820e03..987676accfc 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeFile/main/module.info @@ -1,8 +1,8 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 modifications: - U : m.kt.new -> m.kt - dirty: m.kt + U : m.new.kt -> m.kt + modified ir: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/removeFile/project.info b/js/js.translator/testData/incremental/invalidation/removeFile/project.info index 2b4d78d81dc..1e8777de442 100644 --- a/js/js.translator/testData/incremental/invalidation/removeFile/project.info +++ b/js/js.translator/testData/incremental/invalidation/removeFile/project.info @@ -1,8 +1,5 @@ MODULES: lib1, lib2, main -STEP 0: - libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main -STEP 1: +STEP 0..1: libs: lib1, lib2, main dirty js: lib1, lib2, main diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/removeModule/lib1/l1.kt index 859b384ad7f..9d198400fd7 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/removeModule/lib1/l1.kt @@ -1 +1 @@ -fun foo() = 42 \ No newline at end of file +fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib1/module.info b/js/js.translator/testData/incremental/invalidation/removeModule/lib1/module.info index d66ee7e368c..b8d56805ac9 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeModule/lib1/module.info @@ -1,6 +1,4 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib - flags: FP UNUSED + updated exports: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.1.kt b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.1.kt new file mode 100644 index 00000000000..6c76f55fcc2 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.1.kt @@ -0,0 +1 @@ +fun qux() = 99 diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt index baeaa737440..3c096ceace6 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt @@ -1,2 +1 @@ - -fun qux() = foo() \ No newline at end of file +fun qux() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt.1 b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt.1 deleted file mode 100644 index 768c06be4fc..00000000000 --- a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/l2.kt.1 +++ /dev/null @@ -1,2 +0,0 @@ - -fun qux() = 99 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/module.info b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/module.info index 5f5d59240bd..fc4690244ae 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeModule/lib2/module.info @@ -1,8 +1,7 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib modifications: - U : l2.kt.1 -> l2.kt - dirty: l2.kt + U : l2.1.kt -> l2.kt + modified ir: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/main/m.kt b/js/js.translator/testData/incremental/invalidation/removeModule/main/m.kt index 10481919e36..64362abc661 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/removeModule/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/main/module.info b/js/js.translator/testData/incremental/invalidation/removeModule/main/module.info index 507ff56ba8f..b1506de9a28 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeModule/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib2 + dependencies: lib2 diff --git a/js/js.translator/testData/incremental/invalidation/removeModule/project.info b/js/js.translator/testData/incremental/invalidation/removeModule/project.info index 9ddce48f7c0..ec60a5cb1eb 100644 --- a/js/js.translator/testData/incremental/invalidation/removeModule/project.info +++ b/js/js.translator/testData/incremental/invalidation/removeModule/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main dirty js: lib2 diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_0.kt b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_0.kt index 38e164c8a68..986cae72471 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_0.kt +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_0.kt @@ -1 +1 @@ -fun foo0() = 42 \ No newline at end of file +fun foo0() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_1.kt b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_1.kt index 6bbac8b1257..fcb4be972d4 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_1.kt +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/l1_1.kt @@ -1 +1 @@ -fun foo1() = 24 \ No newline at end of file +fun foo1() = 24 diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/module.info b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/module.info index 1e581fc29be..7f1029d67a0 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/lib1/module.info @@ -1,10 +1,6 @@ STEP 0: - dependencies: stdlib - dirty: l1_0.kt, l1_1.kt + added file: l1_0.kt, l1_1.kt STEP 1: - dependencies: stdlib modifications: D : l1_1.kt STEP 2: - dependencies: stdlib - flags: FP diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/m.kt b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/m.kt index ac2fd73c575..b423b98ac1a 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/m.kt @@ -1,4 +1,3 @@ - fun box(): String { if (foo0() != 42) return "Fail" return "OK" diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/module.info b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/module.info index 7dcd9e4a2f0..549c56cad93 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/main/module.info @@ -1,8 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt -STEP 1: - dependencies: stdlib, lib1 -STEP 2: - dependencies: stdlib, lib1 - flags: FP + dependencies: lib1 + added file: m.kt +STEP 1..2: + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/project.info b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/project.info index 3d92db19a6f..cc9512033df 100644 --- a/js/js.translator/testData/incremental/invalidation/removeUnusedFile/project.info +++ b/js/js.translator/testData/incremental/invalidation/removeUnusedFile/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1: libs: lib1, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/renameFile/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/renameFile/lib1/l1.kt index 859b384ad7f..9d198400fd7 100644 --- a/js/js.translator/testData/incremental/invalidation/renameFile/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/renameFile/lib1/l1.kt @@ -1 +1 @@ -fun foo() = 42 \ No newline at end of file +fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/renameFile/lib1/module.info b/js/js.translator/testData/incremental/invalidation/renameFile/lib1/module.info index 9849dc5c214..e5601abb703 100644 --- a/js/js.translator/testData/incremental/invalidation/renameFile/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/renameFile/lib1/module.info @@ -1,9 +1,7 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: D : l1.kt U : l1.kt -> l1_new.kt - dirty: l1_new.kt + added file: l1_new.kt diff --git a/js/js.translator/testData/incremental/invalidation/renameFile/main/m.kt b/js/js.translator/testData/incremental/invalidation/renameFile/main/m.kt index e7b5ed244a5..444245621df 100644 --- a/js/js.translator/testData/incremental/invalidation/renameFile/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/renameFile/main/m.kt @@ -1,4 +1,3 @@ - fun box(): String { if (foo() != 42) return "Fail" return "OK" diff --git a/js/js.translator/testData/incremental/invalidation/renameFile/main/module.info b/js/js.translator/testData/incremental/invalidation/renameFile/main/module.info index 1548fa8071c..0e40a9b2d50 100644 --- a/js/js.translator/testData/incremental/invalidation/renameFile/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/renameFile/main/module.info @@ -1,5 +1,6 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 + removed direct depends: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/renameFile/project.info b/js/js.translator/testData/incremental/invalidation/renameFile/project.info index d5bc61c3174..a506eed60e3 100644 --- a/js/js.translator/testData/incremental/invalidation/renameFile/project.info +++ b/js/js.translator/testData/incremental/invalidation/renameFile/project.info @@ -1,8 +1,5 @@ MODULES: lib1, main -STEP 0: +STEP 0..1: libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1: - libs: lib1, main - dirty js: lib1 + dirty js: lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/simple/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/simple/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/simple/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/simple/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/simple/lib1/module.info b/js/js.translator/testData/incremental/invalidation/simple/lib1/module.info index a9dea2597b7..b00df4e0597 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/simple/lib1/module.info @@ -1,8 +1,6 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/simple/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/simple/lib2/l2.kt index baeaa737440..3c096ceace6 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/simple/lib2/l2.kt @@ -1,2 +1 @@ - -fun qux() = foo() \ No newline at end of file +fun qux() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/simple/lib2/module.info b/js/js.translator/testData/incremental/invalidation/simple/lib2/module.info index c1c7c4b5a69..d1d31ca5618 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/simple/lib2/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: l2.kt + dependencies: lib1 + added file: l2.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/simple/main/m.kt b/js/js.translator/testData/incremental/invalidation/simple/main/m.kt index 88654f7e0cd..350e771d812 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/simple/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/simple/main/module.info b/js/js.translator/testData/incremental/invalidation/simple/main/module.info index a2d4e3c24e6..406ec8bd244 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/simple/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2 - dirty: m.kt + dependencies: lib1, lib2 + added file: m.kt STEP 1: - dependencies: stdlib, lib1, lib2 + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/simple/project.info b/js/js.translator/testData/incremental/invalidation/simple/project.info index ca17baa143e..3a84c058f4e 100644 --- a/js/js.translator/testData/incremental/invalidation/simple/project.info +++ b/js/js.translator/testData/incremental/invalidation/simple/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib2, main STEP 0: libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main + dirty js: lib1, lib2, main STEP 1: libs: lib1, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/module.info b/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/module.info index 47593b4c4fe..4ae641e95be 100644 --- a/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/suspendFunctions/lib1/module.info @@ -1,15 +1,12 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/m.kt b/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/m.kt index 74852df8d5b..57d30e27c03 100644 --- a/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/m.kt @@ -1,4 +1,3 @@ - suspend fun suspendBox(): Int { val x = fooX() val y = fooY() diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/module.info b/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/module.info index d2fd779009d..39e307c89d9 100644 --- a/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/suspendFunctions/main/module.info @@ -1,8 +1,8 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1: - dependencies: stdlib, lib1 + dependencies: lib1 STEP 2: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/suspendFunctions/project.info b/js/js.translator/testData/incremental/invalidation/suspendFunctions/project.info index 739d806ed37..912abf292a5 100644 --- a/js/js.translator/testData/incremental/invalidation/suspendFunctions/project.info +++ b/js/js.translator/testData/incremental/invalidation/suspendFunctions/project.info @@ -1,11 +1,5 @@ MODULES: lib1, main -STEP 0: - libs: lib1, main - dirty js: stdlib, lib1, main -STEP 1: +STEP 0..2: libs: lib1, main dirty js: lib1, main -STEP 2: - libs: lib1, main - dirty js: stdlib, lib1, main diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.1.kt b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.1.kt new file mode 100644 index 00000000000..aadb92dc917 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.1.kt @@ -0,0 +1 @@ +inline fun foo() = 33 diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt index d03afdac779..c7b2afa6adf 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt @@ -1,2 +1 @@ - -inline fun foo() = 42 \ No newline at end of file +inline fun foo() = 42 diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt.1 b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt.1 deleted file mode 100644 index b9ec1aa61e3..00000000000 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/l1.kt.1 +++ /dev/null @@ -1,2 +0,0 @@ - -inline fun foo() = 33 \ No newline at end of file diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/module.info b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/module.info index 5963605a540..b00df4e0597 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib1/module.info @@ -1,8 +1,6 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1 -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/l2.kt b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/l2.kt index 39b7239355c..6fc191794a6 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/l2.kt +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/l2.kt @@ -1,2 +1 @@ - -inline fun qux() = foo() \ No newline at end of file +inline fun qux() = foo() diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/module.info b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/module.info index f73e46361ac..0a26fbd41ea 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/lib2/module.info @@ -1,3 +1,6 @@ -STEP 0..1: - dependencies: stdlib, lib1 - dirty: l2.kt +STEP 0: + dependencies: lib1 + added file: l2.kt +STEP 1: + dependencies: lib1 + updated inline imports: l2.kt diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/m.kt b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/m.kt index 88654f7e0cd..350e771d812 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/m.kt @@ -1,4 +1,3 @@ - fun box(stepId: Int): String { when (stepId) { 0 -> if (qux() != 42) return "Fail" diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/module.info b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/module.info index bf31ce71736..594cd0dce5b 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/main/module.info @@ -1,3 +1,6 @@ -STEP 0..1: - dependencies: stdlib, lib1, lib2 - dirty: m.kt +STEP 0: + dependencies: lib1, lib2 + added file: m.kt +STEP 1: + dependencies: lib1, lib2 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/project.info b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/project.info index 2b4d78d81dc..1e8777de442 100644 --- a/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/project.info +++ b/js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/project.info @@ -1,8 +1,5 @@ MODULES: lib1, lib2, main -STEP 0: - libs: lib1, lib2, main - dirty js: stdlib, lib1, lib2, main -STEP 1: +STEP 0..1: libs: lib1, lib2, main dirty js: lib1, lib2, main diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/module.info b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/module.info index bb55764b2ea..00d0c9dd728 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib1/module.info @@ -1,11 +1,7 @@ STEP 0: - dependencies: stdlib - dirty: l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 2: - flags: FP - dependencies: stdlib diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib2/module.info b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib2/module.info index 075743dedf0..a013669af61 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib2/module.info +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib2/module.info @@ -1,7 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib3 - dirty: l2.kt -STEP 1: - dependencies: stdlib, lib1, lib3 -STEP 2: - dependencies: stdlib, lib1, lib3 + dependencies: lib1, lib3 + added file: l2.kt +STEP 1..2: + dependencies: lib1, lib3 diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/l3.kt.2.txt b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/l3.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/l3.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/l3.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/module.info b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/module.info index 428b6d34e59..67a6a228b40 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/module.info +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/lib3/module.info @@ -1,11 +1,7 @@ STEP 0: - dependencies: stdlib - dirty: l3.kt + added file: l3.kt STEP 1: - dependencies: stdlib - flags: FP STEP 2: - dependencies: stdlib modifications: - U : l3.kt.2.txt -> l3.kt - dirty: l3.kt + U : l3.2.kt -> l3.kt + modified ir: l3.kt diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/m.kt b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/m.kt index f0782c96460..9000a34e945 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/m.kt +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/m.kt @@ -1,4 +1,3 @@ - fun box(step: Int): String { return when (step) { 0 -> checkStep(step, qux = "\uD800", quz = "\uD800") @@ -21,4 +20,4 @@ fun checkStep(step: Int, qux: String, quz: String): String { } return "OK" -} \ No newline at end of file +} diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/module.info b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/module.info index d52200bd35a..c6ea6e29b59 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/main/module.info @@ -1,7 +1,5 @@ STEP 0: - dependencies: stdlib, lib1, lib2, lib3 - dirty: m.kt -STEP 1: - dependencies: stdlib, lib1, lib2, lib3 -STEP 2: - dependencies: stdlib, lib1, lib2, lib3 + dependencies: lib1, lib2, lib3 + added file: m.kt +STEP 1..2: + dependencies: lib1, lib2, lib3 diff --git a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/project.info b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/project.info index 85efae698fa..95742c6dfbd 100644 --- a/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/project.info +++ b/js/js.translator/testData/incremental/invalidation/unicodeSerializationAndDeserialization/project.info @@ -2,7 +2,7 @@ MODULES: lib1, lib3, lib2, main STEP 0: libs: lib1, lib3, lib2, main - dirty js: stdlib, lib1, lib2, lib3, main + dirty js: lib1, lib2, lib3, main STEP 1: libs: lib1, lib3, lib2, main dirty js: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1a.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1a.kt new file mode 100644 index 00000000000..fbd4d437451 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1a.kt @@ -0,0 +1 @@ +fun fun1() = "fun1" diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1b.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1b.kt new file mode 100644 index 00000000000..265ca7688da --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1b.kt @@ -0,0 +1 @@ +fun fun2() = "fun2" diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1c.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1c.kt new file mode 100644 index 00000000000..cf4cb5a76dc --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1c.kt @@ -0,0 +1 @@ +fun fun3() = "fun3" diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1d.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1d.kt new file mode 100644 index 00000000000..01204dc5493 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/l1d.kt @@ -0,0 +1 @@ +fun fun4() = "fun4" diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib1/module.info b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/module.info new file mode 100644 index 00000000000..162f8bc02f8 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib1/module.info @@ -0,0 +1,19 @@ +STEP 0: + added file: l1a.kt, l1b.kt, l1c.kt, l1d.kt +STEP 1: +STEP 2: + updated exports: l1c.kt +STEP 3: +STEP 4: + updated exports: l1b.kt +STEP 5: + updated exports: l1d.kt, l1c.kt + removed inverse depends: l1a.kt +STEP 6: + updated exports: l1b.kt, l1c.kt +STEP 7: + removed inverse depends: l1d.kt, l1c.kt, l1a.kt, l1b.kt +STEP 8: + updated exports: l1c.kt +STEP 9: + updated exports: l1b.kt diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.0.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.0.kt new file mode 100644 index 00000000000..fc0960969eb --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.0.kt @@ -0,0 +1,2 @@ +fun funA() = listOf(fun1()).joinToString() +fun funB() = listOf(fun2()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.1.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.1.kt new file mode 100644 index 00000000000..6633156ef4a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.1.kt @@ -0,0 +1 @@ +fun funA() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.2.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.2.kt new file mode 100644 index 00000000000..3de1612708a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.2.kt @@ -0,0 +1 @@ +fun funA() = listOf(fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.3.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.3.kt new file mode 100644 index 00000000000..6633156ef4a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.3.kt @@ -0,0 +1 @@ +fun funA() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.7.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.7.kt new file mode 100644 index 00000000000..522c67a7544 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.7.kt @@ -0,0 +1,2 @@ +fun funA() = listOf(fun4()).joinToString() +fun funB() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.8.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.8.kt new file mode 100644 index 00000000000..e2776365a33 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.8.kt @@ -0,0 +1 @@ +fun funB() = listOf(fun4()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.9.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.9.kt new file mode 100644 index 00000000000..cc2ec026e55 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2a.9.kt @@ -0,0 +1 @@ +fun funB() = listOf(fun1(), fun3(), fun2()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.1.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.1.kt new file mode 100644 index 00000000000..c5d5bf87766 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.1.kt @@ -0,0 +1 @@ +fun funB() = listOf(fun2(), fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.3.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.3.kt new file mode 100644 index 00000000000..4ddb8ab661f --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.3.kt @@ -0,0 +1 @@ +fun funB() = listOf(fun2(), fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.4.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.4.kt new file mode 100644 index 00000000000..cf5f7e66392 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.4.kt @@ -0,0 +1 @@ +fun funB() = listOf(fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.5.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.5.kt new file mode 100644 index 00000000000..522c67a7544 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.5.kt @@ -0,0 +1,2 @@ +fun funA() = listOf(fun4()).joinToString() +fun funB() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.6.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.6.kt new file mode 100644 index 00000000000..cac7af8eee1 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.6.kt @@ -0,0 +1,2 @@ +fun funA() = listOf(fun4(), fun3()).joinToString() +fun funB() = listOf(fun1(), fun2(), fun4()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.8.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.8.kt new file mode 100644 index 00000000000..940b025ca5c --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.8.kt @@ -0,0 +1 @@ +fun funA() = listOf(fun1(), fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.9.kt b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.9.kt new file mode 100644 index 00000000000..f91fa9edc21 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/l2b.9.kt @@ -0,0 +1 @@ +fun funA() = listOf(fun4()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/lib2/module.info b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/module.info new file mode 100644 index 00000000000..1af73547025 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/lib2/module.info @@ -0,0 +1,58 @@ +STEP 0: + dependencies: lib1 + modifications: + U : l2a.0.kt -> l2a.kt + added file: l2a.kt +STEP 1: + dependencies: lib1 + modifications: + U : l2a.1.kt -> l2a.kt + U : l2b.1.kt -> l2b.kt + added file: l2b.kt + modified ir: l2a.kt +STEP 2: + dependencies: lib1 + modifications: + U : l2a.2.kt -> l2a.kt + modified ir: l2a.kt +STEP 3: + dependencies: lib1 + modifications: + U : l2a.3.kt -> l2a.kt + U : l2b.3.kt -> l2b.kt + modified ir: l2a.kt, l2b.kt +STEP 4: + dependencies: lib1 + modifications: + U : l2b.4.kt -> l2b.kt + modified ir: l2b.kt +STEP 5: + dependencies: lib1 + modifications: + U : l2b.5.kt -> l2b.kt + D : l2a.kt + modified ir: l2b.kt +STEP 6: + dependencies: lib1 + modifications: + U : l2b.6.kt -> l2b.kt + modified ir: l2b.kt +STEP 7: + dependencies: lib1 + modifications: + U : l2a.7.kt -> l2a.kt + D : l2b.kt + added file: l2a.kt +STEP 8: + dependencies: lib1 + modifications: + U : l2a.8.kt -> l2a.kt + U : l2b.8.kt -> l2b.kt + modified ir: l2a.kt + added file: l2b.kt +STEP 9: + dependencies: lib1 + modifications: + U : l2a.9.kt -> l2a.kt + U : l2b.9.kt -> l2b.kt + modified ir: l2a.kt, l2b.kt diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/main/m.kt b/js/js.translator/testData/incremental/invalidation/updateExports/main/m.kt new file mode 100644 index 00000000000..84949178e1e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/main/m.kt @@ -0,0 +1,46 @@ +fun box(stepId: Int): String { + when (stepId) { + 0 -> { + if (funA() != "fun1") return "Fail funA" + if (funB() != "fun2") return "Fail funB" + } + 1 -> { + if (funA() != "fun1") return "Fail funA" + if (funB() != "fun2, fun1") return "Fail funB" + } + 2 -> { + if (funA() != "fun3") return "Fail funA" + if (funB() != "fun2, fun1") return "Fail funB" + } + 3 -> { + if (funA() != "fun1") return "Fail funA" + if (funB() != "fun2, fun3") return "Fail funB" + } + 4 -> { + if (funA() != "fun1") return "Fail funA" + if (funB() != "fun3") return "Fail funB" + } + 5 -> { + if (funA() != "fun4") return "Fail funA" + if (funB() != "fun1") return "Fail funB" + } + 6 -> { + if (funA() != "fun4, fun3") return "Fail funA" + if (funB() != "fun1, fun2, fun4") return "Fail funB" + } + 7 -> { + if (funA() != "fun4") return "Fail funA" + if (funB() != "fun1") return "Fail funB" + } + 8 -> { + if (funA() != "fun1, fun3") return "Fail funA" + if (funB() != "fun4") return "Fail funB" + } + 9 -> { + if (funA() != "fun4") return "Fail funA" + if (funB() != "fun1, fun3, fun2") return "Fail funB" + } + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/main/module.info b/js/js.translator/testData/incremental/invalidation/updateExports/main/module.info new file mode 100644 index 00000000000..94931ecc544 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/main/module.info @@ -0,0 +1,15 @@ +STEP 0: + dependencies: lib1, lib2 + added file: m.kt +STEP 1..4: + dependencies: lib1, lib2 +STEP 5: + dependencies: lib1, lib2 + removed direct depends: m.kt +STEP 6: + dependencies: lib1, lib2 +STEP 7: + dependencies: lib1, lib2 + removed direct depends: m.kt +STEP 8..9: + dependencies: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/updateExports/project.info b/js/js.translator/testData/incremental/invalidation/updateExports/project.info new file mode 100644 index 00000000000..80b38ddc8ce --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExports/project.info @@ -0,0 +1,29 @@ +MODULES: lib1, lib2, main + +STEP 0: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 1: + libs: lib1, lib2, main + dirty js: lib2 +STEP 2: + libs: lib1, lib2, main + dirty js: lib1, lib2 +STEP 3: + libs: lib1, lib2, main + dirty js: lib2 +STEP 4: + libs: lib1, lib2, main + dirty js: lib1, lib2 +STEP 5: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 6: + libs: lib1, lib2, main + dirty js: lib1, lib2 +STEP 7: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 8..9: + libs: lib1, lib2, main + dirty js: lib1, lib2 diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.0.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.0.kt new file mode 100644 index 00000000000..ef1b4adb973 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.0.kt @@ -0,0 +1 @@ +inline fun fun1() = "fun1" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.2.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.2.kt new file mode 100644 index 00000000000..2e0f7ca0e12 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.2.kt @@ -0,0 +1 @@ +inline fun fun1() = "fun1-2" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.3.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.3.kt new file mode 100644 index 00000000000..ed868af45ca --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.3.kt @@ -0,0 +1 @@ +inline fun fun1() = "fun1-3" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.6.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.6.kt new file mode 100644 index 00000000000..b05afaf4e02 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.6.kt @@ -0,0 +1 @@ +inline fun fun1() = "fun1-6" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.8.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.8.kt new file mode 100644 index 00000000000..c8ad0bfc272 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1a.8.kt @@ -0,0 +1 @@ +inline fun fun1() = "fun1-8" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.0.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.0.kt new file mode 100644 index 00000000000..8937bb3f002 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.0.kt @@ -0,0 +1 @@ +inline fun fun2() = "fun2" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.2.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.2.kt new file mode 100644 index 00000000000..093f42f7e3a --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.2.kt @@ -0,0 +1 @@ +inline fun fun2() = "fun2-2" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.8.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.8.kt new file mode 100644 index 00000000000..1f28ecd637b --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1b.8.kt @@ -0,0 +1 @@ +inline fun fun2() = "fun2-8" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.1.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.1.kt new file mode 100644 index 00000000000..24bfb69ef59 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.1.kt @@ -0,0 +1 @@ +inline fun fun3() = "fun3" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.2.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.2.kt new file mode 100644 index 00000000000..305985613cb --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.2.kt @@ -0,0 +1 @@ +inline fun fun3() = "fun3-2" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.3.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.3.kt new file mode 100644 index 00000000000..2be81bfac0e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.3.kt @@ -0,0 +1 @@ +inline fun fun3() = "fun3-3" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.4.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.4.kt new file mode 100644 index 00000000000..e69f1ebac3e --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.4.kt @@ -0,0 +1 @@ +inline fun fun3() = "fun3-4" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.8.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.8.kt new file mode 100644 index 00000000000..f49ec2fb9c8 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/l1c.8.kt @@ -0,0 +1 @@ +inline fun fun3() = "fun3-8" diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/module.info b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/module.info new file mode 100644 index 00000000000..5ee563affa4 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib1/module.info @@ -0,0 +1,39 @@ +STEP 0: + modifications: + U : l1a.0.kt -> l1a.kt + U : l1b.0.kt -> l1b.kt + added file: l1a.kt, l1b.kt +STEP 1: + modifications: + U : l1c.1.kt -> l1c.kt + added file: l1c.kt + updated exports: l1a.kt +STEP 2: + modifications: + U : l1a.2.kt -> l1a.kt + U : l1b.2.kt -> l1b.kt + U : l1c.2.kt -> l1c.kt + modified ir: l1a.kt, l1b.kt, l1c.kt +STEP 3: + modifications: + U : l1a.3.kt -> l1a.kt + U : l1c.3.kt -> l1c.kt + modified ir: l1a.kt, l1c.kt +STEP 4: + modifications: + U : l1c.4.kt -> l1c.kt + modified ir: l1c.kt +STEP 5: + removed inverse depends: l1b.kt +STEP 6: + modifications: + U : l1a.6.kt -> l1a.kt + modified ir: l1a.kt +STEP 7: + updated exports: l1a.kt, l1b.kt, l1c.kt +STEP 6: + modifications: + U : l1a.8.kt -> l1a.kt + U : l1b.8.kt -> l1b.kt + U : l1c.8.kt -> l1c.kt + modified ir: l1a.kt, l1b.kt, l1c.kt diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.0.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.0.kt new file mode 100644 index 00000000000..3e285aa25b6 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.0.kt @@ -0,0 +1,2 @@ +inline fun funA() = listOf(fun1()).joinToString() +inline fun funB() = listOf(fun2()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.1.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.1.kt new file mode 100644 index 00000000000..4e16539217b --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.1.kt @@ -0,0 +1 @@ +inline fun funA() = listOf(fun2()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.7.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.7.kt new file mode 100644 index 00000000000..a717d1a1094 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2a.7.kt @@ -0,0 +1 @@ +inline fun funB() = listOf(fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.1.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.1.kt new file mode 100644 index 00000000000..a717d1a1094 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.1.kt @@ -0,0 +1 @@ +inline fun funB() = listOf(fun3()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.3.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.3.kt new file mode 100644 index 00000000000..127b90b99bb --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.3.kt @@ -0,0 +1 @@ +inline fun funB() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.5.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.5.kt new file mode 100644 index 00000000000..caa649ecc89 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.5.kt @@ -0,0 +1,2 @@ +inline fun funA() = listOf(fun1()).joinToString() +inline fun funB() = listOf(fun1()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.7.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.7.kt new file mode 100644 index 00000000000..4e16539217b --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/l2b.7.kt @@ -0,0 +1 @@ +inline fun funA() = listOf(fun2()).joinToString() diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/module.info b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/module.info new file mode 100644 index 00000000000..9bb17b4afe4 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/lib2/module.info @@ -0,0 +1,41 @@ +STEP 0: + dependencies: lib1 + modifications: + U : l2a.0.kt -> l2a.kt + added file: l2a.kt +STEP 1: + dependencies: lib1 + modifications: + U : l2a.1.kt -> l2a.kt + U : l2b.1.kt -> l2b.kt + added file: l2b.kt + modified ir: l2a.kt +STEP 2: + dependencies: lib1 + updated inline imports: l2b.kt, l2a.kt +STEP 3: + dependencies: lib1 + modifications: + U : l2b.3.kt -> l2b.kt + modified ir: l2b.kt +STEP 4: + dependencies: lib1 +STEP 5: + dependencies: lib1 + modifications: + U : l2b.5.kt -> l2b.kt + D : l2a.kt + modified ir: l2b.kt +STEP 6: + dependencies: lib1 + updated inline imports: l2b.kt +STEP 7: + dependencies: lib1 + modifications: + U : l2a.7.kt -> l2a.kt + U : l2b.7.kt -> l2b.kt + added file: l2a.kt + modified ir: l2b.kt +STEP 8: + dependencies: lib1 + updated inline imports: l2a.kt, l2b.kt diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/m.kt b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/m.kt new file mode 100644 index 00000000000..1859bc4a999 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/m.kt @@ -0,0 +1,38 @@ +fun box(stepId: Int): String { + when (stepId) { + 0 -> { + if (funA() != "fun1") return "Fail funA" + if (funB() != "fun2") return "Fail funB" + } + 1 -> { + if (funA() != "fun2") return "Fail funA" + if (funB() != "fun3") return "Fail funB" + } + 2 -> { + if (funA() != "fun2-2") return "Fail funA" + if (funB() != "fun3-2") return "Fail funB" + } + 3, 4 -> { + if (funA() != "fun2-2") return "Fail funA" + if (funB() != "fun1-3") return "Fail funB" + } + 5 -> { + if (funA() != "fun1-3") return "Fail funA" + if (funB() != "fun1-3") return "Fail funB" + } + 6 -> { + if (funA() != "fun1-6") return "Fail funA" + if (funB() != "fun1-6") return "Fail funB" + } + 7 -> { + if (funA() != "fun2-2") return "Fail funA" + if (funB() != "fun3-4") return "Fail funB" + } + 8 -> { + if (funA() != "fun2-8") return "Fail funA" + if (funB() != "fun3-8") return "Fail funB" + } + else -> return "Unknown" + } + return "OK" +} diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/module.info b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/module.info new file mode 100644 index 00000000000..25494673642 --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/main/module.info @@ -0,0 +1,14 @@ +STEP 0: + dependencies: lib1, lib2 + added file: m.kt +STEP 1..3: + dependencies: lib1, lib2 + updated inline imports: m.kt +STEP 4: + dependencies: lib1, lib2 +STEP 5: + dependencies: lib1, lib2 + removed direct depends: m.kt +STEP 6..8: + dependencies: lib1, lib2 + updated inline imports: m.kt diff --git a/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/project.info b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/project.info new file mode 100644 index 00000000000..7c67888bdcd --- /dev/null +++ b/js/js.translator/testData/incremental/invalidation/updateExportsAndInlineImports/project.info @@ -0,0 +1,11 @@ +MODULES: lib1, lib2, main + +STEP 0..3: + libs: lib1, lib2, main + dirty js: lib1, lib2, main +STEP 4: + libs: lib1, lib2, main + dirty js: lib1 +STEP 5..8: + libs: lib1, lib2, main + dirty js: lib1, lib2, main diff --git a/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.0.txt b/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.0.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.0.txt rename to js/js.translator/testData/incremental/invalidation/variance/lib1/l1.0.kt diff --git a/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.1.txt b/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.1.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.1.txt rename to js/js.translator/testData/incremental/invalidation/variance/lib1/l1.1.kt diff --git a/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.2.txt b/js/js.translator/testData/incremental/invalidation/variance/lib1/l1.2.kt similarity index 100% rename from js/js.translator/testData/incremental/invalidation/variance/lib1/l1.kt.2.txt rename to js/js.translator/testData/incremental/invalidation/variance/lib1/l1.2.kt diff --git a/js/js.translator/testData/incremental/invalidation/variance/lib1/module.info b/js/js.translator/testData/incremental/invalidation/variance/lib1/module.info index 7482d79e3cd..49fb4da652c 100644 --- a/js/js.translator/testData/incremental/invalidation/variance/lib1/module.info +++ b/js/js.translator/testData/incremental/invalidation/variance/lib1/module.info @@ -1,15 +1,12 @@ STEP 0: - dependencies: stdlib modifications: - U : l1.kt.0.txt -> l1.kt - dirty: l1.kt + U : l1.0.kt -> l1.kt + added file: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.1.txt -> l1.kt - dirty: l1.kt + U : l1.1.kt -> l1.kt + modified ir: l1.kt STEP 1: - dependencies: stdlib modifications: - U : l1.kt.2.txt -> l1.kt - dirty: l1.kt + U : l1.2.kt -> l1.kt + modified ir: l1.kt diff --git a/js/js.translator/testData/incremental/invalidation/variance/main/module.info b/js/js.translator/testData/incremental/invalidation/variance/main/module.info index 63fcbf11b28..549c56cad93 100644 --- a/js/js.translator/testData/incremental/invalidation/variance/main/module.info +++ b/js/js.translator/testData/incremental/invalidation/variance/main/module.info @@ -1,5 +1,5 @@ STEP 0: - dependencies: stdlib, lib1 - dirty: m.kt + dependencies: lib1 + added file: m.kt STEP 1..2: - dependencies: stdlib, lib1 + dependencies: lib1 diff --git a/js/js.translator/testData/incremental/invalidation/variance/project.info b/js/js.translator/testData/incremental/invalidation/variance/project.info index 4c2690d8461..9af68d0168a 100644 --- a/js/js.translator/testData/incremental/invalidation/variance/project.info +++ b/js/js.translator/testData/incremental/invalidation/variance/project.info @@ -2,7 +2,7 @@ MODULES: lib1, main STEP 0: libs: lib1, main - dirty js: stdlib, lib1, main + dirty js: lib1, main STEP 1..2: libs: lib1, main dirty js: lib1 diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt index 42a2e067a43..cd09a32483f 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt @@ -172,7 +172,7 @@ class Kotlin2JsIrGradlePluginIT : AbstractKotlin2JsGradlePluginIT(true) { } } - @DisplayName("incremental compilation for JS IR consider multiple artifacts in one project") + @DisplayName("incremental compilation for JS IR consider multiple artifacts in one project") @GradleTest fun testJsIrIncrementalMultipleArtifacts(gradleVersion: GradleVersion) { project("kotlin-js-ir-ic-multiple-artifacts", gradleVersion) { @@ -196,14 +196,15 @@ class Kotlin2JsIrGradlePluginIT : AbstractKotlin2JsGradlePluginIT(true) { .filter { it.isFile } .forEach { val text = it.readText() - if (text.contains("")) { + // cache keeps the js code of compiled module, this substring from that js code + if (text.contains("kotlin_js_ir_ic_multiple_artifacts_lib ")) { if (lib) { error("lib should be only once in cache") } lib = true } - - if (text.contains("")) { + // cache keeps the js code of compiled module, this substring from that js code + if (text.contains("kotlin_js_ir_ic_multiple_artifacts_lib_other ")) { if (libOther) { error("libOther should be only once in cache") } @@ -1335,4 +1336,4 @@ class GeneralKotlin2JsGradlePluginIT : KGPBaseTest() { } } } -} \ No newline at end of file +}