Restore ability to derive schemas with Scala 2 for hierarchy of sum types(#822)

Author: googley42

zio-schema-derivation/shared/src/main/scala-2/zio/schema/DeriveSchema.scala

@@ -563,7 +563,7 @@ object DeriveSchema {
           child.typeSignature
           val childClass = child.asClass
           if (childClass.isSealed && childClass.isTrait)
-            Set(childClass.asType.toType)
+            knownSubclassesOf(childClass)
           else if (childClass.isCaseClass || (childClass.isClass && childClass.isAbstract)) {
             val st = concreteType(concreteType(tpe, parent.asType.toType), child.asType.toType)
             Set(appliedSubtype(st))

zio-schema-derivation/shared/src/test/scala/zio/schema/DeriveSchemaSpec.scala

@@ -564,16 +564,6 @@ object DeriveSchemaSpec extends ZIOSpecDefault with VersionSpecificDeriveSchemaS
           )
         assert(derived)(hasSameSchema(expected))
       },
-      test(
-        "correctly derives schema for sealed trait with intermediate traits, having leaf classes for Scala2"
-      ) {
-        intermediateTraitTest(enum2Annotations = Chunk.empty)
-      } @@ TestAspect.scala2Only,
-      test(
-        "correctly derives schema for sealed trait with intermediate traits, having leaf classes for Scala3"
-      ) {
-        intermediateTraitTest(enum2Annotations = Chunk(simpleEnum(automaticallyAdded = true)))
-      } @@ TestAspect.scala3Only,
       test(
         "correctly derives schema for abstract sealed class with intermediate subclasses, having case class leaf classes"
       ) {
@@ -628,62 +618,4 @@ object DeriveSchemaSpec extends ZIOSpecDefault with VersionSpecificDeriveSchemaS
     versionSpecificSuite
   )
 
-  // Needed as I think is an unrelated existing bug in Scala 3 DeriveSchema whereby it adds simpleEnum annotation at the
-  // top level of the EnumN schema when one of the cases is a simple enum - however this does not happen with the Scala 2 macro.
-  // I think the Scala2 behavior is correct ie this should be a the leaf schema level.
-  // Create issue https://github.com/zio/zio-schema/issues/750 to track this
-  private def intermediateTraitTest(enum2Annotations: Chunk[Annotation]) = {
-    val derived: Schema.Enum2[TraitLeaf.type, MiddleTrait, TraitWithMiddleTrait] =
-      DeriveSchema.gen[TraitWithMiddleTrait]
-
-    val middleTraitLeafSchema = Schema.CaseClass0(
-      TypeId.fromTypeName("zio.schema.DeriveSchemaSpec.MiddleTraitLeaf"),
-      () => MiddleTraitLeaf,
-      Chunk.empty
-    )
-    val middleTraitLeafCase = Schema.Case[MiddleTrait, MiddleTraitLeaf.type](
-      "MiddleTraitLeaf",
-      middleTraitLeafSchema,
-      (a: MiddleTrait) => a.asInstanceOf[MiddleTraitLeaf.type],
-      (a: MiddleTraitLeaf.type) => a.asInstanceOf[MiddleTrait],
-      (a: MiddleTrait) => a.isInstanceOf[MiddleTraitLeaf.type]
-    )
-    val middleTraitSchema = Schema.Enum1[MiddleTraitLeaf.type, MiddleTrait](
-      TypeId.parse("zio.schema.DeriveSchemaSpec.MiddleTrait"),
-      middleTraitLeafCase,
-      Chunk(simpleEnum(automaticallyAdded = true))
-    )
-
-    val traitLeafSchema = Schema.CaseClass0(
-      TypeId.fromTypeName("zio.schema.DeriveSchemaSpec.TraitLeaf"),
-      () => TraitLeaf,
-      Chunk.empty
-    )
-    val traitLeafCase = Schema.Case[TraitWithMiddleTrait, TraitLeaf.type](
-      "TraitLeaf",
-      traitLeafSchema,
-      (a: TraitWithMiddleTrait) => a.asInstanceOf[TraitLeaf.type],
-      (a: TraitLeaf.type) => a.asInstanceOf[TraitWithMiddleTrait],
-      (a: TraitWithMiddleTrait) => a.isInstanceOf[TraitLeaf.type]
-    )
-
-    val middleTraitCase = Schema.Case[TraitWithMiddleTrait, MiddleTrait](
-      "MiddleTrait",
-      middleTraitSchema,
-      (a: TraitWithMiddleTrait) => a.asInstanceOf[MiddleTrait],
-      (a: MiddleTrait) => a.asInstanceOf[TraitWithMiddleTrait],
-      (a: TraitWithMiddleTrait) => a.isInstanceOf[MiddleTrait]
-    )
-
-    val expected =
-      Schema.Enum2[TraitLeaf.type, MiddleTrait, TraitWithMiddleTrait](
-        TypeId.parse("zio.schema.DeriveSchemaSpec.TraitWithMiddleTrait"),
-        traitLeafCase,
-        middleTraitCase,
-        enum2Annotations
-      )
-
-    assert(derived)(hasSameSchema(expected))
-  }
-
 }

