JS IR: moved klib creation to the serialization_test module

2019-03-21 20:12:46 +03:00
parent 0f183ed662
commit ad4c2144a7
11 changed files with 87 additions and 55 deletions
@@ -212,6 +212,8 @@ extra["compilerModules"] = arrayOf(
        ":compiler:ir.backend.common",
        ":compiler:backend.jvm",
        ":compiler:backend.js",
+        ":compiler:ir.serialization.common",
+        ":compiler:ir.serialization.js",
        ":compiler:backend-common",
        ":compiler:backend",
        ":compiler:plugin-api",
@@ -45,7 +45,7 @@ fun compile(
    moduleFragment.files.clear()
    moduleFragment.files += irFiles

-    // TODO Why is this needed?
+    // Create stubs
    ExternalDependenciesGenerator(
        moduleDescriptor = moduleDescriptor,
        symbolTable = symbolTable,
@@ -4,6 +4,7 @@ plugins {
 }

 dependencies {
+    // TODO: decouple from backend.common
    compile(project(":compiler:ir.backend.common"))
    compile(project(":compiler:ir.tree"))
 }
@@ -4,21 +4,40 @@ plugins {
 }

 dependencies {
-    compile(project(":compiler:util"))
-    compile(project(":compiler:frontend"))
-    compile(project(":compiler:backend-common"))
-    compile(project(":compiler:ir.tree"))
    compile(project(":compiler:ir.psi2ir"))
-    compile(project(":compiler:ir.backend.common"))
    compile(project(":compiler:ir.serialization.common"))
-    compile(project(":js:js.ast"))
    compile(project(":js:js.frontend"))

    compileOnly(intellijCoreDep()) { includeJars("intellij-core") }
+
+    testCompile(projectTests(":compiler:tests-common"))
+    testCompileOnly(project(":compiler:frontend"))
+    testCompileOnly(project(":compiler:cli"))
+    testCompileOnly(project(":compiler:util"))
 }

 sourceSets {
    "main" { projectDefault() }
-    "test" {}
+    "test" { projectDefault() }
 }

+val generateIrRuntimeKlib by smartJavaExec {
+    val inDirs = arrayOf(fileFrom(rootDir, "core", "builtins", "src"),
+                         fileFrom(rootDir, "core", "builtins", "native"),
+                         fileFrom(rootDir, "libraries", "stdlib", "common", "src"),
+                         fileFrom(rootDir, "libraries", "stdlib", "src", "kotlin"),
+                         fileFrom(rootDir, "libraries", "stdlib", "js", "src", "generated"),
+                         fileFrom(rootDir, "libraries", "stdlib", "js", "irRuntime"),
+                         fileFrom(rootDir, "libraries", "stdlib", "unsigned"),
+                         fileFrom(rootDir, "js", "js.translator", "testData", "_commonFiles"))
+    inDirs.forEach { inputs.dir(it) }
+
+    val outDir = "$rootDir/js/js.translator/testData/out/klibs/"
+    outputs.dir(outDir)
+
+    classpath = sourceSets.test.get().runtimeClasspath
+    main = "org.jetbrains.kotlin.ir.backend.js.GenerateIrRuntimeKt"
+    workingDir = rootDir
+}
+
+testsJar {}
@@ -35,7 +35,10 @@ import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration
 import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator
+import org.jetbrains.kotlin.psi2ir.generators.GeneratorContext
+import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
@@ -53,10 +56,8 @@ data class KlibModuleRef(
 internal val JS_KLIBRARY_CAPABILITY = ModuleDescriptor.Capability<File>("JS KLIBRARY")
 internal val moduleHeaderFileName = "module.kji"
 internal val declarationsDirName = "ir/"
-private val logggg = object : LoggingContext {
-    override var inVerbosePhase: Boolean
-        get() = TODO("not implemented")
-        set(_) {}
+private val emptyLoggingContext = object : LoggingContext {
+    override var inVerbosePhase = false

    override fun log(message: () -> String) {}
 }
@@ -76,12 +77,9 @@ fun generateKLib(
 ): KlibModuleRef {
    val depsDescriptors = ModulesStructure(project, files, configuration, immediateDependencies, allDependencies)

-    val analysisResult = depsDescriptors.runAnalysis()
+    val psi2IrContext = runAnalysisAndPreparePsi2Ir(depsDescriptors)

-    val psi2IrTranslator = Psi2IrTranslator(configuration.languageVersionSettings)
-    val psi2IrContext = psi2IrTranslator.createGeneratorContext(analysisResult.moduleDescriptor, analysisResult.bindingContext)
-
-    val moduleFragment = psi2IrTranslator.generateModuleFragment(psi2IrContext, files)
+    val moduleFragment = psi2IrContext.generateModuleFragment(files)

    val moduleName = configuration[CommonConfigurationKeys.MODULE_NAME]!!
    serializeModuleIntoKlib(
@@ -114,28 +112,40 @@ fun loadIr(
 ): IrModuleInfo {
    val depsDescriptors = ModulesStructure(project, files, configuration, immediateDependencies, allDependencies)

-    val analysisResult = depsDescriptors.runAnalysis()
+    val psi2IrContext = runAnalysisAndPreparePsi2Ir(depsDescriptors)

-    val moduleDescriptor = analysisResult.moduleDescriptor
-
-    val symbolTable = SymbolTable()
-
-    val psi2IrTranslator = Psi2IrTranslator(configuration.languageVersionSettings)
-    val psi2IrContext = psi2IrTranslator.createGeneratorContext(moduleDescriptor, analysisResult.bindingContext, symbolTable)
    val irBuiltIns = psi2IrContext.irBuiltIns
+    val symbolTable = psi2IrContext.symbolTable
+    val moduleDescriptor = psi2IrContext.moduleDescriptor

-    val deserializer = JsIrLinker(moduleDescriptor, logggg, irBuiltIns, symbolTable)
+    val deserializer = JsIrLinker(moduleDescriptor, emptyLoggingContext, irBuiltIns, symbolTable)

    val deserializedModuleFragments = depsDescriptors.sortedImmediateDependencies.map {
-        val moduleFile = File(it.klibPath, moduleHeaderFileName)
        deserializer.deserializeIrModuleHeader(depsDescriptors.getModuleDescriptor(it))!!
    }

-    val moduleFragment = psi2IrTranslator.generateModuleFragment(psi2IrContext, files, deserializer)
+    val moduleFragment = psi2IrContext.generateModuleFragment(files, deserializer)

    return IrModuleInfo(moduleFragment, deserializedModuleFragments, irBuiltIns, symbolTable, deserializer)
 }

+private fun runAnalysisAndPreparePsi2Ir(depsDescriptors: ModulesStructure): GeneratorContext {
+    val analysisResult = depsDescriptors.runAnalysis()
+
+    return GeneratorContext(
+        Psi2IrConfiguration(),
+        analysisResult.moduleDescriptor,
+        analysisResult.bindingContext,
+        depsDescriptors.compilerConfiguration.languageVersionSettings,
+        SymbolTable(),
+        GeneratorExtensions()
+    )
+}
+
+private fun GeneratorContext.generateModuleFragment(files: List<KtFile>, deserializer: JsIrLinker? = null) =
+    Psi2IrTranslator(languageVersionSettings, configuration).generateModuleFragment(this, files, deserializer)
+
+
 private fun loadKlibMetadataParts(
    moduleId: KlibModuleRef
 ): JsKlibMetadataParts {
@@ -157,8 +167,12 @@ private fun loadKlibMetadata(
 ): ModuleDescriptorImpl {
    assert(isBuiltIn == (builtinsModule === null))
    val builtIns = builtinsModule?.builtIns ?: object : KotlinBuiltIns(storageManager) {}
-    val md = ModuleDescriptorImpl(Name.special("<${moduleId.moduleName}>"), storageManager, builtIns,
-                                  capabilities = mapOf(JS_KLIBRARY_CAPABILITY to File(moduleId.klibPath)))
+    val md = ModuleDescriptorImpl(
+        Name.special("<${moduleId.moduleName}>"),
+        storageManager,
+        builtIns,
+        capabilities = mapOf(JS_KLIBRARY_CAPABILITY to File(moduleId.klibPath))
+    )
    if (isBuiltIn) builtIns.builtInsModule = md
    val currentModuleFragmentProvider = createJsKlibMetadataPackageFragmentProvider(
        storageManager, md, parts.header, parts.body, metadataVersion,
@@ -178,10 +192,10 @@ private fun loadKlibMetadata(
 }


-class ModulesStructure(
+private class ModulesStructure(
    private val project: Project,
    private val files: List<KtFile>,
-    private val compilerConfiguration: CompilerConfiguration,
+    val compilerConfiguration: CompilerConfiguration,
    immediateDependencies: List<KlibModuleRef>,
    private val allDependencies: List<KlibModuleRef>
 ) {
@@ -265,7 +279,7 @@ fun serializeModuleIntoKlib(
 ) {
    val declarationTable = JsDeclarationTable(moduleFragment.irBuiltins, DescriptorTable())

-    val serializedIr = JsIrModuleSerializer(logggg, declarationTable).serializedIrModule(moduleFragment)
+    val serializedIr = JsIrModuleSerializer(emptyLoggingContext, declarationTable).serializedIrModule(moduleFragment)
    val serializer = JsKlibMetadataSerializationUtil

    val moduleDescription =
@@ -3,21 +3,20 @@
 * that can be found in the license/LICENSE.txt file.
 */

-package org.jetbrains.kotlin.generators.tests
+package org.jetbrains.kotlin.ir.backend.js

-import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiManager
-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.generateKLib
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.test.JsIrTestRuntime
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.serialization.js.ModuleKind

+import com.intellij.openapi.Disposable
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+
 fun buildConfiguration(environment: KotlinCoreEnvironment): CompilerConfiguration {
    val runtimeConfiguration = environment.configuration.copy()
    runtimeConfiguration.put(CommonConfigurationKeys.MODULE_NAME, "JS_IR_RUNTIME")
@@ -3,7 +3,7 @@
 * that can be found in the license/LICENSE.txt file.
 */

-package org.jetbrains.kotlin.js.test
+package org.jetbrains.kotlin.ir.backend.js

 import org.jetbrains.kotlin.test.KotlinTestUtils
 import java.io.File
@@ -62,7 +62,7 @@ private val fullRuntimeSources = listOfKtFilesFrom(

    "core/builtins/src/kotlin/Unit.kt",
    unimplementedNativeBuiltInsDir.path,
-    BasicBoxTest.COMMON_FILES_DIR_PATH
+    "js/js.translator/testData/_commonFiles"
 ) - listOfKtFilesFrom(
    "libraries/stdlib/common/src/kotlin/JvmAnnotationsH.kt",
    "libraries/stdlib/src/kotlin/annotations/Multiplatform.kt",
@@ -117,7 +117,7 @@ private val fullRuntimeSources = listOfKtFilesFrom(
    "libraries/stdlib/js/src/kotlin/builtins.kt"
 )

-val reducedRuntimeSources = fullRuntimeSources - listOfKtFilesFrom(
+private val reducedRuntimeSources = fullRuntimeSources - listOfKtFilesFrom(
    "libraries/stdlib/unsigned",
    "libraries/stdlib/common/src/generated/_Arrays.kt",
    "libraries/stdlib/common/src/generated/_Collections.kt",
@@ -167,7 +167,7 @@ val reducedRuntimeSources = fullRuntimeSources - listOfKtFilesFrom(
 )

 private fun listOfKtFilesFrom(vararg paths: String): List<String> {
-    val currentDir = File(".")
+    val currentDir = File("")
    return paths.flatMap { path ->
        File(path)
            .walkTopDown()
@@ -19,8 +19,6 @@ node {
 val antLauncherJar by configurations.creating
 val testJsRuntime by configurations.creating

-val generateIrRuntimeKlib by generator("org.jetbrains.kotlin.generators.tests.GenerateIrRuntimeKt")
-
 dependencies {
    testRuntime(intellijDep())

@@ -32,6 +30,7 @@ dependencies {
    testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") }
    testCompileOnly(intellijDep()) { includeJars("openapi", "idea", "idea_rt", "util") }
    testCompile(project(":compiler:backend.js"))
+    testCompile(projectTests(":compiler:ir.serialization.js"))
    testCompile(project(":js:js.translator"))
    testCompile(project(":js:js.serializer"))
    testCompile(project(":js:js.dce"))
@@ -72,7 +71,7 @@ sourceSets {
 fun Test.setUpBoxTests(jsEnabled: Boolean, jsIrEnabled: Boolean, skipIrKlib: Boolean = false) {
    dependsOn(":dist")
    if (jsEnabled) dependsOn(testJsRuntime)
-    if (jsIrEnabled && !skipIrKlib) dependsOn(generateIrRuntimeKlib)
+    if (jsIrEnabled && !skipIrKlib) dependsOn(":compiler:ir.serialization.js:generateIrRuntimeKlib")

    if (jsEnabled && !jsIrEnabled) exclude("org/jetbrains/kotlin/js/test/ir/semantics/*")
    if (!jsEnabled && jsIrEnabled) include("org/jetbrains/kotlin/js/test/ir/semantics/*")
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.incremental.js.IncrementalDataProviderImpl
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
+import org.jetbrains.kotlin.ir.backend.js.JsIrTestRuntime
 import org.jetbrains.kotlin.js.JavaScript
 import org.jetbrains.kotlin.js.backend.JsToStringGenerationVisitor
 import org.jetbrains.kotlin.js.backend.ast.*
@@ -206,7 +207,7 @@ abstract class BasicBoxTest(
            }

            if (!dontRunGeneratedCode) {
-                runGeneratedCode(allJsFiles, mainModuleName, testPackage, testFunction, expectedResult, withModuleSystem, runtimeType)
+                runGeneratedCode(allJsFiles, mainModuleName, testPackage, testFunction, expectedResult, withModuleSystem)
            }

            performAdditionalChecks(generatedJsFiles.map { it.first }, outputPrefixFile, outputPostfixFile)
@@ -264,8 +265,7 @@ abstract class BasicBoxTest(
        testPackage: String?,
        testFunction: String,
        expectedResult: String,
-        withModuleSystem: Boolean,
-        runtime: JsIrTestRuntime
+        withModuleSystem: Boolean
    ) {
        testChecker.check(jsFiles, testModuleName, testPackage, testFunction, expectedResult, withModuleSystem)
    }
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.js.test

 import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.config.JsConfig
@@ -54,8 +53,9 @@ abstract class BasicIrBoxTest(

    override val testChecker get() = if (runTestInNashorn) NashornIrJsTestChecker() else V8IrJsTestChecker

-    private val runtimes = mapOf(JsIrTestRuntime.DEFAULT to defaultRuntimeKlib,
-                                 JsIrTestRuntime.FULL to fullRuntimeKlib)
+    private val runtimes = mapOf(
+        JsIrTestRuntime.DEFAULT to defaultRuntimeKlib,
+        JsIrTestRuntime.FULL to fullRuntimeKlib)

    override fun translateFiles(
        units: List<TranslationUnit>,
@@ -142,8 +142,7 @@ abstract class BasicIrBoxTest(
        testPackage: String?,
        testFunction: String,
        expectedResult: String,
-        withModuleSystem: Boolean,
-        runtime: JsIrTestRuntime
+        withModuleSystem: Boolean
    ) {
        // TODO: should we do anything special for module systems?
        // TODO: return list of js from translateFiles and provide then to this function with other js files
@@ -24,8 +24,7 @@ abstract class AbstractWebDemoExamplesTest(relativePath: String) : BasicBoxTest(
        testPackage: String?,
        testFunction: String,
        expectedResult: String,
-        withModuleSystem: Boolean,
-        runtime: JsIrTestRuntime
+        withModuleSystem: Boolean
    ) {
        testChecker.checkStdout(jsFiles, expectedResult)
    }