Report pre-release errors if release LV is used

#KT-21267 Fixed

compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt

@@ -17,7 +17,7 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.shouldWritePreReleaseFlag
+import org.jetbrains.kotlin.config.isPreRelease
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
@@ -36,7 +36,7 @@ fun writeKotlinMetadata(
     av.visit(JvmAnnotationNames.BYTECODE_VERSION_FIELD_NAME, JvmBytecodeBinaryVersion.INSTANCE.toArray())
     av.visit(JvmAnnotationNames.KIND_FIELD_NAME, kind.id)
     var flags = extraFlags
-    if (state.languageVersionSettings.shouldWritePreReleaseFlag()) {
+    if (state.languageVersionSettings.isPreRelease()) {
         flags = flags or JvmAnnotationNames.METADATA_PRE_RELEASE_FLAG
     }
     if (flags != 0) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt

@@ -19,12 +19,13 @@ package org.jetbrains.kotlin.resolve
 import org.jetbrains.kotlin.config.AnalysisFlag
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isPreRelease
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 
 class CompilerDeserializationConfiguration(languageVersionSettings: LanguageVersionSettings) : DeserializationConfiguration {
     override val skipMetadataVersionCheck = languageVersionSettings.getFlag(AnalysisFlag.skipMetadataVersionCheck)
 
-    override val skipPreReleaseCheck = skipMetadataVersionCheck || !languageVersionSettings.languageVersion.isStable
+    override val reportErrorsOnPreReleaseDependencies = !skipMetadataVersionCheck && !languageVersionSettings.isPreRelease()
 
     override val typeAliasesAllowed = languageVersionSettings.supportsFeature(LanguageFeature.TypeAliases)
 

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryLatestStable/library/a.kt

@@ -0,0 +1,5 @@
+package a
+
+class A
+
+fun A.foo() = ""

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryLatestStable/output.txt

@@ -0,0 +1 @@
+OK

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryLatestStable/source.kt

@@ -0,0 +1,7 @@
+package usage
+
+import a.*
+
+fun baz(param: A) {
+    param.foo()
+}

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion/library/a.kt

@@ -0,0 +1,5 @@
+package a
+
+class A
+
+fun foo() = ""

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion/output.txt

@@ -0,0 +1,8 @@
+error: incompatible classes were found in dependencies. Remove them from the classpath or use '-Xskip-metadata-version-check' to suppress errors
+compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion/source.kt:5:16: error: class 'a.A' is compiled by a pre-release version of Kotlin and cannot be loaded by this version of the compiler
+fun baz(param: A) {
+               ^
+compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion/source.kt:6:5: error: class 'a.AKt' is compiled by a pre-release version of Kotlin and cannot be loaded by this version of the compiler
+    foo()
+    ^
+COMPILATION_ERROR

compiler/testData/compileKotlinAgainstCustomBinaries/preReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion/source.kt

@@ -0,0 +1,7 @@
+package usage
+
+import a.*
+
+fun baz(param: A) {
+    foo()
+}

compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.codegen.inline.remove
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.common.intConstant
 import org.jetbrains.kotlin.config.KotlinCompilerVersion.TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY
+import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
@@ -131,27 +132,28 @@ class CompileKotlinAgainstCustomBinariesTest : AbstractKotlinCompilerIntegration
     ) {
         // Compiles the library with the "pre-release" flag, then compiles a usage of this library in the release mode
 
-        val result = try {
-            System.setProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY, "true")
+        val result = withPreRelease(true) {
             when (compiler) {
                 is K2JSCompiler -> compileJsLibrary(libraryName)
                 is K2JVMCompiler -> compileLibrary(libraryName)
                 else -> throw UnsupportedOperationException(compiler.toString())
             }
         }
-        finally {
-            System.clearProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY)
-        }
 
-        try {
-            System.setProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY, "false")
+        withPreRelease(false) {
             compileKotlin("source.kt", usageDestination, listOf(result), compiler, additionalOptions.toList())
         }
-        finally {
-            System.clearProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY)
-        }
     }
 
+    private fun <T> withPreRelease(value: Boolean, block: () -> T): T =
+            try {
+                System.setProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY, value.toString())
+                block()
+            }
+            finally {
+                System.clearProperty(TEST_IS_PRE_RELEASE_SYSTEM_PROPERTY)
+            }
+
     // ------------------------------------------------------------------------------
 
     fun testRawTypes() {
@@ -258,6 +260,23 @@ class CompileKotlinAgainstCustomBinariesTest : AbstractKotlinCompilerIntegration
         doTestPreReleaseKotlinLibrary(K2JSCompiler(), "library", File(tmpdir, "usage.js"), "-Xskip-metadata-version-check")
     }
 
+    fun testPreReleaseCompilerAgainstPreReleaseLibraryStableLanguageVersion() {
+        withPreRelease(true) {
+            val library = compileLibrary("library")
+            val someStableReleasedVersion = LanguageVersion.values().first().also { assert(it.isStable) }
+            compileKotlin("source.kt", tmpdir, listOf(library), K2JVMCompiler(),
+                          listOf("-language-version", someStableReleasedVersion.versionString))
+        }
+    }
+
+    fun testPreReleaseCompilerAgainstPreReleaseLibraryLatestStable() {
+        withPreRelease(true) {
+            val library = compileLibrary("library")
+            compileKotlin("source.kt", tmpdir, listOf(library), K2JVMCompiler(),
+                          listOf("-language-version", LanguageVersion.LATEST_STABLE.versionString))
+        }
+    }
+
     fun testWrongMetadataVersion() {
         doTestKotlinLibraryWithWrongMetadataVersion("library", null)
     }

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -189,10 +189,10 @@ class LanguageVersionSettingsImpl @JvmOverloads constructor(
     }
 }
 
-fun LanguageVersionSettings.shouldWritePreReleaseFlag(): Boolean =
-        languageVersion.shouldWritePreReleaseFlag()
+fun LanguageVersionSettings.isPreRelease(): Boolean =
+        languageVersion.isPreRelease()
 
-fun LanguageVersion.shouldWritePreReleaseFlag(): Boolean {
+fun LanguageVersion.isPreRelease(): Boolean {
     if (!isStable) return true
 
     return KotlinCompilerVersion.isPreRelease() && this == LanguageVersion.LATEST_STABLE