Add expectedVersion to IncompatibleVersionErrorData, move to deserialization

compiler/backend/src/org/jetbrains/kotlin/codegen/state/IncompatibleClassTracker.kt

@@ -16,9 +16,10 @@
 
 package org.jetbrains.kotlin.codegen.state
 
-import org.jetbrains.kotlin.load.java.components.IncompatibleVersionErrorData
+import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.util.slicedMap.Slices
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 
@@ -36,13 +37,18 @@ class IncompatibleClassTrackerImpl(val trace: BindingTrace) : IncompatibleClassT
 
     override fun record(binaryClass: KotlinJvmBinaryClass) {
         if (classes.add(binaryClass.location)) {
-            val errorData = IncompatibleVersionErrorData(binaryClass.classHeader.bytecodeVersion, binaryClass.location, binaryClass.classId)
+            val errorData = IncompatibleVersionErrorData(
+                    binaryClass.classHeader.bytecodeVersion,
+                    JvmBytecodeBinaryVersion.INSTANCE,
+                    binaryClass.location,
+                    binaryClass.classId
+            )
             trace.record(BYTECODE_VERSION_ERRORS, binaryClass.location, errorData)
         }
     }
 
     companion object {
         @JvmField
-        val BYTECODE_VERSION_ERRORS: WritableSlice<String, IncompatibleVersionErrorData> = Slices.createCollectiveSlice()
+        val BYTECODE_VERSION_ERRORS: WritableSlice<String, IncompatibleVersionErrorData<JvmBytecodeBinaryVersion>> = Slices.createCollectiveSlice()
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/common/messages/AnalyzerWithCompilerReport.kt

@@ -27,8 +27,6 @@ import org.jetbrains.kotlin.codegen.state.IncompatibleClassTrackerImpl
 import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils.sortedDiagnostics
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
-import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion
-import org.jetbrains.kotlin.load.java.components.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter
 import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
 import org.jetbrains.kotlin.psi.KtFile
@@ -39,7 +37,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.JvmBindingContextSlices
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
-import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
+import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import java.util.*
 
 class AnalyzerWithCompilerReport(private val messageCollector: MessageCollector) {
@@ -84,12 +82,12 @@ class AnalyzerWithCompilerReport(private val messageCollector: MessageCollector)
         }
     }
 
-    private val abiVersionErrors: List<IncompatibleVersionErrorData>
+    private val abiVersionErrors: List<IncompatibleVersionErrorData<JvmMetadataVersion>>
         get() {
             val bindingContext = analysisResult.bindingContext
 
             val errorClasses = bindingContext.getKeys(TraceBasedErrorReporter.METADATA_VERSION_ERRORS)
-            val result = ArrayList<IncompatibleVersionErrorData>(errorClasses.size)
+            val result = ArrayList<IncompatibleVersionErrorData<JvmMetadataVersion>>(errorClasses.size)
             for (kotlinClass in errorClasses) {
                 result.add(bindingContext.get(TraceBasedErrorReporter.METADATA_VERSION_ERRORS, kotlinClass)!!)
             }
@@ -97,9 +95,9 @@ class AnalyzerWithCompilerReport(private val messageCollector: MessageCollector)
             return result
         }
 
-    private fun reportMetadataVersionErrors(errors: List<IncompatibleVersionErrorData>) {
+    private fun reportMetadataVersionErrors(errors: List<IncompatibleVersionErrorData<JvmMetadataVersion>>) {
         for (data in errors) {
-            reportIncompatibleBinaryVersion(messageCollector, data, JvmMetadataVersion.INSTANCE, "metadata", CompilerMessageSeverity.ERROR)
+            reportIncompatibleBinaryVersion(messageCollector, data, "metadata", CompilerMessageSeverity.ERROR)
         }
     }
 
@@ -245,21 +243,20 @@ class AnalyzerWithCompilerReport(private val messageCollector: MessageCollector)
             for (location in locations) {
                 val data = bindingContext.get(IncompatibleClassTrackerImpl.BYTECODE_VERSION_ERRORS, location)
                            ?: error("Value is missing for key in binding context: " + location)
-                reportIncompatibleBinaryVersion(messageCollector, data, JvmBytecodeBinaryVersion.INSTANCE, "bytecode", severity)
+                reportIncompatibleBinaryVersion(messageCollector, data, "bytecode", severity)
             }
         }
 
         private fun reportIncompatibleBinaryVersion(
                 messageCollector: MessageCollector,
-                data: IncompatibleVersionErrorData,
-                expectedVersion: BinaryVersion,
+                data: IncompatibleVersionErrorData<*>,
                 versionSortText: String,
                 severity: CompilerMessageSeverity) {
             messageCollector.report(
                     severity,
                     "Class '" + JvmClassName.byClassId(data.classId) + "' was compiled with an incompatible version of Kotlin. " +
                     "The binary version of its " + versionSortText + " is " + data.actualVersion + ", " +
-                    "expected version is " + expectedVersion,
+                    "expected version is " + data.expectedVersion,
                     CompilerMessageLocation.create(toSystemDependentName(data.filePath), -1, -1, null)
             )
         }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedErrorReporter.kt

@@ -18,11 +18,13 @@ package org.jetbrains.kotlin.load.java.components
 
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.OverrideResolver
 import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
 import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
+import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData
 import org.jetbrains.kotlin.util.slicedMap.BasicWritableSlice
 import org.jetbrains.kotlin.util.slicedMap.Slices
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
@@ -30,7 +32,7 @@ import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
     companion object {
         @JvmField
-        val METADATA_VERSION_ERRORS: WritableSlice<String, IncompatibleVersionErrorData> = Slices.createCollectiveSlice()
+        val METADATA_VERSION_ERRORS: WritableSlice<String, IncompatibleVersionErrorData<JvmMetadataVersion>> = Slices.createCollectiveSlice()
 
         @JvmField
         val INCOMPLETE_HIERARCHY: WritableSlice<ClassDescriptor, List<String>> = Slices.createCollectiveSlice()
@@ -41,7 +43,7 @@ class TraceBasedErrorReporter(private val trace: BindingTrace) : ErrorReporter {
     }
 
     override fun reportIncompatibleMetadataVersion(classId: ClassId, filePath: String, actualVersion: BinaryVersion) {
-        trace.record(METADATA_VERSION_ERRORS, filePath, IncompatibleVersionErrorData(actualVersion, filePath, classId))
+        trace.record(METADATA_VERSION_ERRORS, filePath, IncompatibleVersionErrorData(actualVersion as JvmMetadataVersion, JvmMetadataVersion.INSTANCE, filePath, classId))
     }
 
     override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: List<String>) {

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/IncompatibleVersionErrorData.kt → core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/IncompatibleVersionErrorData.kt

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.load.java.components
+package org.jetbrains.kotlin.serialization.deserialization
 
 import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
 
-data class IncompatibleVersionErrorData(
-        val actualVersion: BinaryVersion,
+data class IncompatibleVersionErrorData<out T : BinaryVersion>(
+        val actualVersion: T,
+        val expectedVersion: T,
         val filePath: String,
         val classId: ClassId
 )