Names from new runtime

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializerJsTranslator.kt

@@ -123,9 +123,9 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
             unsubstitutedMemberScope.getDescriptorsFiltered { it == Name.identifier(funcName) }
 
     override fun generateSave(function: FunctionDescriptor) = generateFunction(function) { jsFun, ctx ->
-        val kOutputClass = serializerDescriptor.getClassFromSerializationPackage("KOutput")
+        val kOutputClass = serializerDescriptor.getClassFromSerializationPackage("StructureEncoder")
         val wBeginFunc = ctx.getNameForDescriptor(
-                kOutputClass.getFuncDesc("writeBegin").single { (it as FunctionDescriptor).valueParameters.size == 2 })
+                kOutputClass.getFuncDesc("beginStructure").single { (it as FunctionDescriptor).valueParameters.size == 2 })
         val serialClassDescRef = JsNameRef(context.getNameForDescriptor(serialDescPropertyDescriptor!!), JsThisRef())
 
         // output.writeBegin(desc, [])
@@ -151,7 +151,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
             val innerSerial = serializerInstance(sti.serializer, property.module, property.type, property.genericIndex)
             if (innerSerial == null) {
                 val writeFunc =
-                        kOutputClass.getFuncDesc("write${sti.elementMethodPrefix}ElementValue").single()
+                        kOutputClass.getFuncDesc("encode${sti.elementMethodPrefix}ElementValue").single()
                                 .let { ctx.getNameForDescriptor(it) }
                 +JsInvocation(JsNameRef(writeFunc, localOutputRef),
                               serialClassDescRef,
@@ -160,7 +160,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
             }
             else {
                 val writeFunc =
-                        kOutputClass.getFuncDesc("write${sti.elementMethodPrefix}SerializableElementValue").single()
+                        kOutputClass.getFuncDesc("encode${sti.elementMethodPrefix}SerializableElementValue").single()
                                 .let { ctx.getNameForDescriptor(it) }
                 +JsInvocation(JsNameRef(writeFunc, localOutputRef),
                               serialClassDescRef,
@@ -171,7 +171,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
         }
 
         // output.writeEnd(serialClassDesc)
-        val wEndFunc = kOutputClass.getFuncDesc("writeEnd").single()
+        val wEndFunc = kOutputClass.getFuncDesc("endStructure").single()
                 .let { ctx.getNameForDescriptor(it) }
         +JsInvocation(JsNameRef(wEndFunc, localOutputRef), serialClassDescRef).makeStmt()
     }
@@ -212,7 +212,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
 
 
     override fun generateLoad(function: FunctionDescriptor) = generateFunction(function) { jsFun, context ->
-        val inputClass = serializerDescriptor.getClassFromSerializationPackage("KInput")
+        val inputClass = serializerDescriptor.getClassFromSerializationPackage("StructureDecoder")
         val serialClassDescRef = JsNameRef(context.getNameForDescriptor(serialDescPropertyDescriptor!!), JsThisRef())
 
         // var index = -1, readAll = false
@@ -237,7 +237,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
             JsNameRef(context.scope().declareName("$typeArgPrefix$idx"), JsThisRef())
         }
         val inputVar = JsNameRef(jsFun.scope.declareFreshName("input"))
-        val readBeginF = inputClass.getFuncDesc("readBegin").single()
+        val readBeginF = inputClass.getFuncDesc("beginStructure").single()
         val call = JsInvocation(JsNameRef(context.getNameForDescriptor(readBeginF), JsNameRef(jsFun.parameters[0].name)),
                                 serialClassDescRef, JsArrayLiteral(typeParams))
         +JsVars(JsVars.JsVar(inputVar.name, call))
@@ -247,7 +247,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
         val loopRef = JsNameRef(loop.name)
         jsWhile(JsBooleanLiteral(true), {
             // index = input.readElement(classDesc)
-            val readElementF = context.getNameForDescriptor(inputClass.getFuncDesc("readElement").single())
+            val readElementF = context.getNameForDescriptor(inputClass.getFuncDesc("decodeElement").single())
             +JsAstUtils.assignment(
                     indexVar,
                     JsInvocation(JsNameRef(readElementF, inputVar), serialClassDescRef)
@@ -270,7 +270,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
                         val call: JsExpression = if (innerSerial == null) {
                             val unknownSer = (sti.elementMethodPrefix.isEmpty())
                             val readFunc =
-                                    inputClass.getFuncDesc("read${sti.elementMethodPrefix}ElementValue")
+                                    inputClass.getFuncDesc("decode${sti.elementMethodPrefix}ElementValue")
                                             // if readElementValue, must have 3 parameters, if readXXXElementValue - 2
                                             .single { !unknownSer || (it is FunctionDescriptor && it.valueParameters.size == 3) }
                                             .let { context.getNameForDescriptor(it) }
@@ -281,7 +281,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
                         else {
                             val notSeenTest = propNotSeenTest(bitMasks[i / 32], i)
                             val readFunc =
-                                    inputClass.getFuncDesc("read${sti.elementMethodPrefix}SerializableElementValue").single()
+                                    inputClass.getFuncDesc("decode${sti.elementMethodPrefix}SerializableElementValue").single()
                                             .let { context.getNameForDescriptor(it) }
                             val updateFunc =
                                     inputClass.getFuncDesc("update${sti.elementMethodPrefix}SerializableElementValue").single()
@@ -349,7 +349,7 @@ class SerializerJsTranslator(declaration: KtPureClassOrObject,
         }, loop)
 
         // input.readEnd(desc)
-        val readEndF = inputClass.getFuncDesc("readEnd").single()
+        val readEndF = inputClass.getFuncDesc("endStructure").single()
                 .let { context.getNameForDescriptor(it) }
         +JsInvocation(
                 JsNameRef(readEndF, inputVar),

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/JVMCodegenUtil.kt

@@ -34,14 +34,14 @@ import org.jetbrains.kotlinx.serialization.compiler.resolve.KSerializerDescripto
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter
 
-internal val descType = Type.getObjectType("kotlinx/serialization/KSerialClassDesc")
+internal val descType = Type.getObjectType("kotlinx/serialization/SerialDescriptor")
 internal val descImplType = Type.getObjectType("kotlinx/serialization/internal/SerialClassDescImpl")
-internal val kOutputType = Type.getObjectType("kotlinx/serialization/KOutput")
-internal val kInputType = Type.getObjectType("kotlinx/serialization/KInput")
+internal val kOutputType = Type.getObjectType("kotlinx/serialization/StructureEncoder")
+internal val kInputType = Type.getObjectType("kotlinx/serialization/StructureDecoder")
 
 
-internal val kSerialSaverType = Type.getObjectType("kotlinx/serialization/KSerialSaver")
-internal val kSerialLoaderType = Type.getObjectType("kotlinx/serialization/KSerialLoader")
+internal val kSerialSaverType = Type.getObjectType("kotlinx/serialization/SerializationStrategy")
+internal val kSerialLoaderType = Type.getObjectType("kotlinx/serialization/DeserializationStrategy")
 internal val kSerializerType = Type.getObjectType("kotlinx/serialization/KSerializer")
 internal val kSerializerArrayType = Type.getObjectType("[Lkotlinx/serialization/KSerializer;")
 
@@ -77,11 +77,11 @@ fun InstructionAdapter.genKOutputMethodCall(property: SerializableProperty, clas
     val useSerializer = if (fromClassStartVar == null) stackValueSerializerInstanceFromSerializer(classCodegen, sti)
     else stackValueSerializerInstanceFromClass(classCodegen, sti, fromClassStartVar)
     if (!sti.unit) classCodegen.genPropertyOnStack(this, expressionCodegen.context, property.descriptor, propertyOwnerType, ownerVar)
-    invokevirtual(kOutputType.internalName,
-                  "write" + sti.elementMethodPrefix + (if (useSerializer) "Serializable" else "") + "ElementValue",
+    invokeinterface(kOutputType.internalName,
+                  "encode" + sti.elementMethodPrefix + (if (useSerializer) "Serializable" else "") + "ElementValue",
                   "(" + descType.descriptor + "I" +
                   (if (useSerializer) kSerialSaverType.descriptor else "") +
-                  (if (sti.unit) "" else sti.type.descriptor) + ")V", false)
+                  (if (sti.unit) "" else sti.type.descriptor) + ")V")
 }
 
 internal fun InstructionAdapter.buildInternalConstructorDesc(propsStartVar: Int, bitMaskBase: Int, codegen: ClassBodyCodegen, args: List<SerializableProperty>): String {

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/jvm/SerializerCodegenImpl.kt

@@ -155,9 +155,9 @@ class SerializerCodegenImpl(
             load(outputVar, kOutputType)
             load(descVar, descType)
             genArrayOfTypeParametersSerializers()
-            invokevirtual(kOutputType.internalName, "writeBegin",
+            invokeinterface(kOutputType.internalName, "beginStructure",
                           "(" + descType.descriptor + kSerializerArrayType.descriptor +
-                          ")" + kOutputType.descriptor, false)
+                          ")" + kOutputType.descriptor)
             store(outputVar, kOutputType)
             if (serializableDescriptor.isInternalSerializable) {
                 val sig = StringBuilder("(${kOutputType.descriptor}${descType.descriptor}")
@@ -190,8 +190,8 @@ class SerializerCodegenImpl(
             // output.writeEnd(classDesc)
             load(outputVar, kOutputType)
             load(descVar, descType)
-            invokevirtual(kOutputType.internalName, "writeEnd",
-                          "(" + descType.descriptor + ")V", false)
+            invokeinterface(kOutputType.internalName, "endStructure",
+                          "(" + descType.descriptor + ")V")
             // return
             areturn(Type.VOID_TYPE)
         }
@@ -245,17 +245,17 @@ class SerializerCodegenImpl(
             load(inputVar, kInputType)
             load(descVar, descType)
             genArrayOfTypeParametersSerializers()
-            invokevirtual(kInputType.internalName, "readBegin",
+            invokeinterface(kInputType.internalName, "beginStructure",
                           "(" + descType.descriptor + kSerializerArrayType.descriptor +
-                          ")" + kInputType.descriptor, false)
+                          ")" + kInputType.descriptor)
             store(inputVar, kInputType)
             // readElement: int index = input.readElement(classDesc)
             val readElementLabel = Label()
             visitLabel(readElementLabel)
             load(inputVar, kInputType)
             load(descVar, descType)
-            invokevirtual(kInputType.internalName, "readElement",
-                          "(" + descType.descriptor + ")I", false)
+            invokeinterface(kInputType.internalName, "decodeElement",
+                          "(" + descType.descriptor + ")I")
             store(indexVar, Type.INT_TYPE)
             // switch(index)
             val labeledProperties = orderedProperties.filter { !it.transient }
@@ -296,13 +296,13 @@ class SerializerCodegenImpl(
                     }
 
                     fun produceCall(update: Boolean) {
-                        invokevirtual(kInputType.internalName,
-                                      (if (update) "update" else "read") + sti.elementMethodPrefix + (if (useSerializer) "Serializable" else "") + "ElementValue",
+                        invokeinterface(kInputType.internalName,
+                                      (if (update) "update" else "decode") + sti.elementMethodPrefix + (if (useSerializer) "Serializable" else "") + "ElementValue",
                                       "(" + descType.descriptor + "I" +
                                       (if (useSerializer) kSerialLoaderType.descriptor else "")
                                       + (if (unknownSer) AsmTypes.K_CLASS_TYPE.descriptor else "")
                                       + (if (update) sti.type.descriptor else "")
-                                      + ")" + (if (sti.unit) "V" else sti.type.descriptor), false)
+                                      + ")" + (if (sti.unit) "V" else sti.type.descriptor))
                     }
 
                     if (useSerializer) {
@@ -351,8 +351,8 @@ class SerializerCodegenImpl(
             visitLabel(readEndLabel)
             load(inputVar, kInputType)
             load(descVar, descType)
-            invokevirtual(kInputType.internalName, "readEnd",
-                          "(" + descType.descriptor + ")V", false)
+            invokeinterface(kInputType.internalName, "endStructure",
+                          "(" + descType.descriptor + ")V")
             if (!serializableDescriptor.isInternalSerializable) {
                 //validate all required (constructor) fields
                 val nonThrowLabel = Label()

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/KSerializationUtil.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
 import org.jetbrains.kotlin.types.typeUtil.supertypes
+import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.descType
 import org.jetbrains.kotlinx.serialization.compiler.resolve.KSerializerDescriptorResolver.SERIALIZER_CLASS_NAME
 
 internal val packageFqName = FqName("kotlinx.serialization")
@@ -192,7 +193,7 @@ fun getSerializableClassDescriptorBySerializer(serializerDescriptor: ClassDescri
 }
 
 fun ClassDescriptor.checkSerializableClassPropertyResult(prop: PropertyDescriptor): Boolean =
-        prop.returnType!!.isSubtypeOf(getClassFromSerializationPackage("KSerialClassDesc").toSimpleType(false)) // todo: cache lookup
+        prop.returnType!!.isSubtypeOf(getClassFromSerializationPackage("SerialDescriptor").toSimpleType(false)) // todo: cache lookup
 
 // todo: serialization: do an actual check better that just number of parameters
 fun ClassDescriptor.checkSaveMethodParameters(parameters: List<ValueParameterDescriptor>): Boolean =

plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/KSerializerDescriptorResolver.kt

@@ -39,8 +39,8 @@ import java.util.*
 object KSerializerDescriptorResolver {
 
     val SERIAL_DESC_FIELD = "serialClassDesc"
-    val SAVE = "save"
-    val LOAD = "load"
+    val SAVE = "serialize"
+    val LOAD = "deserialize"
     val SERIALIZER_CLASS = "\$serializer"
 
     internal val typeArgPrefix = "typeSerial"
@@ -379,7 +379,7 @@ object KSerializerDescriptorResolver {
                 i++,
                 Annotations.EMPTY,
                 Name.identifier("output"),
-                thisClass.getClassFromSerializationPackage("KOutput").toSimpleType(false),
+                thisClass.getClassFromSerializationPackage("StructureEncoder").toSimpleType(false),
                 false,
                 false,
                 false,
@@ -393,7 +393,7 @@ object KSerializerDescriptorResolver {
                 i++,
                 Annotations.EMPTY,
                 Name.identifier("serialDesc"),
-                thisClass.getClassFromSerializationPackage("KSerialClassDesc").toSimpleType(false),
+                thisClass.getClassFromSerializationPackage("SerialDescriptor").toSimpleType(false),
                 false,
                 false,
                 false,