Add internal compiler argument to change metadata version

Will be used in tests to check how we behave on binaries produced by a
"future" compiler

build-common/src/org/jetbrains/kotlin/build/BuildMetaInfo.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.config.isPreRelease
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import kotlin.reflect.KClass
 
 interface BuildMetaInfo {
@@ -40,7 +41,8 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
         multiplatformEnable: Boolean,
         ownVersion: Int,
         coroutinesVersion: Int,
-        multiplatformVersion: Int
+        multiplatformVersion: Int,
+        metadataVersionArray: IntArray?
     ): T
 
     fun create(args: CommonCompilerArguments): T {
@@ -57,7 +59,8 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
             multiplatformEnable = args.multiPlatform,
             ownVersion = OWN_VERSION,
             coroutinesVersion = COROUTINES_VERSION,
-            multiplatformVersion = MULTIPLATFORM_VERSION
+            multiplatformVersion = MULTIPLATFORM_VERSION,
+            metadataVersionArray = args.metadataVersion?.let((BinaryVersion)::parseVersionArray)
         )
     }
 
@@ -72,4 +75,4 @@ abstract class BuildMetaInfoFactory<T : BuildMetaInfo>(private val metaInfoClass
         const val COROUTINES_VERSION: Int = 0
         const val MULTIPLATFORM_VERSION: Int = 0
     }
-}
+}

