⏺ Merge series/0.18 into series/0.19

  Includes:
  - Long literal rendering fix (L suffix) from disneystreaming#1898
  - Mill 1.x backport from disneystreaming#1899
  - Codegen Scala 3 cross-compilation
  - Recursive scheme caching improvements

  Generated files kept as 0.19 (Hints.dynamic) variants;
  Long literal fix carried through Renderer merge.

Author: yisraelU

CHANGELOG.md

@@ -97,6 +97,21 @@ Prevents using it as an implicit conversion in Scala 2
 
 The handwritten Java `TraitService` implementations for all smithy4s meta traits in the protocol module have been removed and are now generated by smithy4s itself. This should not affect users who are not programmatically using those traits directly. (see [#1901](https://github.com/disneystreaming/smithy4s/pull/1901))
 
+## Fix Long literal rendering in [#1898](https://github.com/disneystreaming/smithy4s/pull/1898)
+
+* codegen: Fix `Long` literal rendering to add `L` suffix, preventing `integer number too large` compilation errors for values exceeding `Int.MaxValue`
+
+# 0.18.49
+
+* mill codegen plugin: now supports Mill 1.x (tested with 1.1.1), in addition to the existing Mill 0.11.x and 0.12.x support
+* codegen: Cross comple codegen module against Scala 3
+* codegen: Fix `Long` literal rendering to add `L` suffix, preventing `integer number too large` compilation errors for values exceeding `Int.MaxValue` in [#1898](https://github.com/disneystreaming/smithy4s/pull/1898)
+
+# 0.18.48
+
+* codegen: Update codegen of numbers when using dynamic bindings in [#1886](https://github.com/disneystreaming/smithy4s/pull/1886)
+* codegen: Add type params to `struct` and `union` in codegen schemas in [#1893](https://github.com/disneystreaming/smithy4s/pull/1893)
+
 # 0.18.47
 
 * core: Add `asSurjection` method to `ValidatedNewtype` class (see [#1873](https://github.com/disneystreaming/smithy4s/pull/1873))

build.sbt

@@ -417,7 +417,8 @@ lazy val codegen = projectMatrix
       Dependencies.Circe.parser.value,
       Dependencies.Circe.generic.value,
       ("io.get-coursier" %% "coursier" % "2.1.24")
-        .cross(CrossVersion.for3Use2_13)
+        .cross(CrossVersion.for3Use2_13),
+      Dependencies.Mima.core % Test
     ),
     libraryDependencies ++= {
       if (scalaVersion.value.startsWith("2."))

modules/bootstrapped/src/generated/smithy4s/example/ArbitraryDataTest.scala

@@ -12,7 +12,7 @@ object ArbitraryDataTest extends ShapeTag.Companion[ArbitraryDataTest] {
   val id: ShapeId = ShapeId("smithy4s.example", "ArbitraryDataTest")
 
   val hints: Hints = Hints(
-    smithy4s.example.ArbitraryData(smithy4s.Document.obj("str" -> smithy4s.Document.fromString("hello"), "int" -> smithy4s.Document.fromLong(1), "bool" -> smithy4s.Document.fromBoolean(true), "arr" -> smithy4s.Document.array(smithy4s.Document.fromString("one"), smithy4s.Document.fromString("two"), smithy4s.Document.fromString("three")), "obj" -> smithy4s.Document.obj("str" -> smithy4s.Document.fromString("s"), "i" -> smithy4s.Document.fromLong(1)))),
+    smithy4s.example.ArbitraryData(smithy4s.Document.obj("str" -> smithy4s.Document.fromString("hello"), "int" -> smithy4s.Document.fromLong(1L), "bool" -> smithy4s.Document.fromBoolean(true), "arr" -> smithy4s.Document.array(smithy4s.Document.fromString("one"), smithy4s.Document.fromString("two"), smithy4s.Document.fromString("three")), "obj" -> smithy4s.Document.obj("str" -> smithy4s.Document.fromString("s"), "i" -> smithy4s.Document.fromLong(1L)))),
   ).lazily
 
 

modules/bootstrapped/src/generated/smithy4s/example/HealthResponse.scala

@@ -13,7 +13,7 @@ object HealthResponse extends ShapeTag.Companion[HealthResponse] {
   val id: ShapeId = ShapeId("smithy4s.example", "HealthResponse")
 
   val hints: Hints = Hints(
-    smithy4s.example.FreeForm(smithy4s.Document.obj("i" -> smithy4s.Document.fromLong(1), "a" -> smithy4s.Document.fromLong(2))),
+    smithy4s.example.FreeForm(smithy4s.Document.obj("i" -> smithy4s.Document.fromLong(1L), "a" -> smithy4s.Document.fromLong(2L))),
   ).lazily
 
   // constructor using the original order from the spec

modules/bootstrapped/src/generated/smithy4s/example/LeafNode.scala

@@ -0,0 +1,23 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.schema.Schema.int
+import smithy4s.schema.Schema.struct
+
+final case class LeafNode(value: Int)
+
+object LeafNode extends ShapeTag.Companion[LeafNode] {
+  val id: ShapeId = ShapeId("smithy4s.example", "LeafNode")
+
+  val hints: Hints = Hints.empty
+
+  // constructor using the original order from the spec
+  private def make(value: Int): LeafNode = LeafNode(value)
+
+  implicit val schema: Schema[LeafNode] = struct(
+    int.required[LeafNode]("value", _.value),
+  )(make).withId(id).addHints(hints)
+}

modules/bootstrapped/src/generated/smithy4s/example/Tree.scala

@@ -0,0 +1,67 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.recursive
+import smithy4s.schema.Schema.union
+
+sealed trait Tree extends scala.Product with scala.Serializable { self =>
+  @inline final def widen: Tree = this
+  def $ordinal: Int
+
+  object project {
+    def tree: Option[TreeNode] = Tree.TreeCase.alt.project.lift(self).map(_.tree)
+    def leaf: Option[LeafNode] = Tree.LeafCase.alt.project.lift(self).map(_.leaf)
+  }
+
+  def accept[A](visitor: Tree.Visitor[A]): A = this match {
+    case value: Tree.TreeCase => visitor.tree(value.tree)
+    case value: Tree.LeafCase => visitor.leaf(value.leaf)
+  }
+}
+object Tree extends ShapeTag.Companion[Tree] {
+
+  def tree(tree: TreeNode): Tree = TreeCase(tree)
+  def leaf(leaf: LeafNode): Tree = LeafCase(leaf)
+
+  val id: ShapeId = ShapeId("smithy4s.example", "Tree")
+
+  val hints: Hints = Hints.empty
+
+  final case class TreeCase(tree: TreeNode) extends Tree { final def $ordinal: Int = 0 }
+  final case class LeafCase(leaf: LeafNode) extends Tree { final def $ordinal: Int = 1 }
+
+  object TreeCase {
+    val hints: Hints = Hints.empty
+    val schema: Schema[Tree.TreeCase] = bijection(TreeNode.schema.addHints(hints), Tree.TreeCase(_), _.tree)
+    val alt = schema.oneOf[Tree]("tree")
+  }
+  object LeafCase {
+    val hints: Hints = Hints.empty
+    val schema: Schema[Tree.LeafCase] = bijection(LeafNode.schema.addHints(hints), Tree.LeafCase(_), _.leaf)
+    val alt = schema.oneOf[Tree]("leaf")
+  }
+
+  trait Visitor[A] {
+    def tree(value: TreeNode): A
+    def leaf(value: LeafNode): A
+  }
+
+  object Visitor {
+    trait Default[A] extends Visitor[A] {
+      def default: A
+      def tree(value: TreeNode): A = default
+      def leaf(value: LeafNode): A = default
+    }
+  }
+
+  implicit val schema: Schema[Tree] = recursive(union(
+    Tree.TreeCase.alt,
+    Tree.LeafCase.alt,
+  ){
+    _.$ordinal
+  }.withId(id).addHints(hints))
+}

modules/bootstrapped/src/generated/smithy4s/example/TreeNode.scala

@@ -0,0 +1,24 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.schema.Schema.recursive
+import smithy4s.schema.Schema.struct
+
+final case class TreeNode(left: Tree, right: Tree)
+
+object TreeNode extends ShapeTag.Companion[TreeNode] {
+  val id: ShapeId = ShapeId("smithy4s.example", "TreeNode")
+
+  val hints: Hints = Hints.empty
+
+  // constructor using the original order from the spec
+  private def make(left: Tree, right: Tree): TreeNode = TreeNode(left, right)
+
+  implicit val schema: Schema[TreeNode] = recursive(struct(
+    Tree.schema.required[TreeNode]("left", _.left),
+    Tree.schema.required[TreeNode]("right", _.right),
+  )(make).withId(id).addHints(hints))
+}

modules/bootstrapped/test/src/smithy4s/RecursiveSpec.scala

@@ -0,0 +1,139 @@
+package smithy4s
+
+import munit.FunSuite
+
+import smithy4s.example.{Tree, TreeNode, LeafNode, Foo}
+import cats.Hash
+import smithy4s.schema._
+import scala.annotation.tailrec
+import smithy4s.internals.maps.MMap
+import smithy4s.interopcats.SchemaVisitorHash
+import smithy4s.schema.Schema.recursive
+import smithy4s.schema.Schema._
+
+class RecursiveSpec extends FunSuite {
+
+  case class Recurse(n: Option[Recurse])
+
+  object Recurse {
+    implicit val schema: Schema[Recurse] = recursive {
+      struct(
+        schema.optional[Recurse]("n", _.n)
+      )(Recurse.apply)
+    }
+  }
+
+  def buildTree(size: Int): Tree = {
+    val seed = Math.round(Math.random() * 1000).toInt
+    val nodes = (1 to size).map(i => Tree.leaf(LeafNode(i * seed))).toList
+
+    @tailrec()
+    def recursiveFold(els: List[Tree]): Tree =
+      els match {
+        case head :: Nil => head
+        case x => {
+          val joined: List[Tree] = x
+            .sliding(2, 2)
+            .flatMap {
+              case left :: right :: Nil =>
+                List(Tree.tree(TreeNode(left, right)))
+              case x => x
+            }
+            .toList
+          recursiveFold(joined)
+        }
+      }
+
+    recursiveFold(nodes)
+  }
+
+  def buildRecursive(size: Int): Recurse =
+    (1 to size).foldLeft(Recurse(None))((tail, i) => Recurse(Some(tail)))
+
+  def useLazyTestCache[F[_]](store: MMap[Any, Any]) = new CompilationCache[F] {
+    override def getOrElseUpdate[A](
+        schema: Schema[A],
+        fetch: Schema[A] => F[A]
+    ): F[A] = {
+      store.getOrElseUpdate(schema, fetch(schema)).asInstanceOf[F[A]]
+    }
+  }
+
+  def ignoreLazyTestCache[F[_]](store: MMap[Any, Any]) =
+    new CompilationCache[F] {
+      override def getOrElseUpdate[A](
+          schema: Schema[A],
+          fetch: Schema[A] => F[A]
+      ): F[A] = {
+        if (schema.isInstanceOf[Schema.LazySchema[_]]) { fetch(schema) }
+        else store.getOrElseUpdate(schema, fetch(schema)).asInstanceOf[F[A]]
+      }
+    }
+
+  def runTest[A](
+      caseString: String,
+      value: Int => A,
+      buildCache: MMap[Any, Any] => CompilationCache[Hash],
+      transformSchema: Schema[A] => Schema[A] = (x: Schema[A]) => x
+  )(implicit schema: Schema[A]) =
+    test(s"$caseString") {
+      val store: MMap[Any, Any] = MMap.empty
+
+      val updatedSchema = transformSchema(schema)
+
+      val hashVisitor: Hash[A] =
+        SchemaVisitorHash.fromSchema(updatedSchema, buildCache(store))
+
+      // Invoke hash with a size that will have some recursion so that the build cache an be materialized
+      hashVisitor.hash(value(2))
+      val sizeAfterInitializing = store.size
+
+      val sizes = List(10, 100, 256)
+      sizes.foreach(i => hashVisitor.hash(value(i)))
+      val sizeAfterHashing = store.size
+
+      assertEquals(
+        sizeAfterHashing,
+        sizeAfterInitializing,
+        "cache store size has grown after initialization"
+      )
+    }
+
+  def addHints[A](schema: Schema[A]): Schema[A] = {
+    schema.transformHintsTransitively(
+      _.add(
+        smithy.api.Documentation("Adding some hints")
+      )
+    )
+  }
+
+  def runTestCases[A: Schema](caseString: String, value: Int => A) = {
+    runTest(
+      s"$caseString: current cache, hints unchanged",
+      value,
+      buildCache = ignoreLazyTestCache
+    )
+    runTest(
+      s"$caseString: current cache, hints transformed",
+      value,
+      buildCache = ignoreLazyTestCache,
+      transformSchema = addHints[A]
+    )
+    runTest(
+      s"$caseString: updated cache, hints unchanged",
+      value,
+      buildCache = useLazyTestCache
+    )
+    runTest(
+      s"$caseString: updated cache, hints transformed",
+      value,
+      buildCache = useLazyTestCache,
+      transformSchema = addHints[A]
+    )
+  }
+
+  runTestCases("Foo", Foo.int)
+  runTestCases("Tree", buildTree)
+  runTestCases("Recurse", buildRecursive)
+
+}

modules/bootstrapped/test/src/smithy4s/http/AcceptHeaderSpec.scala

@@ -33,7 +33,7 @@ final class AcceptHeaderSpec extends FunSuite {
       try fa
       catch { case e: Throwable => f(e) }
     def pure[A](a: A): Id[A] = a
-    def zipMapAll[A](seq: IndexedSeq[Id[Any]])(f: IndexedSeq[Any] => A): Id[A] =
+    def zipMapAll[A,B](seq: IndexedSeq[Id[A]])(f: IndexedSeq[A] => B): Id[B] =
       f(seq)
   }