Continuous improvements: Tuples, TypeUnions, descriptor extraction (#21)

aSemy · web-flow · commit f20ea577fadb · 2022-04-09T20:42:18.000+02:00
* change tuple constructor to use an iterator, so it's not indexed based (and so a little less fragile)

* distinct the given serializers, before generating

* make a distinction between a type alias (to one type) and type union (helps with the 'brand typing' option')

- change the formatting of type unions
-

* add kotest

* fix extracting SerialDescriptors from within subclasses

* additional test for serializer extraction from sealed classes

* document polymorphic descriptor extraction
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
@@ -17,7 +17,7 @@ object Versions {
   const val kotlinxSerialization = "1.3.2"
   const val ksp = "1.6.10-1.0.4"
 
-  const val kotest = "5.1.0"
+  const val kotest = "5.2.3"
 }
 
 
diff --git a/docs/code/example/example-tuple-01.kt b/docs/code/example/example-tuple-01.kt
@@ -27,14 +27,14 @@ data class SimpleTypes(
       element(SimpleTypes::privateMember)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): SimpleTypes {
+    override fun tupleConstructor(elements: Iterator<*>): SimpleTypes {
       // When deserializing, the elements will be available as a list, in the order defined
       return SimpleTypes(
-        elements[0] as String,
-        elements[1] as Int,
-        elements[2] as Double,
-        elements[3] as Boolean,
-        elements[4] as String,
+        elements.next() as String,
+        elements.next() as Int,
+        elements.next() as Double,
+        elements.next() as Boolean,
+        elements.next() as String,
       )
     }
   }
diff --git a/docs/code/example/example-tuple-02.kt b/docs/code/example/example-tuple-02.kt
@@ -22,7 +22,7 @@ data class OptionalFields(
       element(OptionalFields::nullableOptionalString)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): OptionalFields {
+    override fun tupleConstructor(elements: Iterator<*>): OptionalFields {
       val iter = elements.iterator()
       return OptionalFields(
         iter.next() as String,
diff --git a/docs/code/example/example-tuple-03.kt b/docs/code/example/example-tuple-03.kt
@@ -20,11 +20,11 @@ data class Coordinates(
       element(Coordinates::z)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): Coordinates {
+    override fun tupleConstructor(elements: Iterator<*>): Coordinates {
       return Coordinates(
-        elements[0] as Int,
-        elements[1] as Int,
-        elements[2] as Int,
+        elements.next() as Int,
+        elements.next() as Int,
+        elements.next() as Int,
       )
     }
   }
diff --git a/docs/code/test/PolymorphismTest.kt b/docs/code/test/PolymorphismTest.kt
@@ -75,7 +75,9 @@ class PolymorphismTest {
       .shouldBe(
         // language=TypeScript
         """
-          |export type Project = Project.DeprecatedProject | Project.OProj;
+          |export type Project =
+          |  | Project.DeprecatedProject
+          |  | Project.OProj;
           |
           |export namespace Project {
           |  export enum Type {
@@ -108,7 +110,10 @@ class PolymorphismTest {
       .shouldBe(
         // language=TypeScript
         """
-          |export type Dog = Dog.Golden | Dog.Mutt | Dog.NovaScotia;
+          |export type Dog =
+          |  | Dog.Golden
+          |  | Dog.Mutt
+          |  | Dog.NovaScotia;
           |
           |export namespace Dog {
           |  export enum Type {
@@ -185,7 +190,9 @@ class PolymorphismTest {
       .shouldBe(
         // language=TypeScript
         """
-          |export type Response = Response.EmptyResponse | Response.TextResponse;
+          |export type Response =
+          |  | Response.EmptyResponse
+          |  | Response.TextResponse;
           |
           |export namespace Response {
           |  export enum Type {
diff --git a/docs/polymorphism.md b/docs/polymorphism.md
@@ -163,7 +163,9 @@ fun main() {
 > You can get the full code [here](./code/example/example-polymorphic-sealed-class-01.kt).
 
 ```typescript
-export type Project = Project.DeprecatedProject | Project.OProj;
+export type Project =
+  | Project.DeprecatedProject
+  | Project.OProj;
 
 export namespace Project {
   export enum Type {
@@ -231,7 +233,10 @@ fun main() {
 > You can get the full code [here](./code/example/example-polymorphic-sealed-class-02.kt).
 
 ```typescript
-export type Dog = Dog.Golden | Dog.Mutt | Dog.NovaScotia;
+export type Dog =
+  | Dog.Golden
+  | Dog.Mutt
+  | Dog.NovaScotia;
 
 export namespace Dog {
   export enum Type {
@@ -322,7 +327,9 @@ fun main() {
 > You can get the full code [here](./code/example/example-polymorphic-objects-01.kt).
 
 ```typescript
-export type Response = Response.EmptyResponse | Response.TextResponse;
+export type Response =
+  | Response.EmptyResponse
+  | Response.TextResponse;
 
 export namespace Response {
   export enum Type {
diff --git a/docs/tuples.md b/docs/tuples.md
@@ -58,14 +58,14 @@ data class SimpleTypes(
       element(SimpleTypes::privateMember)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): SimpleTypes {
+    override fun tupleConstructor(elements: Iterator<*>): SimpleTypes {
       // When deserializing, the elements will be available as a list, in the order defined
       return SimpleTypes(
-        elements[0] as String,
-        elements[1] as Int,
-        elements[2] as Double,
-        elements[3] as Boolean,
-        elements[4] as String,
+        elements.next() as String,
+        elements.next() as Int,
+        elements.next() as Double,
+        elements.next() as Boolean,
+        elements.next() as String,
       )
     }
   }
@@ -111,7 +111,7 @@ data class OptionalFields(
       element(OptionalFields::nullableOptionalString)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): OptionalFields {
+    override fun tupleConstructor(elements: Iterator<*>): OptionalFields {
       val iter = elements.iterator()
       return OptionalFields(
         iter.next() as String,
@@ -154,11 +154,11 @@ data class Coordinates(
       element(Coordinates::z)
     }
   ) {
-    override fun tupleConstructor(elements: List<*>): Coordinates {
+    override fun tupleConstructor(elements: Iterator<*>): Coordinates {
       return Coordinates(
-        elements[0] as Int,
-        elements[1] as Int,
-        elements[2] as Int,
+        elements.next() as Int,
+        elements.next() as Int,
+        elements.next() as Int,
       )
     }
   }
diff --git a/modules/kxs-ts-gen-core/build.gradle.kts b/modules/kxs-ts-gen-core/build.gradle.kts
@@ -6,9 +6,11 @@ plugins {
   buildsrc.convention.`maven-publish`
   kotlin("plugin.serialization")
 //  id("org.jetbrains.reflekt")
+  id("io.kotest.multiplatform")
 }
 
 val kotlinxSerializationVersion = "1.3.2"
+val kotestVersion = "5.2.2"
 
 kotlin {
 
@@ -70,6 +72,12 @@ kotlin {
     val commonTest by getting {
       dependencies {
         implementation(kotlin("test"))
+
+        implementation("io.kotest:kotest-assertions-core:$kotestVersion")
+        implementation("io.kotest:kotest-assertions-json:$kotestVersion")
+        implementation("io.kotest:kotest-property:$kotestVersion")
+        implementation("io.kotest:kotest-framework-engine:$kotestVersion")
+        implementation("io.kotest:kotest-framework-datatest:$kotestVersion")
       }
     }
 //    val nativeMain by getting
@@ -81,6 +89,11 @@ kotlin {
         implementation(kotlin("reflect"))
       }
     }
-//    val jvmTest by getting
+
+    val jvmTest by getting {
+      dependencies {
+        implementation("io.kotest:kotest-runner-junit5-jvm:$kotestVersion")
+      }
+    }
   }
 }
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/KxsTsGenerator.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/KxsTsGenerator.kt
@@ -68,6 +68,7 @@ open class KxsTsGenerator(
 
   open fun generate(vararg serializers: KSerializer<*>): String {
     return serializers
+      .toSet()
 
       // 1. get all SerialDescriptors from a KSerializer
       .flatMap { serializer ->
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/KxsTsSourceCodeGenerator.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/KxsTsSourceCodeGenerator.kt
@@ -17,15 +17,17 @@ abstract class KxsTsSourceCodeGenerator(
       is TsDeclaration.TsEnum      -> generateEnum(element)
       is TsDeclaration.TsInterface -> generateInterface(element)
       is TsDeclaration.TsNamespace -> generateNamespace(element)
-      is TsDeclaration.TsTypeAlias -> generateType(element)
+      is TsDeclaration.TsTypeUnion -> generateTypeUnion(element)
+      is TsDeclaration.TsTypeAlias -> generateTypeAlias(element)
       is TsDeclaration.TsTuple     -> generateTuple(element)
     }
   }
 
   abstract fun generateEnum(enum: TsDeclaration.TsEnum): String
   abstract fun generateInterface(element: TsDeclaration.TsInterface): String
   abstract fun generateNamespace(namespace: TsDeclaration.TsNamespace): String
-  abstract fun generateType(element: TsDeclaration.TsTypeAlias): String
+  abstract fun generateTypeAlias(element: TsDeclaration.TsTypeAlias): String
+  abstract fun generateTypeUnion(element: TsDeclaration.TsTypeUnion): String
   abstract fun generateTuple(tuple: TsDeclaration.TsTuple): String
 
   abstract fun generateMapTypeReference(tsMap: TsLiteral.TsMap): String
@@ -117,17 +119,13 @@ abstract class KxsTsSourceCodeGenerator(
     }
 
 
-    override fun generateType(element: TsDeclaration.TsTypeAlias): String {
-      val aliases =
-        element.typeRefs
-          .map { generateTypeReference(it) }
-          .sorted()
-          .joinToString(" | ")
+    override fun generateTypeAlias(element: TsDeclaration.TsTypeAlias): String {
+      val aliasedRef = generateTypeReference(element.typeRef)
 
       return when (config.typeAliasTyping) {
         KxsTsConfig.TypeAliasTypingConfig.None        ->
           """
-            |export type ${element.id.name} = ${aliases};
+            |export type ${element.id.name} = ${aliasedRef};
           """.trimMargin()
         KxsTsConfig.TypeAliasTypingConfig.BrandTyping -> {
 
@@ -141,12 +139,31 @@ abstract class KxsTsSourceCodeGenerator(
             }.joinToString("")
 
           """
-            |export type ${element.id.name} = $aliases & { __${brandType}__: void };
+            |export type ${element.id.name} = $aliasedRef & { __${brandType}__: void };
           """.trimMargin()
         }
       }
     }
 
+    override fun generateTypeUnion(element: TsDeclaration.TsTypeUnion): String {
+      return if (element.typeRefs.isEmpty()) {
+        """
+          |export type ${element.id.name} = ${generatePrimitive(TsLiteral.Primitive.TsUnknown)};
+        """.trimMargin()
+      } else {
+        val aliases = element.typeRefs
+          .map { "${config.indent}| ${generateTypeReference(it)}" }
+          .sorted()
+          .joinToString("\n")
+
+        """
+          ¦export type ${element.id.name} =
+          ¦$aliases;
+        """.trimMargin("¦")
+      }
+    }
+
+
     override fun generateTuple(tuple: TsDeclaration.TsTuple): String {
 
       val types = tuple.elements.joinToString(separator = ", ") {
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/SerializerDescriptorsExtractor.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/SerializerDescriptorsExtractor.kt
@@ -66,10 +66,25 @@ fun interface SerializerDescriptorsExtractor {
         StructureKind.OBJECT  -> descriptor.elementDescriptors
 
         PolymorphicKind.SEALED,
-        PolymorphicKind.OPEN  -> descriptor
-          .elementDescriptors
-          .filter { it.kind is PolymorphicKind }
-          .flatMap { it.elementDescriptors }
+        PolymorphicKind.OPEN  ->
+          // Polymorphic descriptors have 2 elements, the 'type' and 'value' - we don't need either
+          // for generation, they're metadata that will be used later.
+          // The elements of 'value' are similarly unneeded, but their elements might contain new
+          // descriptors - so extract them
+          descriptor.elementDescriptors
+            .flatMap { it.elementDescriptors }
+            .flatMap { it.elementDescriptors }
+
+        // Example:
+        // com.application.Polymorphic<MySealedClass>
+        //   ├── 'type' descriptor (ignore / it's a String, so check its elements, it doesn't hurt)
+        //   └── 'value' descriptor (check elements...)
+        //        ├── com.application.Polymorphic<Subclass1>  (ignore)
+        //        │   ├── Double                              (extract!)
+        //        │   └── com.application.SomeOtherClass      (extract!)
+        //        └── com.application.Polymorphic<Subclass2>  (ignore)
+        //            ├── UInt                                (extract!)
+        //            └── List<com.application.AnotherClass   (extract!
       }
     }
   }
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/TsElementConverter.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/TsElementConverter.kt
@@ -132,7 +132,7 @@ fun interface TsElementConverter {
         }
 
         // create type union and namespace
-        val subInterfaceTypeUnion = TsDeclaration.TsTypeAlias(
+        val subInterfaceTypeUnion = TsDeclaration.TsTypeUnion(
           namespaceId,
           subInterfaceRefs.keys
         )
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/experiments/tuple.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/experiments/tuple.kt
@@ -96,7 +96,7 @@ abstract class TupleSerializer<T>(
   }
   private val indexedTupleElements = tupleElements.associateBy { it.index }
 
-  abstract fun tupleConstructor(elements: List<*>): T
+  abstract fun tupleConstructor(elements: Iterator<*>): T
 
   override val descriptor: SerialDescriptor = buildSerialDescriptor(
     serialName = serialName,
@@ -123,7 +123,7 @@ abstract class TupleSerializer<T>(
       generateSequence {
         val index = decodeElementIndex(descriptor)
         indexedTupleElements[index]?.decodeElement(this)
-      }.toList()
+      }.iterator()
     }
     return tupleConstructor(elements)
   }
diff --git a/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/tsElements.kt b/modules/kxs-ts-gen-core/src/commonMain/kotlin/dev/adamko/kxstsgen/core/tsElements.kt
@@ -38,14 +38,18 @@ sealed interface TsDeclaration : TsElement {
   val id: TsElementId
 
 
-  /** A named reference to one or more other types. */
+  /** A named reference to another type. */
   data class TsTypeAlias(
+    override val id: TsElementId,
+    val typeRef: TsTypeRef,
+  ) : TsDeclaration
+
+
+  /** A named reference to one or more other types. */
+  data class TsTypeUnion(
     override val id: TsElementId,
     val typeRefs: Set<TsTypeRef>,
-  ) : TsDeclaration {
-    constructor(id: TsElementId, typeRef: TsTypeRef, vararg typeRefs: TsTypeRef) :
-      this(id, typeRefs.toSet() + typeRef)
-  }
+  ) : TsDeclaration
 
 
   /**  A [tuple type](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types). */
diff --git a/modules/kxs-ts-gen-core/src/commonTest/kotlin/dev/adamko/kxstsgen/core/SerializerDescriptorsExtractorTest.kt b/modules/kxs-ts-gen-core/src/commonTest/kotlin/dev/adamko/kxstsgen/core/SerializerDescriptorsExtractorTest.kt

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ object Versions {`
`17`	`17`	`const val kotlinxSerialization = "1.3.2"`
`18`	`18`	`const val ksp = "1.6.10-1.0.4"`
`19`	`19`
`20`		`- const val kotest = "5.1.0"`
	`20`	`+ const val kotest = "5.2.3"`
`21`	`21`	`}`
`22`	`22`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,14 @@ data class SimpleTypes(`
`27`	`27`	`element(SimpleTypes::privateMember)`
`28`	`28`	`}`
`29`	`29`	`) {`
`30`		`- override fun tupleConstructor(elements: List<*>): SimpleTypes {`
	`30`	`+ override fun tupleConstructor(elements: Iterator<*>): SimpleTypes {`
`31`	`31`	`// When deserializing, the elements will be available as a list, in the order defined`
`32`	`32`	`return SimpleTypes(`
`33`		`- elements[0] as String,`
`34`		`- elements[1] as Int,`
`35`		`- elements[2] as Double,`
`36`		`- elements[3] as Boolean,`
`37`		`- elements[4] as String,`
	`33`	`+ elements.next() as String,`
	`34`	`+ elements.next() as Int,`
	`35`	`+ elements.next() as Double,`
	`36`	`+ elements.next() as Boolean,`
	`37`	`+ elements.next() as String,`
`38`	`38`	`)`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ data class OptionalFields(`
`22`	`22`	`element(OptionalFields::nullableOptionalString)`
`23`	`23`	`}`
`24`	`24`	`) {`
`25`		`- override fun tupleConstructor(elements: List<*>): OptionalFields {`
	`25`	`+ override fun tupleConstructor(elements: Iterator<*>): OptionalFields {`
`26`	`26`	`val iter = elements.iterator()`
`27`	`27`	`return OptionalFields(`
`28`	`28`	`iter.next() as String,`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,11 @@ data class Coordinates(`
`20`	`20`	`element(Coordinates::z)`
`21`	`21`	`}`
`22`	`22`	`) {`
`23`		`- override fun tupleConstructor(elements: List<*>): Coordinates {`
	`23`	`+ override fun tupleConstructor(elements: Iterator<*>): Coordinates {`
`24`	`24`	`return Coordinates(`
`25`		`- elements[0] as Int,`
`26`		`- elements[1] as Int,`
`27`		`- elements[2] as Int,`
	`25`	`+ elements.next() as Int,`
	`26`	`+ elements.next() as Int,`
	`27`	`+ elements.next() as Int,`
`28`	`28`	`)`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,14 +58,14 @@ data class SimpleTypes(`
`58`	`58`	`element(SimpleTypes::privateMember)`
`59`	`59`	`}`
`60`	`60`	`) {`
`61`		`- override fun tupleConstructor(elements: List<*>): SimpleTypes {`
	`61`	`+ override fun tupleConstructor(elements: Iterator<*>): SimpleTypes {`
`62`	`62`	`// When deserializing, the elements will be available as a list, in the order defined`
`63`	`63`	`return SimpleTypes(`
`64`		`- elements[0] as String,`
`65`		`- elements[1] as Int,`
`66`		`- elements[2] as Double,`
`67`		`- elements[3] as Boolean,`
`68`		`- elements[4] as String,`
	`64`	`+ elements.next() as String,`
	`65`	`+ elements.next() as Int,`
	`66`	`+ elements.next() as Double,`
	`67`	`+ elements.next() as Boolean,`
	`68`	`+ elements.next() as String,`
`69`	`69`	`)`
`70`	`70`	`}`
`71`	`71`	`}`
`@@ -111,7 +111,7 @@ data class OptionalFields(`
`111`	`111`	`element(OptionalFields::nullableOptionalString)`
`112`	`112`	`}`
`113`	`113`	`) {`
`114`		`- override fun tupleConstructor(elements: List<*>): OptionalFields {`
	`114`	`+ override fun tupleConstructor(elements: Iterator<*>): OptionalFields {`
`115`	`115`	`val iter = elements.iterator()`
`116`	`116`	`return OptionalFields(`
`117`	`117`	`iter.next() as String,`
`@@ -154,11 +154,11 @@ data class Coordinates(`
`154`	`154`	`element(Coordinates::z)`
`155`	`155`	`}`
`156`	`156`	`) {`
`157`		`- override fun tupleConstructor(elements: List<*>): Coordinates {`
	`157`	`+ override fun tupleConstructor(elements: Iterator<*>): Coordinates {`
`158`	`158`	`return Coordinates(`
`159`		`- elements[0] as Int,`
`160`		`- elements[1] as Int,`
`161`		`- elements[2] as Int,`
	`159`	`+ elements.next() as Int,`
	`160`	`+ elements.next() as Int,`
	`161`	`+ elements.next() as Int,`
`162`	`162`	`)`
`163`	`163`	`}`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,9 +6,11 @@ plugins {`
`6`	`6`	buildsrc.convention.`maven-publish`
`7`	`7`	`kotlin("plugin.serialization")`
`8`	`8`	`// id("org.jetbrains.reflekt")`
	`9`	`+ id("io.kotest.multiplatform")`
`9`	`10`	`}`
`10`	`11`
`11`	`12`	`val kotlinxSerializationVersion = "1.3.2"`
	`13`	`+val kotestVersion = "5.2.2"`
`12`	`14`
`13`	`15`	`kotlin {`
`14`	`16`
`@@ -70,6 +72,12 @@ kotlin {`
`70`	`72`	`val commonTest by getting {`
`71`	`73`	`dependencies {`
`72`	`74`	`implementation(kotlin("test"))`
	`75`	`+`
	`76`	`+ implementation("io.kotest:kotest-assertions-core:$kotestVersion")`
	`77`	`+ implementation("io.kotest:kotest-assertions-json:$kotestVersion")`
	`78`	`+ implementation("io.kotest:kotest-property:$kotestVersion")`
	`79`	`+ implementation("io.kotest:kotest-framework-engine:$kotestVersion")`
	`80`	`+ implementation("io.kotest:kotest-framework-datatest:$kotestVersion")`
`73`	`81`	`}`
`74`	`82`	`}`
`75`	`83`	`// val nativeMain by getting`
`@@ -81,6 +89,11 @@ kotlin {`
`81`	`89`	`implementation(kotlin("reflect"))`
`82`	`90`	`}`
`83`	`91`	`}`
`84`		`-// val jvmTest by getting`
	`92`	`+`
	`93`	`+ val jvmTest by getting {`
	`94`	`+ dependencies {`
	`95`	`+ implementation("io.kotest:kotest-runner-junit5-jvm:$kotestVersion")`
	`96`	`+ }`
	`97`	`+ }`
`85`	`98`	`}`
`86`	`99`	`}`