Exciting Clause related alterations

modules/microsite/src/main/scala/DocsHelpers.scala

@@ -98,7 +98,7 @@ object DocsHelpers {
           q"""
           def routes(...${parms}): ${rtpe} = ${Term.Apply(
               fun = q"HttpRoutes.of",
-              args = List(Term.Block(stats = List(Term.PartialFunction(cases = cases.take(2)))))
+              argClause = Term.ArgClause(List(Term.Block(stats = List(Term.PartialFunction(cases = cases.take(2))))))
             )}
         """
         }.toList

modules/scala-akka-http/src/main/scala/dev/guardrail/generators/scala/akkaHttp/AkkaHttpClientGenerator.scala

@@ -399,7 +399,7 @@ class AkkaHttpClientGenerator private (modelGeneratorType: ModelGeneratorType) e
             HttpProtocols.`HTTP/1.1`
           ).flatMap(req =>
             EitherT(${httpClientName}(req).flatMap(resp =>
-              ${Term.Match(q"resp.status", cases)}
+              ${Term.Match(q"resp.status", cases, Nil)}
             ).recover({
               case e: Throwable =>
                 Left(Left(e))
@@ -557,17 +557,15 @@ class AkkaHttpClientGenerator private (modelGeneratorType: ModelGeneratorType) e
       )
     }
 
-    def paramsToArgs(params: List[List[Term.Param]]): List[List[Term]] =
-      params.map {
-        _.map(_.name.value)
+    def paramsToArgs(params: List[List[Term.Param]]): List[Term.ArgClause] =
+      params.map { params =>
+        Term.ArgClause(params.map(_.name.value)
           .map(v => Term.Assign(Term.Name(v), Term.Name(v)))
           .toList
+          )
       }.toList
 
-    val ctorCall: Term.New =
-      q"""
-          new ${Type.Name(clientName)}(...${paramsToArgs(ctorArgs)})
-        """
+    val ctorCall: Term.New = Term.New(Init(Type.Name(clientName), Name.Anonymous(), paramsToArgs(ctorArgs)))
 
     for {
       extraDecls <- extraConstructors(tracingName, serverUrls, Type.Name(clientName), ctorCall, tracing)

modules/scala-akka-http/src/main/scala/dev/guardrail/generators/scala/akkaHttp/AkkaHttpServerGenerator.scala

@@ -295,16 +295,20 @@ class AkkaHttpServerGenerator private (akkaHttpVersion: AkkaHttpVersion, modelGe
           ${Defn.Def(
           List(mod"implicit"),
           Term.Name(s"${responseClsName.uncapitalized}TRM"),
-          tparams = List.empty,
-          NonEmptyList.fromList(protocolImplicits).fold(List.empty[List[Term.Param]])(nel => List(nel.toList)),
+
+          List(Member.ParamClauseGroup(
+            Type.ParamClause(Nil),
+            NonEmptyList.fromList(protocolImplicits).fold(List.empty[Term.ParamClause])(nel => List(Term.ParamClause(nel.toList))),
+          )),
+
           Some(t"ToResponseMarshaller[${responseSuperType}]"),
           q"""Marshaller { implicit ec => resp => ${Term.Name(s"${responseClsName.uncapitalized}TR")}(resp) }"""
         )};
             implicit def ${Term
           .Name(
             s"${responseClsName.uncapitalized}TR"
           )}(value: ${responseSuperType})(..$toResponseImplicits): scala.concurrent.Future[List[Marshalling[HttpResponse]]] =
-              ${Term.Match(Term.Name("value"), marshallers)}
+              ${Term.Match(Term.Name("value"), marshallers, Nil)}
 
             def apply[T](value: T)(implicit ev: T => ${responseSuperType}): ${responseSuperType} = ev(value)
 
@@ -681,7 +685,7 @@ class AkkaHttpServerGenerator private (akkaHttpVersion: AkkaHttpVersion, modelGe
                         val ${collected.toVar} = successes.collectFirst(${Term.PartialFunction(
                         List(
                           Case(
-                            Pat.Extract(Term.Select(partsTerm, containerName.toTerm), List(pats)),
+                            Pat.Extract(Term.Select(partsTerm, containerName.toTerm), Pat.ArgClause(List(pats))),
                             None,
                             terms
                           )
@@ -878,7 +882,7 @@ class AkkaHttpServerGenerator private (akkaHttpVersion: AkkaHttpVersion, modelGe
                             Nil
                           }
                         }).mapAsync(1)(${Term.Block(
-                      List(Term.Function(List(Term.Param(List.empty, q"part", None, None)), Term.Match(q"part.name", allCases)))
+                      List(Term.Function(Term.ParamClause(List(Term.Param(List.empty, q"part", None, None))), Term.Match(q"part.name", allCases, Nil)))
                     )})
                           .toMat(Sink.seq[Either[Throwable, ${Type.Select(partsTerm, Type.Name("Part"))}]])(Keep.right).run()
                       } yield {
@@ -1056,11 +1060,11 @@ class AkkaHttpServerGenerator private (akkaHttpVersion: AkkaHttpVersion, modelGe
               .fold[Term => Term](identity)(_.foldLeft[Term => Term](identity) { case (acc, (directive, params)) =>
                 params match {
                   case List() =>
-                    next => acc(Term.Apply(directive, List(next)))
+                    next => acc(Term.Apply(directive, Term.ArgClause(List(next))))
                   case xs =>
                     next =>
                       acc(
-                        Term.Apply(Term.Select(directive, Term.Name("apply")), List(Term.Function(xs.map(x => Term.Param(List.empty, x, None, None)), next)))
+                        Term.Apply(Term.Select(directive, Term.Name("apply")), Term.ArgClause(List(Term.Function(Term.ParamClause(xs.map(x => Term.Param(List.empty, x, None, None))), next))))
                       )
                 }
               })
@@ -1146,8 +1150,10 @@ class AkkaHttpServerGenerator private (akkaHttpVersion: AkkaHttpVersion, modelGe
       } yield Defn.Def(
         mods = List.empty,
         Term.Name(s"${methodName}Decoder"),
-        tparams = List.empty,
-        NonEmptyList.fromList(decoderImplicits).fold(List.empty[List[Term.Param]])(nel => List(nel.toList)),
+        List(Member.ParamClauseGroup(
+          Type.ParamClause(Nil),
+          NonEmptyList.fromList(decoderImplicits).fold(List.empty[List[Term.Param]])(nel => List(Term.ParamClause(nel.toList))),
+        )),
         Some(t"FromRequestUnmarshaller[$baseType]"),
         q"""
               val extractEntity = implicitly[Unmarshaller[HttpMessage, HttpEntity]]

modules/scala-dropwizard/src/main/scala/dev/guardrail/generators/scala/dropwizard/DropwizardServerGenerator.scala

@@ -172,22 +172,22 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
   }
 
   private def unwrapContainer(tpe: Type): (Type, Type => Type) = {
-    def rewrap(wrapper: Type)(tpe: Type): Type = Type.Apply(wrapper, List(tpe))
+    def rewrap(wrapper: Type)(tpe: Type): Type = Type.Apply(wrapper, Type.ArgClause(List(tpe)))
     tpe match {
       case t"Option[$inner]"       => (inner, rewrap(t"Option"))
       case t"Vector[$inner]"       => (inner, rewrap(t"Vector"))
       case t"List[$inner]"         => (inner, rewrap(t"List"))
       case t"Seq[$inner]"          => (inner, rewrap(t"Seq"))
       case t"IndexedSeq[$inner]"   => (inner, rewrap(t"IndexedSeq"))
       case t"Iterable[$inner]"     => (inner, rewrap(t"Iterable"))
-      case t"Map[$keyTpe, $inner]" => (inner, x => Type.Apply(t"Map", List(keyTpe, x)))
+      case t"Map[$keyTpe, $inner]" => (inner, x => Type.Apply(t"Map", Type.ArgClause(List(keyTpe, x))))
       case other                   => (other, identity)
     }
   }
 
   private object paramTransformers {
     private def annotateHttpParameter(parameterName: RawParameterName, annotationName: Option[String])(param: Term.Param): Term.Param = param.copy(
-      mods = annotationName.map(an => Mod.Annot(Init(Type.Name(an), Name.Anonymous(), List(List(Lit.String(parameterName.value)))))).toList ++ param.mods
+      mods = annotationName.map(an => Mod.Annot(Init(Type.Name(an), Name.Anonymous(), List(Term.ArgClause(List(Lit.String(parameterName.value)), None))))).toList ++ param.mods
     )
 
     private def handleDefaultValue(defaultValue: Option[Term])(param: Term.Param): Term.Param = param.copy(
@@ -204,7 +204,7 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
           case Lit.Double(d)     => Some(Lit.String(d))
           case _                 => None
         }
-        defaultStr.map(s => Mod.Annot(Init(Type.Name("DefaultValue"), Name.Anonymous(), List(List(s)))))
+        defaultStr.map(s => Mod.Annot(Init(Type.Name("DefaultValue"), Name.Anonymous(), List(Term.ArgClause(List(s))))))
       }.toList ++ param.mods,
       default = None
     )
@@ -231,7 +231,7 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
 
     def stripOptionFromCollections(param: Term.Param): Term.Param = param.copy(
       decltpe = param.decltpe.map {
-        case Type.Apply(t"Option", List(Type.Apply(containerType, innerTypes))) if CONTAINER_TYPES.contains(containerType.toString) =>
+        case Type.Apply.After_4_6_0(t"Option", Type.ArgClause(List(Type.Apply.After_4_6_0(containerType, innerTypes)))) if CONTAINER_TYPES.contains(containerType.toString) =>
           t"$containerType[..$innerTypes]"
         case other => other
       }
@@ -436,7 +436,7 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
         val pathSuffix     = ResponseHelpers.splitPathComponents(path.unwrapTracker).drop(commonPathPrefix.length).mkString("/", "/", "")
         val pathAnnotation = Option(pathSuffix).filter(_.nonEmpty).filterNot(_ == "/").map(p => mod"@Path(${Lit.String(p)})")
 
-        val httpMethodAnnotation = Mod.Annot(Init(Type.Name(method.name()), Name.Anonymous(), List.empty))
+        val httpMethodAnnotation = Mod.Annot(Init(Type.Name(method.name()), Name.Anonymous(), List.empty[Term.ArgClause]))
 
         val allConsumes        = operation.downField("consumes", _.consumes).map(_.flatMap(ContentType.unapply)).unwrapTracker
         val consumes           = ResponseHelpers.getBestConsumes(operation, allConsumes, parameters)
@@ -482,8 +482,8 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
           val nameTerm = Term.Name(param.name.value)
           param.decltpe.fold[Term](nameTerm) {
             case Type.Select(Term.Select(q"java", q"time"), _)                              => q"$nameTerm.get"
-            case Type.Apply(_, List(Type.Select(Term.Select(q"java", q"time"), _)))         => q"$nameTerm.map(_.get)"
-            case Type.Apply(t"Map", List(_, Type.Select(Term.Select(q"java", q"time"), _))) => q"$nameTerm.mapValues(_.get)"
+            case Type.Apply.After_4_6_0(_, List(Type.Select(Term.Select(q"java", q"time"), _)))         => q"$nameTerm.map(_.get)"
+            case Type.Apply.After_4_6_0(t"Map", List(_, Type.Select(Term.Select(q"java", q"time"), _))) => q"$nameTerm.mapValues(_.get)"
             case _                                                                          => nameTerm
           }
         }
@@ -494,7 +494,7 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
           response.value.fold(
             p"case $resourceNameTerm.$responseClsSubTerm => responseBuilder.build()"
           ) { _ =>
-            p"case ${Pat.Extract(Term.Select(resourceNameTerm, responseClsSubTerm), List(p"value"))} => responseBuilder.entity(value).build()"
+            p"case ${Pat.Extract(Term.Select(resourceNameTerm, responseClsSubTerm), Pat.ArgClause(List(p"value")))} => responseBuilder.entity(value).build()"
           }
         }
 
@@ -509,7 +509,7 @@ class DropwizardServerGenerator private extends ServerTerms[ScalaLanguage, Targe
              this.handler.$methodNameTerm($responseClsTerm)(..$handlerArgs).onComplete({
                case scala.util.Success(result) =>
                  val responseBuilder = Response.status(result.statusCode)
-                 val response = ${Term.Match(Term.Name("result"), responseCases)}
+                 val response = ${Term.Match(Term.Name("result"), responseCases, Nil)}
                  asyncResponse.resume(response)
                case scala.util.Failure(err) =>
                  logger.error("{} threw an exception ({}): {}", ${Lit.String(s"$resourceName.$methodName")}, err.getClass.getName, err.getMessage, err)

modules/scala-http4s/src/main/scala/dev/guardrail/generators/scala/http4s/Http4sClientGenerator.scala

@@ -539,21 +539,18 @@ class Http4sClientGenerator(version: Http4sVersion) extends ClientTerms[ScalaLan
       )
     }
 
-    def paramsToArgs(params: List[List[Term.Param]]): List[List[Term]] =
-      params.map {
-        _.map(_.name.value)
+    def paramsToArgs(params: List[List[Term.Param]]): List[Term.ArgClause] =
+      params.map { params =>
+        Term.ArgClause(params.map(_.name.value)
           .map(v => Term.Assign(Term.Name(v), Term.Name(v)))
           .toList
+          )
       }.toList
 
-    val ctorCall: Term.New =
-      q"""
-          new ${Type
-          .Apply(Type.Name(clientName), List(Type.Name("F")))}(...${paramsToArgs(ctorArgs)})
-        """
+    val ctorCall: Term.New = Term.New(Init(Type.Apply(Type.Name(clientName), Type.ArgClause(List(Type.Name("F")))), Name.Anonymous(), paramsToArgs(ctorArgs)))
 
     val decls: List[Defn] =
-      q"""def apply[F[_]](...${ctorArgs}): ${Type.Apply(Type.Name(clientName), List(Type.Name("F")))} = ${ctorCall}""" +:
+      q"""def apply[F[_]](...${ctorArgs}): ${Type.Apply(Type.Name(clientName), Type.ArgClause(List(Type.Name("F"))))} = ${ctorCall}""" +:
         extraConstructors(tracingName, serverUrls, Type.Name(clientName), ctorCall, tracing)
     Target.pure(
       StaticDefns[ScalaLanguage](

modules/scala-http4s/src/main/scala/dev/guardrail/generators/scala/http4s/Http4sServerGenerator.scala

@@ -284,7 +284,7 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
 
     val errorTermName = Term.Name(authErrorTypeName.value)
     val (simpleAuthErrors, simpleAuthenticator) = if (authImplementation == AuthImplementation.Simple) {
-      val errorInit = Init(authErrorTypeName, Name(""), List.empty)
+      val errorInit = Init(authErrorTypeName, Name(""), List.empty[Term.ArgClause])
       val authErrors = List(
         q"""sealed trait $authErrorTypeName""",
         q"""
@@ -330,7 +330,7 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
           else Target.log.warning(s"Security requirement '${reqName.unwrapTracker}' is missing in security schemes (${reqName.showHistory})")
 
         existanceCheck *> Target.pure(q"""
-          case object ${securitySchemeNameToClassName(reqName.unwrapTracker)} extends ${Init(authSchemesTypeName, Name(""), List.empty)} {
+          case object ${securitySchemeNameToClassName(reqName.unwrapTracker)} extends ${Init(authSchemesTypeName, Name(""), List.empty[Term.ArgClause])} {
             override val name: String = ${Lit.String(reqName.unwrapTracker)}
           }
         """)
@@ -346,8 +346,8 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
 
               sealed trait $authRequirementTypeName
               object ${Term.Name(authRequirementTypeName.value)} {
-                case object Required extends ${Init(authRequirementTypeName, Name(""), List.empty)}
-                case object Optional extends ${Init(authRequirementTypeName, Name(""), List.empty)}
+                case object Required extends ${Init(authRequirementTypeName, Name(""), List.empty[Term.ArgClause])}
+                case object Optional extends ${Init(authRequirementTypeName, Name(""), List.empty[Term.ArgClause])}
               }
 
               ..$list
@@ -984,7 +984,7 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
             val marshallers = responses.value.map { case Response(statusCodeName, valueType, headers) =>
               val responseTerm  = Term.Name(s"${statusCodeName.value}")
               val baseRespType  = Type.Select(responseCompanionTerm, Type.Name(statusCodeName.value))
-              val respType      = if (isGeneric) Type.Apply(baseRespType, List(t"F")) else baseRespType
+              val respType      = if (isGeneric) Type.Apply(baseRespType, Type.ArgClause(List(t"F"))) else baseRespType
               val generatorName = Term.Name(s"$methodName${statusCodeName}EntityResponseGenerator")
               val encoderName   = Term.Name(s"$methodName${statusCodeName}Encoder")
               (valueType, headers.value) match {
@@ -1016,7 +1016,7 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
         val matchers = (http4sForm ++ http4sHeaders).flatMap(_.matcher)
         val responseInMatch = NonEmptyList.fromList(matchers).fold(responseExpr) {
           case NonEmptyList((expr, pat), Nil) =>
-            Term.Match(expr, List(Case(pat, None, responseExpr), Case(p"_", None, q"""BadRequest("Invalid data")""")))
+            Term.Match(expr, List(Case(pat, None, responseExpr), Case(p"_", None, q"""BadRequest("Invalid data")""")), Nil)
           case matchers @ NonEmptyList(_, _) =>
             val NonEmptyList(head, xs) = matchers.reverse
             val (base, rest)           = xs.splitAt(21).bimap(left => NonEmptyList(head, left).reverse, _.grouped(21).map(_.reverse.unzip).toList)
@@ -1037,7 +1037,8 @@ class Http4sServerGenerator private (version: Http4sVersion) extends ServerTerms
               List(
                 Case(fullPat, None, responseExpr),
                 Case(Pat.Wildcard(), None, q"""BadRequest("Invalid data")""")
-              )
+              ),
+              Nil
             )
         }
         val responseInMatchInFor = (http4sForm ++ http4sHeaders).flatMap(_.generator) match {

modules/scala-support/src/main/scala/dev/guardrail/generators/scala/ResponseADTHelper.scala

@@ -17,7 +17,7 @@ object ResponseADTHelper {
 
     val responseSuperType     = Type.Name(responseClsName)
     val responseSuperTerm     = Term.Name(responseClsName)
-    val responseSuperTemplate = Init(if (isGeneric) Type.Apply(responseSuperType, extraTypes) else responseSuperType, Name(""), List.empty)
+    val responseSuperTemplate = Init(if (isGeneric) Type.Apply(responseSuperType, Type.ArgClause(extraTypes)) else responseSuperType, Name(""), Seq.empty)
 
     val (terms, foldPair) = responses.value.map { case Response(statusCodeName, valueType, headers) =>
       val responseTerm = Term.Name(s"${statusCodeName.value}")
@@ -52,7 +52,7 @@ object ResponseADTHelper {
 
     val cls = q"""
         sealed abstract class ${responseSuperType}[..$extraTypeParams] {
-          def fold[A](..${foldParams}): A = ${Term.Match(Term.This(Name("")), foldCases)}
+          def fold[A](..${foldParams}): A = ${Term.Match(Term.This(Name("")), foldCases, Nil)}
         }
       """
     List[Defn](cls, companion)

modules/scala-support/src/main/scala/dev/guardrail/generators/scala/circe/CirceRefinedProtocolGenerator.scala

@@ -104,7 +104,7 @@ object CirceRefinedProtocolGenerator {
             val refined =
               Type.Apply(
                 t"_root_.eu.timepit.refined.string.MatchesRegex",
-                List(Type.Select(Term.Select(Term.Name(className), Term.Name(s""""$prepend$pat$append"""")), t"T"))
+                Type.ArgClause(List(Type.Select(Term.Select(Term.Name(className), Term.Name(s""""$prepend$pat$append"""")), t"T")))
               )
             t"""String Refined $refined"""
           }

modules/scala-support/src/main/scala/dev/guardrail/generators/scala/jackson/JacksonProtocolGenerator.scala

@@ -86,7 +86,7 @@ class JacksonProtocolGenerator private extends ProtocolTerms[ScalaLanguage, Targ
       case _                              => List.empty
     }
     val presenceHandling = param.term.decltpe match {
-      case Some(t"Presence[_]") | Some(Type.Apply(Type.Select(_, Type.Name("Presence")), _)) =>
+      case Some(t"Presence[_]") | Some(Type.Apply.After_4_6_0(Type.Select(_, Type.Name("Presence")), _)) =>
         List(
           mod"@com.fasterxml.jackson.annotation.JsonInclude(value = com.fasterxml.jackson.annotation.JsonInclude.Include.NON_EMPTY)",
           mod"@com.fasterxml.jackson.databind.annotation.JsonSerialize(using = classOf[$presenceSerType])",
@@ -1283,7 +1283,7 @@ class JacksonProtocolGenerator private extends ProtocolTerms[ScalaLanguage, Targ
           .fold(base)(parent =>
             base.copy(
               templ =
-                Template(Nil, (parent.clsName +: parent.interfaces).map(n => Init(Type.Name(n), Name(""), Nil)), Self(Name(""), None), base.templ.stats, Nil)
+                Template(Nil, (parent.clsName +: parent.interfaces).map(n => Init(Type.Name(n), Name(""), List.empty[Term.ArgClause])), Self(Name(""), None), base.templ.stats, Nil)
             )
           )
       }