GraphQL\Schema::isPossibleType PHP Method

    public function isPossibleType(AbstractType $abstractType, ObjectType $possibleType)
    {
        if (null === $this->possibleTypeMap) {
            $this->possibleTypeMap = [];
        }
        if (!isset($this->possibleTypeMap[$abstractType->name])) {
            $tmp = [];
            foreach ($this->getPossibleTypes($abstractType) as $type) {
                $tmp[$type->name] = true;
            }
            Utils::invariant(!empty($tmp), 'Could not find possible implementing types for $%s ' . 'in schema. Check that schema.types is defined and is an array of ' . 'all possible types in the schema.', $abstractType->name);
            $this->possibleTypeMap[$abstractType->name] = $tmp;
        }
        return !empty($this->possibleTypeMap[$abstractType->name][$possibleType->name]);
    }

 /**
  * Provided two composite types, determine if they "overlap". Two composite
  * types overlap when the Sets of possible concrete types for each intersect.
  *
  * This is often used to determine if a fragment of a given type could possibly
  * be visited in a context of another type.
  *
  * This function is commutative.
  */
 static function doTypesOverlap(Schema $schema, CompositeType $typeA, CompositeType $typeB)
 {
     // Equivalent types overlap
     if ($typeA === $typeB) {
         return true;
     }
     if ($typeA instanceof AbstractType) {
         if ($typeB instanceof AbstractType) {
             // If both types are abstract, then determine if there is any intersection
             // between possible concrete types of each.
             foreach ($schema->getPossibleTypes($typeA) as $type) {
                 if ($schema->isPossibleType($typeB, $type)) {
                     return true;
                 }
             }
             return false;
         }
         /** @var $typeB ObjectType */
         // Determine if the latter type is a possible concrete type of the former.
         return $schema->isPossibleType($typeA, $typeB);
     }
     if ($typeB instanceof AbstractType) {
         /** @var $typeA ObjectType */
         // Determine if the former type is a possible concrete type of the latter.
         return $schema->isPossibleType($typeB, $typeA);
     }
     // Otherwise the types do not overlap.
     return false;
 }