build-common/src/org/jetbrains/kotlin/build/CommonBuildMetaInfo.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.build
 
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
-import org.jetbrains.kotlin.utils.JsMetadataVersion
 
 /**
  * If you want to add a new field, check its type is supported by [serializeToPlainText], [deserializeFromPlainText]
@@ -39,22 +38,26 @@ data class CommonBuildMetaInfo(
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
-            multiplatformVersion: Int
+            multiplatformVersion: Int,
-        ) = CommonBuildMetaInfo(
+            metadataVersionArray: IntArray?
-            isEAP = isEAP,
+        ): CommonBuildMetaInfo {
-            compilerBuildVersion = compilerBuildVersion,
+            val metadataVersion = metadataVersionArray?.let(::JvmMetadataVersion) ?: JvmMetadataVersion.INSTANCE
-            languageVersionString = languageVersionString,
+            return CommonBuildMetaInfo(
-            apiVersionString = apiVersionString,
+                isEAP = isEAP,
-            coroutinesEnable = coroutinesEnable,
+                compilerBuildVersion = compilerBuildVersion,
-            coroutinesWarn = coroutinesWarn,
+                languageVersionString = languageVersionString,
-            coroutinesError = coroutinesError,
+                apiVersionString = apiVersionString,
-            multiplatformEnable = multiplatformEnable,
+                coroutinesEnable = coroutinesEnable,
-            metadataVersionMajor = JvmMetadataVersion.INSTANCE.major,
+                coroutinesWarn = coroutinesWarn,
-            metadataVersionMinor = JvmMetadataVersion.INSTANCE.minor,
+                coroutinesError = coroutinesError,
-            metadataVersionPatch = JvmMetadataVersion.INSTANCE.patch,
+                multiplatformEnable = multiplatformEnable,
-            ownVersion = ownVersion,
+                metadataVersionMajor = metadataVersion.major,
-            coroutinesVersion = coroutinesVersion,
+                metadataVersionMinor = metadataVersion.minor,
-            multiplatformVersion = multiplatformVersion
+                metadataVersionPatch = metadataVersion.patch,
-        )
+                ownVersion = ownVersion,
+                coroutinesVersion = coroutinesVersion,
+                multiplatformVersion = multiplatformVersion
+            )
+        }
     }
-}
+}

build-common/src/org/jetbrains/kotlin/build/JsBuildMetaInfo.kt

@@ -38,22 +38,26 @@ data class JsBuildMetaInfo(
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
-            multiplatformVersion: Int
+            multiplatformVersion: Int,
-        ) = JsBuildMetaInfo(
+            metadataVersionArray: IntArray?
-            isEAP = isEAP,
+        ): JsBuildMetaInfo {
-            compilerBuildVersion = compilerBuildVersion,
+            val metadataVersion = metadataVersionArray?.let(::JsMetadataVersion) ?: JsMetadataVersion.INSTANCE
-            languageVersionString = languageVersionString,
+            return JsBuildMetaInfo(
-            apiVersionString = apiVersionString,
+                isEAP = isEAP,
-            coroutinesEnable = coroutinesEnable,
+                compilerBuildVersion = compilerBuildVersion,
-            coroutinesWarn = coroutinesWarn,
+                languageVersionString = languageVersionString,
-            coroutinesError = coroutinesError,
+                apiVersionString = apiVersionString,
-            multiplatformEnable = multiplatformEnable,
+                coroutinesEnable = coroutinesEnable,
-            metadataVersionMajor = JsMetadataVersion.INSTANCE.major,
+                coroutinesWarn = coroutinesWarn,
-            metadataVersionMinor = JsMetadataVersion.INSTANCE.minor,
+                coroutinesError = coroutinesError,
-            metadataVersionPatch = JsMetadataVersion.INSTANCE.patch,
+                multiplatformEnable = multiplatformEnable,
-            ownVersion = ownVersion,
+                metadataVersionMajor = metadataVersion.major,
-            coroutinesVersion = coroutinesVersion,
+                metadataVersionMinor = metadataVersion.minor,
-            multiplatformVersion = multiplatformVersion
+                metadataVersionPatch = metadataVersion.patch,
-        )
+                ownVersion = ownVersion,
+                coroutinesVersion = coroutinesVersion,
+                multiplatformVersion = multiplatformVersion
+            )
+        }
     }
-}
+}

build-common/src/org/jetbrains/kotlin/build/JvmBuildMetaInfo.kt

@@ -53,25 +53,29 @@ data class JvmBuildMetaInfo(
             multiplatformEnable: Boolean,
             ownVersion: Int,
             coroutinesVersion: Int,
-            multiplatformVersion: Int
+            multiplatformVersion: Int,
-        ) = JvmBuildMetaInfo(
+            metadataVersionArray: IntArray?
-            isEAP = isEAP,
+        ): JvmBuildMetaInfo {
-            compilerBuildVersion = compilerBuildVersion,
+            val metadataVersion = metadataVersionArray?.let(::JvmMetadataVersion) ?: JvmMetadataVersion.INSTANCE
-            languageVersionString = languageVersionString,
+            return JvmBuildMetaInfo(
-            apiVersionString = apiVersionString,
+                isEAP = isEAP,
-            coroutinesEnable = coroutinesEnable,
+                compilerBuildVersion = compilerBuildVersion,
-            coroutinesWarn = coroutinesWarn,
+                languageVersionString = languageVersionString,
-            coroutinesError = coroutinesError,
+                apiVersionString = apiVersionString,
-            multiplatformEnable = multiplatformEnable,
+                coroutinesEnable = coroutinesEnable,
-            metadataVersionMajor = JvmMetadataVersion.INSTANCE.major,
+                coroutinesWarn = coroutinesWarn,
-            metadataVersionMinor = JvmMetadataVersion.INSTANCE.minor,
+                coroutinesError = coroutinesError,
-            metadataVersionPatch = JvmMetadataVersion.INSTANCE.patch,
+                multiplatformEnable = multiplatformEnable,
-            bytecodeVersionMajor = JvmBytecodeBinaryVersion.INSTANCE.major,
+                metadataVersionMajor = metadataVersion.major,
-            bytecodeVersionMinor = JvmBytecodeBinaryVersion.INSTANCE.minor,
+                metadataVersionMinor = metadataVersion.minor,
-            bytecodeVersionPatch = JvmBytecodeBinaryVersion.INSTANCE.patch,
+                metadataVersionPatch = metadataVersion.patch,
-            ownVersion = ownVersion,
+                bytecodeVersionMajor = JvmBytecodeBinaryVersion.INSTANCE.major,
-            coroutinesVersion = coroutinesVersion,
+                bytecodeVersionMinor = JvmBytecodeBinaryVersion.INSTANCE.minor,
-            multiplatformVersion = multiplatformVersion
+                bytecodeVersionPatch = JvmBytecodeBinaryVersion.INSTANCE.patch,
-        )
+                ownVersion = ownVersion,
+                coroutinesVersion = coroutinesVersion,
+                multiplatformVersion = multiplatformVersion
+            )
+        }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java

@@ -33,10 +33,8 @@ import org.jetbrains.kotlin.descriptors.DescriptorUtilKt;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation;
 import org.jetbrains.kotlin.load.kotlin.ModuleMappingUtilKt;
-import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
 import org.jetbrains.kotlin.metadata.jvm.JvmModuleProtoBuf;
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMappingKt;
 import org.jetbrains.kotlin.metadata.jvm.deserialization.PackageParts;
@@ -125,7 +123,7 @@ public class ClassFileFactory implements OutputFileCollection {
         generators.put(outputFilePath, new OutAndSourceFileList(CollectionsKt.toList(sourceFiles)) {
             @Override
             public byte[] asBytes(ClassBuilderFactory factory) {
-                return ModuleMappingKt.serializeToByteArray(moduleProto, JvmMetadataVersion.INSTANCE.toArray());
+                return ModuleMappingKt.serializeToByteArray(moduleProto, state.getMetadataVersion().toArray());
             }
 
             @Override

compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt

@@ -16,11 +16,9 @@ import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.lazy.types.RawTypeImpl
 import org.jetbrains.kotlin.load.kotlin.NON_EXISTENT_CLASS_NAME
 import org.jetbrains.kotlin.metadata.ProtoBuf
-import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.metadata.jvm.deserialization.ClassMapperLite
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmFlags
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.metadata.serialization.MutableVersionRequirementTable
 import org.jetbrains.kotlin.name.FqName
@@ -46,9 +44,7 @@ class JvmSerializerExtension(private val bindings: JvmSerializationBindings, sta
     private val moduleName = state.moduleName
     private val classBuilderMode = state.classBuilderMode
     private val isReleaseCoroutines = state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines)
-
+    override val metadataVersion = state.metadataVersion
-    override val metadataVersion: BinaryVersion
-        get() = JvmMetadataVersion.INSTANCE
 
     override fun shouldUseTypeTable(): Boolean = useTypeTable
 

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

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 import org.jetbrains.kotlin.modules.TargetId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -237,6 +238,8 @@ class GenerationState private constructor(
 
     val disableOptimization = configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false)
 
+    val metadataVersion = configuration.get(CommonConfigurationKeys.METADATA_VERSION) ?: JvmMetadataVersion.INSTANCE
+
     init {
         this.interceptedBuilderFactory = builderFactory
             .wrapWith(

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

@@ -17,22 +17,20 @@
 package org.jetbrains.kotlin.codegen
 
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.isPreRelease
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmBytecodeBinaryVersion
-import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor
 
 fun writeKotlinMetadata(
-        cb: ClassBuilder,
+    cb: ClassBuilder,
-        state: GenerationState,
+    state: GenerationState,
-        kind: KotlinClassHeader.Kind,
+    kind: KotlinClassHeader.Kind,
-        extraFlags: Int,
+    extraFlags: Int,
-        action: (AnnotationVisitor) -> Unit
+    action: (AnnotationVisitor) -> Unit
 ) {
     val av = cb.newAnnotation(JvmAnnotationNames.METADATA_DESC, true)
-    av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, JvmMetadataVersion.INSTANCE.toArray())
+    av.visit(JvmAnnotationNames.METADATA_VERSION_FIELD_NAME, state.metadataVersion.toArray())
     av.visit(JvmAnnotationNames.BYTECODE_VERSION_FIELD_NAME, JvmBytecodeBinaryVersion.INSTANCE.toArray())
     av.visit(JvmAnnotationNames.KIND_FIELD_NAME, kind.id)
     var flags = extraFlags

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.EmptyPackageFragmentDescriptor
+import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -41,7 +42,7 @@ import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerial
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import java.io.File
 
-class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(dependOnOldBuiltIns) {
+class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(BuiltInsBinaryVersion.INSTANCE, dependOnOldBuiltIns) {
     fun serialize(
             destDir: File,
             srcDirs: List<File>,

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt

@@ -174,6 +174,12 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
     )
     var progressiveMode by FreezableVar(false)
 
+    @Argument(
+        value = "-Xmetadata-version",
+        description = "Change metadata version of the generated binary files"
+    )
+    var metadataVersion: String? by FreezableVar(null)
+
     open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
         return HashMap<AnalysisFlag<*>, Any>().apply {
             put(AnalysisFlag.skipMetadataVersionCheck, skipMetadataVersionCheck)

compiler/cli/src/org/jetbrains/kotlin/cli/common/CLICompiler.java

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CommonConfigurationKeysKt;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion;
 import org.jetbrains.kotlin.progress.CompilationCanceledException;
 import org.jetbrains.kotlin.progress.CompilationCanceledStatus;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
@@ -42,6 +43,7 @@ import org.jetbrains.kotlin.utils.PathUtil;
 import java.io.File;
 import java.io.PrintStream;
 
+import static org.jetbrains.kotlin.cli.common.CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY;
 import static org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR;
 import static org.jetbrains.kotlin.cli.common.ExitCode.INTERNAL_ERROR;
 import static org.jetbrains.kotlin.cli.common.environment.UtilKt.setIdeaIoUseFallback;
@@ -75,7 +77,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         GroupingMessageCollector groupingCollector = new GroupingMessageCollector(messageCollector, arguments.getAllWarningsAsErrors());
 
         CompilerConfiguration configuration = new CompilerConfiguration();
-        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, groupingCollector);
+        configuration.put(MESSAGE_COLLECTOR_KEY, groupingCollector);
         configuration.put(CLIConfigurationKeys.PERF_MANAGER, performanceManager);
         try {
             setupCommonArgumentsAndServices(configuration, arguments, services);
@@ -96,7 +98,7 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
                 performanceManager.notifyCompilationFinished();
                 if (arguments.getReportPerf()) {
                     performanceManager.getMeasurementResults().forEach(
-                            it -> configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY).report(INFO, "PERF: " + it.render(), null)
+                            it -> configuration.get(MESSAGE_COLLECTOR_KEY).report(INFO, "PERF: " + it.render(), null)
                     );
                 }
 
@@ -148,6 +150,18 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         if (arguments.getReportOutputFiles()) {
             configuration.put(CommonConfigurationKeys.REPORT_OUTPUT_FILES, true);
         }
+
+        String metadataVersionString = arguments.getMetadataVersion();
+        if (metadataVersionString != null) {
+            int[] versionArray = BinaryVersion.parseVersionArray(metadataVersionString);
+            if (versionArray == null) {
+                configuration.getNotNull(MESSAGE_COLLECTOR_KEY).report(ERROR, "Invalid metadata version: " + metadataVersionString, null);
+            }
+            else {
+                configuration.put(CommonConfigurationKeys.METADATA_VERSION, createMetadataVersion(versionArray));
+            }
+        }
+
         @SuppressWarnings("deprecation")
         CompilerJarLocator locator = services.get(CompilerJarLocator.class);
         if (locator != null) {
@@ -157,11 +171,14 @@ public abstract class CLICompiler<A extends CommonCompilerArguments> extends CLI
         setupLanguageVersionSettings(configuration, arguments);
     }
 
+    @NotNull
+    protected abstract BinaryVersion createMetadataVersion(@NotNull int[] versionArray);
+
     private void setupLanguageVersionSettings(@NotNull CompilerConfiguration configuration, @NotNull A arguments) {
-
+        CommonConfigurationKeysKt.setLanguageVersionSettings(
-        MessageCollector collector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY);
+                configuration,
-
+                arguments.configureLanguageVersionSettings(configuration.getNotNull(MESSAGE_COLLECTOR_KEY))
-        CommonConfigurationKeysKt.setLanguageVersionSettings(configuration, arguments.configureLanguageVersionSettings(collector));
+        );
     }
 
     @Nullable

compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -63,6 +63,7 @@ import org.jetbrains.kotlin.js.facade.TranslationResult;
 import org.jetbrains.kotlin.js.facade.TranslationUnit;
 import org.jetbrains.kotlin.js.facade.exceptions.TranslationException;
 import org.jetbrains.kotlin.js.sourceMap.SourceFilePathResolver;
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.serialization.js.ModuleKind;
@@ -537,11 +538,15 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
         return "kotlinc-js";
     }
 
+    @NotNull
+    @Override
+    protected BinaryVersion createMetadataVersion(@NotNull int[] versionArray) {
+        return new JsMetadataVersion(versionArray);
+    }
+
     private static final class K2JSCompilerPerformanceManager extends CommonCompilerPerformanceManager {
         public K2JSCompilerPerformanceManager() {
             super("Kotlin to JS Compiler");
         }
     }
-
-
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -21,8 +21,11 @@ import com.intellij.openapi.Disposable
 import org.jetbrains.kotlin.cli.common.*
 import org.jetbrains.kotlin.cli.common.ExitCode.*
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.*
+import org.jetbrains.kotlin.cli.common.messages.FilteringMessageCollector
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.messages.MessageUtil
+import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.CompileEnvironmentUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -41,6 +44,8 @@ import org.jetbrains.kotlin.javac.JavacWrapper
 import org.jetbrains.kotlin.load.java.JavaClassesTracker
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
+import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion
 import org.jetbrains.kotlin.script.ScriptDefinitionProvider
 import org.jetbrains.kotlin.script.StandardScriptDefinition
 import org.jetbrains.kotlin.utils.KotlinPaths
@@ -333,6 +338,8 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
 
     override fun executableScriptFileName(): String = "kotlinc-jvm"
 
+    override fun createMetadataVersion(versionArray: IntArray): BinaryVersion = JvmMetadataVersion(*versionArray)
+
     private class K2JVMCompilerPerformanceManager : CommonCompilerPerformanceManager("Kotlin to JVM Compiler")
 
     companion object {

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/K2MetadataCompiler.kt

@@ -35,6 +35,8 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.load.java.JvmAbi
+import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.utils.KotlinPaths
 import java.io.File
 
@@ -89,7 +91,9 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
         }
 
         try {
-            MetadataSerializer(true).serialize(environment)
+            val metadataVersion =
+                configuration.get(CommonConfigurationKeys.METADATA_VERSION) as? BuiltInsBinaryVersion ?: BuiltInsBinaryVersion.INSTANCE
+            MetadataSerializer(metadataVersion, true).serialize(environment)
         }
         catch (e: CompilationException) {
             collector.report(EXCEPTION, OutputMessageUtil.renderException(e), MessageUtil.psiElementToMessageLocation(e.element))
@@ -102,6 +106,8 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
     // TODO: update this once a launcher script for K2MetadataCompiler is available
     override fun executableScriptFileName(): String = "kotlinc"
 
+    override fun createMetadataVersion(versionArray: IntArray): BinaryVersion = BuiltInsBinaryVersion(*versionArray)
+
     override fun getPerformanceManager(): CommonCompilerPerformanceManager = performanceManager
 
     companion object {
@@ -112,4 +118,4 @@ class K2MetadataCompiler : CLICompiler<K2MetadataCompilerArguments>() {
     }
 
     private class K2MetadataCompilerPerformanceManager : CommonCompilerPerformanceManager("Kotlin to Metadata compiler")
-}
+}

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializer.kt

@@ -48,7 +48,10 @@ import java.io.ByteArrayOutputStream
 import java.io.DataOutputStream
 import java.io.File
 
-open class MetadataSerializer(private val dependOnOldBuiltIns: Boolean) {
+open class MetadataSerializer(
+    private val metadataVersion: BuiltInsBinaryVersion,
+    private val dependOnOldBuiltIns: Boolean
+) {
     protected var totalSize = 0
     protected var totalFiles = 0
 
@@ -127,12 +130,13 @@ open class MetadataSerializer(private val dependOnOldBuiltIns: Boolean) {
                 table.addTo(this)
             }
         }.build().serializeToByteArray(JvmMetadataVersion.INSTANCE.toArray()) // TODO: use another version here, not JVM
+        // TODO: also, use CommonConfigurationKeys.METADATA_VERSION if needed
 
         kotlinModuleFile.parentFile.mkdirs()
         kotlinModuleFile.writeBytes(packageTableBytes)
     }
 
-    protected open fun createSerializerExtension(): KotlinSerializerExtensionBase = MetadataSerializerExtension()
+    protected open fun createSerializerExtension(): KotlinSerializerExtensionBase = MetadataSerializerExtension(metadataVersion)
 
     private fun getPackageFilePath(packageFqName: FqName, fileName: String): String =
             packageFqName.asString().replace('.', '/') + "/" +
@@ -185,7 +189,7 @@ open class MetadataSerializer(private val dependOnOldBuiltIns: Boolean) {
         private fun serializeBuiltInsFile() {
             val stream = ByteArrayOutputStream()
             with(DataOutputStream(stream)) {
-                val version = BuiltInsBinaryVersion.INSTANCE.toArray()
+                val version = extension.metadataVersion.toArray()
                 writeInt(version.size)
                 version.forEach { writeInt(it) }
             }

compiler/cli/src/org/jetbrains/kotlin/cli/metadata/MetadataSerializerExtension.kt

@@ -17,13 +17,11 @@
 package org.jetbrains.kotlin.cli.metadata
 
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
-import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase
 import org.jetbrains.kotlin.serialization.deserialization.builtins.BuiltInSerializerProtocol
 
-class MetadataSerializerExtension : KotlinSerializerExtensionBase(BuiltInSerializerProtocol) {
+class MetadataSerializerExtension(
-    override val metadataVersion: BinaryVersion
+    override val metadataVersion: BuiltInsBinaryVersion
-        get() = BuiltInsBinaryVersion.INSTANCE
+) : KotlinSerializerExtensionBase(BuiltInSerializerProtocol) {
-
     override fun shouldUseTypeTable(): Boolean = true
 }

compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.config
 
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 
 object CommonConfigurationKeys {
     @JvmField
@@ -37,6 +38,9 @@ object CommonConfigurationKeys {
 
     @JvmField
     val EXPECT_ACTUAL_TRACKER = CompilerConfigurationKey.create<ExpectActualTracker>("expect actual tracker")
+
+    @JvmField
+    val METADATA_VERSION = CompilerConfigurationKey.create<BinaryVersion>("metadata version")
 }
 
 var CompilerConfiguration.languageVersionSettings: LanguageVersionSettings

compiler/testData/cli/js/jsExtraHelp.out

@@ -11,6 +11,7 @@ where advanced options include:
   -Xexperimental=<fq.name>   Enable and propagate usages of experimental API for marker annotation with the given fully qualified name
   -Xintellij-plugin-root=<path> Path to the kotlin-compiler.jar or directory where IntelliJ configuration files can be found
   -Xlegacy-smart-cast-after-try Allow var smart casts despite assignment in try block
+  -Xmetadata-version         Change metadata version of the generated binary files
   -Xmulti-platform           Enable experimental language support for multi-platform projects
   -Xnew-inference            Enable new experimental generic type inference algorithm
   -Xno-check-actual          Do not check presence of 'actual' modifier in multi-platform projects

compiler/testData/cli/jvm/extraHelp.out

@@ -66,6 +66,7 @@ where advanced options include:
   -Xexperimental=<fq.name>   Enable and propagate usages of experimental API for marker annotation with the given fully qualified name
   -Xintellij-plugin-root=<path> Path to the kotlin-compiler.jar or directory where IntelliJ configuration files can be found
   -Xlegacy-smart-cast-after-try Allow var smart casts despite assignment in try block
+  -Xmetadata-version         Change metadata version of the generated binary files
   -Xmulti-platform           Enable experimental language support for multi-platform projects
   -Xnew-inference            Enable new experimental generic type inference algorithm
   -Xno-check-actual          Do not check presence of 'actual' modifier in multi-platform projects

compiler/testData/cli/jvm/invalidMetadataVersion.args

@@ -0,0 +1,4 @@
+$TESTDATA_DIR$/simple.kt
+-d
+$TEMP_DIR$
+-Xmetadata-version=1..2.3

compiler/testData/cli/jvm/invalidMetadataVersion.out

@@ -0,0 +1,2 @@
+error: invalid metadata version: 1..2.3
+COMPILATION_ERROR

compiler/tests/org/jetbrains/kotlin/cli/CliTestGenerated.java

@@ -276,6 +276,11 @@ public class CliTestGenerated extends AbstractCliTest {
             runTest("compiler/testData/cli/jvm/internalArgumentOverrideExtraArgument.args");
         }
 
+        @TestMetadata("invalidMetadataVersion.args")
+        public void testInvalidMetadataVersion() throws Exception {
+            runTest("compiler/testData/cli/jvm/invalidMetadataVersion.args");
+        }
+
         @TestMetadata("javaSrcWrongPackage.args")
         public void testJavaSrcWrongPackage() throws Exception {
             runTest("compiler/testData/cli/jvm/javaSrcWrongPackage.args");

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.config.languageVersionSettings
@@ -82,7 +83,8 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
                     data = analysisResult.moduleDescriptor
             )
             val serializedMetadata = KotlinJavascriptSerializationUtil.serializeMetadata(
-                    analysisResult.bindingContext, description, configuration.languageVersionSettings
+                    analysisResult.bindingContext, description, configuration.languageVersionSettings,
+                    configuration.get(CommonConfigurationKeys.METADATA_VERSION) as? JsMetadataVersion ?: JsMetadataVersion.INSTANCE
             )
             FileUtil.writeToFile(metaFile, serializedMetadata.asString())
         }

compiler/util/src/org/jetbrains/kotlin/utils/KotlinJavascriptMetadataUtils.kt

@@ -71,8 +71,8 @@ object KotlinJavascriptMetadataUtils {
     fun hasMetadata(text: String): Boolean =
             KOTLIN_JAVASCRIPT_METHOD_NAME_PATTERN.matcher(text).find() && METADATA_PATTERN.matcher(text).find()
 
-    fun formatMetadataAsString(moduleName: String, content: ByteArray): String =
+    fun formatMetadataAsString(moduleName: String, content: ByteArray, metadataVersion: JsMetadataVersion): String =
-        "// Kotlin.$KOTLIN_JAVASCRIPT_METHOD_NAME(${JsMetadataVersion.INSTANCE.toInteger()}, \"$moduleName\", " +
+        "// Kotlin.$KOTLIN_JAVASCRIPT_METHOD_NAME(${metadataVersion.toInteger()}, \"$moduleName\", " +
         "\"${Base64.getEncoder().encodeToString(content)}\");\n"
 
     @JvmStatic

core/metadata/src/org/jetbrains/kotlin/metadata/deserialization/BinaryVersion.kt

@@ -65,5 +65,11 @@ abstract class BinaryVersion(private vararg val numbers: Int) {
 
     companion object {
         private const val UNKNOWN = -1
+
+        @JvmStatic
+        fun parseVersionArray(string: String): IntArray? =
+            string.split(".")
+                .map { part -> part.toIntOrNull() ?: return null }
+                .toTypedArray().toIntArray()
     }
 }

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion
 import org.jetbrains.kotlin.metadata.js.JsProtoBuf
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.CodedInputStream
@@ -70,26 +71,32 @@ object KotlinJavascriptSerializationUtil {
     fun serializeMetadata(
         bindingContext: BindingContext,
         jsDescriptor: JsModuleDescriptor<ModuleDescriptor>,
-        languageVersionSettings: LanguageVersionSettings
+        languageVersionSettings: LanguageVersionSettings,
+        metadataVersion: JsMetadataVersion
     ): SerializedMetadata {
         val serializedFragments = HashMap<FqName, ProtoBuf.PackageFragment>()
         val module = jsDescriptor.data
 
         for (fqName in getPackagesFqNames(module).sortedBy { it.asString() }) {
-            val fragment = serializePackageFragment(bindingContext, module, fqName, languageVersionSettings)
+            val fragment = serializeDescriptors(
+                bindingContext, module,
+                module.getPackage(fqName).memberScope.getContributedDescriptors(),
+                fqName, languageVersionSettings, metadataVersion
+            )
 
             if (!fragment.isEmpty()) {
                 serializedFragments[fqName] = fragment
             }
         }
 
-        return SerializedMetadata(serializedFragments, jsDescriptor, languageVersionSettings)
+        return SerializedMetadata(serializedFragments, jsDescriptor, languageVersionSettings, metadataVersion)
     }
 
     class SerializedMetadata(
         private val serializedFragments: Map<FqName, ProtoBuf.PackageFragment>,
         private val jsDescriptor: JsModuleDescriptor<ModuleDescriptor>,
-        private val languageVersionSettings: LanguageVersionSettings
+        private val languageVersionSettings: LanguageVersionSettings,
+        private val metadataVersion: JsMetadataVersion
     ) {
         class SerializedPackage(val fqName: FqName, val bytes: ByteArray)
 
@@ -99,7 +106,7 @@ object KotlinJavascriptSerializationUtil {
             for ((fqName, part) in serializedFragments) {
                 val stream = ByteArrayOutputStream()
                 with(DataOutputStream(stream)) {
-                    val version = JsMetadataVersion.INSTANCE.toArray()
+                    val version = metadataVersion.toArray()
                     writeInt(version.size)
                     version.forEach(this::writeInt)
                 }
@@ -114,7 +121,7 @@ object KotlinJavascriptSerializationUtil {
         }
 
         fun asString(): String =
-            KotlinJavascriptMetadataUtils.formatMetadataAsString(jsDescriptor.name, asByteArray())
+            KotlinJavascriptMetadataUtils.formatMetadataAsString(jsDescriptor.name, asByteArray(), metadataVersion)
 
         private fun asByteArray(): ByteArray =
             ByteArrayOutputStream().apply {
@@ -153,28 +160,13 @@ object KotlinJavascriptSerializationUtil {
         }
     }
 
-    private fun serializePackageFragment(
-        bindingContext: BindingContext,
-        module: ModuleDescriptor,
-        fqName: FqName,
-        languageVersionSettings: LanguageVersionSettings
-    ): ProtoBuf.PackageFragment {
-        val packageView = module.getPackage(fqName)
-        return serializeDescriptors(
-            bindingContext,
-            module,
-            packageView.memberScope.getContributedDescriptors(),
-            fqName,
-            languageVersionSettings
-        )
-    }
-
     fun serializeDescriptors(
         bindingContext: BindingContext,
         module: ModuleDescriptor,
         scope: Collection<DeclarationDescriptor>,
         fqName: FqName,
-        languageVersionSettings: LanguageVersionSettings
+        languageVersionSettings: LanguageVersionSettings,
+        metadataVersion: BinaryVersion
     ): ProtoBuf.PackageFragment {
         val builder = ProtoBuf.PackageFragment.newBuilder()
 
@@ -190,7 +182,7 @@ object KotlinJavascriptSerializationUtil {
         }
 
         val fileRegistry = KotlinFileRegistry()
-        val extension = KotlinJavascriptSerializerExtension(fileRegistry, languageVersionSettings)
+        val extension = KotlinJavascriptSerializerExtension(fileRegistry, languageVersionSettings, metadataVersion)
 
         val classDescriptors = scope.filterIsInstance<ClassDescriptor>().sortedBy { it.fqNameSafe.asString() }
 

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerExtension.kt

@@ -28,15 +28,12 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.source.PsiSourceFile
 import org.jetbrains.kotlin.serialization.KotlinSerializerExtensionBase
 import org.jetbrains.kotlin.types.FlexibleType
-import org.jetbrains.kotlin.utils.JsMetadataVersion
 
 class KotlinJavascriptSerializerExtension(
     private val fileRegistry: KotlinFileRegistry,
-    private val languageVersionSettings: LanguageVersionSettings
+    private val languageVersionSettings: LanguageVersionSettings,
-) : KotlinSerializerExtensionBase(JsSerializerProtocol) {
     override val metadataVersion: BinaryVersion
-        get() = JsMetadataVersion.INSTANCE
+) : KotlinSerializerExtensionBase(JsSerializerProtocol) {
-
     override val stringTable = JavaScriptStringTable()
 
     override fun serializeFlexibleType(flexibleType: FlexibleType, lowerProto: ProtoBuf.Type.Builder, upperProto: ProtoBuf.Type.Builder) {

js/js.translator/src/org/jetbrains/kotlin/js/facade/K2JSTranslator.java

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.js.facade;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CommonConfigurationKeysKt;
 import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -42,12 +43,14 @@ import org.jetbrains.kotlin.js.translate.general.AstGenerationResult;
 import org.jetbrains.kotlin.js.translate.general.Translation;
 import org.jetbrains.kotlin.js.translate.utils.ExpandIsCallsKt;
 import org.jetbrains.kotlin.metadata.ProtoBuf;
+import org.jetbrains.kotlin.metadata.deserialization.BinaryVersion;
 import org.jetbrains.kotlin.progress.ProgressIndicatorAndCompilationCanceledStatus;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics;
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil;
 import org.jetbrains.kotlin.serialization.js.ast.JsAstSerializer;
+import org.jetbrains.kotlin.utils.JsMetadataVersion;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -176,9 +179,12 @@ public final class K2JSTranslator {
 
                 List<DeclarationDescriptor> scope = translationResult.getFileMemberScopes().get(file);
                 assert scope != null : "Could not find descriptors for file: " + file;
+                BinaryVersion metadataVersion = config.getConfiguration().get(CommonConfigurationKeys.METADATA_VERSION);
                 ProtoBuf.PackageFragment packagePart = serializationUtil.serializeDescriptors(
                         bindingTrace.getBindingContext(), moduleDescriptor, scope, file.getPackageFqName(),
-                        CommonConfigurationKeysKt.getLanguageVersionSettings(config.getConfiguration()));
+                        CommonConfigurationKeysKt.getLanguageVersionSettings(config.getConfiguration()),
+                        metadataVersion != null ? metadataVersion : JsMetadataVersion.INSTANCE
+                );
 
                 File ioFile = VfsUtilCore.virtualToIoFile(file.getVirtualFile());
                 incrementalResults.processPackagePart(ioFile, packagePart.toByteArray(), binaryAst);

js/js.translator/src/org/jetbrains/kotlin/js/facade/TranslationResult.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.js.facade
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.VfsUtilCore
 import org.jetbrains.kotlin.backend.common.output.*
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.js.backend.JsToStringGenerationVisitor
@@ -39,6 +40,7 @@ import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import java.io.File
 import java.util.*
@@ -109,16 +111,18 @@ abstract class TranslationResult protected constructor(val diagnostics: Diagnost
                     kind = config.moduleKind,
                     imported = importedModules
                 )
-                val settings = config.configuration.languageVersionSettings
+                val serializedMetadata = KotlinJavascriptSerializationUtil.serializeMetadata(
-                val serializedMetadata = KotlinJavascriptSerializationUtil.serializeMetadata(bindingContext, moduleDescription, settings)
+                    bindingContext, moduleDescription,
+                    config.configuration.languageVersionSettings,
+                    config.configuration.get(CommonConfigurationKeys.METADATA_VERSION) as? JsMetadataVersion ?: JsMetadataVersion.INSTANCE
+                )
                 val metaFileContent = serializedMetadata.asString()
                 val sourceFilesForMetaFile = ArrayList(sourceFiles)
                 val jsMetaFile = SimpleOutputFile(sourceFilesForMetaFile, metaFileName, metaFileContent)
                 outputFiles.add(jsMetaFile)
 
                 for (serializedPackage in serializedMetadata.serializedPackages()) {
-                    val outputBinaryFile = kjsmFileForPackage(serializedPackage.fqName, serializedPackage.bytes)
+                    outputFiles.add(kjsmFileForPackage(serializedPackage.fqName, serializedPackage.bytes))
-                    outputFiles.add(outputBinaryFile)
                 }
             }