Rename JsBinaryVersion -> JsMetadataVersion

For consistency with JvmMetadataVersion

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir;
 import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
-import org.jetbrains.kotlin.utils.JsBinaryVersion;
+import org.jetbrains.kotlin.utils.JsMetadataVersion;
 import org.jetbrains.kotlin.utils.PathUtil;
 import org.jetbrains.kotlin.utils.StringsKt;
 import org.junit.Assert;
@@ -159,7 +159,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir {
     }
 
     protected void doJsTest(@NotNull String fileName) throws Exception {
-        doTest(fileName, new K2JSCompiler(), JsBinaryVersion.INSTANCE);
+        doTest(fileName, new K2JSCompiler(), JsMetadataVersion.INSTANCE);
     }
 
     public static String removePerfOutput(String output) {

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

@@ -23,25 +23,25 @@ import java.io.InputStream
 import javax.xml.bind.DatatypeConverter.parseBase64Binary
 import javax.xml.bind.DatatypeConverter.printBase64Binary
 
-class KotlinJavascriptMetadata(val version: JsBinaryVersion, val moduleName: String, val body: ByteArray)
+class KotlinJavascriptMetadata(val version: JsMetadataVersion, val moduleName: String, val body: ByteArray)
 
 // TODO: move to JS modules
-class JsBinaryVersion(vararg numbers: Int) : BinaryVersion(*numbers) {
+class JsMetadataVersion(vararg numbers: Int) : BinaryVersion(*numbers) {
     override fun isCompatible() = this.isCompatibleTo(INSTANCE)
 
     fun toInteger() = (patch shl 16) + (minOf(minor, 255) shl 8) + minOf(major, 255)
 
     companion object {
         @JvmField
-        val INSTANCE = JsBinaryVersion(0, 8, 0)
+        val INSTANCE = JsMetadataVersion(1, 0, 0)
 
         @JvmField
-        val INVALID_VERSION = JsBinaryVersion()
+        val INVALID_VERSION = JsMetadataVersion()
 
-        fun fromInteger(version: Int): JsBinaryVersion =
+        fun fromInteger(version: Int): JsMetadataVersion =
-                JsBinaryVersion(version and 255, (version shr 8) and 255, version shr 16)
+                JsMetadataVersion(version and 255, (version shr 8) and 255, version shr 16)
 
-        fun readFrom(stream: InputStream): JsBinaryVersion {
+        fun readFrom(stream: InputStream): JsMetadataVersion {
             val dataInput = DataInputStream(stream)
             val size = dataInput.readInt()
 
@@ -49,7 +49,7 @@ class JsBinaryVersion(vararg numbers: Int) : BinaryVersion(*numbers) {
             // of integers from old .kjsm files (pre-1.1) because they did not have the version in the beginning
             if (size != INSTANCE.toArray().size) return INVALID_VERSION
 
-            return JsBinaryVersion(*(1..size).map { dataInput.readInt() }.toIntArray())
+            return JsMetadataVersion(*(1..size).map { dataInput.readInt() }.toIntArray())
         }
     }
 }
@@ -72,7 +72,7 @@ object KotlinJavascriptMetadataUtils {
             KOTLIN_JAVASCRIPT_METHOD_NAME_PATTERN.matcher(text).find() && METADATA_PATTERN.matcher(text).find()
 
     fun formatMetadataAsString(moduleName: String, content: ByteArray): String =
-        "// Kotlin.$KOTLIN_JAVASCRIPT_METHOD_NAME(${JsBinaryVersion.INSTANCE.toInteger()}, \"$moduleName\", \"${printBase64Binary(content)}\");\n"
+        "// Kotlin.$KOTLIN_JAVASCRIPT_METHOD_NAME(${JsMetadataVersion.INSTANCE.toInteger()}, \"$moduleName\", \"${printBase64Binary(content)}\");\n"
 
     @JvmStatic
     fun loadMetadata(file: File): List<KotlinJavascriptMetadata> {
@@ -95,7 +95,7 @@ object KotlinJavascriptMetadataUtils {
 
         val matcher = METADATA_PATTERN.matcher(text)
         while (matcher.find()) {
-            val abiVersion = JsBinaryVersion.fromInteger(matcher.group(1).toInt())
+            val abiVersion = JsMetadataVersion.fromInteger(matcher.group(1).toInt())
             val moduleName = matcher.group(3)
             val data = matcher.group(5)
             metadataList.add(KotlinJavascriptMetadata(abiVersion, moduleName, parseBase64Binary(data)))

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/js/KotlinJavaScriptMetaFileDecompiler.kt

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.serialization.deserialization.NameResolverImpl
 import org.jetbrains.kotlin.serialization.js.JsProtoBuf
 import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol
-import org.jetbrains.kotlin.utils.JsBinaryVersion
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import java.io.ByteArrayInputStream
 import java.io.IOException
 
@@ -64,10 +64,10 @@ fun buildDecompiledTextFromJsMetadata(kjsmFile: VirtualFile): DecompiledText {
 
     when (file) {
         null -> {
-            return createIncompatibleAbiVersionDecompiledText(JsBinaryVersion.INSTANCE, JsBinaryVersion.INVALID_VERSION)
+            return createIncompatibleAbiVersionDecompiledText(JsMetadataVersion.INSTANCE, JsMetadataVersion.INVALID_VERSION)
         }
         is KjsmFile.Incompatible -> {
-            return createIncompatibleAbiVersionDecompiledText(JsBinaryVersion.INSTANCE, file.version)
+            return createIncompatibleAbiVersionDecompiledText(JsMetadataVersion.INSTANCE, file.version)
         }
         is KjsmFile.Compatible -> {
             val packageFqName = file.packageFqName
@@ -85,7 +85,7 @@ fun buildDecompiledTextFromJsMetadata(kjsmFile: VirtualFile): DecompiledText {
 
 // TODO: deduplicate code with BuiltInDefinitionFile
 sealed class KjsmFile {
-    class Incompatible(val version: JsBinaryVersion) : KjsmFile()
+    class Incompatible(val version: JsMetadataVersion) : KjsmFile()
 
     class Compatible(val header: JsProtoBuf.Header, val proto: JsProtoBuf.Library.Part) : KjsmFile() {
         val packageFqName = FqName(header.packageFqName)
@@ -99,7 +99,7 @@ sealed class KjsmFile {
         fun read(file: VirtualFile): KjsmFile? {
             val stream = ByteArrayInputStream(readFileContentsSafely(file) ?: return null)
 
-            val version = JsBinaryVersion.readFrom(stream)
+            val version = JsMetadataVersion.readFrom(stream)
             if (!version.isCompatible()) {
                 return Incompatible(version)
             }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragment
 import org.jetbrains.kotlin.serialization.js.JsProtoBuf
-import org.jetbrains.kotlin.utils.JsBinaryVersion
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import java.io.ByteArrayInputStream
 import java.io.DataInput
 import java.io.DataOutput
@@ -104,7 +104,7 @@ object KotlinJavaScriptMetaFileIndex : KotlinFileIndexBase<KotlinJavaScriptMetaF
 
     private val INDEXER = indexer { fileContent ->
         val stream = ByteArrayInputStream(fileContent.content)
-        if (JsBinaryVersion.readFrom(stream).isCompatible()) {
+        if (JsMetadataVersion.readFrom(stream).isCompatible()) {
             FqName(JsProtoBuf.Header.parseDelimitedFrom(stream).packageFqName)
         }
         else null

idea/src/org/jetbrains/kotlin/idea/versions/KotlinJavaScriptAbiVersionIndex.kt

@@ -21,13 +21,13 @@ import com.intellij.util.indexing.DataIndexer
 import com.intellij.util.indexing.FileBasedIndex
 import com.intellij.util.indexing.FileContent
 import org.jetbrains.kotlin.js.JavaScript
-import org.jetbrains.kotlin.utils.JsBinaryVersion
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import java.util.*
 
-object KotlinJavaScriptAbiVersionIndex : KotlinAbiVersionIndexBase<KotlinJavaScriptAbiVersionIndex, JsBinaryVersion>(
+object KotlinJavaScriptAbiVersionIndex : KotlinAbiVersionIndexBase<KotlinJavaScriptAbiVersionIndex, JsMetadataVersion>(
-        KotlinJavaScriptAbiVersionIndex::class.java, ::JsBinaryVersion
+        KotlinJavaScriptAbiVersionIndex::class.java, ::JsMetadataVersion
 ) {
     override fun getIndexer() = INDEXER
 
@@ -38,7 +38,7 @@ object KotlinJavaScriptAbiVersionIndex : KotlinAbiVersionIndexBase<KotlinJavaScr
     private val VERSION = 3
 
     private val INDEXER = DataIndexer { inputData: FileContent ->
-        val result = HashMap<JsBinaryVersion, Void?>()
+        val result = HashMap<JsMetadataVersion, Void?>()
 
         tryBlock(inputData) {
             val text = VfsUtilCore.loadText(inputData.file)
@@ -47,7 +47,7 @@ object KotlinJavaScriptAbiVersionIndex : KotlinAbiVersionIndexBase<KotlinJavaScr
             for (metadata in metadataList) {
                 val version = metadata.version.takeIf { it.isCompatible() }
                               // Version is set to something weird
-                              ?: JsBinaryVersion.INVALID_VERSION
+                              ?: JsMetadataVersion.INVALID_VERSION
                 result[version] = null
             }
         }

idea/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryUtil.kt

@@ -55,7 +55,7 @@ import org.jetbrains.kotlin.idea.vfilefinder.JsVirtualFileFinderFactory
 import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
-import org.jetbrains.kotlin.utils.JsBinaryVersion
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.utils.addToStdlib.constant
 import java.io.File
@@ -65,8 +65,8 @@ fun getLibraryRootsWithAbiIncompatibleKotlinClasses(module: Module): Collection<
     return getLibraryRootsWithAbiIncompatibleVersion(module, JvmMetadataVersion.INSTANCE, KotlinMetadataVersionIndex)
 }
 
-fun getLibraryRootsWithAbiIncompatibleForKotlinJs(module: Module): Collection<BinaryVersionedFile<JsBinaryVersion>> {
+fun getLibraryRootsWithAbiIncompatibleForKotlinJs(module: Module): Collection<BinaryVersionedFile<JsMetadataVersion>> {
-    return getLibraryRootsWithAbiIncompatibleVersion(module, JsBinaryVersion.INSTANCE, KotlinJavaScriptAbiVersionIndex)
+    return getLibraryRootsWithAbiIncompatibleVersion(module, JsMetadataVersion.INSTANCE, KotlinJavaScriptAbiVersionIndex)
 }
 
 fun updateLibraries(project: Project, libraries: Collection<Library>) {

js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor;
 import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil;
 import org.jetbrains.kotlin.serialization.js.ModuleKind;
 import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.utils.JsBinaryVersion;
+import org.jetbrains.kotlin.utils.JsMetadataVersion;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata;
 
 import java.util.ArrayList;
@@ -129,7 +129,7 @@ public abstract class JsConfig {
 
     private JsModuleDescriptor<ModuleDescriptorImpl> createModuleDescriptor(KotlinJavascriptMetadata metadata) {
         assert metadata.getVersion().isCompatible() :
-                "Expected JS metadata version " + JsBinaryVersion.INSTANCE + ", but actual metadata version is " + metadata.getVersion();
+                "Expected JS metadata version " + JsMetadataVersion.INSTANCE + ", but actual metadata version is " + metadata.getVersion();
 
         ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(
                 Name.special("<" + metadata.getModuleName() + ">"), storageManager, JsPlatform.INSTANCE.getBuiltIns()

js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java

@@ -32,7 +32,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.KotlinFileType;
 import org.jetbrains.kotlin.psi.KtFile;
-import org.jetbrains.kotlin.utils.JsBinaryVersion;
+import org.jetbrains.kotlin.utils.JsMetadataVersion;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata;
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils;
 import org.jetbrains.kotlin.utils.LibraryUtils;
@@ -148,7 +148,7 @@ public class LibrarySourcesConfig extends JsConfig {
                     if (!metadata.getVersion().isCompatible()) {
                         report.invoke("File '" + path + "' was compiled with an incompatible version of Kotlin. " +
                                       "The binary version of its metadata is " + metadata.getVersion() +
-                                      ", expected version is " + JsBinaryVersion.INSTANCE);
+                                      ", expected version is " + JsMetadataVersion.INSTANCE);
                         return true;
                     }
                 }

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.serialization.AnnotationSerializer
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.utils.JsBinaryVersion
+import org.jetbrains.kotlin.utils.JsMetadataVersion
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
@@ -162,7 +162,7 @@ object KotlinJavascriptSerializationUtil {
 
             val stream = ByteArrayOutputStream()
             with(DataOutputStream(stream)) {
-                val version = JsBinaryVersion.INSTANCE.toArray()
+                val version = JsMetadataVersion.INSTANCE.toArray()
                 writeInt(version.size)
                 version.forEach(this::writeInt)
             }