azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

K2JsIrCompiler: hoist common front-end preparation logic

Browse Source 
Instead of creating ModuleStructure and run analysis in each backend,
the common preparation logic is moved into K2JsIrCompiler.doExecute().
This commit is contained in:
Ting-Yuan Huang
2021-03-23 22:15:40 -07:00
committed by TeamCityServer
parent 94af3adb4b
commit e75ca75e3e
9 changed files with 192 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt
+32 -24
View File
@@ -205,7 +205,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
cachePath = outputFilePath,
project = projectJs,
mainModule = mainModule,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
dependencies = libraries,
friendDependencies = friendLibraries,
@@ -219,18 +218,29 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
return OK
}
// Run analysis if main module is sources
lateinit var sourceModule: ModulesStructure
if (arguments.includes == null) {
sourceModule = prepareAnalyzedSourceModule(
projectJs,
environmentForJS.getSourceFiles(),
configurationJs,
libraries,
friendLibraries,
AnalyzerWithCompilerReport(config.configuration),
icUseGlobalSignatures = icCaches.isNotEmpty(),
icUseStdlibCache = icCaches.isNotEmpty(),
icCache = if (icCaches.isNotEmpty()) checkCaches(libraries, icCaches, skipLib = arguments.includes).data else emptyMap()
)
}
if (arguments.irProduceKlibDir || arguments.irProduceKlibFile) {
if (arguments.irProduceKlibFile) {
require(outputFile.extension == KLIB_FILE_EXTENSION) { "Please set up .klib file as output" }
}
generateKLib(
project = config.project,
files = sourcesFiles,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
dependencies = libraries,
friendDependencies = friendLibraries,
sourceModule,
irFactory = PersistentIrFactory(), // TODO IrFactoryImpl?
outputKlibPath = outputFile.path,
nopack = arguments.irProduceKlibDir,
@@ -246,28 +256,33 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
val includes = arguments.includes
val mainModule = if (includes != null) {
val module = if (includes != null) {
if (sourcesFiles.isNotEmpty()) {
messageCollector.report(ERROR, "Source files are not supported when -Xinclude is present")
}
val includesPath = File(includes).canonicalPath
val mainLibPath = libraries.find { File(it).canonicalPath == includesPath }
?: error("No library with name $includes ($includesPath) found")
MainModule.Klib(mainLibPath)
val kLib = MainModule.Klib(mainLibPath)
ModulesStructure(
projectJs,
kLib,
configuration,
libraries,
friendLibraries,
icUseGlobalSignatures = icCaches.isNotEmpty(),
icUseStdlibCache = icCaches.isNotEmpty(),
icCache = if (icCaches.isNotEmpty()) checkCaches(libraries, icCaches, skipLib = includes).data else emptyMap()
)
} else {
MainModule.SourceFiles(sourcesFiles)
sourceModule
}
if (arguments.wasm) {
val res = compileWasm(
projectJs,
mainModule,
AnalyzerWithCompilerReport(config.configuration),
config.configuration,
module,
PhaseConfig(wasmPhases),
IrFactoryImpl,
dependencies = libraries,
friendDependencies = friendLibraries,
exportedDeclarations = setOf(FqName("main"))
)
val outputWasmFile = outputFile.withReplacedExtensionOrNull(outputFile.extension, "wasm")!!
@@ -289,14 +304,9 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
val start = System.currentTimeMillis()
val compiledModule = compile(
projectJs,
mainModule,
AnalyzerWithCompilerReport(config.configuration),
config.configuration,
module,
phaseConfig,
if (arguments.irDceDriven) PersistentIrFactory() else IrFactoryImpl,
dependencies = libraries,
friendDependencies = friendLibraries,
mainArguments = mainCallArguments,
generateFullJs = !arguments.irDce,
generateDceJs = arguments.irDce,
@@ -316,8 +326,6 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
messageCollector
),
lowerPerModule = icCaches.isNotEmpty(),
useStdlibCache = icCaches.isNotEmpty(),
icCache = if (icCaches.isNotEmpty()) checkCaches(libraries, icCaches, skipLib = includes).data else emptyMap(),
)
messageCollector.report(INFO, "Executable production duration: ${System.currentTimeMillis() - start}ms")
compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt
+5 -17
View File
@@ -39,14 +39,9 @@ class CompilationOutputs(
)
fun compile(
project: Project,
mainModule: MainModule,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
depsDescriptors: ModulesStructure,
phaseConfig: PhaseConfig,
irFactory: IrFactory,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
mainArguments: List<String>?,
exportedDeclarations: Set<FqName> = emptySet(),
generateFullJs: Boolean = true,
@@ -63,18 +58,11 @@ fun compile(
lowerPerModule: Boolean = false,
safeExternalBoolean: Boolean = false,
safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null,
useStdlibCache: Boolean = false,
icCache: Map<String, SerializedIcData> = emptyMap(),
): CompilerResult {
if (lowerPerModule) {
return icCompile(
project,
mainModule,
analyzer,
configuration,
dependencies,
friendDependencies,
depsDescriptors,
mainArguments,
exportedDeclarations,
generateFullJs,
@@ -88,13 +76,13 @@ fun compile(
legacyPropertyAccess,
safeExternalBoolean,
safeExternalBooleanDiagnostic,
useStdlibCache,
icCache,
)
}
val (moduleFragment: IrModuleFragment, dependencyModules, irBuiltIns, symbolTable, deserializer, moduleToName) =
loadIr(project, mainModule, analyzer, configuration, dependencies, friendDependencies, irFactory, verifySignatures)
loadIr(depsDescriptors, irFactory, verifySignatures)
val mainModule = depsDescriptors.mainModule
val configuration = depsDescriptors.compilerConfiguration
val moduleDescriptor = moduleFragment.descriptor
compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/fileUtil.kt
+1 -2
View File
@@ -26,7 +26,6 @@ fun buildCache(
cachePath: String,
project: Project,
mainModule: MainModule.Klib,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
@@ -50,7 +49,7 @@ fun buildCache(
icDir.deleteRecursively()
icDir.mkdirs()
val icData = prepareSingleLibraryIcCache(project, analyzer, configuration, mainModule.libPath, dependencies, friendDependencies, exportedDeclarations, icCache.data)
val icData = prepareSingleLibraryIcCache(project, configuration, mainModule.libPath, dependencies, friendDependencies, exportedDeclarations, icCache.data)
icData.writeTo(File(cachePath))
compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/ic/ic.kt
+14 -46
View File
@@ -29,7 +29,6 @@ import java.io.PrintWriter
fun prepareSingleLibraryIcCache(
project: Project,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
libPath: String,
dependencies: Collection<String>,
@@ -41,21 +40,23 @@ fun prepareSingleLibraryIcCache(
val controller = WholeWorldStageController()
irFactory.stageController = controller
val (context, deserializer, allModules) = prepareIr(
val depsDescriptor = ModulesStructure(
project,
MainModule.Klib(libPath),
analyzer,
configuration,
dependencies,
friendDependencies,
true,
true,
icCache
)
val (context, deserializer, allModules) = prepareIr(
depsDescriptor,
exportedDeclarations,
null,
false,
false,
irFactory,
useGlobalSignatures = true,
useStdlibCache = true,
icCache = icCache
)
val moduleFragment = allModules.last()
@@ -118,12 +119,7 @@ private fun dumpIr(module: IrModuleFragment, fileName: String) {
}
fun icCompile(
project: Project,
mainModule: MainModule,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
depsDescriptor: ModulesStructure,
mainArguments: List<String>?,
exportedDeclarations: Set<FqName> = emptySet(),
generateFullJs: Boolean = true,
@@ -137,8 +133,6 @@ fun icCompile(
baseClassIntoMetadata: Boolean = false,
safeExternalBoolean: Boolean = false,
safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null,
useStdlibCache: Boolean,
icCache: Map<String, SerializedIcData> = emptyMap()
): CompilerResult {
val irFactory = PersistentIrFactory()
@@ -146,12 +140,7 @@ fun icCompile(
irFactory.stageController = controller
val (context, _, allModules, moduleToName, loweredIrLoaded) = prepareIr(
project,
mainModule,
analyzer,
configuration,
dependencies,
friendDependencies,
depsDescriptor,
exportedDeclarations,
dceRuntimeDiagnostic,
es6mode,
@@ -160,10 +149,7 @@ fun icCompile(
baseClassIntoMetadata,
legacyPropertyAccess,
safeExternalBoolean,
safeExternalBooleanDiagnostic,
useStdlibCache,
useStdlibCache,
icCache,
safeExternalBooleanDiagnostic
)
val modulesToLower = allModules.filter { it !in loweredIrLoaded }
@@ -220,12 +206,7 @@ fun lowerPreservingIcData(module: IrModuleFragment, context: JsIrBackendContext,
}
private fun prepareIr(
project: Project,
mainModule: MainModule,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
depsDescriptor: ModulesStructure,
exportedDeclarations: Set<FqName> = emptySet(),
dceRuntimeDiagnostic: RuntimeDiagnostic? = null,
es6mode: Boolean = false,
@@ -235,26 +216,13 @@ private fun prepareIr(
baseClassIntoMetadata: Boolean = false,
safeExternalBoolean: Boolean = false,
safeExternalBooleanDiagnostic: RuntimeDiagnostic? = null,
useGlobalSignatures: Boolean,
useStdlibCache: Boolean,
icCache: Map<String, SerializedIcData>,
): PreparedIr {
val cacheProvider: LoweringsCacheProvider? = when {
useStdlibCache -> object : LoweringsCacheProvider {
override fun cacheByPath(path: String): SerializedIcData? {
return icCache[path]
}
}
useGlobalSignatures -> EmptyLoweringsCacheProvider
else -> null
}
val (moduleFragment: IrModuleFragment, dependencyModules, irBuiltIns, symbolTable, deserializer, moduleToName, loweredIrLoaded) =
loadIr(project, mainModule, analyzer, configuration, dependencies, friendDependencies, irFactory, false, cacheProvider)
loadIr(depsDescriptor, irFactory, false)
val moduleDescriptor = moduleFragment.descriptor
val allModules = when (mainModule) {
val allModules = when (depsDescriptor.mainModule) {
is MainModule.SourceFiles -> dependencyModules + listOf(moduleFragment)
is MainModule.Klib -> dependencyModules
}
@@ -265,7 +233,7 @@ private fun prepareIr(
symbolTable,
allModules.first(),
exportedDeclarations,
configuration,
depsDescriptor.compilerConfiguration,
es6mode = es6mode,
dceRuntimeDiagnostic = dceRuntimeDiagnostic,
propertyLazyInitialization = propertyLazyInitialization,
compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/compiler.kt
+5 -11
View File
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.backend.wasm.ir2wasm.WasmModuleFragmentGenerator
import org.jetbrains.kotlin.backend.wasm.ir2wasm.generateStringLiteralsSupport
import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.ir.backend.js.MainModule
import org.jetbrains.kotlin.ir.backend.js.ModulesStructure
import org.jetbrains.kotlin.ir.backend.js.loadIr
import org.jetbrains.kotlin.ir.declarations.IrFactory
import org.jetbrains.kotlin.ir.util.ExternalDependenciesGenerator
@@ -28,21 +29,14 @@ import java.io.ByteArrayOutputStream
class WasmCompilerResult(val wat: String, val js: String, val wasm: ByteArray)
fun compileWasm(
project: Project,
mainModule: MainModule,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
depsDescriptors: ModulesStructure,
phaseConfig: PhaseConfig,
irFactory: IrFactory,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
exportedDeclarations: Set<FqName> = emptySet()
): WasmCompilerResult {
val (moduleFragment, dependencyModules, irBuiltIns, symbolTable, deserializer) =
loadIr(
project, mainModule, analyzer, configuration, dependencies, friendDependencies,
irFactory, verifySignatures = false
)
val mainModule = depsDescriptors.mainModule
val configuration = depsDescriptors.compilerConfiguration
val (moduleFragment, dependencyModules, irBuiltIns, symbolTable, deserializer) = loadIr(depsDescriptors, irFactory, verifySignatures = false)
val allModules = when (mainModule) {
is MainModule.SourceFiles -> dependencyModules + listOf(moduleFragment)
compiler/ir/serialization.js/src/org/jetbrains/kotlin/ir/backend/js/klib.kt
+64 -34
View File
@@ -120,12 +120,7 @@ private fun IrMessageLogger?.toResolverLogger(): Logger {
}
fun generateKLib(
project: Project,
files: List<KtFile>,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
depsDescriptors: ModulesStructure,
irFactory: IrFactory,
outputKlibPath: String,
nopack: Boolean,
@@ -133,6 +128,10 @@ fun generateKLib(
abiVersion: KotlinAbiVersion = KotlinAbiVersion.CURRENT,
jsOutputName: String?
) {
val project = depsDescriptors.project
val files = (depsDescriptors.mainModule as MainModule.SourceFiles).files
val configuration = depsDescriptors.compilerConfiguration
val allDependencies = depsDescriptors.allDependencies
val incrementalDataProvider = configuration.get(JSConfigurationKeys.INCREMENTAL_DATA_PROVIDER)
val errorPolicy = configuration.get(JSConfigurationKeys.ERROR_TOLERANCE_POLICY) ?: ErrorTolerancePolicy.DEFAULT
val messageLogger = configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None
@@ -167,10 +166,7 @@ fun generateKLib(
serializedIrFiles = null
}
val depsDescriptors =
ModulesStructure(project, MainModule.SourceFiles(files), analyzer, configuration, dependencies, friendDependencies, EmptyLoweringsCacheProvider)
val allDependencies = depsDescriptors.allDependencies
val (psi2IrContext, hasErrors) = runAnalysisAndPreparePsi2Ir(depsDescriptors, errorPolicy, SymbolTable(IdSignatureDescriptor(JsManglerDesc), irFactory))
val (psi2IrContext, hasErrors) = preparePsi2Ir(depsDescriptors, errorPolicy, SymbolTable(IdSignatureDescriptor(JsManglerDesc), irFactory))
val irBuiltIns = psi2IrContext.irBuiltIns
val expectDescriptorToSymbol = mutableMapOf<DeclarationDescriptor, IrSymbol>()
@@ -256,27 +252,23 @@ object EmptyLoweringsCacheProvider : LoweringsCacheProvider {
@OptIn(ObsoleteDescriptorBasedAPI::class)
fun loadIr(
project: Project,
mainModule: MainModule,
analyzer: AbstractAnalyzerWithCompilerReport,
configuration: CompilerConfiguration,
dependencies: Collection<String>,
friendDependencies: Collection<String>,
depsDescriptors: ModulesStructure,
irFactory: IrFactory,
verifySignatures: Boolean,
loweringsCacheProvider: LoweringsCacheProvider? = null
verifySignatures: Boolean
): IrModuleInfo {
val depsDescriptors = ModulesStructure(project, mainModule, analyzer, configuration, dependencies, friendDependencies, loweringsCacheProvider ?: EmptyLoweringsCacheProvider)
val project = depsDescriptors.project
val mainModule = depsDescriptors.mainModule
val configuration = depsDescriptors.compilerConfiguration
val allDependencies = depsDescriptors.allDependencies
val errorPolicy = configuration.get(JSConfigurationKeys.ERROR_TOLERANCE_POLICY) ?: ErrorTolerancePolicy.DEFAULT
val messageLogger = configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None
val allDependencies = depsDescriptors.allDependencies
val signaturer = IdSignatureDescriptor(JsManglerDesc)
val symbolTable = SymbolTable(signaturer, irFactory)
when (mainModule) {
is MainModule.SourceFiles -> {
val (psi2IrContext, _) = runAnalysisAndPreparePsi2Ir(depsDescriptors, errorPolicy, symbolTable)
val (psi2IrContext, _) = preparePsi2Ir(depsDescriptors, errorPolicy, symbolTable)
val irBuiltIns = psi2IrContext.irBuiltIns
val feContext = psi2IrContext.run {
JsIrLinker.JsFePluginContext(moduleDescriptor, symbolTable, typeTranslator, irBuiltIns)
@@ -335,12 +327,12 @@ fun loadIr(
TypeTranslatorImpl(symbolTable, depsDescriptors.compilerConfiguration.languageVersionSettings, moduleDescriptor)
val irBuiltIns = IrBuiltInsOverDescriptors(moduleDescriptor.builtIns, typeTranslator, symbolTable)
val loweredIcData = if (loweringsCacheProvider == null) emptyMap() else {
val loweredIcData = if (!depsDescriptors.icUseStdlibCache && !depsDescriptors.icUseStdlibCache) emptyMap() else {
val result = mutableMapOf<ModuleDescriptor, SerializedIcData>()
for (lib in depsDescriptors.moduleDependencies.keys) {
val path = lib.libraryFile.absolutePath
val icData = loweringsCacheProvider.cacheByPath(path)
val icData = depsDescriptors.loweringsCacheProvider.cacheByPath(path)
if (icData != null) {
val desc = depsDescriptors.getModuleDescriptor(lib)
result[desc] = icData
@@ -393,12 +385,31 @@ fun loadIr(
}
}
private fun runAnalysisAndPreparePsi2Ir(
fun prepareAnalyzedSourceModule(
project: Project,
files: List<KtFile>,
configuration: CompilerConfiguration,
dependencies: List<String>,
friendDependencies: List<String>,
analyzer: AbstractAnalyzerWithCompilerReport,
icUseGlobalSignatures: Boolean = false,
icUseStdlibCache: Boolean = false,
icCache: Map<String, SerializedIcData> = emptyMap(),
errorPolicy: ErrorTolerancePolicy = configuration.get(JSConfigurationKeys.ERROR_TOLERANCE_POLICY) ?: ErrorTolerancePolicy.DEFAULT,
): ModulesStructure {
val mainModule = MainModule.SourceFiles(files)
val sourceModule = ModulesStructure(project, mainModule, configuration, dependencies, friendDependencies, icUseGlobalSignatures, icUseStdlibCache, icCache)
return sourceModule.apply {
runAnalysis(errorPolicy, analyzer)
}
}
private fun preparePsi2Ir(
depsDescriptors: ModulesStructure,
errorIgnorancePolicy: ErrorTolerancePolicy,
symbolTable: SymbolTable,
): Pair<GeneratorContext, Boolean> {
val analysisResult = depsDescriptors.runAnalysis(errorIgnorancePolicy)
val analysisResult = depsDescriptors.jsFrontEndResult
val psi2Ir = Psi2IrTranslator(
depsDescriptors.compilerConfiguration.languageVersionSettings,
Psi2IrConfiguration(errorIgnorancePolicy.allowErrors)
@@ -469,15 +480,26 @@ sealed class MainModule {
class Klib(val libPath: String) : MainModule()
}
private class ModulesStructure(
private val project: Project,
private val mainModule: MainModule,
private val analyzer: AbstractAnalyzerWithCompilerReport,
class ModulesStructure(
val project: Project,
val mainModule: MainModule,
val compilerConfiguration: CompilerConfiguration,
dependencies: Collection<String>,
val dependencies: Collection<String>,
friendDependenciesPaths: Collection<String>,
private val loweringsCacheProvider: LoweringsCacheProvider
val icUseGlobalSignatures: Boolean,
val icUseStdlibCache: Boolean,
val icCache: Map<String, SerializedIcData>,
) {
val loweringsCacheProvider: LoweringsCacheProvider = when {
icUseStdlibCache -> object : LoweringsCacheProvider {
override fun cacheByPath(path: String): SerializedIcData? {
return icCache[path]
}
}
icUseGlobalSignatures -> EmptyLoweringsCacheProvider
else -> EmptyLoweringsCacheProvider
}
val allResolvedDependencies = jsResolveLibraries(
dependencies,
compilerConfiguration[JSConfigurationKeys.REPOSITORIES] ?: emptyList(),
@@ -502,9 +524,17 @@ private class ModulesStructure(
val builtInsDep = allDependencies.find { it.library.isBuiltIns }
class JsFrontEndResult(val moduleDescriptor: ModuleDescriptor, val bindingContext: BindingContext, val hasErrors: Boolean)
class JsFrontEndResult(val jsAnalysisResult: AnalysisResult, val hasErrors: Boolean) {
val moduleDescriptor: ModuleDescriptor
get() = jsAnalysisResult.moduleDescriptor
fun runAnalysis(errorPolicy: ErrorTolerancePolicy): JsFrontEndResult {
val bindingContext: BindingContext
get() = jsAnalysisResult.bindingContext
}
lateinit var jsFrontEndResult: JsFrontEndResult
fun runAnalysis(errorPolicy: ErrorTolerancePolicy, analyzer: AbstractAnalyzerWithCompilerReport) {
require(mainModule is MainModule.SourceFiles)
val files = mainModule.files
@@ -538,7 +568,7 @@ private class ModulesStructure(
hasErrors = TopDownAnalyzerFacadeForJSIR.checkForErrors(files, analysisResult.bindingContext, errorPolicy) || hasErrors
return JsFrontEndResult(analysisResult.moduleDescriptor, analysisResult.bindingContext, hasErrors)
jsFrontEndResult = JsFrontEndResult(analysisResult, hasErrors)
}
private val languageVersionSettings: LanguageVersionSettings = compilerConfiguration.languageVersionSettings
js/js.tests/test/org/jetbrains/kotlin/js/test/ApiTest.kt
+9 -2
View File
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.impl.EnumEntrySyntheticClassDescriptor
import org.jetbrains.kotlin.ir.backend.js.MainModule
import org.jetbrains.kotlin.ir.backend.js.ModulesStructure
import org.jetbrains.kotlin.ir.backend.js.loadIr
import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
import org.jetbrains.kotlin.js.config.JSConfigurationKeys
@@ -72,13 +73,19 @@ class ApiTest : KotlinTestWithEnvironment() {
val project = environment.project
val configuration = environment.configuration
return loadIr(
val klibModule = ModulesStructure(
project,
MainModule.Klib(File(fullRuntimeKlib).canonicalPath),
AnalyzerWithCompilerReport(configuration),
configuration,
listOf(fullRuntimeKlib),
emptyList(),
false,
false,
emptyMap()
)
return loadIr(
klibModule,
IrFactoryImpl,
verifySignatures = true
).module.descriptor.packagesSerialized()
js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt
+49 -31
View File
@@ -128,13 +128,16 @@ abstract class BasicIrBoxTest(
prepareRuntimePirCaches(config, icCache)
if (isMainModule && klibMainModule) {
val module = prepareAnalyzedSourceModule(
config.project,
filesToCompile,
config.configuration,
allKlibPaths,
emptyList(),
AnalyzerWithCompilerReport(config.configuration),
)
generateKLib(
project = config.project,
files = filesToCompile,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
dependencies = allKlibPaths,
friendDependencies = emptyList(),
module,
irFactory = IrFactoryImpl,
outputKlibPath = klibPath,
nopack = true,
@@ -168,23 +171,42 @@ abstract class BasicIrBoxTest(
PhaseConfig(jsPhases)
}
val mainModule = if (!klibMainModule) {
MainModule.SourceFiles(filesToCompile)
} else {
MainModule.Klib(klibPath)
fun prepareModule(allowIc: Boolean): ModulesStructure {
val useIc = runIcMode && allowIc
val icCache = if (useIc) icCache else emptyMap()
return if (!klibMainModule) {
prepareAnalyzedSourceModule(
config.project,
filesToCompile,
config.configuration,
allKlibPaths,
emptyList(),
AnalyzerWithCompilerReport(config.configuration),
icUseGlobalSignatures = useIc,
icUseStdlibCache = useIc,
icCache = icCache
)
} else {
ModulesStructure(
config.project,
MainModule.Klib(klibPath),
config.configuration,
allKlibPaths,
emptyList(),
icUseGlobalSignatures = useIc,
icUseStdlibCache = useIc,
icCache = icCache
)
}
}
if (!skipRegularMode) {
val module = prepareModule(true)
val irFactory = if (lowerPerModule) PersistentIrFactory() else IrFactoryImpl
val compiledModule = compile(
project = config.project,
mainModule = mainModule,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
module,
phaseConfig = phaseConfig,
irFactory = irFactory,
dependencies = allKlibPaths,
friendDependencies = emptyList(),
mainArguments = mainCallParameters.run { if (shouldBeGenerated()) arguments() else null },
exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, testFunction))),
generateFullJs = true,
@@ -196,8 +218,6 @@ abstract class BasicIrBoxTest(
safeExternalBoolean = safeExternalBoolean,
safeExternalBooleanDiagnostic = safeExternalBooleanDiagnostic,
verifySignatures = !skipMangleVerification,
useStdlibCache = runIcMode,
icCache = icCache
)
compiledModule.outputs!!.writeTo(outputFile, config)
@@ -212,15 +232,11 @@ abstract class BasicIrBoxTest(
}
if (runIrPir && !skipDceDriven) {
val module = prepareModule(false)
compile(
project = config.project,
mainModule = mainModule,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
module,
phaseConfig = phaseConfig,
irFactory = PersistentIrFactory(),
dependencies = allKlibPaths,
friendDependencies = emptyList(),
mainArguments = mainCallParameters.run { if (shouldBeGenerated()) arguments() else null },
exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, testFunction))),
dceDriven = true,
@@ -233,13 +249,16 @@ abstract class BasicIrBoxTest(
).outputs!!.writeTo(pirOutputFile, config)
}
} else {
val module = prepareAnalyzedSourceModule(
config.project,
filesToCompile,
config.configuration,
allKlibPaths,
emptyList(),
AnalyzerWithCompilerReport(config.configuration)
)
generateKLib(
project = config.project,
files = filesToCompile,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
dependencies = allKlibPaths,
friendDependencies = emptyList(),
module,
irFactory = IrFactoryImpl,
outputKlibPath = actualOutputFile,
nopack = true,
@@ -262,7 +281,6 @@ abstract class BasicIrBoxTest(
private fun createPirCache(path: String, allKlibPaths: Collection<String>, config: JsConfig, icCache: Map<String, SerializedIcData>): SerializedIcData {
val icData = predefinedKlibHasIcCache[path] ?: prepareSingleLibraryIcCache(
project = project,
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
libPath = path,
dependencies = allKlibPaths,
js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt
+13 -7
View File
@@ -16,7 +16,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.config.*
import org.jetbrains.kotlin.ir.backend.js.MainModule
import org.jetbrains.kotlin.ir.backend.js.ModulesStructure
import org.jetbrains.kotlin.ir.backend.js.loadKlib
import org.jetbrains.kotlin.ir.backend.js.prepareAnalyzedSourceModule
import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
import org.jetbrains.kotlin.js.config.JsConfig
import org.jetbrains.kotlin.js.facade.TranslationUnit
@@ -135,16 +137,20 @@ abstract class BasicWasmBoxTest(
PhaseConfig(wasmPhases)
}
val sourceModule = prepareAnalyzedSourceModule(
config.project,
filesToCompile,
config.configuration,
// TODO: Bypass the resolver fow wasm.
listOf(System.getProperty("kotlin.wasm.stdlib.path")!!),
emptyList(),
AnalyzerWithCompilerReport(config.configuration)
)
val compilerResult = compileWasm(
project = config.project,
mainModule = MainModule.SourceFiles(filesToCompile),
analyzer = AnalyzerWithCompilerReport(config.configuration),
configuration = config.configuration,
sourceModule,
phaseConfig = phaseConfig,
irFactory = IrFactoryImpl,
// TODO: Bypass the resolver fow wasm.
dependencies = listOf(System.getProperty("kotlin.wasm.stdlib.path")!!),
friendDependencies = emptyList(),
exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, testFunction)))
)