Fix handling of annotations for Lazy (and thus failing tests)

zio-schema-json/shared/src/main/scala/zio/schema/codec/JsonCodec.scala

@@ -109,7 +109,7 @@ object JsonCodec extends Codec {
       case Schema.Fail(_, _)                  => unitEncoder.contramap(_ => ())
       case Schema.GenericRecord(structure, _) => recordEncoder(structure.toChunk)
       case EitherSchema(left, right, _)       => JsonEncoder.either(schemaEncoder(left), schemaEncoder(right))
-      case l @ Schema.Lazy(_, _)              => schemaEncoder(l.schema)
+      case l @ Schema.Lazy(_)                 => schemaEncoder(l.schema)
       case Schema.Meta(_, _)                  => astEncoder
       case ProductEncoder(encoder)            => encoder
       case Schema.Enum1(c, _)                 => enumEncoder(c)
@@ -196,7 +196,7 @@ object JsonCodec extends Codec {
       case Schema.Fail(message, _)             => failDecoder(message)
       case Schema.GenericRecord(structure, _)  => recordDecoder(structure.toChunk)
       case Schema.EitherSchema(left, right, _) => JsonDecoder.either(schemaDecoder(left), schemaDecoder(right))
-      case l @ Schema.Lazy(_, _)               => schemaDecoder(l.schema)
+      case l @ Schema.Lazy(_)                  => schemaDecoder(l.schema)
       case Schema.Meta(_, _)                   => astDecoder
       case ProductDecoder(decoder)             => decoder
       case Schema.Enum1(c, _)                  => enumDecoder(c)

zio-schema-protobuf/shared/src/main/scala/zio/schema/codec/ProtobufCodec.scala

@@ -91,7 +91,7 @@ object ProtobufCodec extends Codec {
       case _: Schema.Optional[_]             => false
       case _: Schema.Fail[_]                 => false
       case _: Schema.EitherSchema[_, _]      => false
-      case lzy @ Schema.Lazy(_, _)           => canBePacked(lzy.schema)
+      case lzy @ Schema.Lazy(_)              => canBePacked(lzy.schema)
       case _                                 => false
     }
 
@@ -141,7 +141,7 @@ object ProtobufCodec extends Codec {
         case (Schema.Tuple(left, right, _), v @ (_, _))              => encodeTuple(fieldNumber, left, right, v)
         case (Schema.Optional(codec, _), v: Option[_])               => encodeOptional(fieldNumber, codec, v)
         case (Schema.EitherSchema(left, right, _), v: Either[_, _])  => encodeEither(fieldNumber, left, right, v)
-        case (lzy @ Schema.Lazy(_, _), v)                            => encode(fieldNumber, lzy.schema, v)
+        case (lzy @ Schema.Lazy(_), v)                               => encode(fieldNumber, lzy.schema, v)
         case (Schema.Meta(ast, _), _)                                => encode(fieldNumber, Schema[SchemaAst], ast)
         case ProductEncoder(encode)                                  => encode(fieldNumber)
         case (Schema.Enum1(c, _), v)                                 => encodeEnum(fieldNumber, v, c)
@@ -449,7 +449,7 @@ object ProtobufCodec extends Codec {
         case Schema.Optional(codec, _)           => optionalDecoder(codec)
         case Schema.Fail(message, _)             => fail(message)
         case Schema.EitherSchema(left, right, _) => eitherDecoder(left, right)
-        case lzy @ Schema.Lazy(_, _)             => decoder(lzy.schema)
+        case lzy @ Schema.Lazy(_)                => decoder(lzy.schema)
         case Schema.Meta(_, _)                   => astDecoder
         case ProductDecoder(decoder)             => decoder
         case Schema.Enum1(c, _)                  => enumDecoder(c)
@@ -506,8 +506,8 @@ object ProtobufCodec extends Codec {
         }
 
     private def packedSequenceDecoder[A](schema: Schema[A]): Decoder[Chunk[A]] = schema match {
-      case lzy @ Schema.Lazy(_, _) => decoder(lzy.schema).loop
-      case _                       => decoder(schema).loop
+      case lzy @ Schema.Lazy(_) => decoder(lzy.schema).loop
+      case _                    => decoder(schema).loop
     }
 
     private def nonPackedSequenceDecoder[A](schema: Schema[A]): Decoder[Chunk[A]] =

zio-schema/shared/src/main/scala/zio/schema/Diff.scala

@@ -101,7 +101,7 @@ object Differ {
     case Schema.Optional(schema, _)                          => fromSchema(schema).optional
     case Schema.Sequence(schema, _, f, _)                    => fromSchema(schema).foreach(f)
     case Schema.EitherSchema(leftSchema, rightSchema, _)     => either(fromSchema(leftSchema), fromSchema(rightSchema))
-    case s @ Schema.Lazy(_, _)                               => fromSchema(s.schema)
+    case s @ Schema.Lazy(_)                                  => fromSchema(s.schema)
     case Schema.Transform(schema, _, f, _)                   => fromSchema(schema).transformOrFail(f)
     case Schema.Fail(_, _)                                   => fail
     case Schema.GenericRecord(structure, _)                  => record(structure.toChunk)
@@ -440,7 +440,7 @@ sealed trait Diff { self =>
       case (Primitive(StandardType.Duration(_), _), Temporal(dist1 :: dist2 :: Nil)) => Right(JDuration.ofSeconds(a.getSeconds - dist1, a.getNano() - dist2))
       // TODO need to deal with leap year differences
       case (Primitive(StandardType.MonthDay, _), Temporal(regDiff :: _ :: Nil)) => Right(MonthDay.from(ChronoUnit.DAYS.addTo(a.atYear(2001), regDiff.toLong)))
-      case (s @ Schema.Lazy(_, _), diff)                                        => diff.patch(a)(s.schema)
+      case (s @ Schema.Lazy(_), diff)                                           => diff.patch(a)(s.schema)
       case (Optional(_, _), Total(_, Diff.Tag.Left))                            => Right(None)
       case (Optional(_, _), Total(right, Diff.Tag.Right))                       => Right(Some(right))
       case (Optional(schema, _), diff) =>

zio-schema/shared/src/main/scala/zio/schema/DynamicValue.scala

@@ -67,7 +67,7 @@ trait DynamicValue { self =>
       case (DynamicValue.Transform(value), Schema.Transform(schema, f, _, _)) =>
         value.toTypedValue(schema).flatMap(f)
 
-      case (_, l @ Schema.Lazy(_, _)) =>
+      case (_, l @ Schema.Lazy(_)) =>
         toTypedValue(l.schema)
 
       case (DynamicValue.Error(message), _) =>
@@ -85,7 +85,7 @@ object DynamicValue {
   def fromSchemaAndValue[A](schema: Schema[A], value: A): DynamicValue =
     schema match {
 
-      case l @ Schema.Lazy(_, _) => fromSchemaAndValue(l.schema, value)
+      case l @ Schema.Lazy(_) => fromSchemaAndValue(l.schema, value)
 
       case Schema.Primitive(p, _) => DynamicValue.Primitive(value, p)
 

zio-schema/shared/src/main/scala/zio/schema/Schema.scala

@@ -331,8 +331,7 @@ object Schema extends TupleSchemas with RecordSchemas with EnumSchemas {
 
   }
 
-  final case class Lazy[A](private val schema0: () => Schema[A], annotations: Chunk[Any] = Chunk.empty)
-      extends Schema[A] {
+  final case class Lazy[A](private val schema0: () => Schema[A]) extends Schema[A] {
     override type Accessors[Lens[_, _], Prism[_, _], Traversal[_, _]] = schema.Accessors[Lens, Prism, Traversal]
 
     lazy val schema: Schema[A] = schema0()
@@ -341,6 +340,8 @@ object Schema extends TupleSchemas with RecordSchemas with EnumSchemas {
       schema.makeAccessors(b)
 
     override def toString: String = "$Lazy$"
+
+    override def annotations: Chunk[Any] = schema0().annotations
   }
 
   final case class Meta(ast: SchemaAst, annotations: Chunk[Any] = Chunk.empty) extends Schema[Schema[_]] {

zio-schema/shared/src/main/scala/zio/schema/ast/SchemaAst.scala

@@ -189,7 +189,7 @@ object SchemaAst {
     case Schema.Sequence(schema, _, _, _) =>
       subtree(NodePath.root, Chunk.empty, schema, dimensions = 1)
     case Schema.Transform(schema, _, _, _) => subtree(NodePath.root, Chunk.empty, schema)
-    case lzy @ Schema.Lazy(_, _)           => fromSchema(lzy.schema)
+    case lzy @ Schema.Lazy(_)              => fromSchema(lzy.schema)
     case s: Schema.Record[A] =>
       s.structure
         .foldLeft(NodeBuilder(NodePath.root, Chunk(s.hashCode() -> NodePath.root))) { (node, field) =>
@@ -236,7 +236,7 @@ object SchemaAst {
           case Schema.Sequence(schema, _, _, _) =>
             subtree(path, lineage, schema, optional, dimensions + 1)
           case Schema.Transform(schema, _, _, _) => subtree(path, lineage, schema, optional, dimensions)
-          case lzy @ Schema.Lazy(_, _)           => subtree(path, lineage, lzy.schema, optional, dimensions)
+          case lzy @ Schema.Lazy(_)              => subtree(path, lineage, lzy.schema, optional, dimensions)
           case s: Schema.Record[_] =>
             s.structure
               .foldLeft(NodeBuilder(path, lineage :+ (s.hashCode() -> path), optional, dimensions)) { (node, field) =>

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

@@ -18,7 +18,7 @@ object DeriveSchemaSpec extends DefaultRunnableSpec {
   sealed case class UserId(id: String)
 
   @annotation1("foo")
-  sealed case class User(name: String, @annotation1("foo") @annotation2("bar") id: UserId)
+  sealed case class User(name: String, @annotation1("foo") @annotation2("bar") userId: UserId)
 
   sealed trait Status
   case class Ok(response: List[String]) extends Status
@@ -71,7 +71,7 @@ object DeriveSchemaSpec extends DefaultRunnableSpec {
         val derived: Schema[UserId] = Schema[UserId]
         val expected: Schema[UserId] =
           Schema.CaseClass1(
-            annotations = Chunk.empty,
+            annotations = Chunk(annotation1("bar")),
             field = Schema.Field("id", Schema.Primitive(StandardType.StringType)),
             UserId.apply,
             (uid: UserId) => uid.id
@@ -89,12 +89,12 @@ object DeriveSchemaSpec extends DefaultRunnableSpec {
         val derived: Schema[User] = Schema[User]
         val expected: Schema[User] =
           Schema.CaseClass2(
-            annotations = Chunk.empty,
+            annotations = Chunk(annotation1("foo")),
             field1 = Schema.Field("name", Schema.Primitive(StandardType.StringType)),
             field2 = Schema.Field(
-              "id",
+              "userId",
               Schema.CaseClass1(
-                annotations = Chunk.empty,
+                annotations = Chunk(annotation1("bar")),
                 field = Schema.Field("id", Schema.Primitive(StandardType.StringType, Chunk.empty)),
                 construct = UserId.apply,
                 extractField = (uid: UserId) => uid.id
@@ -103,7 +103,7 @@ object DeriveSchemaSpec extends DefaultRunnableSpec {
             ),
             User.apply,
             (u: User) => u.name,
-            (u: User) => u.id
+            (u: User) => u.userId
           )
         assert(derived)(hasSameSchema(expected))
       },

zio-schema/shared/src/test/scala/zio/schema/DynamicValueGen.scala

@@ -79,7 +79,7 @@ object DynamicValueGen {
         Gen.oneOf(anyDynamicLeftValueOfSchema(left), anyDynamicRightValueOfSchema(right))
       case Schema.Transform(schema, _, _, _) => anyDynamicValueOfSchema(schema).map(DynamicValue.Transform(_))
       case Schema.Fail(message, _)           => Gen.const(DynamicValue.Error(message))
-      case l @ Schema.Lazy(_, _)             => anyDynamicValueOfSchema(l.schema)
+      case l @ Schema.Lazy(_)                => anyDynamicValueOfSchema(l.schema)
       case Schema.Meta(meta, _)              => anyDynamicValueOfSchema(meta.toSchema)
     }
   //scalafmt: { maxColumn = 120 }

zio-schema/shared/src/test/scala/zio/schema/SchemaAssertions.scala

@@ -107,21 +107,12 @@ object SchemaAssertions {
       case (Schema.Enum3(l1, l2, l3, lA), Schema.Enum3(r1, r2, r3, rA)) =>
         hasSameCases(Seq(l1, l2, l3), Seq(r1, r2, r3)) && lA.equals(rA)
       case (Schema.EnumN(ls, lA), Schema.EnumN(rs, rA)) => hasSameCases(ls.toSeq, rs.toSeq) && lA.equals(rA)
-      case (l @ Schema.Lazy(_, a1), r @ Schema.Lazy(_, a2)) =>
-        equalsSchema(l.schema.asInstanceOf[Schema[Any]], r.schema.asInstanceOf[Schema[Any]]) && equalsAnnotations(
-          a1,
-          a2
-        )
-      case (lazySchema @ Schema.Lazy(_, a1), eagerSchema) =>
-        equalsSchema(lazySchema.schema.asInstanceOf[Schema[Any]], eagerSchema.asInstanceOf[Schema[Any]]) && equalsAnnotations(
-          a1,
-          eagerSchema.annotations
-        )
-      case (eagerSchema, lazySchema @ Schema.Lazy(_, a2)) =>
-        equalsSchema(lazySchema.asInstanceOf[Schema[Any]], eagerSchema.asInstanceOf[Schema[Any]]) && equalsAnnotations(
-          eagerSchema.annotations,
-          a2
-        )
+      case (l @ Schema.Lazy(_), r @ Schema.Lazy(_)) =>
+        equalsSchema(l.schema.asInstanceOf[Schema[Any]], r.schema.asInstanceOf[Schema[Any]])
+      case (lazySchema @ Schema.Lazy(_), eagerSchema) =>
+        equalsSchema(lazySchema.schema.asInstanceOf[Schema[Any]], eagerSchema.asInstanceOf[Schema[Any]])
+      case (eagerSchema, lazySchema @ Schema.Lazy(_)) =>
+        equalsSchema(lazySchema.asInstanceOf[Schema[Any]], eagerSchema.asInstanceOf[Schema[Any]])
       case _ => false
     }