From bd3eb81aee997899fbcf6853769b12e72c111970 Mon Sep 17 00:00:00 2001 From: Alexander Korepanov Date: Tue, 7 Mar 2023 18:51:01 +0100 Subject: [PATCH] [JS FIR] Use FIR in JS IR invalidation tests Related to KT-56740 --- .../jetbrains/kotlin/cli/js/K2JsIrCompiler.kt | 174 ++------ .../kotlin/cli/js/klib/compilerPipeline.kt | 193 +++++++++ .../jetbrains/kotlin/ir/backend/js/klib.kt | 4 + .../generators/tests/GenerateJsTests.kt | 5 + .../incremental/AbstractInvalidationTest.kt | 105 ++--- .../FirAbstractInvalidationTest.kt | 86 ++++ .../incremental/IrAbstractInvalidationTest.kt | 77 ++++ .../JsFirInvalidationTestGenerated.java | 397 ++++++++++++++++++ 8 files changed, 814 insertions(+), 227 deletions(-) create mode 100644 compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt create mode 100644 js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt create mode 100644 js/js.tests/test/org/jetbrains/kotlin/incremental/IrAbstractInvalidationTest.kt create mode 100644 js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/JsFirInvalidationTestGenerated.java 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 e2cab0bd500..be6cb8fd516 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 @@ -7,18 +7,13 @@ package org.jetbrains.kotlin.cli.js import com.intellij.openapi.Disposable import com.intellij.openapi.util.text.StringUtil -import org.jetbrains.kotlin.KtSourceFile import org.jetbrains.kotlin.backend.common.CompilationException -import org.jetbrains.kotlin.backend.common.CommonJsKLibResolver -import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig import org.jetbrains.kotlin.backend.wasm.compileToLoweredIr import org.jetbrains.kotlin.backend.wasm.compileWasm import org.jetbrains.kotlin.backend.wasm.dce.eliminateDeadDeclarations import org.jetbrains.kotlin.backend.wasm.wasmPhases import org.jetbrains.kotlin.backend.wasm.writeCompilationResult -import org.jetbrains.kotlin.builtins.DefaultBuiltIns -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.cli.common.* import org.jetbrains.kotlin.cli.common.ExitCode.* import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments @@ -26,7 +21,6 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.RUNTIME_DIAGNOSTIC_EXCEPTION import org.jetbrains.kotlin.cli.common.arguments.K2JsArgumentConstants.RUNTIME_DIAGNOSTIC_LOG import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot -import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.* @@ -34,29 +28,16 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.common.messages.MessageUtil import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForJSIR import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm +import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization +import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib +import org.jetbrains.kotlin.cli.js.klib.transformFirToIr import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory -import org.jetbrains.kotlin.fir.BinaryModuleData -import org.jetbrains.kotlin.fir.DependencyListForCliModule -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions -import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor -import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar -import org.jetbrains.kotlin.fir.pipeline.FirResult -import org.jetbrains.kotlin.fir.pipeline.buildResolveAndCheckFir -import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize -import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable -import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension -import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.js.IncrementalDataProvider @@ -65,7 +46,6 @@ import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumer import org.jetbrains.kotlin.ir.backend.js.* import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity import org.jetbrains.kotlin.ir.backend.js.ic.* -import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputsBuilt import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.JsCodeGenerator @@ -73,27 +53,19 @@ import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC import org.jetbrains.kotlin.ir.symbols.IrSymbol -import org.jetbrains.kotlin.ir.util.IrMessageLogger import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult import org.jetbrains.kotlin.js.config.* -import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices -import org.jetbrains.kotlin.library.KotlinAbiVersion import org.jetbrains.kotlin.library.metadata.KlibMetadataVersion -import org.jetbrains.kotlin.library.unresolvedDependencies import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.platform.js.JsPlatforms import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.serialization.js.ModuleKind -import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.utils.KotlinPaths import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.join -import org.jetbrains.kotlin.utils.metadataVersion import java.io.File import java.io.IOException -import java.nio.file.Paths +import java.nio.charset.Charset private val K2JSCompilerArguments.granularity: JsGenerationGranularity get() = when { @@ -490,134 +462,36 @@ class K2JsIrCompiler : CLICompiler() { val configuration = environmentForJS.configuration val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter() - val renderDiagnosticNames = configuration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME) - - // FIR - val extensionRegistrars = FirExtensionRegistrar.getInstances(environmentForJS.project) - - val mainModuleName = configuration.get(CommonConfigurationKeys.MODULE_NAME)!! - val escapedMainModuleName = Name.special("<$mainModuleName>") - - val ktFiles = environmentForJS.getSourceFiles() - val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile -> - AnalyzerWithCompilerReport.reportSyntaxErrors(ktFile, messageCollector).isHasErrors or errorsFound - } val mainModule = MainModule.SourceFiles(environmentForJS.getSourceFiles()) + val moduleStructure = ModulesStructure(environmentForJS.project, mainModule, configuration, libraries, friendLibraries) - val binaryModuleData = BinaryModuleData.initialize(escapedMainModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices) - val dependencyList = DependencyListForCliModule.build(binaryModuleData) { - dependencies(libraries.map { Paths.get(it).toAbsolutePath() }) - friendDependencies(friendLibraries.map { Paths.get(it).toAbsolutePath() }) - // TODO: !!! dependencies module data? - } - - val logger = configuration.resolverLogger - val resolvedLibraries = CommonJsKLibResolver.resolve(libraries + friendLibraries, logger).getFullResolvedList() - - val sessionsWithSources = prepareJsSessions( - ktFiles, configuration, escapedMainModuleName.asString(), resolvedLibraries, dependencyList, - extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi - ) - - val outputs = sessionsWithSources.map { - buildResolveAndCheckFir(it.session, it.files, diagnosticsReporter) - } - - if (syntaxErrors || diagnosticsReporter.hasErrors) { - FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(diagnosticsReporter, messageCollector, renderDiagnosticNames) - return null - } + val outputs = compileModuleToAnalyzedFir( + moduleStructure = moduleStructure, + ktFiles = environmentForJS.getSourceFiles(), + libraries = libraries, + friendLibraries = friendLibraries, + messageCollector = messageCollector, + diagnosticsReporter = diagnosticsReporter + ) ?: return null // FIR2IR - - val fir2IrExtensions = Fir2IrExtensions.Default - - var builtInsModule: KotlinBuiltIns? = null - val dependencies = mutableListOf() - - val librariesDescriptors = resolvedLibraries.map { resolvedLibrary -> - val storageManager = LockBasedStorageManager("ModulesStructure") - - val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns( - resolvedLibrary.library, - configuration.languageVersionSettings, - storageManager, - builtInsModule, - packageAccessHandler = null, - lookupTracker = LookupTracker.DO_NOTHING - ) - dependencies += moduleDescriptor - moduleDescriptor.setDependencies(ArrayList(dependencies)) - - val isBuiltIns = resolvedLibrary.library.unresolvedDependencies.isEmpty() - if (isBuiltIns) builtInsModule = moduleDescriptor.builtIns - - moduleDescriptor - } - - val firResult = FirResult(outputs) - val irResult = firResult.convertToIrAndActualize( - fir2IrExtensions, - IrGenerationExtension.getInstances(environmentForJS.project), - linkViaSignatures = false, - signatureComposerCreator = null, - irMangler = JsManglerIr, - visibilityConverter = Fir2IrVisibilityConverter.Default, - kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, - fir2IrResultPostCompute = { - (this.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors } - } - ) + val irResult = transformFirToIr(moduleStructure, outputs) // Serialize klib - if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) { - val sourceFiles = mutableListOf() - val firFilesAndSessionsBySourceFile = mutableMapOf>() - - for (output in outputs) { - output.fir.forEach { - sourceFiles.add(it.sourceFile!!) - firFilesAndSessionsBySourceFile[it.sourceFile!!] = Triple(it, output.session, output.scopeSession) - } - } - - val icData = environmentForJS.configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList() - - val metadataVersion = configuration.metadataVersion() - - serializeModuleIntoKlib( - configuration[CommonConfigurationKeys.MODULE_NAME]!!, - configuration, - configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None, - sourceFiles, - klibPath = outputKlibPath, - resolvedLibraries.map { it.library }, - irResult.irModuleFragment, - expectDescriptorToSymbol = mutableMapOf(), - cleanFiles = icData, - nopack = true, - perFile = false, - containsErrorCode = messageCollector.hasErrors() || diagnosticsReporter.hasErrors, - abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data - jsOutputName = null - ) { file -> - val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[file] - ?: error("cannot find FIR file by source file ${file.name} (${file.path})") - serializeSingleFirFile( - firFile, - session, - scopeSession, - FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()), - configuration.languageVersionSettings, - ) - } + serializeFirKlib( + moduleStructure = moduleStructure, + firOutputs = outputs, + irResult = irResult, + outputKlibPath = outputKlibPath, + messageCollector = messageCollector, + diagnosticsReporter = diagnosticsReporter, + jsOutputName = arguments.irPerModuleOutputName + ) } - return ModulesStructure( - environmentForJS.project, mainModule, configuration, libraries, friendLibraries - ) + return moduleStructure } class IcCachesArtifacts(val artifacts: List, val cacheGuard: IncrementalCacheGuard) diff --git a/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt new file mode 100644 index 00000000000..d35b0a68b21 --- /dev/null +++ b/compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt @@ -0,0 +1,193 @@ +/* + * Copyright 2010-2023 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.cli.js.klib + +import org.jetbrains.kotlin.KtSourceFile +import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.cli.common.fileBelongsToModuleForPsi +import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter +import org.jetbrains.kotlin.cli.common.isCommonSourceForPsi +import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.cli.common.prepareJsSessions +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticsCollector +import org.jetbrains.kotlin.fir.BinaryModuleData +import org.jetbrains.kotlin.fir.DependencyListForCliModule +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions +import org.jetbrains.kotlin.fir.backend.Fir2IrResult +import org.jetbrains.kotlin.fir.backend.Fir2IrVisibilityConverter +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar +import org.jetbrains.kotlin.fir.pipeline.FirResult +import org.jetbrains.kotlin.fir.pipeline.ModuleCompilerAnalyzedOutput +import org.jetbrains.kotlin.fir.pipeline.buildResolveAndCheckFir +import org.jetbrains.kotlin.fir.pipeline.convertToIrAndActualize +import org.jetbrains.kotlin.fir.resolve.ScopeSession +import org.jetbrains.kotlin.fir.serialization.FirElementAwareSerializableStringTable +import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension +import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.ir.backend.js.* +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr +import org.jetbrains.kotlin.ir.util.IrMessageLogger +import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices +import org.jetbrains.kotlin.library.KotlinAbiVersion +import org.jetbrains.kotlin.library.unresolvedDependencies +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.platform.js.JsPlatforms +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.utils.metadataVersion +import java.nio.file.Paths + +fun compileModuleToAnalyzedFir( + moduleStructure: ModulesStructure, + ktFiles: List, + libraries: List, + friendLibraries: List, + messageCollector: MessageCollector, + diagnosticsReporter: BaseDiagnosticsCollector +): List? { + val renderDiagnosticNames = moduleStructure.compilerConfiguration.getBoolean(CLIConfigurationKeys.RENDER_DIAGNOSTIC_INTERNAL_NAME) + + // FIR + val extensionRegistrars = FirExtensionRegistrar.getInstances(moduleStructure.project) + + val mainModuleName = moduleStructure.compilerConfiguration.get(CommonConfigurationKeys.MODULE_NAME)!! + val escapedMainModuleName = Name.special("<$mainModuleName>") + + val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile -> + AnalyzerWithCompilerReport.reportSyntaxErrors(ktFile, messageCollector).isHasErrors or errorsFound + } + + val binaryModuleData = BinaryModuleData.initialize(escapedMainModuleName, JsPlatforms.defaultJsPlatform, JsPlatformAnalyzerServices) + val dependencyList = DependencyListForCliModule.build(binaryModuleData) { + dependencies(libraries.map { Paths.get(it).toAbsolutePath() }) + friendDependencies(friendLibraries.map { Paths.get(it).toAbsolutePath() }) + // TODO: !!! dependencies module data? + } + + val resolvedLibraries = moduleStructure.fullResolvedLibraries + + val sessionsWithSources = prepareJsSessions( + ktFiles, moduleStructure.compilerConfiguration, escapedMainModuleName.asString(), + resolvedLibraries, dependencyList, extensionRegistrars, isCommonSourceForPsi, fileBelongsToModuleForPsi + ) + + val outputs = sessionsWithSources.map { + buildResolveAndCheckFir(it.session, it.files, diagnosticsReporter) + } + + if (syntaxErrors || diagnosticsReporter.hasErrors) { + FirDiagnosticsCompilerResultsReporter.reportToMessageCollector(diagnosticsReporter, messageCollector, renderDiagnosticNames) + return null + } + + return outputs +} + +fun transformFirToIr( + moduleStructure: ModulesStructure, + firOutputs: List +): Fir2IrResult { + val fir2IrExtensions = Fir2IrExtensions.Default + + var builtInsModule: KotlinBuiltIns? = null + val dependencies = mutableListOf() + + val librariesDescriptors = moduleStructure.fullResolvedLibraries.map { resolvedLibrary -> + val storageManager = LockBasedStorageManager("ModulesStructure") + + val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns( + resolvedLibrary.library, + moduleStructure.compilerConfiguration.languageVersionSettings, + storageManager, + builtInsModule, + packageAccessHandler = null, + lookupTracker = LookupTracker.DO_NOTHING + ) + dependencies += moduleDescriptor + moduleDescriptor.setDependencies(ArrayList(dependencies)) + + val isBuiltIns = resolvedLibrary.library.unresolvedDependencies.isEmpty() + if (isBuiltIns) builtInsModule = moduleDescriptor.builtIns + + moduleDescriptor + } + + val firResult = FirResult(firOutputs) + return firResult.convertToIrAndActualize( + fir2IrExtensions, + IrGenerationExtension.getInstances(moduleStructure.project), + linkViaSignatures = false, + signatureComposerCreator = null, + irMangler = JsManglerIr, + visibilityConverter = Fir2IrVisibilityConverter.Default, + kotlinBuiltIns = builtInsModule ?: DefaultBuiltIns.Instance, + fir2IrResultPostCompute = { + (this.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = librariesDescriptors } + } + ) +} + +fun serializeFirKlib( + moduleStructure: ModulesStructure, + firOutputs: List, + irResult: Fir2IrResult, + outputKlibPath: String, + messageCollector: MessageCollector, + diagnosticsReporter: BaseDiagnosticsCollector, + jsOutputName: String? +) { + val sourceFiles = mutableListOf() + val firFilesAndSessionsBySourceFile = mutableMapOf>() + + for (output in firOutputs) { + output.fir.forEach { + sourceFiles.add(it.sourceFile!!) + firFilesAndSessionsBySourceFile[it.sourceFile!!] = Triple(it, output.session, output.scopeSession) + } + } + + val icData = moduleStructure.compilerConfiguration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList() + + val metadataVersion = moduleStructure.compilerConfiguration.metadataVersion() + + serializeModuleIntoKlib( + moduleStructure.compilerConfiguration[CommonConfigurationKeys.MODULE_NAME]!!, + moduleStructure.compilerConfiguration, + moduleStructure.compilerConfiguration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None, + sourceFiles, + klibPath = outputKlibPath, + moduleStructure.fullResolvedLibraries.map { it.library }, + irResult.irModuleFragment, + expectDescriptorToSymbol = mutableMapOf(), + cleanFiles = icData, + nopack = true, + perFile = false, + containsErrorCode = messageCollector.hasErrors() || diagnosticsReporter.hasErrors, + abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data + jsOutputName = jsOutputName + ) { file -> + val (firFile, session, scopeSession) = firFilesAndSessionsBySourceFile[file] + ?: error("cannot find FIR file by source file ${file.name} (${file.path})") + serializeSingleFirFile( + firFile, + session, + scopeSession, + FirKLibSerializerExtension(session, metadataVersion, FirElementAwareSerializableStringTable()), + moduleStructure.compilerConfiguration.languageVersionSettings, + ) + } +} diff --git a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt index 52b20b491c4..5a592f83dcf 100644 --- a/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt +++ b/compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt @@ -475,6 +475,10 @@ class ModulesStructure( compilerConfiguration.resolverLogger ) + val fullResolvedLibraries by lazy { + allDependenciesResolution.resolveWithDependencies().getFullResolvedList() + } + val allDependencies: List get() = allDependenciesResolution.libraries diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt index e140f93b9ce..982522b6e47 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5 import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.incremental.AbstractJsIrES6InvalidationTest import org.jetbrains.kotlin.incremental.AbstractJsIrInvalidationTest +import org.jetbrains.kotlin.incremental.AbstractJsFirInvalidationTest import org.jetbrains.kotlin.js.test.* import org.jetbrains.kotlin.js.test.fir.* import org.jetbrains.kotlin.js.test.ir.* @@ -55,6 +56,10 @@ fun main(args: Array) { testClass { model("incremental/invalidation/", pattern = "^([^_](.+))$", targetBackend = TargetBackend.JS_IR_ES6, recursive = false) } + + testClass { + model("incremental/invalidation/", pattern = "^([^_](.+))$", targetBackend = TargetBackend.JS_IR, recursive = false) + } } testGroup("js/js.tests/tests-gen", "compiler/testData/binaryCompatibility", testRunnerMethodName = "runTest0") { 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 e308bfe07b9..22f6d98b7a1 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt @@ -12,8 +12,6 @@ import com.intellij.psi.PsiManager import com.intellij.psi.SingleRootFileViewProvider import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig import org.jetbrains.kotlin.backend.common.phaser.toPhaseMap -import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport -import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.* @@ -21,16 +19,13 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.languageVersionSettings -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.ir.backend.js.* import org.jetbrains.kotlin.ir.backend.js.ic.* import org.jetbrains.kotlin.ir.backend.js.SourceMapsInfo import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.CompilationOutputs import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.safeModuleName -import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC -import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.js.config.JSConfigurationKeys import org.jetbrains.kotlin.js.test.converters.ClassicJsBackendFacade import org.jetbrains.kotlin.js.test.utils.MODULE_EMULATION_FILE @@ -48,9 +43,6 @@ import org.junit.ComparisonFailure import java.io.File import java.util.EnumSet -abstract class AbstractJsIrInvalidationTest : AbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidation") -abstract class AbstractJsIrES6InvalidationTest : AbstractInvalidationTest(TargetBackend.JS_IR_ES6, "incrementalOut/invalidationES6") - abstract class AbstractInvalidationTest( private val targetBackend: TargetBackend, private val workingDirPath: String @@ -90,7 +82,9 @@ abstract class AbstractInvalidationTest( val projectInfoFile = File(testDirectory, PROJECT_INFO_FILE) val projectInfo = parseProjectInfo(testName, projectInfoFile) - if (projectInfo.muted) return + if (isIgnoredTest(projectInfo)){ + return + } val modulesInfos = mutableMapOf() for (module in projectInfo.modules) { @@ -182,7 +176,8 @@ abstract class AbstractInvalidationTest( } } val configuration = createConfiguration(module, projStep.language) - buildArtifact(configuration, module, moduleSourceDir, dependencies, friends, outputKlibFile) + outputKlibFile.delete() + buildKlib(configuration, module, moduleSourceDir, dependencies, friends, outputKlibFile) } val dtsFile = moduleStep.expectedDTS.ifNotEmpty { @@ -369,77 +364,11 @@ abstract class AbstractInvalidationTest( private fun String.isAllowedJsFile() = endsWith(".js") && !TEST_FILE_IGNORE_PATTERN.matches(this) - private fun File.filteredKtFiles(): Collection { + protected fun File.filteredKtFiles(): Collection { assert(isDirectory && exists()) return listFiles { _, name -> name.isAllowedKtFile() }!!.toList() } - private fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile { - val psiManager = PsiManager.getInstance(project) - val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem - - val vFile = fileSystem.findFileByIoFile(file) ?: error("File not found: $file") - - return SingleRootFileViewProvider(psiManager, vFile).allFiles.find { - it is KtFile && it.virtualFile.canonicalPath == vFile.canonicalPath - } as KtFile - } - - private fun buildArtifact( - configuration: CompilerConfiguration, - moduleName: String, - sourceDir: File, - dependencies: Collection, - friends: Collection, - outputKlibFile: File - ) { - if (outputKlibFile.exists()) outputKlibFile.delete() - - val projectJs = environment.project - - val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) } - - val sourceModule = prepareAnalyzedSourceModule( - project = projectJs, - files = sourceFiles, - configuration = configuration, - dependencies = dependencies.map { it.canonicalPath }, - friendDependencies = friends.map { it.canonicalPath }, - analyzer = AnalyzerWithCompilerReport(configuration) - ) - - val moduleSourceFiles = (sourceModule.mainModule as MainModule.SourceFiles).files - val icData = sourceModule.compilerConfiguration.incrementalDataProvider?.getSerializedData(moduleSourceFiles) ?: emptyList() - val expectDescriptorToSymbol = mutableMapOf() - val (moduleFragment, _) = generateIrForKlibSerialization( - environment.project, - moduleSourceFiles, - configuration, - sourceModule.jsFrontEndResult.jsAnalysisResult, - sortDependencies(sourceModule.moduleDependencies), - icData, - expectDescriptorToSymbol, - IrFactoryImpl, - verifySignatures = true - ) { - sourceModule.getModuleDescriptor(it) - } - val metadataSerializer = - KlibMetadataIncrementalSerializer(configuration, sourceModule.project, sourceModule.jsFrontEndResult.hasErrors) - - generateKLib( - sourceModule, - outputKlibFile.canonicalPath, - nopack = false, - jsOutputName = moduleName, - icData = icData, - expectDescriptorToSymbol = expectDescriptorToSymbol, - moduleFragment = moduleFragment - ) { file -> - metadataSerializer.serializeScope(file, sourceModule.jsFrontEndResult.bindingContext, moduleFragment.descriptor) - } - } - private fun initializeWorkingDir(projectInfo: ProjectInfo, testDir: File, sourceDir: File, buildDir: File) { for (module in projectInfo.modules) { val moduleSourceDir = File(sourceDir, module).also { it.invalidateDir() } @@ -466,4 +395,26 @@ abstract class AbstractInvalidationTest( return dir } + + protected fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile { + val psiManager = PsiManager.getInstance(project) + val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem + + val vFile = fileSystem.findFileByIoFile(file) ?: error("File not found: $file") + + return SingleRootFileViewProvider(psiManager, vFile).allFiles.find { + it is KtFile && it.virtualFile.canonicalPath == vFile.canonicalPath + } as KtFile + } + + protected open fun isIgnoredTest(projectInfo: ProjectInfo) = projectInfo.muted + + protected abstract fun buildKlib( + configuration: CompilerConfiguration, + moduleName: String, + sourceDir: File, + dependencies: Collection, + friends: Collection, + outputKlibFile: File + ) } diff --git a/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt b/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt new file mode 100644 index 00000000000..a7158c97df9 --- /dev/null +++ b/js/js.tests/test/org/jetbrains/kotlin/incremental/FirAbstractInvalidationTest.kt @@ -0,0 +1,86 @@ +/* + * Copyright 2010-2023 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.incremental + +import org.jetbrains.kotlin.cli.common.messages.MessageRenderer +import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector +import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFir +import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib +import org.jetbrains.kotlin.cli.js.klib.transformFirToIr +import org.jetbrains.kotlin.codegen.ProjectInfo +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory +import org.jetbrains.kotlin.ir.backend.js.* +import org.jetbrains.kotlin.test.TargetBackend +import java.io.ByteArrayOutputStream +import java.io.File +import java.io.PrintStream +import java.nio.charset.Charset + +abstract class AbstractJsFirInvalidationTest : FirAbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidationFir") + +abstract class FirAbstractInvalidationTest( + targetBackend: TargetBackend, + workingDirPath: String +) : AbstractInvalidationTest(targetBackend, workingDirPath) { + private val mutedTests = setOf("constVals", "enum") + + override fun isIgnoredTest(projectInfo: ProjectInfo): Boolean { + return super.isIgnoredTest(projectInfo) || projectInfo.name in mutedTests + } + + override fun buildKlib( + configuration: CompilerConfiguration, + moduleName: String, + sourceDir: File, + dependencies: Collection, + friends: Collection, + outputKlibFile: File + ) { + val outputStream = ByteArrayOutputStream() + val messageCollector = PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.PLAIN_FULL_PATHS, true) + val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter() + + val libraries = dependencies.map { it.absolutePath } + val friendLibraries = friends.map { it.absolutePath } + val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) } + val moduleStructure = ModulesStructure( + project = environment.project, + mainModule = MainModule.SourceFiles(sourceFiles), + compilerConfiguration = configuration, + dependencies = libraries, + friendDependenciesPaths = friendLibraries + ) + + val outputs = compileModuleToAnalyzedFir( + moduleStructure = moduleStructure, + ktFiles = sourceFiles, + libraries = libraries, + friendLibraries = friendLibraries, + messageCollector = messageCollector, + diagnosticsReporter = diagnosticsReporter + ) + + if (outputs != null) { + val irResult = transformFirToIr(moduleStructure, outputs) + + serializeFirKlib( + moduleStructure = moduleStructure, + firOutputs = outputs, + irResult = irResult, + outputKlibPath = outputKlibFile.absolutePath, + messageCollector = messageCollector, + diagnosticsReporter = diagnosticsReporter, + jsOutputName = moduleName + ) + } + + if (messageCollector.hasErrors()) { + val messages = outputStream.toByteArray().toString(Charset.forName("UTF-8")) + throw AssertionError("The following errors occurred compiling test:\n$messages") + } + } +} diff --git a/js/js.tests/test/org/jetbrains/kotlin/incremental/IrAbstractInvalidationTest.kt b/js/js.tests/test/org/jetbrains/kotlin/incremental/IrAbstractInvalidationTest.kt new file mode 100644 index 00000000000..b20498812c4 --- /dev/null +++ b/js/js.tests/test/org/jetbrains/kotlin/incremental/IrAbstractInvalidationTest.kt @@ -0,0 +1,77 @@ +/* + * Copyright 2010-2023 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.incremental + +import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport +import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.ir.backend.js.* +import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.test.TargetBackend +import java.io.File + +abstract class AbstractJsIrInvalidationTest : IrAbstractInvalidationTest(TargetBackend.JS_IR, "incrementalOut/invalidation") +abstract class AbstractJsIrES6InvalidationTest : IrAbstractInvalidationTest(TargetBackend.JS_IR_ES6, "incrementalOut/invalidationES6") + +abstract class IrAbstractInvalidationTest( + targetBackend: TargetBackend, + workingDirPath: String +) : AbstractInvalidationTest(targetBackend, workingDirPath) { + override fun buildKlib( + configuration: CompilerConfiguration, + moduleName: String, + sourceDir: File, + dependencies: Collection, + friends: Collection, + outputKlibFile: File + ) { + val projectJs = environment.project + + val sourceFiles = sourceDir.filteredKtFiles().map { environment.createPsiFile(it) } + + val sourceModule = prepareAnalyzedSourceModule( + project = projectJs, + files = sourceFiles, + configuration = configuration, + dependencies = dependencies.map { it.canonicalPath }, + friendDependencies = friends.map { it.canonicalPath }, + analyzer = AnalyzerWithCompilerReport(configuration) + ) + + val moduleSourceFiles = (sourceModule.mainModule as MainModule.SourceFiles).files + val icData = sourceModule.compilerConfiguration.incrementalDataProvider?.getSerializedData(moduleSourceFiles) ?: emptyList() + val expectDescriptorToSymbol = mutableMapOf() + val (moduleFragment, _) = generateIrForKlibSerialization( + environment.project, + moduleSourceFiles, + configuration, + sourceModule.jsFrontEndResult.jsAnalysisResult, + sortDependencies(sourceModule.moduleDependencies), + icData, + expectDescriptorToSymbol, + IrFactoryImpl, + verifySignatures = true + ) { + sourceModule.getModuleDescriptor(it) + } + val metadataSerializer = + KlibMetadataIncrementalSerializer(configuration, sourceModule.project, sourceModule.jsFrontEndResult.hasErrors) + + generateKLib( + sourceModule, + outputKlibFile.canonicalPath, + nopack = false, + jsOutputName = moduleName, + icData = icData, + expectDescriptorToSymbol = expectDescriptorToSymbol, + moduleFragment = moduleFragment + ) { file -> + metadataSerializer.serializeScope(file, sourceModule.jsFrontEndResult.bindingContext, moduleFragment.descriptor) + } + } +} diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/JsFirInvalidationTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/JsFirInvalidationTestGenerated.java new file mode 100644 index 00000000000..cabbc35fe5e --- /dev/null +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/JsFirInvalidationTestGenerated.java @@ -0,0 +1,397 @@ +/* + * Copyright 2010-2023 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.incremental; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateJsTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("js/js.translator/testData/incremental/invalidation") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JsFirInvalidationTestGenerated extends AbstractJsFirInvalidationTest { + private void runTest(String testDataFilePath) throws Exception { + 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("breakKlibBinaryCompatibilityWithVariance") + public void testBreakKlibBinaryCompatibilityWithVariance() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/breakKlibBinaryCompatibilityWithVariance/"); + } + + @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/"); + } + + @TestMetadata("classFunctionsAndFields") + public void testClassFunctionsAndFields() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/"); + } + + @TestMetadata("companionFunction") + public void testCompanionFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/companionFunction/"); + } + + @TestMetadata("companionInlineFunction") + public void testCompanionInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/companionInlineFunction/"); + } + + @TestMetadata("companionProperties") + public void testCompanionProperties() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/companionProperties/"); + } + + @TestMetadata("companionWithStdLibCall") + public void testCompanionWithStdLibCall() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/companionWithStdLibCall/"); + } + + @TestMetadata("constVals") + public void testConstVals() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/constVals/"); + } + + @TestMetadata("crossModuleReferences") + public void testCrossModuleReferences() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/crossModuleReferences/"); + } + + @TestMetadata("eagerInitialization") + public void testEagerInitialization() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/eagerInitialization/"); + } + + @TestMetadata("enum") + public void testEnum() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/enum/"); + } + + @TestMetadata("enumsInInlineFunctions") + public void testEnumsInInlineFunctions() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/enumsInInlineFunctions/"); + } + + @TestMetadata("exceptionsFromInlineFunction") + public void testExceptionsFromInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/exceptionsFromInlineFunction/"); + } + + @TestMetadata("exportsThroughInlineFunction") + public void testExportsThroughInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/exportsThroughInlineFunction/"); + } + + @TestMetadata("fakeOverrideClassFunctionQualifiers") + public void testFakeOverrideClassFunctionQualifiers() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideClassFunctionQualifiers/"); + } + + @TestMetadata("fakeOverrideInheritance") + public void testFakeOverrideInheritance() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInheritance/"); + } + + @TestMetadata("fakeOverrideInlineExtension") + public void testFakeOverrideInlineExtension() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineExtension/"); + } + + @TestMetadata("fakeOverrideInlineFunction") + public void testFakeOverrideInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineFunction/"); + } + + @TestMetadata("fakeOverrideInlineProperty") + public void testFakeOverrideInlineProperty() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInlineProperty/"); + } + + @TestMetadata("fakeOverrideInterfaceFunctionQualifiers") + public void testFakeOverrideInterfaceFunctionQualifiers() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fakeOverrideInterfaceFunctionQualifiers/"); + } + + @TestMetadata("fastPath1") + public void testFastPath1() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fastPath1/"); + } + + @TestMetadata("fastPath2") + public void testFastPath2() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/fastPath2/"); + } + + @TestMetadata("friendDependency") + public void testFriendDependency() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/friendDependency/"); + } + + @TestMetadata("functionDefaultParams") + public void testFunctionDefaultParams() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/functionDefaultParams/"); + } + + @TestMetadata("functionSignature") + public void testFunctionSignature() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/functionSignature/"); + } + + @TestMetadata("functionTypeInterface") + public void testFunctionTypeInterface() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/functionTypeInterface/"); + } + + @TestMetadata("functionTypeInterfaceReflect") + public void testFunctionTypeInterfaceReflect() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/functionTypeInterfaceReflect/"); + } + + @TestMetadata("genericFunctions") + public void testGenericFunctions() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/genericFunctions/"); + } + + @TestMetadata("genericInlineFunctions") + public void testGenericInlineFunctions() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/genericInlineFunctions/"); + } + + @TestMetadata("gettersAndSettersInlining") + public void testGettersAndSettersInlining() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/gettersAndSettersInlining/"); + } + + @TestMetadata("inlineBecomeNonInline") + public void testInlineBecomeNonInline() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/"); + } + + @TestMetadata("inlineFunctionAnnotations") + public void testInlineFunctionAnnotations() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAnnotations/"); + } + + @TestMetadata("inlineFunctionAsFunctionReference") + public void testInlineFunctionAsFunctionReference() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAsFunctionReference/"); + } + + @TestMetadata("inlineFunctionAsParam") + public void testInlineFunctionAsParam() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/"); + } + + @TestMetadata("inlineFunctionCircleUsage") + public void testInlineFunctionCircleUsage() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionCircleUsage/"); + } + + @TestMetadata("inlineFunctionDefaultParams") + public void testInlineFunctionDefaultParams() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/"); + } + + @TestMetadata("inlineFunctionWithObject") + public void testInlineFunctionWithObject() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/inlineFunctionWithObject/"); + } + + @TestMetadata("interfaceSuperUsage") + public void testInterfaceSuperUsage() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/interfaceSuperUsage/"); + } + + @TestMetadata("interfaceWithDefaultParams") + public void testInterfaceWithDefaultParams() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/interfaceWithDefaultParams/"); + } + + @TestMetadata("jsCode") + public void testJsCode() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/jsCode/"); + } + + @TestMetadata("jsExport") + public void testJsExport() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/jsExport/"); + } + + @TestMetadata("jsModuleAnnotation") + public void testJsModuleAnnotation() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/jsModuleAnnotation/"); + } + + @TestMetadata("languageVersionSettings") + public void testLanguageVersionSettings() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/languageVersionSettings/"); + } + + @TestMetadata("localInlineFunction") + public void testLocalInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/localInlineFunction/"); + } + + @TestMetadata("mainModuleInvalidation") + public void testMainModuleInvalidation() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/"); + } + + @TestMetadata("moveAndModifyInlineFunction") + public void testMoveAndModifyInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/moveAndModifyInlineFunction/"); + } + + @TestMetadata("moveExternalDeclarationsBetweenJsModules") + public void testMoveExternalDeclarationsBetweenJsModules() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/moveExternalDeclarationsBetweenJsModules/"); + } + + @TestMetadata("moveFilesBetweenModules") + public void testMoveFilesBetweenModules() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/"); + } + + @TestMetadata("moveInlineFunctionBetweenModules") + public void testMoveInlineFunctionBetweenModules() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/"); + } + + @TestMetadata("nestedClass") + public void testNestedClass() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/nestedClass/"); + } + + @TestMetadata("nonInlineBecomeInline") + public void testNonInlineBecomeInline() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/"); + } + + @TestMetadata("privateDeclarationLeakThroughDefaultParam") + public void testPrivateDeclarationLeakThroughDefaultParam() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/privateDeclarationLeakThroughDefaultParam/"); + } + + @TestMetadata("privateInlineFunction1") + public void testPrivateInlineFunction1() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/privateInlineFunction1/"); + } + + @TestMetadata("removeFile") + public void testRemoveFile() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/removeFile/"); + } + + @TestMetadata("removeModule") + public void testRemoveModule() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/removeModule/"); + } + + @TestMetadata("removeUnusedFile") + public void testRemoveUnusedFile() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/removeUnusedFile/"); + } + + @TestMetadata("renameFile") + public void testRenameFile() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/renameFile/"); + } + + @TestMetadata("renameModule") + public void testRenameModule() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/renameModule/"); + } + + @TestMetadata("simple") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/simple/"); + } + + @TestMetadata("splitJoinModule") + public void testSplitJoinModule() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/splitJoinModule/"); + } + + @TestMetadata("suspendFunctions") + public void testSuspendFunctions() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/suspendFunctions/"); + } + + @TestMetadata("suspendInterfaceWithDefaultParams") + public void testSuspendInterfaceWithDefaultParams() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/suspendInterfaceWithDefaultParams/"); + } + + @TestMetadata("toplevelProperties") + public void testToplevelProperties() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/toplevelProperties/"); + } + + @TestMetadata("transitiveInlineFunction") + public void testTransitiveInlineFunction() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/transitiveInlineFunction/"); + } + + @TestMetadata("typeScriptExports") + public void testTypeScriptExports() throws Exception { + runTest("js/js.translator/testData/incremental/invalidation/typeScriptExports/"); + } + + @TestMetadata("unicodeSerializationAndDeserialization") + public void testUnicodeSerializationAndDeserialization() throws Exception { + 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/"); + } +}