Make DynamicValue.fromSchemaAndValue and codecs stack safe

.sbtopts

@@ -1,5 +1,3 @@
--J-Xss512M
-
 -J-Xms5120m
 -J-Xmx5120m
 -J-XX:MaxMetaspaceSize=1024m

tests/shared/src/test/scala-2/zio/schema/DynamicValueSpec.scala

@@ -10,80 +10,97 @@ object DynamicValueSpec extends ZIOSpecDefault {
 
   def spec: Spec[Environment, Any] =
     suite("DynamicValueSpec")(
-      suite("Primitives")(primitiveTests: _*),
-      test("round-trips Records") {
-        check(SchemaGen.anyRecordOfRecordsAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+      suite("round-trip")(
+        suite("Primitives")(primitiveTests: _*),
+        test("round-trips Records") {
+          check(SchemaGen.anyRecordOfRecordsAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Enumerations") {
+          check(SchemaGen.anyEnumerationAndValue) {
+            case (schema, a) =>
+              assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Eithers") {
+          check(SchemaGen.anyEitherAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Tuples") {
+          check(SchemaGen.anyTupleAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Optionals") {
+          check(SchemaGen.anyOptionalAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Transform") {
+          check(SchemaGen.anyTransformAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips CaseClass") {
+          check(SchemaGen.anyCaseClassAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips Enum") {
+          check(SchemaGen.anyEnumAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips any un-nested schema") {
+          check(SchemaGen.anyLeafAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips any nested schema") {
+          check(SchemaGen.anyTree(1).flatMap(s => DynamicValueGen.anyDynamicValueOfSchema(s).map(s -> _))) {
+            case (schema, dynamic) =>
+              assert(schema.fromDynamic(dynamic))(isRight)
+          }
+        },
+        test("round-trips recursive data types") {
+          check(SchemaGen.anyRecursiveTypeAndValue) {
+            case (schema, a) =>
+              assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips sequence") {
+          check(SchemaGen.anySequenceAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips set") {
+          check(SchemaGen.anySetAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
+        },
+        test("round-trips map") {
+          check(SchemaGen.anyMapAndValue) {
+            case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
+          }
         }
-      },
-      test("round-trips Enumerations") {
-        check(SchemaGen.anyEnumerationAndValue) {
-          case (schema, a) =>
-            assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips Eithers") {
-        check(SchemaGen.anyEitherAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips Tuples") {
-        check(SchemaGen.anyTupleAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips Optionals") {
-        check(SchemaGen.anyOptionalAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips Transform") {
-        check(SchemaGen.anyTransformAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips CaseClass") {
-        check(SchemaGen.anyCaseClassAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips Enum") {
-        check(SchemaGen.anyEnumAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips any un-nested schema") {
-        check(SchemaGen.anyLeafAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips any nested schema") {
-        check(SchemaGen.anyTree(1).flatMap(s => DynamicValueGen.anyDynamicValueOfSchema(s).map(s -> _))) {
-          case (schema, dynamic) =>
-            assert(schema.fromDynamic(dynamic))(isRight)
-        }
-      },
-      test("round-trips recursive data types") {
-        check(SchemaGen.anyRecursiveTypeAndValue) {
-          case (schema, a) =>
-            assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips sequence") {
-        check(SchemaGen.anySequenceAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips set") {
-        check(SchemaGen.anySetAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      },
-      test("round-trips map") {
-        check(SchemaGen.anyMapAndValue) {
-          case (schema, a) => assert(schema.fromDynamic(schema.toDynamic(a)))(isRight(equalTo(a)))
-        }
-      }
+      ),
+      suite("stack safety")(
+        test("fromSchemaAndValue is stack safe") {
+          check(Json.genDeep) { json =>
+            val _ = DynamicValue.fromSchemaAndValue(Json.schema, json)
+            assertCompletes
+          }
+        } @@ TestAspect.sized(100),
+        test("toTyped is stack safe") {
+          check(Json.genDeep) { json =>
+            val dyn   = DynamicValue.fromSchemaAndValue(Json.schema, json)
+            val json2 = dyn.toTypedValue(Json.schema)
+            assertTrue(json2 == Right(json))
+          }
+        } @@ TestAspect.sized(250)
+      )
     )
 
   val primitiveTests: List[Spec[Sized with TestConfig, Nothing]] = schemasAndGens.map {

tests/shared/src/test/scala-2/zio/schema/SchemaGen.scala

@@ -632,6 +632,18 @@ object SchemaGen {
         keys   <- Gen.setOfN(3)(Gen.string)
         values <- Gen.setOfN(3)(leafGen)
       } yield JObject(keys.zip(values).toList)
+
+    val genDeep: Gen[Sized, Json] =
+      Gen.sized { max =>
+        Gen.bounded(1, max) { depth =>
+          leafGen.map { leaf =>
+            (1 to depth).foldLeft(leaf) {
+              case (gen, n) =>
+                JObject(List(n.toString -> gen))
+            }
+          }
+        }
+      }
   }
 
   lazy val anyRecursiveType: Gen[Sized, Schema[_]] =
@@ -643,6 +655,12 @@ object SchemaGen {
       value  <- Json.gen
     } yield (schema, value)
 
+  lazy val anyDeepRecursiveTypeAndValue: Gen[Sized, SchemaAndValue[_]] =
+    for {
+      schema <- Gen.const(Schema[Json])
+      value  <- Json.genDeep
+    } yield (schema, value)
+
   lazy val anyDynamic: Gen[Any, Schema[DynamicValue]] = Gen.const(Schema.dynamicValue)
 
   case class SchemaTest[A](name: String, schema: StandardType[A], gen: Gen[Sized, A])

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

@@ -569,6 +569,12 @@ object JsonCodecSpec extends ZIOSpecDefault {
             assertEncodesThenDecodes(schema, value)
         }
       },
+      test("deep recursive data type") {
+        check(SchemaGen.anyDeepRecursiveTypeAndValue) {
+          case (schema, value) =>
+            assertEncodesThenDecodes(schema, value)
+        }
+      } @@ TestAspect.sized(200),
       suite("dynamic")(
         test("dynamic int") {
           check(