introduce CollectRootFields and CollectSubfields

Rather than merging subSelectionSets of a field set using MergeSelectionSets and then calling CollectFields, introducing CollectSubfields allows the field set's groupedSubfieldSet to be calculated directly.

This may be helpful if the specification were ever to be altered such that additional state beyond the current selection set were to be required to calculate the response, i.e. if it were to be required to know the originating selectionSet of a given field within the fieldSet for determining when to communicate a reference signal.

See #998 (comment)

# Conflicts:
#	spec/Section 6 -- Execution.md

Author: robrichard

spec/Section 5 -- Validation.md

@@ -463,7 +463,7 @@ unambiguous. Therefore any two field selections which might both be encountered
 for the same object are only valid if they are equivalent.
 
 During execution, the simultaneous execution of fields with the same response
-name is accomplished by {MergeSelectionSets()} and {CollectFields()}.
+name is accomplished by {CollectFields()}.
 
 For simple hand-written GraphQL, this rule is obviously a clear developer error,
 however nested fragments can make this difficult to detect manually.

spec/Section 6 -- Execution.md

@@ -132,9 +132,11 @@ ExecuteQuery(query, schema, variableValues, initialValue):
 - Let {queryType} be the root Query type in {schema}.
 - Assert: {queryType} is an Object type.
 - Let {selectionSet} be the top level Selection Set in {query}.
+- Let {groupedFieldSet} be the result of {CollectRootFields(queryType,
+  selectionSet, variableValues)}.
 - Let {data}, {defers} and {streams} be the result of running
-  {ExecuteSelectionSet(selectionSet, queryType, initialValue, variableValues)}
-  _normally_ (allowing parallelization).
+  {ExecuteGroupedFieldSet(groupedFieldSet, queryType, initialValue,
+  variableValues)} _normally_ (allowing parallelization).
 - Let {errors} be the list of all _field error_ raised while executing the
   selection set.
 - If {defers} is an empty map and {streams} is an empty list:
@@ -219,7 +221,7 @@ variableValues):
         entries of {fieldDetails}.
       - Let {selectionSet} be a new selection set consisting of {fields}.
       - Let {data}, {childDefers} and {childStreams} be the result of running
