Fix issue with fragment condition type coercing (#2090)

* Fix issue with fragment condition type coercing

Closes #1975

* Feedback

(cherry picked from commit 64d1716)

Author: sav007

apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/parser/GraphQLDocumentParser.kt

@@ -280,7 +280,7 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
     val fields = selectionSet().parse(schemaFieldType)
     val fragmentRefs = selectionSet().fragmentRefs()
     val inlineFragments = selectionSet()?.selection()?.mapNotNull { ctx ->
-      ctx.inlineFragment()?.parse(parentSelectionSet = selectionSet(), parentSchemaType = schemaFieldType)
+      ctx.inlineFragment()?.parse(parentSchemaType = schemaFieldType, parentFields = fields)
     }?.flatten() ?: ParseResult(result = emptyList())
 
     val inlineFragmentFieldsToMerge = inlineFragments.result
@@ -387,38 +387,55 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
   }
 
   private fun GraphQLParser.InlineFragmentContext.parse(
-      parentSelectionSet: GraphQLParser.SelectionSetContext,
-      parentSchemaType: Schema.Type
+      parentSchemaType: Schema.Type,
+      parentFields: ParseResult<List<Field>>
+
   ): ParseResult<InlineFragment> {
     val typeCondition = typeCondition().typeName().NAME().text
     val schemaType = schema[typeCondition] ?: throw ParseException(
         message = "Unknown type`$typeCondition}`",
         token = typeCondition().typeName().start
     )
 
-    if (!parentSchemaType.isAssignableFrom(schema = schema, other = schemaType)) {
+    if (!parentSchemaType.isAssignableFrom(other = schemaType, schema = schema)) {
       throw ParseException(
-          message = "Fragment cannot be spread here as objects of type `${parentSchemaType.name}` can never be of type `$typeCondition`",
+          message = "Fragment cannot be spread here as result can never be of type `$typeCondition`",
           token = typeCondition().typeName().start
       )
     }
 
-    val possibleTypes = when (schemaType) {
-      is Schema.Type.Interface -> schemaType.possibleTypes?.map { it.rawType.name!! } ?: emptyList()
-      is Schema.Type.Union -> schemaType.possibleTypes?.map { it.rawType.name!! } ?: emptyList()
-      else -> listOf(typeCondition)
-    }.distinct()
+    val decoratedParentFields = parentFields.let { (parentFields, usedTypes) ->
+      // if inline fragment conditional type contains the same field as parent type
+      // carry over meta info such as: `description`, `isDeprecated`, `deprecationReason`
+      val decoratedFields = parentFields.map { parentField ->
+        when (schemaType) {
+          is Schema.Type.Interface -> schemaType.fields?.find { it.name == parentField.fieldName }
+          is Schema.Type.Object -> schemaType.fields?.find { it.name == parentField.fieldName }
+          is Schema.Type.Union -> schemaType.fields?.find { it.name == parentField.fieldName }
+          else -> null
+        }?.let { field ->
+          parentField.copy(
+              description = field.description ?: parentField.description,
+              isDeprecated = field.isDeprecated,
+              deprecationReason = field.deprecationReason ?: ""
+          )
+        } ?: parentField
+      }
+      ParseResult(
+          result = decoratedFields,
+          usedTypes = usedTypes
+      )
+    }
 
-    val fields = parentSelectionSet.parse(schemaType).plus(
-        selectionSet().parse(schemaType)
-    ) { left, right -> left.union(right) }
+    val fields = decoratedParentFields.plus(selectionSet().parse(schemaType)) { left, right -> left.union(right) }
     if (fields.result.isEmpty()) {
       throw ParseException(
           message = "Inline fragment `$typeCondition` must have a selection of sub-fields",
           token = typeCondition().typeName().NAME().symbol
       )
     }
 
+    val possibleTypes = schemaType.possibleTypes(schema).toList()
     return ParseResult(
         result = InlineFragment(
             typeCondition = typeCondition,
@@ -449,12 +466,7 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
         token = typeCondition().typeName().NAME().symbol
     )
 
-    val possibleTypes = when (schemaType) {
-      is Schema.Type.Interface -> schemaType.possibleTypes?.map { it.rawType.name!! } ?: emptyList()
-      is Schema.Type.Union -> schemaType.possibleTypes?.map { it.rawType.name!! } ?: emptyList()
-      else -> listOf(typeCondition)
-    }.distinct()
-
+    val possibleTypes = schemaType.possibleTypes(schema)
     val fields = selectionSet().parse(schemaType)
     if (fields.result.isEmpty()) {
       throw ParseException(
@@ -466,7 +478,7 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
     val fragmentRefs = selectionSet().fragmentRefs()
 
     val inlineFragments = selectionSet()?.selection()?.mapNotNull { ctx ->
-      ctx.inlineFragment()?.parse(parentSelectionSet = selectionSet(), parentSchemaType = schemaType)
+      ctx.inlineFragment()?.parse(parentSchemaType = schemaType, parentFields = fields)
     }?.flatten() ?: ParseResult(result = emptyList())
 
     val mergeInlineFragmentFields = inlineFragments.result
@@ -482,7 +494,7 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
             fragmentName = fragmentName,
             typeCondition = typeCondition,
             source = graphQLDocumentSource,
-            possibleTypes = possibleTypes,
+            possibleTypes = possibleTypes.toList(),
             fields = fields.result.mergeFields(mergeInlineFragmentFields),
             fragmentRefs = fragmentRefs.union(mergeInlineFragmentRefs).toList(),
             inlineFragments = inlineFragments.result.filter { it.typeCondition != typeCondition },
@@ -744,8 +756,7 @@ class GraphQLDocumentParser(val schema: Schema, private val packageNameProvider:
       }.also { possibleTypes ->
         if (fragment.possibleTypes.intersect(possibleTypes).isEmpty()) {
           throw GraphQLDocumentParseException(
-              message = "Fragment `${ref.name}` can't be spread here as objects of type `$typeCondition` can never be of " +
-                  "type `${fragment.typeCondition}`",
+              message = "Fragment `${ref.name}` can't be spread here as result can never be of type `${fragment.typeCondition}`",
               sourceLocation = ref.sourceLocation,
               graphQLFilePath = filePath
           )

apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/parser/Utils.kt

@@ -25,23 +25,12 @@ internal fun Schema.Type.possibleTypes(schema: Schema): Set<String> {
   }
 }
 
-internal fun Schema.Type.isAssignableFrom(schema: Schema, other: Schema.Type): Boolean {
-  if (name == other.name) {
-    return true
-  }
-  return when (this) {
-    is Schema.Type.Union -> possibleTypes(schema).intersect(other.possibleTypes(schema)).isNotEmpty()
-    is Schema.Type.Interface -> {
-      val possibleTypes = (possibleTypes ?: emptyList()).mapNotNull { it.rawType.name }
-      possibleTypes.contains(other.name) || possibleTypes.any { typeName ->
-        val schemaType = schema[typeName] ?: throw GraphQLParseException(
-            message = "Unknown possible type `$typeName` for INTERFACE `$name`"
-        )
-        schemaType.isAssignableFrom(schema = schema, other = other)
-      }
-    }
-    else -> false
-  }
+internal fun Schema.Type.isAssignableFrom(other: Schema.Type, schema: Schema): Boolean {
+  return Schema.TypeRef(kind = kind, name = name)
+      .isAssignableFrom(
+          other = Schema.TypeRef(kind = other.kind, name = other.name),
+          schema = schema
+      )
 }
 
 internal operator fun SourceLocation.Companion.invoke(token: Token) = SourceLocation(
@@ -57,25 +46,27 @@ internal fun Schema.TypeRef.asGraphQLType(): String {
   }
 }
 
-internal fun Schema.TypeRef.isAssignableFrom(other: Schema.TypeRef): Boolean {
+internal fun Schema.TypeRef.isAssignableFrom(other: Schema.TypeRef, schema: Schema): Boolean {
   return when (kind) {
     Schema.Kind.NON_NULL -> {
-      other.kind == Schema.Kind.NON_NULL && ofType!!.isAssignableFrom(other.ofType!!)
+      other.kind == Schema.Kind.NON_NULL && ofType!!.isAssignableFrom(other = other.ofType!!, schema = schema)
     }
 
     Schema.Kind.LIST -> {
       if (other.kind == Schema.Kind.NON_NULL) {
-        isAssignableFrom(other.ofType!!)
+        isAssignableFrom(other = other.ofType!!, schema = schema)
       } else {
-        other.kind == Schema.Kind.LIST && ofType!!.isAssignableFrom(other.ofType!!)
+        other.kind == Schema.Kind.LIST && ofType!!.isAssignableFrom(other = other.ofType!!, schema = schema)
       }
     }
 
     else -> {
       if (other.kind == Schema.Kind.NON_NULL) {
-        isAssignableFrom(other.ofType!!)
+        isAssignableFrom(other = other.ofType!!, schema = schema)
       } else {
-        kind == other.kind && name == other.name
+        val possibleTypes = schema.resolveType(this).possibleTypes(schema)
+        val otherPossibleTypes = schema.resolveType(other).possibleTypes(schema)
+        possibleTypes.intersect(otherPossibleTypes).isNotEmpty()
       }
     }
   }
@@ -99,3 +90,7 @@ internal fun Schema.resolveType(graphqlType: String): Schema.TypeRef = when {
     )
   }
 } ?: throw GraphQLParseException("Unknown type `$graphqlType`")
+
+internal fun Schema.resolveType(typeRef: Schema.TypeRef): Schema.Type {
+  return this[typeRef.name] ?: throw GraphQLParseException("Unknown type `${typeRef.name}`")
+}

apollo-compiler/src/main/kotlin/com/apollographql/apollo/compiler/parser/Validation.kt

@@ -224,7 +224,7 @@ private fun Operation.validateVariableType(name: String, expectedType: Schema.Ty
       "Variable `$name` is not defined by operation `${operationName}`"
   )
   val variableType = schema.resolveType(variable.type)
-  if (!expectedType.isAssignableFrom(variableType)) {
+  if (!expectedType.isAssignableFrom(other = variableType, schema = schema)) {
     throw GraphQLParseException(
         "Variable `$name` of type `${variableType.asGraphQLType()}` used in position expecting type `${expectedType.asGraphQLType()}`"
     )

apollo-compiler/src/test/graphql/com/example/inline_fragment_type_coercion/TestOperation.graphql

@@ -0,0 +1,8 @@
+query TestQuery {
+  foo {
+    foo
+    ... on Bar {
+      bar
+    }
+  }
+}