use groupedFieldSet as variable name

Replicates graphql/graphql-js@a074400

Author: Cito

src/graphql/execution/collect_fields.py

@@ -52,13 +52,13 @@ class PatchFields(NamedTuple):
     """Optionally labelled set of fields to be used as a patch."""
 
     label: str | None
-    fields: GroupedFieldSet
+    grouped_field_set: GroupedFieldSet
 
 
 class FieldsAndPatches(NamedTuple):
     """Tuple of collected fields and patches to be applied."""
 
-    fields: GroupedFieldSet
+    grouped_field_set: GroupedFieldSet
     patches: list[PatchFields]
 
 
@@ -79,7 +79,7 @@ def collect_fields(
 
     For internal use only.
     """
-    fields: dict[str, list[FieldNode]] = defaultdict(list)
+    grouped_field_set: dict[str, list[FieldNode]] = defaultdict(list)
     patches: list[PatchFields] = []
     collect_fields_impl(
         schema,
@@ -88,11 +88,11 @@ def collect_fields(
         operation,
         runtime_type,
         operation.selection_set,
-        fields,
+        grouped_field_set,
         patches,
         set(),
     )
-    return FieldsAndPatches(fields, patches)
+    return FieldsAndPatches(grouped_field_set, patches)
 
 
 def collect_subfields(
@@ -114,11 +114,11 @@ def collect_subfields(
 
     For internal use only.
     """
-    sub_field_nodes: dict[str, list[FieldNode]] = defaultdict(list)
+    sub_grouped_field_set: dict[str, list[FieldNode]] = defaultdict(list)
     visited_fragment_names: set[str] = set()
 
     sub_patches: list[PatchFields] = []
-    sub_fields_and_patches = FieldsAndPatches(sub_field_nodes, sub_patches)
+    sub_fields_and_patches = FieldsAndPatches(sub_grouped_field_set, sub_patches)
 
     for node in field_group:
         if node.selection_set:
@@ -129,7 +129,7 @@ def collect_subfields(
                 operation,
                 return_type,
                 node.selection_set,
-                sub_field_nodes,
+                sub_grouped_field_set,
                 sub_patches,
                 visited_fragment_names,
             )
@@ -143,7 +143,7 @@ def collect_fields_impl(
     operation: OperationDefinitionNode,
     runtime_type: GraphQLObjectType,
     selection_set: SelectionSetNode,
-    fields: dict[str, list[FieldNode]],
+    grouped_field_set: dict[str, list[FieldNode]],
     patches: list[PatchFields],
     visited_fragment_names: set[str],
 ) -> None:
@@ -154,7 +154,7 @@ def collect_fields_impl(
         if isinstance(selection, FieldNode):
             if not should_include_node(variable_values, selection):
                 continue
-            fields[get_field_entry_key(selection)].append(selection)
+            grouped_field_set[get_field_entry_key(selection)].append(selection)
         elif isinstance(selection, InlineFragmentNode):
             if not should_include_node(
                 variable_values, selection
@@ -184,7 +184,7 @@ def collect_fields_impl(
                     operation,
                     runtime_type,
                     selection.selection_set,
-                    fields,
+                    grouped_field_set,
                     patches,
                     visited_fragment_names,
                 )
@@ -229,7 +229,7 @@ def collect_fields_impl(
                     operation,
                     runtime_type,
                     fragment.selection_set,
-                    fields,
+                    grouped_field_set,
                     patches,
                     visited_fragment_names,
                 )

src/graphql/execution/execute.py

@@ -813,7 +813,7 @@ def execute_operation(self) -> AwaitableOrValue[dict[str, Any]]:
             )
             raise GraphQLError(msg, operation)
 
-        root_fields, patches = collect_fields(
+        grouped_field_set, patches = collect_fields(
             schema,
             self.fragments,
             self.variable_values,
@@ -827,12 +827,12 @@ def execute_operation(self) -> AwaitableOrValue[dict[str, Any]]:
             self.execute_fields_serially
             if operation.operation == OperationType.MUTATION
             else self.execute_fields
-        )(root_type, root_value, None, root_fields)  # type: ignore
+        )(root_type, root_value, None, grouped_field_set)  # type: ignore
 
         for patch in patches:
-            label, patch_fields = patch
+            label, patch_grouped_filed_set = patch
             self.execute_deferred_fragment(
-                root_type, root_value, patch_fields, label, None
+                root_type, root_value, patch_grouped_filed_set, label, None
             )
 
         return result
@@ -1604,10 +1604,12 @@ def collect_and_execute_subfields(
         async_payload_record: AsyncPayloadRecord | None,
     ) -> AwaitableOrValue[dict[str, Any]]:
         """Collect sub-fields to execute to complete this value."""
-        sub_field_nodes, sub_patches = self.collect_subfields(return_type, field_group)
+        sub_grouped_field_set, sub_patches = self.collect_subfields(
+            return_type, field_group
+        )
 
         sub_fields = self.execute_fields(
-            return_type, result, path, sub_field_nodes, async_payload_record
+            return_type, result, path, sub_grouped_field_set, async_payload_record
         )
 
         for sub_patch in sub_patches:
@@ -2503,14 +2505,14 @@ def execute_subscription(
         msg = "Schema is not configured to execute subscription operation."
         raise GraphQLError(msg, context.operation)
 
-    root_fields = collect_fields(
+    grouped_field_set = collect_fields(
         schema,
         context.fragments,
         context.variable_values,
         root_type,
         context.operation,
-    ).fields
-    first_root_field = next(iter(root_fields.items()))
+    ).grouped_field_set
+    first_root_field = next(iter(grouped_field_set.items()))
     response_name, field_group = first_root_field
     field_name = field_group[0].name.value
     field_def = schema.get_field(root_type, field_name)

src/graphql/validation/rules/single_field_subscriptions.py

@@ -42,15 +42,15 @@ def enter_operation_definition(
                 for definition in document.definitions
                 if isinstance(definition, FragmentDefinitionNode)
             }
-            fields = collect_fields(
+            grouped_field_set = collect_fields(
                 schema,
                 fragments,
                 variable_values,
                 subscription_type,
                 node,
-            ).fields
-            if len(fields) > 1:
-                field_selection_lists = list(fields.values())
+            ).grouped_field_set
+            if len(grouped_field_set) > 1:
+                field_selection_lists = list(grouped_field_set.values())
                 extra_field_selection_lists = field_selection_lists[1:]
                 extra_field_selection = [
                     field
@@ -72,7 +72,7 @@ def enter_operation_definition(
                         extra_field_selection,
                     )
                 )
-            for field_group in fields.values():
+            for field_group in grouped_field_set.values():
                 field_name = field_group[0].name.value
                 if field_name.startswith("__"):
                     self.report_error(