Merge conflicts

Author: mjmahone

src/execution/collectFields.ts

@@ -2,11 +2,13 @@ import { AccumulatorMap } from '../jsutils/AccumulatorMap';
 import type { ObjMap } from '../jsutils/ObjMap';
 
 import type {
+  ArgumentNode,
   FieldNode,
   FragmentDefinitionNode,
   FragmentSpreadNode,
   InlineFragmentNode,
   SelectionSetNode,
+  ValueNode,
 } from '../language/ast';
 import { Kind } from '../language/kinds';
 
@@ -141,6 +143,8 @@ function collectFieldsImpl(
         ) {
           continue;
         }
+        const selectionSetWithArgumentsApplied =
+          selectionSetWithFragmentArgumentsApplied(fragment, selection);
         collectFieldsImpl(
           schema,
           fragments,

src/language/__tests__/visitor-test.ts

@@ -455,7 +455,7 @@ describe('Visitor', () => {
     ]);
   });
 
-  it('visits variables defined in fragments', () => {
+  it('visits arguments defined on fragments', () => {
     const ast = parse('fragment a($v: Boolean = false) on t { f }', {
       noLocation: true,
     });
@@ -504,6 +504,49 @@ describe('Visitor', () => {
     ]);
   });
 
+  it('visits arguments on fragment spreads', () => {
+    const ast = parse('fragment a on t { ...s(v: false) }', {
+      noLocation: true,
+    });
+    const visited: Array<any> = [];
+
+    visit(ast, {
+      enter(node) {
+        checkVisitorFnArgs(ast, arguments);
+        visited.push(['enter', node.kind, getValue(node)]);
+      },
+      leave(node) {
+        checkVisitorFnArgs(ast, arguments);
+        visited.push(['leave', node.kind, getValue(node)]);
+      },
+    });
+
+    expect(visited).to.deep.equal([
+      ['enter', 'Document', undefined],
+      ['enter', 'FragmentDefinition', undefined],
+      ['enter', 'Name', 'a'],
+      ['leave', 'Name', 'a'],
+      ['enter', 'NamedType', undefined],
+      ['enter', 'Name', 't'],
+      ['leave', 'Name', 't'],
+      ['leave', 'NamedType', undefined],
+      ['enter', 'SelectionSet', undefined],
+      ['enter', 'FragmentSpread', undefined],
+      ['enter', 'Name', 's'],
+      ['leave', 'Name', 's'],
+      ['enter', 'Argument', { kind: 'BooleanValue', value: false }],
+      ['enter', 'Name', 'v'],
+      ['leave', 'Name', 'v'],
+      ['enter', 'BooleanValue', false],
+      ['leave', 'BooleanValue', false],
+      ['leave', 'Argument', { kind: 'BooleanValue', value: false }],
+      ['leave', 'FragmentSpread', undefined],
+      ['leave', 'SelectionSet', undefined],
+      ['leave', 'FragmentDefinition', undefined],
+      ['leave', 'Document', undefined],
+    ]);
+  });
+
   it('n', () => {
     const ast = parse(kitchenSinkQuery, {
       experimentalClientControlledNullability: true,

src/language/ast.ts

@@ -428,8 +428,13 @@ export interface FragmentSpreadNode {
   readonly kind: Kind.FRAGMENT_SPREAD;
   readonly loc?: Location | undefined;
   readonly name: NameNode;
+<<<<<<< HEAD
   readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
   readonly arguments?: ReadonlyArray<ArgumentNode> | undefined;
+=======
+  readonly arguments?: ReadonlyArray<ArgumentNode>;
+  readonly directives?: ReadonlyArray<DirectiveNode>;
+>>>>>>> 01414be319c245415c1c5d4818a4fe9179c2909d
 }
 
 export interface InlineFragmentNode {
@@ -444,9 +449,13 @@ export interface FragmentDefinitionNode {
   readonly kind: Kind.FRAGMENT_DEFINITION;
   readonly loc?: Location | undefined;
   readonly name: NameNode;
+<<<<<<< HEAD
   readonly variableDefinitions?:
     | ReadonlyArray<VariableDefinitionNode>
     | undefined;
+=======
+  readonly variableDefinitions?: ReadonlyArray<VariableDefinitionNode>;
+>>>>>>> 01414be319c245415c1c5d4818a4fe9179c2909d
   readonly typeCondition: NamedTypeNode;
   readonly directives?: ReadonlyArray<DirectiveNode> | undefined;
   readonly selectionSet: SelectionSetNode;

src/language/parser.ts

@@ -80,29 +80,8 @@ export interface ParseOptions {
    * in the source that they correspond to. This configuration flag
    * disables that behavior for performance or testing.
    */
-<<<<<<< HEAD
-<<<<<<< HEAD
   noLocation?: boolean | undefined;
 
-  /**
-   * If enabled, the parser will understand and parse variable definitions
-   * contained in a fragment definition. They'll be represented in the
-   * `variableDefinitions` field of the FragmentDefinitionNode.
-   *
-   * Additionally, the parser will understand arguments passed to fragment
-   * spreads. They'll be represented in the `arguments` field of the
-   * FragmentSpreadNode.
-   *
-   * The syntax is identical to normal, query-defined variables. For example:
-   *
-   * ```graphql
-   * fragment A($var: Boolean = false) on T {
-   *   ...
-   * }
-   * ```
-   */
-  allowLegacyFragmentVariables?: boolean | undefined;
-
   /**
    * EXPERIMENTAL:
    *
@@ -125,12 +104,6 @@ export interface ParseOptions {
    * future.
    */
   experimentalClientControlledNullability?: boolean | undefined;
-=======
-  noLocation?: boolean;
->>>>>>> Remove flag for parsing, but add default validation to indicate fragment args are not yet spec-supported, and may be missing validation.
-=======
-  noLocation?: boolean;
->>>>>>> 01414be319c245415c1c5d4818a4fe9179c2909d
 }
 
 /**
@@ -591,22 +564,10 @@ export class Parser {
   parseFragmentDefinition(): FragmentDefinitionNode {
     const start = this._lexer.token;
     this.expectKeyword('fragment');
-    // Legacy support for defining variables within fragments changes
-    // the grammar of FragmentDefinition:
-    //   - fragment FragmentName VariableDefinitions? on TypeCondition Directives? SelectionSet
-    if (this._options.allowLegacyFragmentVariables === true) {
-      return this.node<FragmentDefinitionNode>(start, {
-        kind: Kind.FRAGMENT_DEFINITION,
-        name,
-        variableDefinitions: this.parseVariableDefinitions(),
-        typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
-        directives: this.parseDirectives(false),
-        selectionSet: this.parseSelectionSet(),
-      });
-    }
     return this.node<FragmentDefinitionNode>(start, {
       kind: Kind.FRAGMENT_DEFINITION,
-      name,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
       typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
       directives: this.parseDirectives(false),
       selectionSet: this.parseSelectionSet(),

src/language/visitor.ts

@@ -77,11 +77,97 @@ type ReducedField<T, R> = T extends null | undefined
   ? ReadonlyArray<R>
   : R;
 
+<<<<<<< HEAD
 /**
  * A KeyMap describes each the traversable properties of each kind of node.
  */
 export type ASTVisitorKeyMap = {
   [NodeT in ASTNode as NodeT['kind']]?: ReadonlyArray<keyof NodeT>;
+=======
+const QueryDocumentKeys = {
+  Name: [],
+
+  Document: ['definitions'],
+  OperationDefinition: [
+    'name',
+    'variableDefinitions',
+    'directives',
+    'selectionSet',
+  ],
+  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],
+  Variable: ['name'],
+  SelectionSet: ['selections'],
+  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
+  Argument: ['name', 'value'],
+
+  FragmentSpread: ['name', 'arguments', 'directives'],
+  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
+  FragmentDefinition: [
+    'name',
+    'variableDefinitions',
+    'typeCondition',
+    'directives',
+    'selectionSet',
+  ],
+
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ['values'],
+  ObjectValue: ['fields'],
+  ObjectField: ['name', 'value'],
+
+  Directive: ['name', 'arguments'],
+
+  NamedType: ['name'],
+  ListType: ['type'],
+  NonNullType: ['type'],
+
+  SchemaDefinition: ['description', 'directives', 'operationTypes'],
+  OperationTypeDefinition: ['type'],
+
+  ScalarTypeDefinition: ['description', 'name', 'directives'],
+  ObjectTypeDefinition: [
+    'description',
+    'name',
+    'interfaces',
+    'directives',
+    'fields',
+  ],
+  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],
+  InputValueDefinition: [
+    'description',
+    'name',
+    'type',
+    'defaultValue',
+    'directives',
+  ],
+  InterfaceTypeDefinition: [
+    'description',
+    'name',
+    'interfaces',
+    'directives',
+    'fields',
+  ],
+  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
+  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
+  EnumValueDefinition: ['description', 'name', 'directives'],
+  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
+
+  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],
+
+  SchemaExtension: ['directives', 'operationTypes'],
+
+  ScalarTypeExtension: ['name', 'directives'],
+  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  UnionTypeExtension: ['name', 'directives', 'types'],
+  EnumTypeExtension: ['name', 'directives', 'values'],
+  InputObjectTypeExtension: ['name', 'directives', 'fields'],
+>>>>>>> 01414be319c245415c1c5d4818a4fe9179c2909d
 };
 
 export const BREAK: unknown = Object.freeze({});

src/validation/specifiedRules.ts

@@ -66,13 +66,6 @@ import { VariablesAreInputTypesRule } from './rules/VariablesAreInputTypesRule';
 // Spec Section: "All Variable Usages Are Allowed"
 import { VariablesInAllowedPositionRule } from './rules/VariablesInAllowedPositionRule';
 import type { SDLValidationRule, ValidationRule } from './ValidationContext';
-
-// Prevent not-yet-in-spec usage of Fragment Arguments by default
-import { NoFragmentArgumentUsageRule } from './rules/custom/NoFragmentArgumentUsageRule';
-
-// Prevent not-yet-in-spec usage of Fragment Arguments by default
-import { NoFragmentArgumentUsageRule } from './rules/custom/NoFragmentArgumentUsageRule';
-
 /**
  * This set includes all validation rules defined by the GraphQL spec.
  *
@@ -94,7 +87,6 @@ export const specifiedRules: ReadonlyArray<ValidationRule> = Object.freeze([
   NoUnusedFragmentsRule,
   PossibleFragmentSpreadsRule,
   NoFragmentCyclesRule,
-  NoFragmentArgumentUsageRule,
   UniqueVariableNamesRule,
   NoUndefinedVariablesRule,
   NoUnusedVariablesRule,