issue #222

build.sbt

@@ -41,6 +41,7 @@ val exampleCases: List[(java.io.File, String, Boolean, List[String])] = List(
   (sampleResource("issues/issue164.yaml"), "issues.issue164", false, List.empty),
   (sampleResource("issues/issue215.yaml"), "issues.issue215", false, List.empty),
   (sampleResource("issues/issue218.yaml"), "issues.issue218", false, List.empty),
+  (sampleResource("issues/issue222.yaml"), "issues.issue222", false, List.empty),
   (sampleResource("issues/issue249.yaml"), "issues.issue249", false, List.empty),
   (sampleResource("multipart-form-data.yaml"), "multipartFormData", false, List.empty),
   (sampleResource("petstore.json"), "examples", false, List("--import", "support.PositiveLong")),

modules/codegen/src/main/scala/com/twilio/guardrail/generators/CirceProtocolGenerator.scala

@@ -171,11 +171,12 @@ object CirceProtocolGenerator {
 
       case RenderDTOClass(clsName, selfParams, parents) =>
         val discriminators = parents.flatMap(_.discriminators)
-        val parenOpt       = parents.headOption
+        val parentOpt      = if (parents.exists(s => s.discriminators.nonEmpty)) { parents.headOption } else { None }
         val terms = (parents.reverse.flatMap(_.params.map(_.term)) ++ selfParams.map(_.term)).filterNot(
           param => discriminators.contains(param.name.value)
         )
-        val code = parenOpt
+
+        val code = parentOpt
           .fold(q"""case class ${Type.Name(clsName)}(..${terms})""")(
             parent =>
               q"""case class ${Type.Name(clsName)}(..${terms}) extends ${template"..${init"${Type.Name(parent.clsName)}(...$Nil)" :: parent.interfaces

modules/codegen/src/main/scala/com/twilio/guardrail/generators/Java/JacksonGenerator.scala

@@ -324,7 +324,7 @@ object JacksonGenerator {
       case RenderDTOClass(clsName, selfParams, parents) =>
         val dtoClassType   = JavaParser.parseClassOrInterfaceType(clsName)
         val discriminators = parents.flatMap(_.discriminators)
-        val parentOpt      = parents.headOption
+        val parentOpt      = if (parents.exists(s => s.discriminators.nonEmpty)) { parents.headOption } else { None }
         val params = (parents.reverse.flatMap(_.params) ++ selfParams).filterNot(
           param => discriminators.contains(param.term.getName().getId())
         )
@@ -801,7 +801,7 @@ object JacksonGenerator {
         Target.pure(None)
 
       case RenderSealedTrait(className, selfParams, discriminator, parents, children) =>
-        val parentOpt                      = parents.headOption
+        val parentOpt                      = if (parents.exists(s => s.discriminators.nonEmpty)) { parents.headOption } else { None }
         val params                         = (parents.reverse.flatMap(_.params) ++ selfParams).filterNot(_.term.getName.getId == discriminator)
         val (requiredTerms, optionalTerms) = sortParams(params)
         val terms                          = requiredTerms ++ optionalTerms

modules/codegen/src/test/scala/core/issues/Issue222.scala

@@ -0,0 +1,90 @@
+package core.issues
+
+import com.twilio.guardrail.generators.Http4s
+import com.twilio.guardrail.languages.ScalaLanguage
+import com.twilio.guardrail.{ClassDefinition, Context, ProtocolDefinitions}
+import org.scalatest.{Assertion, FunSuite, Matchers}
+import support.SwaggerSpecRunner
+
+class Issue222 extends FunSuite with Matchers with SwaggerSpecRunner {
+  import scala.meta._
+
+  val swagger: String = s"""
+                           |swagger: '2.0'
+                           |info:
+                           |  title: someapp
+                           |  description: someapp
+                           |  version: '1'
+                           |basePath: "/v1"
+                           |schemes:
+                           |  - http
+                           |produces:
+                           |  - application/json
+                           |paths: {}
+                           |definitions:
+                           |  Request:
+                           |    description: Request fields with id
+                           |    allOf:
+                           |      - "$$ref": "#/definitions/RequestFields"
+                           |      - type: object
+                           |        properties:
+                           |          id:
+                           |            type: string
+                           |  RequestFields:
+                           |    description: Request fields
+                           |    type: object
+                           |    properties:
+                           |      state:
+                           |        type: integer
+                           |""".stripMargin
+
+  test("Ensure case-to-case inheritance is not generated") {
+    val (ProtocolDefinitions(List(request: ClassDefinition[ScalaLanguage], requestFields: ClassDefinition[ScalaLanguage]), _, _, _), _, _) = runSwaggerSpec(swagger)(Context.empty, Http4s)
+
+    val List(reqEncoder, reqDecoder) = request.staticDefns.definitions
+
+    val expectedRequestTpe = t"""Request"""
+
+    val expectedRequestCls = q"""case class Request(state: Option[BigInt] = None, id: Option[String] = None)"""
+
+    val expectedRequestEncoder = q"""
+         implicit val encodeRequest = {
+           val readOnlyKeys = Set[String]()
+           Encoder.forProduct2("state", "id")((o: Request) => (o.state, o.id)).mapJsonObject(_.filterKeys(key => !(readOnlyKeys contains key))) 
+         }
+      """
+     val expectedRequestDecoder = q"""
+         implicit val decodeRequest = Decoder.forProduct2("state", "id")(Request.apply _)
+      """
+
+
+    compare(request.tpe, expectedRequestTpe)
+    compare(request.cls, expectedRequestCls)
+    compare(reqEncoder, expectedRequestEncoder)
+    compare(reqDecoder, expectedRequestDecoder)
+
+    val expectedFieldsTpe = t"""RequestFields"""
+    val expectedFieldsCls = q"""case class RequestFields(state: Option[BigInt] = None)"""
+
+    val List(fieldsEncoder, fieldsDecoder) = requestFields.staticDefns.definitions
+
+    val expectedFieldsEncoder =  q"""
+         implicit val encodeRequestFields = {
+           val readOnlyKeys = Set[String]()
+           Encoder.forProduct1("state")((o: RequestFields) => o.state).mapJsonObject(_.filterKeys(key => !(readOnlyKeys contains key)))
+         }
+      """
+     val expectedFieldsDecoder = q"""
+         implicit val decodeRequestFields = Decoder.forProduct1("state")(RequestFields.apply _)
+      """
+
+    compare(requestFields.tpe, expectedFieldsTpe)
+    compare(requestFields.cls, expectedFieldsCls)
+    compare(fieldsEncoder, expectedFieldsEncoder)
+    compare(fieldsDecoder, expectedFieldsDecoder) 
+  }
+
+  private def compare(t1: Tree, t2: Tree): Assertion = {
+    t1.structure shouldEqual t2.structure
+  }
+}

modules/sample/src/main/resources/issues/issue222.yaml

@@ -0,0 +1,26 @@
+swagger: '2.0'
+info:
+  title: someapp
+  description: someapp
+  version: '1'
+basePath: "/v1"
+schemes:
+  - http
+produces:
+  - application/json
+paths: {}
+definitions:
+  Request:
+    description: Request fields with id
+    allOf:
+      - "$ref": "#/definitions/RequestFields"
+      - type: object
+        properties:
+          id:
+            type: string
+  RequestFields:
+    description: Request fields
+    type: object
+    properties:
+      state:
+        type: integer