zio-schema-json/shared/src/test/scala/zio/schema/codec/JsonCodecSpec.scala

@@ -1789,6 +1789,12 @@ object JsonCodecSpec extends ZIOSpecDefault {
           RecordExampleWithDiscriminator(f1 = Some("test"), f2 = None)
         )
       },
+      test("nested ADT with discriminator field") {
+        assertEncodesThenDecodes(
+          Schema[GeoJSON.GeoJSON],
+          GeoJSON.Feature(geometry = GeoJSON.Point(1.0 -> 2.0))
+        )
+      } @@ TestAspect.scala2Only,
       test("of case classes with discriminator") {
         assertEncodesThenDecodes(Schema[Command], Command.Cash) &>
           assertEncodesThenDecodes(Schema[Command], Command.Buy(100))
@@ -3094,4 +3100,29 @@ object JsonCodecSpec extends ZIOSpecDefault {
   object BigProduct {
     implicit val schema: Schema[BigProduct] = DeriveSchema.gen
   }
+
+  object GeoJSON {
+    @discriminatorName("type") sealed trait Geometry                            extends Product with Serializable
+    @discriminatorName("type") sealed trait SimpleGeometry                      extends Geometry
+    case class Point(coordinates: (Double, Double))                             extends SimpleGeometry
+    case class MultiPoint(coordinates: Chunk[(Double, Double)])                 extends SimpleGeometry
+    case class LineString(coordinates: Chunk[(Double, Double)])                 extends SimpleGeometry
+    case class MultiLineString(coordinates: Chunk[Chunk[(Double, Double)]])     extends SimpleGeometry
+    case class Polygon(coordinates: Chunk[Chunk[(Double, Double)]])             extends SimpleGeometry
+    case class MultiPolygon(coordinates: Chunk[Chunk[Chunk[(Double, Double)]]]) extends SimpleGeometry
+    case class GeometryCollection(geometries: Chunk[SimpleGeometry])            extends Geometry
+    @discriminatorName("type") sealed trait GeoJSON                             extends Product with Serializable
+    @discriminatorName("type") sealed trait SimpleGeoJSON                       extends GeoJSON
+    case class Feature(
+      properties: Map[String, String] = Map.empty,
+      geometry: Geometry,
+      bbox: Option[(Double, Double, Double, Double)] = None
+    ) extends SimpleGeoJSON
+    case class FeatureCollection(features: Chunk[SimpleGeoJSON], bbox: Option[(Double, Double, Double, Double)] = None)
+        extends GeoJSON
+
+    object GeoJSON {
+      implicit lazy val schema: Schema[GeoJSON] = DeriveSchema.gen
+    }
+  }
 }