graphql 14.0.2 → 14.2.1

package/language/parser.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2015-present, Facebook, Inc.
+ * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
@@ -8,6 +8,7 @@
  */
 
 import inspect from '../jsutils/inspect';
+import defineToJSON from '../jsutils/defineToJSON';
 import { Source } from './source';
 import { syntaxError } from '../error';
 import type { GraphQLError } from '../error';
@@ -115,17 +116,6 @@ export type ParseOptions = {
    * future.
    */
   experimentalFragmentVariables?: boolean,
-
-  /**
-   * EXPERIMENTAL:
-   *
-   * If enabled, the parser understands directives on variable definitions:
-   *
-   * query Foo($var: String = "abc" @variable_definition_directive) {
-   *   ...
-   * }
-   */
-  experimentalVariableDefinitionDirectives?: boolean,
 };
 
 /**
@@ -160,9 +150,9 @@ export function parseValue(
 ): ValueNode {
   const sourceObj = typeof source === 'string' ? new Source(source) : source;
   const lexer = createLexer(sourceObj, options || {});
-  expect(lexer, TokenKind.SOF);
+  expectToken(lexer, TokenKind.SOF);
   const value = parseValueLiteral(lexer, false);
-  expect(lexer, TokenKind.EOF);
+  expectToken(lexer, TokenKind.EOF);
   return value;
 }
 
@@ -182,9 +172,9 @@ export function parseType(
 ): TypeNode {
   const sourceObj = typeof source === 'string' ? new Source(source) : source;
   const lexer = createLexer(sourceObj, options || {});
-  expect(lexer, TokenKind.SOF);
+  expectToken(lexer, TokenKind.SOF);
   const type = parseTypeReference(lexer);
-  expect(lexer, TokenKind.EOF);
+  expectToken(lexer, TokenKind.EOF);
   return type;
 }
 
@@ -192,7 +182,7 @@ export function parseType(
  * Converts a name lex token into a name parse node.
  */
 function parseName(lexer: Lexer<*>): NameNode {
-  const token = expect(lexer, TokenKind.NAME);
+  const token = expectToken(lexer, TokenKind.NAME);
   return {
     kind: Kind.NAME,
     value: ((token.value: any): string),
@@ -312,7 +302,7 @@ function parseOperationDefinition(lexer: Lexer<*>): OperationDefinitionNode {
  * OperationType : one of query mutation subscription
  */
 function parseOperationType(lexer: Lexer<*>): OperationTypeNode {
-  const operationToken = expect(lexer, TokenKind.NAME);
+  const operationToken = expectToken(lexer, TokenKind.NAME);
   switch (operationToken.value) {
     case 'query':
       return 'query';
@@ -341,26 +331,14 @@ function parseVariableDefinitions(
  */
 function parseVariableDefinition(lexer: Lexer<*>): VariableDefinitionNode {
   const start = lexer.token;
-  if (lexer.options.experimentalVariableDefinitionDirectives) {
-    return {
-      kind: Kind.VARIABLE_DEFINITION,
-      variable: parseVariable(lexer),
-      type: (expect(lexer, TokenKind.COLON), parseTypeReference(lexer)),
-      defaultValue: skip(lexer, TokenKind.EQUALS)
-        ? parseValueLiteral(lexer, true)
-        : undefined,
-      directives: parseDirectives(lexer, true),
-      loc: loc(lexer, start),
-    };
-  }
-
   return {
     kind: Kind.VARIABLE_DEFINITION,
     variable: parseVariable(lexer),
-    type: (expect(lexer, TokenKind.COLON), parseTypeReference(lexer)),
-    defaultValue: skip(lexer, TokenKind.EQUALS)
+    type: (expectToken(lexer, TokenKind.COLON), parseTypeReference(lexer)),
+    defaultValue: expectOptionalToken(lexer, TokenKind.EQUALS)
       ? parseValueLiteral(lexer, true)
       : undefined,
+    directives: parseDirectives(lexer, true),
     loc: loc(lexer, start),
   };
 }
@@ -370,7 +348,7 @@ function parseVariableDefinition(lexer: Lexer<*>): VariableDefinitionNode {
  */
 function parseVariable(lexer: Lexer<*>): VariableNode {
   const start = lexer.token;
-  expect(lexer, TokenKind.DOLLAR);
+  expectToken(lexer, TokenKind.DOLLAR);
   return {
     kind: Kind.VARIABLE,
     name: parseName(lexer),
@@ -418,7 +396,7 @@ function parseField(lexer: Lexer<*>): FieldNode {
   const nameOrAlias = parseName(lexer);
   let alias;
   let name;
-  if (skip(lexer, TokenKind.COLON)) {
+  if (expectOptionalToken(lexer, TokenKind.COLON)) {
     alias = nameOrAlias;
     name = parseName(lexer);
   } else {
@@ -456,10 +434,13 @@ function parseArguments(
  */
 function parseArgument(lexer: Lexer<*>): ArgumentNode {
   const start = lexer.token;
+  const name = parseName(lexer);
+
+  expectToken(lexer, TokenKind.COLON);
   return {
     kind: Kind.ARGUMENT,
-    name: parseName(lexer),
-    value: (expect(lexer, TokenKind.COLON), parseValueLiteral(lexer, false)),
+    name,
+    value: parseValueLiteral(lexer, false),
     loc: loc(lexer, start),
   };
 }
@@ -469,7 +450,7 @@ function parseConstArgument(lexer: Lexer<*>): ArgumentNode {
   return {
     kind: Kind.ARGUMENT,
     name: parseName(lexer),
-    value: (expect(lexer, TokenKind.COLON), parseConstValue(lexer)),
+    value: (expectToken(lexer, TokenKind.COLON), parseConstValue(lexer)),
     loc: loc(lexer, start),
   };
 }
@@ -487,8 +468,10 @@ function parseFragment(
   lexer: Lexer<*>,
 ): FragmentSpreadNode | InlineFragmentNode {
   const start = lexer.token;
-  expect(lexer, TokenKind.SPREAD);
-  if (peek(lexer, TokenKind.NAME) && lexer.token.value !== 'on') {
+  expectToken(lexer, TokenKind.SPREAD);
+
+  const hasTypeCondition = expectOptionalKeyword(lexer, 'on');
+  if (!hasTypeCondition && peek(lexer, TokenKind.NAME)) {
     return {
       kind: Kind.FRAGMENT_SPREAD,
       name: parseFragmentName(lexer),
@@ -496,14 +479,9 @@ function parseFragment(
       loc: loc(lexer, start),
     };
   }
-  let typeCondition;
-  if (lexer.token.value === 'on') {
-    lexer.advance();
-    typeCondition = parseNamedType(lexer);
-  }
   return {
     kind: Kind.INLINE_FRAGMENT,
-    typeCondition,
+    typeCondition: hasTypeCondition ? parseNamedType(lexer) : undefined,
     directives: parseDirectives(lexer, false),
     selectionSet: parseSelectionSet(lexer),
     loc: loc(lexer, start),
@@ -668,14 +646,10 @@ function parseList(lexer: Lexer<*>, isConst: boolean): ListValueNode {
  */
 function parseObject(lexer: Lexer<*>, isConst: boolean): ObjectValueNode {
   const start = lexer.token;
-  expect(lexer, TokenKind.BRACE_L);
-  const fields = [];
-  while (!skip(lexer, TokenKind.BRACE_R)) {
-    fields.push(parseObjectField(lexer, isConst));
-  }
+  const item = () => parseObjectField(lexer, isConst);
   return {
     kind: Kind.OBJECT,
-    fields,
+    fields: any(lexer, TokenKind.BRACE_L, item, TokenKind.BRACE_R),
     loc: loc(lexer, start),
   };
 }
@@ -685,10 +659,13 @@ function parseObject(lexer: Lexer<*>, isConst: boolean): ObjectValueNode {
  */
 function parseObjectField(lexer: Lexer<*>, isConst: boolean): ObjectFieldNode {
   const start = lexer.token;
+  const name = parseName(lexer);
+  expectToken(lexer, TokenKind.COLON);
+
   return {
     kind: Kind.OBJECT_FIELD,
-    name: parseName(lexer),
-    value: (expect(lexer, TokenKind.COLON), parseValueLiteral(lexer, isConst)),
+    name,
+    value: parseValueLiteral(lexer, isConst),
     loc: loc(lexer, start),
   };
 }
@@ -714,7 +691,7 @@ function parseDirectives(
  */
 function parseDirective(lexer: Lexer<*>, isConst: boolean): DirectiveNode {
   const start = lexer.token;
-  expect(lexer, TokenKind.AT);
+  expectToken(lexer, TokenKind.AT);
   return {
     kind: Kind.DIRECTIVE,
     name: parseName(lexer),
@@ -734,9 +711,9 @@ function parseDirective(lexer: Lexer<*>, isConst: boolean): DirectiveNode {
 export function parseTypeReference(lexer: Lexer<*>): TypeNode {
   const start = lexer.token;
   let type;
-  if (skip(lexer, TokenKind.BRACKET_L)) {
+  if (expectOptionalToken(lexer, TokenKind.BRACKET_L)) {
     type = parseTypeReference(lexer);
-    expect(lexer, TokenKind.BRACKET_R);
+    expectToken(lexer, TokenKind.BRACKET_R);
     type = ({
       kind: Kind.LIST_TYPE,
       type,
@@ -745,7 +722,7 @@ export function parseTypeReference(lexer: Lexer<*>): TypeNode {
   } else {
     type = parseNamedType(lexer);
   }
-  if (skip(lexer, TokenKind.BANG)) {
+  if (expectOptionalToken(lexer, TokenKind.BANG)) {
     return ({
       kind: Kind.NON_NULL_TYPE,
       type,
@@ -853,7 +830,7 @@ function parseOperationTypeDefinition(
 ): OperationTypeDefinitionNode {
   const start = lexer.token;
   const operation = parseOperationType(lexer);
-  expect(lexer, TokenKind.COLON);
+  expectToken(lexer, TokenKind.COLON);
   const type = parseNamedType(lexer);
   return {
     kind: Kind.OPERATION_TYPE_DEFINITION,
@@ -912,14 +889,13 @@ function parseObjectTypeDefinition(lexer: Lexer<*>): ObjectTypeDefinitionNode {
  */
 function parseImplementsInterfaces(lexer: Lexer<*>): Array<NamedTypeNode> {
   const types = [];
-  if (lexer.token.value === 'implements') {
-    lexer.advance();
+  if (expectOptionalKeyword(lexer, 'implements')) {
     // Optional leading ampersand
-    skip(lexer, TokenKind.AMP);
+    expectOptionalToken(lexer, TokenKind.AMP);
     do {
       types.push(parseNamedType(lexer));
     } while (
-      skip(lexer, TokenKind.AMP) ||
+      expectOptionalToken(lexer, TokenKind.AMP) ||
       // Legacy support for the SDL?
       (lexer.options.allowLegacySDLImplementsInterfaces &&
         peek(lexer, TokenKind.NAME))
@@ -956,7 +932,7 @@ function parseFieldDefinition(lexer: Lexer<*>): FieldDefinitionNode {
   const description = parseDescription(lexer);
   const name = parseName(lexer);
   const args = parseArgumentDefs(lexer);
-  expect(lexer, TokenKind.COLON);
+  expectToken(lexer, TokenKind.COLON);
   const type = parseTypeReference(lexer);
   const directives = parseDirectives(lexer, true);
   return {
@@ -988,10 +964,10 @@ function parseInputValueDef(lexer: Lexer<*>): InputValueDefinitionNode {
   const start = lexer.token;
   const description = parseDescription(lexer);
   const name = parseName(lexer);
-  expect(lexer, TokenKind.COLON);
+  expectToken(lexer, TokenKind.COLON);
   const type = parseTypeReference(lexer);
   let defaultValue;
-  if (skip(lexer, TokenKind.EQUALS)) {
+  if (expectOptionalToken(lexer, TokenKind.EQUALS)) {
     defaultValue = parseConstValue(lexer);
   }
   const directives = parseDirectives(lexer, true);
@@ -1057,12 +1033,12 @@ function parseUnionTypeDefinition(lexer: Lexer<*>): UnionTypeDefinitionNode {
  */
 function parseUnionMemberTypes(lexer: Lexer<*>): Array<NamedTypeNode> {
   const types = [];
-  if (skip(lexer, TokenKind.EQUALS)) {
+  if (expectOptionalToken(lexer, TokenKind.EQUALS)) {
     // Optional leading pipe
-    skip(lexer, TokenKind.PIPE);
+    expectOptionalToken(lexer, TokenKind.PIPE);
     do {
       types.push(parseNamedType(lexer));
-    } while (skip(lexer, TokenKind.PIPE));
+    } while (expectOptionalToken(lexer, TokenKind.PIPE));
   }
   return types;
 }
@@ -1384,7 +1360,7 @@ function parseDirectiveDefinition(lexer: Lexer<*>): DirectiveDefinitionNode {
   const start = lexer.token;
   const description = parseDescription(lexer);
   expectKeyword(lexer, 'directive');
-  expect(lexer, TokenKind.AT);
+  expectToken(lexer, TokenKind.AT);
   const name = parseName(lexer);
   const args = parseArgumentDefs(lexer);
   expectKeyword(lexer, 'on');
@@ -1406,11 +1382,11 @@ function parseDirectiveDefinition(lexer: Lexer<*>): DirectiveDefinitionNode {
  */
 function parseDirectiveLocations(lexer: Lexer<*>): Array<NameNode> {
   // Optional leading pipe
-  skip(lexer, TokenKind.PIPE);
+  expectOptionalToken(lexer, TokenKind.PIPE);
   const locations = [];
   do {
     locations.push(parseDirectiveLocation(lexer));
-  } while (skip(lexer, TokenKind.PIPE));
+  } while (expectOptionalToken(lexer, TokenKind.PIPE));
   return locations;
 }
 
@@ -1471,9 +1447,9 @@ function Loc(startToken: Token, endToken: Token, source: Source) {
 }
 
 // Print a simplified form when appearing in JSON/util.inspect.
-Loc.prototype.toJSON = Loc.prototype.inspect = function toJSON() {
+defineToJSON(Loc, function() {
   return { start: this.start, end: this.end };
-};
+});
 
 /**
  * Determines if the next token is of a given kind
@@ -1482,28 +1458,17 @@ function peek(lexer: Lexer<*>, kind: TokenKindEnum): boolean {
   return lexer.token.kind === kind;
 }
 
-/**
- * If the next token is of the given kind, return true after advancing
- * the lexer. Otherwise, do not change the parser state and return false.
- */
-function skip(lexer: Lexer<*>, kind: TokenKindEnum): boolean {
-  const match = lexer.token.kind === kind;
-  if (match) {
-    lexer.advance();
-  }
-  return match;
-}
-
 /**
  * If the next token is of the given kind, return that token after advancing
  * the lexer. Otherwise, do not change the parser state and throw an error.
  */
-function expect(lexer: Lexer<*>, kind: TokenKindEnum): Token {
+function expectToken(lexer: Lexer<*>, kind: TokenKindEnum): Token {
   const token = lexer.token;
   if (token.kind === kind) {
     lexer.advance();
     return token;
   }
+
   throw syntaxError(
     lexer.source,
     token.start,
@@ -1512,9 +1477,21 @@ function expect(lexer: Lexer<*>, kind: TokenKindEnum): Token {
 }
 
 /**
- * If the next token is a keyword with the given value, return that token after
- * advancing the lexer. Otherwise, do not change the parser state and return
- * false.
+ * If the next token is of the given kind, return that token after advancing
+ * the lexer. Otherwise, do not change the parser state and return undefined.
+ */
+function expectOptionalToken(lexer: Lexer<*>, kind: TokenKindEnum): ?Token {
+  const token = lexer.token;
+  if (token.kind === kind) {
+    lexer.advance();
+    return token;
+  }
+  return undefined;
+}
+
+/**
+ * If the next token is a given keyword, return that token after advancing
+ * the lexer. Otherwise, do not change the parser state and throw an error.
  */
 function expectKeyword(lexer: Lexer<*>, value: string): Token {
   const token = lexer.token;
@@ -1522,6 +1499,7 @@ function expectKeyword(lexer: Lexer<*>, value: string): Token {
     lexer.advance();
     return token;
   }
+
   throw syntaxError(
     lexer.source,
     token.start,
@@ -1529,6 +1507,19 @@ function expectKeyword(lexer: Lexer<*>, value: string): Token {
   );
 }
 
+/**
+ * If the next token is a given keyword, return that token after advancing
+ * the lexer. Otherwise, do not change the parser state and return undefined.
+ */
+function expectOptionalKeyword(lexer: Lexer<*>, value: string): ?Token {
+  const token = lexer.token;
+  if (token.kind === TokenKind.NAME && token.value === value) {
+    lexer.advance();
+    return token;
+  }
+  return undefined;
+}
+
 /**
  * Helper function for creating an error when an unexpected lexed token
  * is encountered.
@@ -1554,9 +1545,9 @@ function any<T>(
   parseFn: (lexer: Lexer<*>) => T,
   closeKind: TokenKindEnum,
 ): Array<T> {
-  expect(lexer, openKind);
+  expectToken(lexer, openKind);
   const nodes = [];
-  while (!skip(lexer, closeKind)) {
+  while (!expectOptionalToken(lexer, closeKind)) {
     nodes.push(parseFn(lexer));
   }
   return nodes;
@@ -1574,9 +1565,9 @@ function many<T>(
   parseFn: (lexer: Lexer<*>) => T,
   closeKind: TokenKindEnum,
 ): Array<T> {
-  expect(lexer, openKind);
+  expectToken(lexer, openKind);
   const nodes = [parseFn(lexer)];
-  while (!skip(lexer, closeKind)) {
+  while (!expectOptionalToken(lexer, closeKind)) {
     nodes.push(parseFn(lexer));
   }
   return nodes;