-        {ExecuteSelectionSet(selectionSet, objectType, objectValue,
+        {ExecuteGroupedFieldSet(selectionSet, objectType, objectValue,
         variableValues, path)}.
       - Let {childErrors} be the list of all _field error_ raised while
         executing the selection set.
@@ -336,8 +338,10 @@ ExecuteMutation(mutation, schema, variableValues, initialValue):
 - Let {mutationType} be the root Mutation type in {schema}.
 - Assert: {mutationType} is an Object type.
 - Let {selectionSet} be the top level Selection Set in {mutation}.
+- Let {groupedFieldSet} be the result of {CollectRootFields(mutationType,
+  selectionSet, variableValues)}.
 - Let {data}, {defers} and {streams} be the result of running
-  {ExecuteSelectionSet(selectionSet, mutationType, initialValue,
+  {ExecuteGroupedFieldSet(groupedFieldSet, mutationType, initialValue,
   variableValues)} _serially_.
 - Let {errors} be the list of all _field error_ raised while executing the
   selection set.
@@ -446,8 +450,8 @@ CreateSourceEventStream(subscription, schema, variableValues, initialValue):
 - Let {subscriptionType} be the root Subscription type in {schema}.
 - Assert: {subscriptionType} is an Object type.
 - Let {selectionSet} be the top level Selection Set in {subscription}.
-- Let {groupedFieldSet} be the result of running
-  {CollectFields(subscriptionType, selectionSet, variableValues)}.
+- Let {groupedFieldSet} be the result of {CollectRootFields(subscriptionType,
+  selectionSet, variableValues)}.
 - If {groupedFieldSet} does not have exactly one entry, raise a _request error_.
 - Let {fieldDetails} be the value of the first entry in {groupedFieldSet}.
 - Let {fieldDetail} be the first entry in {fieldDetails}.
@@ -496,8 +500,10 @@ ExecuteSubscriptionEvent(subscription, schema, variableValues, initialValue):
 - Let {subscriptionType} be the root Subscription type in {schema}.
 - Assert: {subscriptionType} is an Object type.
 - Let {selectionSet} be the top level Selection Set in {subscription}.
+- Let {groupedFieldSet} be the result of {CollectRootFields(subscriptionType,
+  selectionSet, variableValues)}.
 - Let {data}, {defers} and {streams} be the result of running
-  {ExecuteSelectionSet(selectionSet, subscriptionType, initialValue,
+  {ExecuteGroupedFieldSet(groupedFieldSet, subscriptionType, initialValue,
   variableValues)} _normally_ (allowing parallelization).
 - Let {errors} be the list of all _field error_ raised while executing the
   selection set.
@@ -523,22 +529,19 @@ Unsubscribe(responseStream):
 
 - Cancel {responseStream}
 
-## Executing Selection Sets
+## Executing Grouped Field Sets
 
-To execute a selection set, the object value being evaluated and the object type
-need to be known, as well as whether it must be executed serially, or may be
-executed in parallel.
+To execute a grouped field set, the object value being evaluated and the object
+type need to be known, as well as whether it must be executed serially, or may
+be executed in parallel.
 
-First, the selection set is turned into a grouped field set; then, each
-represented field in the grouped field set produces an entry into a response
-map.
+Each represented field in the grouped field set produces an entry into a
+response map.
 
-ExecuteSelectionSet(selectionSet, objectType, objectValue, variableValues,
+ExecuteGroupedFieldSet(groupedFieldSet, objectType, objectValue, variableValues,
 parentPath):
 
 - If {parentPath} is not provided, initialize it to an empty list.
-- Let {groupedFieldSet} be the result of running {CollectFields(objectType,
-  selectionSet, variableValues)}.
 - Initialize {resultMap} to an empty ordered map.
 - Let {defers} be an empty unordered map.
 - Let {streams} be an empty list.
@@ -607,8 +610,8 @@ is explained in greater detail in the Field Collection section below.
 
 **Errors and Non-Null Fields**
 
-If during {ExecuteSelectionSet()} a field with a non-null {fieldType} raises a
-_field error_ then that error must propagate to this entire selection set,
+If during {ExecuteGroupedFieldSet()} a field with a non-null {fieldType} raises
+a _field error_ then that error must propagate to this entire selection set,
 either resolving to {null} if allowed or further propagated to a parent field.
 
 If this occurs, any sibling fields which have not yet executed or have not yet
@@ -747,6 +750,7 @@ response in a stable and predictable order.
 CollectFields(objectType, selectionSet, variableValues, isDeferred,
 visitedFragments):
 
+- Initialize {groupedFieldSet} to an empty ordered map of lists.
 - If {isDeferred} is not provided, initialize it to {false}.
 - If {visitedFragments} is not provided, initialize it to the empty set.
 - Initialize {groupedFields} to an empty ordered map of lists.
@@ -765,7 +769,7 @@ visitedFragments):
     - Let {field} be {selection}.
     - Let {responseKey} be the response key of {field} (the alias if defined,
       otherwise the field name).
-    - Let {groupForResponseKey} be the list in {groupedFields} for
+    - Let {groupForResponseKey} be the list in {groupedFieldSet} for
       {responseKey}; if no such list exists, create it as an empty list.
     - Let {fieldDetail} be an unordered map containing {field} and {isDeferred}.
     - Append {fieldDetail} to the {groupForResponseKey}.
@@ -794,7 +798,7 @@ visitedFragments):
     - For each {fragmentGroup} in {fragmentGroupedFieldSet}:
       - Let {responseKey} be the response key shared by all fields in
         {fragmentGroup}.
-      - Let {groupForResponseKey} be the list in {groupedFields} for
+      - Let {groupForResponseKey} be the list in {groupedFieldSet} for
         {responseKey}; if no such list exists, create it as an empty list.
       - Append all items in {fragmentGroup} to {groupForResponseKey}.
   - If {selection} is an {InlineFragment}:
@@ -815,10 +819,10 @@ visitedFragments):
     - For each {fragmentGroup} in {fragmentGroupedFieldSet}:
       - Let {responseKey} be the response key shared by all fields in
         {fragmentGroup}.
-      - Let {groupForResponseKey} be the list in {groupedFields} for
+      - Let {groupForResponseKey} be the list in {groupedFieldSet} for
         {responseKey}; if no such list exists, create it as an empty list.
       - Append all items in {fragmentGroup} to {groupForResponseKey}.
-- Return {groupedFields}.
+- Return {groupedFields} and {visitedFragments}.
 
 DoesFragmentTypeApply(objectType, fragmentType):
 
@@ -835,6 +839,39 @@ DoesFragmentTypeApply(objectType, fragmentType):
 Note: The steps in {CollectFields()} evaluating the `@skip` and `@include`
 directives may be applied in either order since they apply commutatively.
 
+### Root Field Collection
+
+Root field collection processes the operation's top-level selection set:
+
+CollectRootFields(rootType, operationSelectionSet, variableValues):
+
+- Initialize {visitedFragments} to the empty set.
+- Let {groupedFieldSet} be the result of calling {CollectFields(rootType,
+  operationSelectionSet, variableValues, visitedFragments)}.
+- Return {groupedFieldSet}.
+
+### Object Subfield Collection
+
+Object subfield collection processes a field's sub-selection sets:
+
+CollectSubfields(objectType, fields, variableValues):
+
+- Initialize {visitedFragments} to the empty set.
+- Initialize {groupedSubfieldSet} to an empty ordered map of lists.
+- For each {field} in {fields}:
+  - Let {fieldSelectionSet} be the selection set of {field}.
+  - If {fieldSelectionSet} is null or empty, continue to the next field.
+  - Let {fieldGroupedFieldSet} be the result of calling
+    {CollectFields(objectType, fragmentSelectionSet, variableValues,
+    visitedFragments)}.
+  - For each {fieldGroup} in {fieldGroupedFieldSet}:
+    - Let {responseKey} be the response key shared by all fields in
+      {fragmentGroup}.
+    - Let {groupForResponseKey} be the list in {groupedFieldSet} for
+      {responseKey}; if no such list exists, create it as an empty list.
+    - Append all items in {fieldGroup} to {groupForResponseKey}.
+- Return {groupedSubfieldSet}.
+
 ## Executing Fields
 
 Each field requested in the grouped field set that is defined on the selected
@@ -980,10 +1017,11 @@ CompleteValue(fieldType, fields, result, variableValues, path):
   - Otherwise if {fieldType} is an Interface or Union type.
     - Let {objectType} be the result of running {ResolveAbstractType(fieldType,
       result)}.
-  - Let {subSelectionSet} be the result of running {MergeSelectionSets(fields)}.
+  - Let {groupedSubfieldSet} be the result of calling
+    {CollectSubfields(objectType, fields, variableValues)}.
   - Let {completedResult}, {defers} and {streams} be the result of running
-    {ExecuteSelectionSet(subSelectionSet, objectType, result, variableValues,
-    path)} _normally_ (allowing for parallelization).
+    {ExecuteGroupedFieldSet(groupedSubfieldSet, objectType, result,
+    variableValues, path)} _normally_ (allowing for parallelization).
   - Return {completedResult}, {defers} and {streams}.
 
 **Coercing Results**
@@ -1047,17 +1085,9 @@ sub-selections.
 }
 ```
 
-After resolving the value for `me`, the selection sets are merged together so
-`firstName` and `lastName` can be resolved for one value.
-
-MergeSelectionSets(fields):
-
-- Let {selectionSet} be an empty list.
-- For each {field} in {fields}:
-  - Let {fieldSelectionSet} be the selection set of {field}.
-  - If {fieldSelectionSet} is null or empty, continue to the next field.
-  - Append all selections in {fieldSelectionSet} to {selectionSet}.
-- Return {selectionSet}.
+After resolving the value for `me`, the selection sets are merged together by
+calling {CollectSubfields()} so `firstName` and `lastName` can be resolved for
+one value.
 
 ### Handling Field Errors