Drop JvmMetadataVersion.skipCheck, support this correctly

Pass the value of this flag via DeserializationConfiguration
2017-02-08 18:31:02 +03:00
parent e1463f9e0f
commit a1a71a01b1
18 changed files with 73 additions and 70 deletions
@@ -40,7 +40,7 @@ private fun Iterable<PackageParts>.addCompiledParts(state: GenerationState): Lis
    val incrementalCache = state.incrementalCacheForThisTarget ?: return this.toList()
    val moduleMappingData = incrementalCache.getModuleMappingData() ?: return this.toList()

-    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>")
+    val mapping = ModuleMapping.create(moduleMappingData, "<incremental>", state.deserializationConfiguration)

    incrementalCache.getObsoletePackageParts().forEach { internalName ->
        val qualifier = internalName.substringBeforeLast('/', "").replace('/', '.')
@@ -41,12 +41,10 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtScript
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.BindingTraceFilter
-import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
+import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.org.objectweb.asm.Opcodes
 import java.io.File

@@ -94,6 +92,7 @@ class GenerationState @JvmOverloads constructor(
    val incrementalCacheForThisTarget: IncrementalCache?
    val packagesWithObsoleteParts: Set<FqName>
    val obsoleteMultifileClasses: List<FqName>
+    val deserializationConfiguration: DeserializationConfiguration = CompilerDeserializationConfiguration(configuration)

    init {
        val icComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.compiler.plugin.PluginCliOptionProcessingException
 import org.jetbrains.kotlin.compiler.plugin.cliPluginUsageString
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.load.java.JvmAbi
-import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate
 import org.jetbrains.kotlin.script.StandardScriptDefinition
@@ -114,10 +113,6 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
            return ExitCode.OK
        }

-        if (arguments.skipMetadataVersionCheck) {
-            JvmMetadataVersion.skipCheck = true
-        }
-
        if (arguments.includeRuntime) {
            configuration.put(JVMConfigurationKeys.INCLUDE_RUNTIME, true)
        }
@@ -317,6 +312,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
            configuration.put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, arguments.noOptimize)
            configuration.put(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, arguments.inheritMultifileParts)
            configuration.put(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK, arguments.skipRuntimeVersionCheck)
+            configuration.put(CommonConfigurationKeys.SKIP_METADATA_VERSION_CHECK, arguments.skipMetadataVersionCheck)
            configuration.put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage)
            configuration.put(CLIConfigurationKeys.REPORT_PERF, arguments.reportPerf)
            configuration.put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule)
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.PackageParts
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
 import java.io.EOFException

 class JvmPackagePartProvider(
@@ -32,6 +33,8 @@ class JvmPackagePartProvider(
 ) : PackagePartProvider {
    private data class ModuleMappingInfo(val root: VirtualFile, val mapping: ModuleMapping)

+    private val deserializationConfiguration = CompilerDeserializationConfiguration(env.configuration)
+
    private val notLoadedRoots by lazy(LazyThreadSafetyMode.NONE) {
        env.configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS)
                .filterIsInstance<JvmClasspathRoot>()
@@ -96,7 +99,7 @@ class JvmPackagePartProvider(
            val moduleFiles = metaInf.children.filter { it.name.endsWith(ModuleMapping.MAPPING_FILE_EXT) }
            for (moduleFile in moduleFiles) {
                val mapping = try {
-                    ModuleMapping.create(moduleFile.contentsToByteArray(), moduleFile.toString())
+                    ModuleMapping.create(moduleFile.contentsToByteArray(), moduleFile.toString(), deserializationConfiguration)
                }
                catch (e: EOFException) {
                    throw RuntimeException("Error on reading package parts for '$packageFqName' package in '$moduleFile', " +
@@ -19,18 +19,19 @@ package org.jetbrains.kotlin.load.kotlin.incremental
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
-import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
-import org.jetbrains.kotlin.modules.TargetId
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.storage.StorageManager

-internal class IncrementalPackagePartProvider private constructor(
+internal class IncrementalPackagePartProvider(
        private val parent: PackagePartProvider,
        incrementalCaches: List<IncrementalCache>,
        storageManager: StorageManager
 ) : PackagePartProvider {
+    lateinit var deserializationConfiguration: DeserializationConfiguration
+
    private val moduleMappings = storageManager.createLazyValue {
        incrementalCaches.map { cache ->
-            ModuleMapping.create(cache.getModuleMappingData(), "<incremental>")
+            ModuleMapping.create(cache.getModuleMappingData(), "<incremental>", deserializationConfiguration)
        }
    }

@@ -41,19 +42,4 @@ internal class IncrementalPackagePartProvider private constructor(

    // TODO
    override fun findMetadataPackageParts(packageFqName: String): List<String> = TODO()
-
-    companion object {
-        @JvmStatic
-        fun create(
-                parent: PackagePartProvider,
-                targets: List<TargetId>?,
-                incrementalCompilationComponents: IncrementalCompilationComponents?,
-                storageManager: StorageManager
-        ): PackagePartProvider {
-            if (targets == null || incrementalCompilationComponents == null) return parent
-
-            val incrementalCaches = targets.map { incrementalCompilationComponents.getIncrementalCache(it) }
-            return IncrementalPackagePartProvider(parent, incrementalCaches, storageManager)
-        }
-    }
 }
@@ -63,6 +63,7 @@ import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtens
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.storage.StorageManager
 import java.util.*

@@ -173,18 +174,22 @@ object TopDownAnalyzerFacadeForJVM {
        }
        else null

+        val partProvider = packagePartProvider(sourceScope).let { fragment ->
+            if (targetIds == null || incrementalComponents == null) fragment
+            else IncrementalPackagePartProvider(fragment, targetIds.map(incrementalComponents::getIncrementalCache), storageManager)
+        }
+
        // Note that it's necessary to create container for sources _after_ creation of container for dependencies because
        // CliLightClassGenerationSupport#initialize is invoked when container is created, so only the last module descriptor is going
        // to be stored in CliLightClassGenerationSupport, and it better be the source one (otherwise light classes would not be found)
        // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
        val container = createContainerForTopDownAnalyzerForJvm(
                moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker,
-                IncrementalPackagePartProvider.create(
-                        packagePartProvider(sourceScope), targetIds, incrementalComponents, storageManager
-                ),
-                languageVersionSettings, moduleClassResolver, configuration
+                partProvider, languageVersionSettings, moduleClassResolver, configuration
        ).apply {
            initJvmBuiltInsForTopDownAnalysis(module, languageVersionSettings)
+            (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()
+
            StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(this, null) }
        }

@@ -23,6 +23,9 @@ public class CommonConfigurationKeys {
    public static final CompilerConfigurationKey<LanguageVersionSettings> LANGUAGE_VERSION_SETTINGS =
            CompilerConfigurationKey.create("language version settings");

+    public static final CompilerConfigurationKey<Boolean> SKIP_METADATA_VERSION_CHECK =
+            CompilerConfigurationKey.create("skip metadata version check");
+
    public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
            CompilerConfigurationKey.create("disable inline");

@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.frontend.di

+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
@@ -144,7 +145,9 @@ fun createContainerForLazyResolve(
    useInstance(LookupTracker.DO_NOTHING)
    useInstance(languageVersionSettings)
    //TODO: need to propagate full CompilerConfiguration to frontend
-    useInstance(CompilerConfiguration.EMPTY)
+    useInstance(CompilerConfiguration().apply {
+        put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
+    })

    useImpl<FileScopeProviderImpl>()
    useImpl<CompilerDeserializationConfiguration>()
@@ -16,11 +16,17 @@

 package org.jetbrains.kotlin.resolve

+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.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration

-class CompilerDeserializationConfiguration(private val languageVersionSettings: LanguageVersionSettings) : DeserializationConfiguration {
-    override val typeAliasesAllowed: Boolean
-        get() = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
+class CompilerDeserializationConfiguration(configuration: CompilerConfiguration) : DeserializationConfiguration {
+    private val languageVersionSettings =
+            configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
+
+    override val typeAliasesAllowed = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
+
+    override val skipMetadataVersionCheck = configuration.getBoolean(CommonConfigurationKeys.SKIP_METADATA_VERSION_CHECK)
 }
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.cli.AbstractCliTest
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
+import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase
 import java.io.File
@@ -38,7 +39,10 @@ class JvmPackageTableTest : KtUsefulTestCase() {
        System.err.println(output) // normally output is empty
        assertEquals("Compilation should complete successfully", ExitCode.OK, exitCode)

-        val mapping = ModuleMapping.create(File(tmpdir, "META-INF/$moduleName.${ModuleMapping.MAPPING_FILE_EXT}").readBytes(), "test")
+        val mapping = ModuleMapping.create(
+                File(tmpdir, "META-INF/$moduleName.${ModuleMapping.MAPPING_FILE_EXT}").readBytes(), "test",
+                DeserializationConfiguration.Default
+        )
        val result = buildString {
            for ((fqName, packageParts) in mapping.packageFqName2Parts) {
                appendln(fqName)
@@ -417,14 +417,9 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
        doTestPreReleaseKotlinLibrary("library");
    }

-    /*
-    // This test should pass but is commented out because the compiler flag is implemented via mutation of the public field,
-    // which may cause subsequent tests to behave unexpectedly
-    // TODO: refactor and uncomment
    public void testReleaseCompilerAgainstPreReleaseLibrarySkipVersionCheck() throws Exception {
        doTestPreReleaseKotlinLibrary("library", "-Xskip-metadata-version-check");
    }
-    */

    public void testWrongMetadataVersion() throws Exception {
        doTestKotlinLibraryWithWrongMetadataVersion("library", null);
@@ -466,12 +461,9 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir {
        );
    }

-    /*
-    // TODO: refactor and uncomment
    public void testWrongMetadataVersionSkipVersionCheck() throws Exception {
        doTestKotlinLibraryWithWrongMetadataVersion("library", null, "-Xskip-metadata-version-check");
    }
-    */

    /*test source mapping generation when source info is absent*/
    public void testInlineFunWithoutDebugInfo() throws Exception {