cubefs

1
package parser
2

3
import (
4
	"fmt"
5

6
	"github.com/graphql-go/graphql/gqlerrors"
7
	"github.com/graphql-go/graphql/language/ast"
8
	"github.com/graphql-go/graphql/language/lexer"
9
	"github.com/graphql-go/graphql/language/source"
10
)
11

12
type parseFn func(parser *Parser) (interface{}, error)
13

14
// parse operation, fragment, typeSystem{schema, type..., extension, directives} definition
15
type parseDefinitionFn func(parser *Parser) (ast.Node, error)
16

17
var tokenDefinitionFn map[string]parseDefinitionFn
18

19
func init() {
20
	tokenDefinitionFn = make(map[string]parseDefinitionFn)
21
	{
22
		// for sign
23
		tokenDefinitionFn[lexer.BRACE_L.String()] = parseOperationDefinition
24
		tokenDefinitionFn[lexer.STRING.String()] = parseTypeSystemDefinition
25
		tokenDefinitionFn[lexer.BLOCK_STRING.String()] = parseTypeSystemDefinition
26
		tokenDefinitionFn[lexer.NAME.String()] = parseTypeSystemDefinition
27
		// for NAME
28
		tokenDefinitionFn[lexer.FRAGMENT] = parseFragmentDefinition
29
		tokenDefinitionFn[lexer.QUERY] = parseOperationDefinition
30
		tokenDefinitionFn[lexer.MUTATION] = parseOperationDefinition
31
		tokenDefinitionFn[lexer.SUBSCRIPTION] = parseOperationDefinition
32
		tokenDefinitionFn[lexer.SCHEMA] = parseSchemaDefinition
33
		tokenDefinitionFn[lexer.SCALAR] = parseScalarTypeDefinition
34
		tokenDefinitionFn[lexer.TYPE] = parseObjectTypeDefinition
35
		tokenDefinitionFn[lexer.INTERFACE] = parseInterfaceTypeDefinition
36
		tokenDefinitionFn[lexer.UNION] = parseUnionTypeDefinition
37
		tokenDefinitionFn[lexer.ENUM] = parseEnumTypeDefinition
38
		tokenDefinitionFn[lexer.INPUT] = parseInputObjectTypeDefinition
39
		tokenDefinitionFn[lexer.EXTEND] = parseTypeExtensionDefinition
40
		tokenDefinitionFn[lexer.DIRECTIVE] = parseDirectiveDefinition
41
	}
42
}
43

44
type ParseOptions struct {
45
	NoLocation bool
46
	NoSource   bool
47
}
48

49
type ParseParams struct {
50
	Source  interface{}
51
	Options ParseOptions
52
}
53

54
type Parser struct {
55
	LexToken lexer.Lexer
56
	Source   *source.Source
57
	Options  ParseOptions
58
	PrevEnd  int
59
	Token    lexer.Token
60
}
61

62
func Parse(p ParseParams) (*ast.Document, error) {
63
	var sourceObj *source.Source
64
	switch src := p.Source.(type) {
65
	case *source.Source:
66
		sourceObj = src
67
	default:
68
		body, _ := p.Source.(string)
69
		sourceObj = source.NewSource(&source.Source{Body: []byte(body)})
70
	}
71
	parser, err := makeParser(sourceObj, p.Options)
72
	if err != nil {
73
		return nil, err
74
	}
75
	doc, err := parseDocument(parser)
76
	if err != nil {
77
		return nil, err
78
	}
79
	return doc, nil
80
}
81

82
// TODO: test and expose parseValue as a public
83
func parseValue(p ParseParams) (ast.Value, error) {
84
	var value ast.Value
85
	var sourceObj *source.Source
86
	switch src := p.Source.(type) {
87
	case *source.Source:
88
		sourceObj = src
89
	default:
90
		body, _ := p.Source.(string)
91
		sourceObj = source.NewSource(&source.Source{Body: []byte(body)})
92
	}
93
	parser, err := makeParser(sourceObj, p.Options)
94
	if err != nil {
95
		return value, err
96
	}
97
	value, err = parseValueLiteral(parser, false)
98
	if err != nil {
99
		return value, err
100
	}
101
	return value, nil
102
}
103

104
// Converts a name lex token into a name parse node.
105
func parseName(parser *Parser) (*ast.Name, error) {
106
	token, err := expect(parser, lexer.NAME)
107
	if err != nil {
108
		return nil, err
109
	}
110
	return ast.NewName(&ast.Name{
111
		Value: token.Value,
112
		Loc:   loc(parser, token.Start),
113
	}), nil
114
}
115

116
func makeParser(s *source.Source, opts ParseOptions) (*Parser, error) {
117
	lexToken := lexer.Lex(s)
118
	token, err := lexToken(0)
119
	if err != nil {
120
		return &Parser{}, err
121
	}
122
	return &Parser{
123
		LexToken: lexToken,
124
		Source:   s,
125
		Options:  opts,
126
		PrevEnd:  0,
127
		Token:    token,
128
	}, nil
129
}
130

131
/* Implements the parsing rules in the Document section. */
132

133
func parseDocument(parser *Parser) (*ast.Document, error) {
134
	var (
135
		nodes []ast.Node
136
		node  ast.Node
137
		item  parseDefinitionFn
138
		err   error
139
	)
140
	start := parser.Token.Start
141
	for {
142
		if skp, err := skip(parser, lexer.EOF); err != nil {
143
			return nil, err
144
		} else if skp {
145
			break
146
		}
147
		switch kind := parser.Token.Kind; kind {
148
		case lexer.BRACE_L, lexer.NAME, lexer.STRING, lexer.BLOCK_STRING:
149
			item = tokenDefinitionFn[kind.String()]
150
		default:
151
			return nil, unexpected(parser, lexer.Token{})
152
		}
153
		if node, err = item(parser); err != nil {
154
			return nil, err
155
		}
156
		nodes = append(nodes, node)
157
	}
158
	return ast.NewDocument(&ast.Document{
159
		Loc:         loc(parser, start),
160
		Definitions: nodes,
161
	}), nil
162
}
163

164
/* Implements the parsing rules in the Operations section. */
165

166
/**
167
 * OperationDefinition :
168
 *  - SelectionSet
169
 *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
170
 */
171
func parseOperationDefinition(parser *Parser) (ast.Node, error) {
172
	var (
173
		operation           string
174
		variableDefinitions []*ast.VariableDefinition
175
		name                *ast.Name
176
		directives          []*ast.Directive
177
		selectionSet        *ast.SelectionSet
178
		err                 error
179
	)
180
	start := parser.Token.Start
181
	if peek(parser, lexer.BRACE_L) {
182
		selectionSet, err := parseSelectionSet(parser)
183
		if err != nil {
184
			return nil, err
185
		}
186
		return ast.NewOperationDefinition(&ast.OperationDefinition{
187
			Operation:    ast.OperationTypeQuery,
188
			Directives:   []*ast.Directive{},
189
			SelectionSet: selectionSet,
190
			Loc:          loc(parser, start),
191
		}), nil
192
	}
193
	if operation, err = parseOperationType(parser); err != nil {
194
		return nil, err
195
	}
196

197
	if peek(parser, lexer.NAME) {
198
		if name, err = parseName(parser); err != nil {
199
			return nil, err
200
		}
201
	}
202
	if variableDefinitions, err = parseVariableDefinitions(parser); err != nil {
203
		return nil, err
204
	}
205
	if directives, err = parseDirectives(parser); err != nil {
206
		return nil, err
207
	}
208
	if selectionSet, err = parseSelectionSet(parser); err != nil {
209
		return nil, err
210
	}
211
	return ast.NewOperationDefinition(&ast.OperationDefinition{
212
		Operation:           operation,
213
		Name:                name,
214
		VariableDefinitions: variableDefinitions,
215
		Directives:          directives,
216
		SelectionSet:        selectionSet,
217
		Loc:                 loc(parser, start),
218
	}), nil
219
}
220

221
/**
222
 * OperationType : one of query mutation subscription
223
 */
224
func parseOperationType(parser *Parser) (string, error) {
225
	operationToken, err := expect(parser, lexer.NAME)
226
	if err != nil {
227
		return "", err
228
	}
229
	switch operationToken.Value {
230
	case ast.OperationTypeQuery:
231
		return operationToken.Value, nil
232
	case ast.OperationTypeMutation:
233
		return operationToken.Value, nil
234
	case ast.OperationTypeSubscription:
235
		return operationToken.Value, nil
236
	default:
237
		return "", unexpected(parser, operationToken)
238
	}
239
}
240

241
/**
242
 * VariableDefinitions : ( VariableDefinition+ )
243
 */
244
func parseVariableDefinitions(parser *Parser) ([]*ast.VariableDefinition, error) {
245
	variableDefinitions := []*ast.VariableDefinition{}
246
	if !peek(parser, lexer.PAREN_L) {
247
		return variableDefinitions, nil
248
	}
249
	if vdefs, err := reverse(parser,
250
		lexer.PAREN_L, parseVariableDefinition, lexer.PAREN_R,
251
		true,
252
	); err != nil {
253
		return variableDefinitions, err
254
	} else {
255
		for _, vdef := range vdefs {
256
			variableDefinitions = append(variableDefinitions, vdef.(*ast.VariableDefinition))
257
		}
258
	}
259
	return variableDefinitions, nil
260
}
261

262
/**
263
 * VariableDefinition : Variable : Type DefaultValue?
264
 */
265
func parseVariableDefinition(parser *Parser) (interface{}, error) {
266
	var (
267
		variable *ast.Variable
268
		ttype    ast.Type
269
		err      error
270
	)
271
	start := parser.Token.Start
272
	if variable, err = parseVariable(parser); err != nil {
273
		return nil, err
274
	}
275
	if _, err = expect(parser, lexer.COLON); err != nil {
276
		return nil, err
277
	}
278
	if ttype, err = parseType(parser); err != nil {
279
		return nil, err
280
	}
281
	var defaultValue ast.Value
282
	if skp, err := skip(parser, lexer.EQUALS); err != nil {
283
		return nil, err
284
	} else if skp {
285
		if defaultValue, err = parseValueLiteral(parser, true); err != nil {
286
			return nil, err
287
		}
288
	}
289
	return ast.NewVariableDefinition(&ast.VariableDefinition{
290
		Variable:     variable,
291
		Type:         ttype,
292
		DefaultValue: defaultValue,
293
		Loc:          loc(parser, start),
294
	}), nil
295
}
296

297
/**
298
 * Variable : $ Name
299
 */
300
func parseVariable(parser *Parser) (*ast.Variable, error) {
301
	var (
302
		err  error
303
		name *ast.Name
304
	)
305
	start := parser.Token.Start
306
	if _, err = expect(parser, lexer.DOLLAR); err != nil {
307
		return nil, err
308
	}
309
	if name, err = parseName(parser); err != nil {
310
		return nil, err
311
	}
312
	return ast.NewVariable(&ast.Variable{
313
		Name: name,
314
		Loc:  loc(parser, start),
315
	}), nil
316
}
317

318
/**
319
 * SelectionSet : { Selection+ }
320
 */
321
func parseSelectionSet(parser *Parser) (*ast.SelectionSet, error) {
322
	start := parser.Token.Start
323
	selections := []ast.Selection{}
324
	if iSelections, err := reverse(parser,
325
		lexer.BRACE_L, parseSelection, lexer.BRACE_R,
326
		true,
327
	); err != nil {
328
		return nil, err
329
	} else {
330
		for _, iSelection := range iSelections {
331
			selections = append(selections, iSelection.(ast.Selection))
332
		}
333
	}
334

335
	return ast.NewSelectionSet(&ast.SelectionSet{
336
		Selections: selections,
337
		Loc:        loc(parser, start),
338
	}), nil
339
}
340

341
/**
342
 * Selection :
343
 *   - Field
344
 *   - FragmentSpread
345
 *   - InlineFragment
346
 */
347
func parseSelection(parser *Parser) (interface{}, error) {
348
	if peek(parser, lexer.SPREAD) {
349
		return parseFragment(parser)
350
	}
351
	return parseField(parser)
352
}
353

354
/**
355
 * Field : Alias? Name Arguments? Directives? SelectionSet?
356
 *
357
 * Alias : Name :
358
 */
359
func parseField(parser *Parser) (*ast.Field, error) {
360
	var (
361
		name       *ast.Name
362
		alias      *ast.Name
363
		arguments  []*ast.Argument
364
		directives []*ast.Directive
365
		err        error
366
	)
367
	start := parser.Token.Start
368
	if name, err = parseName(parser); err != nil {
369
		return nil, err
370
	}
371
	if skp, err := skip(parser, lexer.COLON); err != nil {
372
		return nil, err
373
	} else if skp {
374
		alias = name
375
		if name, err = parseName(parser); err != nil {
376
			return nil, err
377
		}
378
	}
379
	if arguments, err = parseArguments(parser); err != nil {
380
		return nil, err
381
	}
382
	if directives, err = parseDirectives(parser); err != nil {
383
		return nil, err
384
	}
385
	var selectionSet *ast.SelectionSet
386
	if peek(parser, lexer.BRACE_L) {
387
		if selectionSet, err = parseSelectionSet(parser); err != nil {
388
			return nil, err
389
		}
390
	}
391
	return ast.NewField(&ast.Field{
392
		Alias:        alias,
393
		Name:         name,
394
		Arguments:    arguments,
395
		Directives:   directives,
396
		SelectionSet: selectionSet,
397
		Loc:          loc(parser, start),
398
	}), nil
399
}
400

401
/**
402
 * Arguments : ( Argument+ )
403
 */
404
func parseArguments(parser *Parser) ([]*ast.Argument, error) {
405
	arguments := []*ast.Argument{}
406
	if peek(parser, lexer.PAREN_L) {
407
		if iArguments, err := reverse(parser,
408
			lexer.PAREN_L, parseArgument, lexer.PAREN_R,
409
			true,
410
		); err != nil {
411
			return arguments, err
412
		} else {
413
			for _, iArgument := range iArguments {
414
				arguments = append(arguments, iArgument.(*ast.Argument))
415
			}
416
		}
417
	}
418
	return arguments, nil
419
}
420

421
/**
422
 * Argument : Name : Value
423
 */
424
func parseArgument(parser *Parser) (interface{}, error) {
425
	var (
426
		err   error
427
		name  *ast.Name
428
		value ast.Value
429
	)
430
	start := parser.Token.Start
431
	if name, err = parseName(parser); err != nil {
432
		return nil, err
433
	}
434
	if _, err = expect(parser, lexer.COLON); err != nil {
435
		return nil, err
436
	}
437
	if value, err = parseValueLiteral(parser, false); err != nil {
438
		return nil, err
439
	}
440
	return ast.NewArgument(&ast.Argument{
441
		Name:  name,
442
		Value: value,
443
		Loc:   loc(parser, start),
444
	}), nil
445
}
446

447
/* Implements the parsing rules in the Fragments section. */
448

449
/**
450
 * Corresponds to both FragmentSpread and InlineFragment in the spec.
451
 *
452
 * FragmentSpread : ... FragmentName Directives?
453
 *
454
 * InlineFragment : ... TypeCondition? Directives? SelectionSet
455
 */
456
func parseFragment(parser *Parser) (interface{}, error) {
457
	var (
458
		err error
459
	)
460
	start := parser.Token.Start
461
	if _, err = expect(parser, lexer.SPREAD); err != nil {
462
		return nil, err
463
	}
464
	if peek(parser, lexer.NAME) && parser.Token.Value != "on" {
465
		name, err := parseFragmentName(parser)
466
		if err != nil {
467
			return nil, err
468
		}
469
		directives, err := parseDirectives(parser)
470
		if err != nil {
471
			return nil, err
472
		}
473
		return ast.NewFragmentSpread(&ast.FragmentSpread{
474
			Name:       name,
475
			Directives: directives,
476
			Loc:        loc(parser, start),
477
		}), nil
478
	}
479
	var typeCondition *ast.Named
480
	if parser.Token.Value == "on" {
481
		if err := advance(parser); err != nil {
482
			return nil, err
483
		}
484
		name, err := parseNamed(parser)
485
		if err != nil {
486
			return nil, err
487
		}
488
		typeCondition = name
489

490
	}
491
	directives, err := parseDirectives(parser)
492
	if err != nil {
493
		return nil, err
494
	}
495
	selectionSet, err := parseSelectionSet(parser)
496
	if err != nil {
497
		return nil, err
498
	}
499
	return ast.NewInlineFragment(&ast.InlineFragment{
500
		TypeCondition: typeCondition,
501
		Directives:    directives,
502
		SelectionSet:  selectionSet,
503
		Loc:           loc(parser, start),
504
	}), nil
505
}
506

507
/**
508
 * FragmentDefinition :
509
 *   - fragment FragmentName on TypeCondition Directives? SelectionSet
510
 *
511
 * TypeCondition : NamedType
512
 */
513
func parseFragmentDefinition(parser *Parser) (ast.Node, error) {
514
	start := parser.Token.Start
515
	_, err := expectKeyWord(parser, lexer.FRAGMENT)
516
	if err != nil {
517
		return nil, err
518
	}
519
	name, err := parseFragmentName(parser)
520
	if err != nil {
521
		return nil, err
522
	}
523
	_, err = expectKeyWord(parser, "on")
524
	if err != nil {
525
		return nil, err
526
	}
527
	typeCondition, err := parseNamed(parser)
528
	if err != nil {
529
		return nil, err
530
	}
531
	directives, err := parseDirectives(parser)
532
	if err != nil {
533
		return nil, err
534
	}
535
	selectionSet, err := parseSelectionSet(parser)
536
	if err != nil {
537
		return nil, err
538
	}
539
	return ast.NewFragmentDefinition(&ast.FragmentDefinition{
540
		Name:          name,
541
		TypeCondition: typeCondition,
542
		Directives:    directives,
543
		SelectionSet:  selectionSet,
544
		Loc:           loc(parser, start),
545
	}), nil
546
}
547

548
/**
549
 * FragmentName : Name but not `on`
550
 */
551
func parseFragmentName(parser *Parser) (*ast.Name, error) {
552
	if parser.Token.Value == "on" {
553
		return nil, unexpected(parser, lexer.Token{})
554
	}
555
	return parseName(parser)
556
}
557

558
/* Implements the parsing rules in the Values section. */
559

560
/**
561
 * Value[Const] :
562
 *   - [~Const] Variable
563
 *   - IntValue
564
 *   - FloatValue
565
 *   - StringValue
566
 *   - BooleanValue
567
 *   - EnumValue
568
 *   - ListValue[?Const]
569
 *   - ObjectValue[?Const]
570
 *
571
 * BooleanValue : one of `true` `false`
572
 *
573
 * EnumValue : Name but not `true`, `false` or `null`
574
 */
575
func parseValueLiteral(parser *Parser, isConst bool) (ast.Value, error) {
576
	token := parser.Token
577
	switch token.Kind {
578
	case lexer.BRACKET_L:
579
		return parseList(parser, isConst)
580
	case lexer.BRACE_L:
581
		return parseObject(parser, isConst)
582
	case lexer.INT:
583
		if err := advance(parser); err != nil {
584
			return nil, err
585
		}
586
		return ast.NewIntValue(&ast.IntValue{
587
			Value: token.Value,
588
			Loc:   loc(parser, token.Start),
589
		}), nil
590
	case lexer.FLOAT:
591
		if err := advance(parser); err != nil {
592
			return nil, err
593
		}
594
		return ast.NewFloatValue(&ast.FloatValue{
595
			Value: token.Value,
596
			Loc:   loc(parser, token.Start),
597
		}), nil
598
	case lexer.BLOCK_STRING, lexer.STRING:
599
		return parseStringLiteral(parser)
600
	case lexer.NAME:
601
		if token.Value == "true" || token.Value == "false" {
602
			if err := advance(parser); err != nil {
603
				return nil, err
604
			}
605
			value := true
606
			if token.Value == "false" {
607
				value = false
608
			}
609
			return ast.NewBooleanValue(&ast.BooleanValue{
610
				Value: value,
611
				Loc:   loc(parser, token.Start),
612
			}), nil
613
		} else if token.Value != "null" {
614
			if err := advance(parser); err != nil {
615
				return nil, err
616
			}
617
			return ast.NewEnumValue(&ast.EnumValue{
618
				Value: token.Value,
619
				Loc:   loc(parser, token.Start),
620
			}), nil
621
		}
622
	case lexer.DOLLAR:
623
		if !isConst {
624
			return parseVariable(parser)
625
		}
626
	}
627

628
	return nil, unexpected(parser, lexer.Token{})
629
}
630

631
func parseConstValue(parser *Parser) (interface{}, error) {
632
	value, err := parseValueLiteral(parser, true)
633
	if err != nil {
634
		return value, err
635
	}
636
	return value, nil
637
}
638

639
func parseValueValue(parser *Parser) (interface{}, error) {
640
	return parseValueLiteral(parser, false)
641
}
642

643
/**
644
 * ListValue[Const] :
645
 *   - [ ]
646
 *   - [ Value[?Const]+ ]
647
 */
648
func parseList(parser *Parser, isConst bool) (*ast.ListValue, error) {
649
	start := parser.Token.Start
650
	var item parseFn = parseValueValue
651
	if isConst {
652
		item = parseConstValue
653
	}
654
	values := []ast.Value{}
655
	if iValues, err := reverse(parser,
656
		lexer.BRACKET_L, item, lexer.BRACKET_R,
657
		false,
658
	); err != nil {
659
		return nil, err
660
	} else {
661
		for _, iValue := range iValues {
662
			values = append(values, iValue.(ast.Value))
663
		}
664
	}
665
	return ast.NewListValue(&ast.ListValue{
666
		Values: values,
667
		Loc:    loc(parser, start),
668
	}), nil
669
}
670

671
/**
672
 * ObjectValue[Const] :
673
 *   - { }
674
 *   - { ObjectField[?Const]+ }
675
 */
676
func parseObject(parser *Parser, isConst bool) (*ast.ObjectValue, error) {
677
	start := parser.Token.Start
678
	if _, err := expect(parser, lexer.BRACE_L); err != nil {
679
		return nil, err
680
	}
681
	fields := []*ast.ObjectField{}
682
	for {
683
		if skp, err := skip(parser, lexer.BRACE_R); err != nil {
684
			return nil, err
685
		} else if skp {
686
			break
687
		}
688
		if field, err := parseObjectField(parser, isConst); err != nil {
689
			return nil, err
690
		} else {
691
			fields = append(fields, field)
692
		}
693
	}
694
	return ast.NewObjectValue(&ast.ObjectValue{
695
		Fields: fields,
696
		Loc:    loc(parser, start),
697
	}), nil
698
}
699

700
/**
701
 * ObjectField[Const] : Name : Value[?Const]
702
 */
703
func parseObjectField(parser *Parser, isConst bool) (*ast.ObjectField, error) {
704
	var (
705
		name  *ast.Name
706
		value ast.Value
707
		err   error
708
	)
709
	start := parser.Token.Start
710
	if name, err = parseName(parser); err != nil {
711
		return nil, err
712
	}
713
	if _, err = expect(parser, lexer.COLON); err != nil {
714
		return nil, err
715
	}
716
	if value, err = parseValueLiteral(parser, isConst); err != nil {
717
		return nil, err
718
	}
719
	return ast.NewObjectField(&ast.ObjectField{
720
		Name:  name,
721
		Value: value,
722
		Loc:   loc(parser, start),
723
	}), nil
724
}
725

726
/* Implements the parsing rules in the Directives section. */
727

728
/**
729
 * Directives : Directive+
730
 */
731
func parseDirectives(parser *Parser) ([]*ast.Directive, error) {
732
	directives := []*ast.Directive{}
733
	for peek(parser, lexer.AT) {
734
		if directive, err := parseDirective(parser); err != nil {
735
			return directives, err
736
		} else {
737
			directives = append(directives, directive)
738
		}
739
	}
740
	return directives, nil
741
}
742

743
/**
744
 * Directive : @ Name Arguments?
745
 */
746
func parseDirective(parser *Parser) (*ast.Directive, error) {
747
	var (
748
		err  error
749
		name *ast.Name
750
		args []*ast.Argument
751
	)
752
	start := parser.Token.Start
753
	if _, err = expect(parser, lexer.AT); err != nil {
754
		return nil, err
755
	}
756
	if name, err = parseName(parser); err != nil {
757
		return nil, err
758
	}
759
	if args, err = parseArguments(parser); err != nil {
760
		return nil, err
761
	}
762
	return ast.NewDirective(&ast.Directive{
763
		Name:      name,
764
		Arguments: args,
765
		Loc:       loc(parser, start),
766
	}), nil
767
}
768

769
/* Implements the parsing rules in the Types section. */
770

771
/**
772
 * Type :
773
 *   - NamedType
774
 *   - ListType
775
 *   - NonNullType
776
 */
777
func parseType(parser *Parser) (ttype ast.Type, err error) {
778
	token := parser.Token
779
	// [ String! ]!
780
	switch token.Kind {
781
	case lexer.BRACKET_L:
782
		if err = advance(parser); err != nil {
783
			return nil, err
784
		}
785
		if ttype, err = parseType(parser); err != nil {
786
			return nil, err
787
		}
788
		fallthrough
789
	case lexer.BRACKET_R:
790
		if err = advance(parser); err != nil {
791
			return nil, err
792
		}
793
		ttype = ast.NewList(&ast.List{
794
			Type: ttype,
795
			Loc:  loc(parser, token.Start),
796
		})
797
	case lexer.NAME:
798
		if ttype, err = parseNamed(parser); err != nil {
799
			return nil, err
800
		}
801
	}
802

803
	// BANG must be executed
804
	if skp, err := skip(parser, lexer.BANG); err != nil {
805
		return nil, err
806
	} else if skp {
807
		ttype = ast.NewNonNull(&ast.NonNull{
808
			Type: ttype,
809
			Loc:  loc(parser, token.Start),
810
		})
811
	}
812
	return ttype, nil
813
}
814

815
/**
816
 * NamedType : Name
817
 */
818
func parseNamed(parser *Parser) (*ast.Named, error) {
819
	start := parser.Token.Start
820
	name, err := parseName(parser)
821
	if err != nil {
822
		return nil, err
823
	}
824
	return ast.NewNamed(&ast.Named{
825
		Name: name,
826
		Loc:  loc(parser, start),
827
	}), nil
828
}
829

830
/* Implements the parsing rules in the Type Definition section. */
831

832
/**
833
 * TypeSystemDefinition :
834
 *   - SchemaDefinition
835
 *   - TypeDefinition
836
 *   - TypeExtension
837
 *   - DirectiveDefinition
838
 *
839
 * TypeDefinition :
840
 *   - ScalarTypeDefinition
841
 *   - ObjectTypeDefinition
842
 *   - InterfaceTypeDefinition
843
 *   - UnionTypeDefinition
844
 *   - EnumTypeDefinition
845
 *   - InputObjectTypeDefinition
846
 */
847
func parseTypeSystemDefinition(parser *Parser) (ast.Node, error) {
848
	var (
849
		item parseDefinitionFn
850
		err  error
851
	)
852
	// Many definitions begin with a description and require a lookahead.
853
	keywordToken := parser.Token
854
	if peekDescription(parser) {
855
		if keywordToken, err = lookahead(parser); err != nil {
856
			return nil, err
857
		}
858
	}
859

860
	if keywordToken.Kind != lexer.NAME {
861
		return nil, unexpected(parser, keywordToken)
862
	}
863
	var ok bool
864
	if item, ok = tokenDefinitionFn[keywordToken.Value]; !ok {
865
		return nil, unexpected(parser, keywordToken)
866
	}
867
	return item(parser)
868
}
869

870
/**
871
 * SchemaDefinition : schema Directives? { OperationTypeDefinition+ }
872
 *
873
 * OperationTypeDefinition : OperationType : NamedType
874
 */
875
func parseSchemaDefinition(parser *Parser) (ast.Node, error) {
876
	start := parser.Token.Start
877
	_, err := expectKeyWord(parser, "schema")
878
	if err != nil {
879
		return nil, err
880
	}
881
	directives, err := parseDirectives(parser)
882
	if err != nil {
883
		return nil, err
884
	}
885
	operationTypesI, err := reverse(
886
		parser,
887
		lexer.BRACE_L, parseOperationTypeDefinition, lexer.BRACE_R,
888
		true,
889
	)
890
	if err != nil {
891
		return nil, err
892
	}
893
	operationTypes := []*ast.OperationTypeDefinition{}
894
	for _, op := range operationTypesI {
895
		if op, ok := op.(*ast.OperationTypeDefinition); ok {
896
			operationTypes = append(operationTypes, op)
897
		}
898
	}
899
	return ast.NewSchemaDefinition(&ast.SchemaDefinition{
900
		OperationTypes: operationTypes,
901
		Directives:     directives,
902
		Loc:            loc(parser, start),
903
	}), nil
904
}
905

906
func parseOperationTypeDefinition(parser *Parser) (interface{}, error) {
907
	start := parser.Token.Start
908
	operation, err := parseOperationType(parser)
909
	if err != nil {
910
		return nil, err
911
	}
912
	_, err = expect(parser, lexer.COLON)
913
	if err != nil {
914
		return nil, err
915
	}
916
	ttype, err := parseNamed(parser)
917
	if err != nil {
918
		return nil, err
919
	}
920
	return ast.NewOperationTypeDefinition(&ast.OperationTypeDefinition{
921
		Operation: operation,
922
		Type:      ttype,
923
		Loc:       loc(parser, start),
924
	}), nil
925
}
926

927
/**
928
 * ScalarTypeDefinition : Description? scalar Name Directives?
929
 */
930
func parseScalarTypeDefinition(parser *Parser) (ast.Node, error) {
931
	start := parser.Token.Start
932
	description, err := parseDescription(parser)
933
	if err != nil {
934
		return nil, err
935
	}
936
	_, err = expectKeyWord(parser, lexer.SCALAR)
937
	if err != nil {
938
		return nil, err
939
	}
940
	name, err := parseName(parser)
941
	if err != nil {
942
		return nil, err
943
	}
944
	directives, err := parseDirectives(parser)
945
	if err != nil {
946
		return nil, err
947
	}
948
	def := ast.NewScalarDefinition(&ast.ScalarDefinition{
949
		Name:        name,
950
		Description: description,
951
		Directives:  directives,
952
		Loc:         loc(parser, start),
953
	})
954
	return def, nil
955
}
956

957
/**
958
 * ObjectTypeDefinition :
959
 *   Description?
960
 *   type Name ImplementsInterfaces? Directives? { FieldDefinition+ }
961
 */
962
func parseObjectTypeDefinition(parser *Parser) (ast.Node, error) {
963
	start := parser.Token.Start
964
	description, err := parseDescription(parser)
965
	if err != nil {
966
		return nil, err
967
	}
968
	_, err = expectKeyWord(parser, lexer.TYPE)
969
	if err != nil {
970
		return nil, err
971
	}
972
	name, err := parseName(parser)
973
	if err != nil {
974
		return nil, err
975
	}
976
	interfaces, err := parseImplementsInterfaces(parser)
977
	if err != nil {
978
		return nil, err
979
	}
980
	directives, err := parseDirectives(parser)
981
	if err != nil {
982
		return nil, err
983
	}
984
	iFields, err := reverse(parser,
985
		lexer.BRACE_L, parseFieldDefinition, lexer.BRACE_R,
986
		false,
987
	)
988
	if err != nil {
989
		return nil, err
990
	}
991
	fields := []*ast.FieldDefinition{}
992
	for _, iField := range iFields {
993
		if iField != nil {
994
			fields = append(fields, iField.(*ast.FieldDefinition))
995
		}
996
	}
997
	return ast.NewObjectDefinition(&ast.ObjectDefinition{
998
		Name:        name,
999
		Description: description,
1000
		Loc:         loc(parser, start),
1001
		Interfaces:  interfaces,
1002
		Directives:  directives,
1003
		Fields:      fields,
1004
	}), nil
1005
}
1006

1007
/**
1008
 * ImplementsInterfaces :
1009
 *   - implements `&`? NamedType
1010
 *   - ImplementsInterfaces & NamedType
1011
 */
1012
func parseImplementsInterfaces(parser *Parser) ([]*ast.Named, error) {
1013
	types := []*ast.Named{}
1014
	if parser.Token.Value == "implements" {
1015
		if err := advance(parser); err != nil {
1016
			return nil, err
1017
		}
1018
		// optional leading ampersand
1019
		skip(parser, lexer.AMP)
1020
		for {
1021
			ttype, err := parseNamed(parser)
1022
			if err != nil {
1023
				return types, err
1024
			}
1025
			types = append(types, ttype)
1026
			if skipped, err := skip(parser, lexer.AMP); !skipped {
1027
				break
1028
			} else if err != nil {
1029
				return types, err
1030
			}
1031
		}
1032
	}
1033
	return types, nil
1034
}
1035

1036
/**
1037
 * FieldDefinition : Description? Name ArgumentsDefinition? : Type Directives?
1038
 */
1039
func parseFieldDefinition(parser *Parser) (interface{}, error) {
1040
	start := parser.Token.Start
1041
	description, err := parseDescription(parser)
1042
	if err != nil {
1043
		return nil, err
1044
	}
1045
	name, err := parseName(parser)
1046
	if err != nil {
1047
		return nil, err
1048
	}
1049
	args, err := parseArgumentDefs(parser)
1050
	if err != nil {
1051
		return nil, err
1052
	}
1053
	_, err = expect(parser, lexer.COLON)
1054
	if err != nil {
1055
		return nil, err
1056
	}
1057
	ttype, err := parseType(parser)
1058
	if err != nil {
1059
		return nil, err
1060
	}
1061
	directives, err := parseDirectives(parser)
1062
	if err != nil {
1063
		return nil, err
1064
	}
1065
	return ast.NewFieldDefinition(&ast.FieldDefinition{
1066
		Name:        name,
1067
		Description: description,
1068
		Arguments:   args,
1069
		Type:        ttype,
1070
		Directives:  directives,
1071
		Loc:         loc(parser, start),
1072
	}), nil
1073
}
1074

1075
/**
1076
 * ArgumentsDefinition : ( InputValueDefinition+ )
1077
 */
1078
func parseArgumentDefs(parser *Parser) ([]*ast.InputValueDefinition, error) {
1079
	inputValueDefinitions := []*ast.InputValueDefinition{}
1080

1081
	if !peek(parser, lexer.PAREN_L) {
1082
		return inputValueDefinitions, nil
1083
	}
1084
	iInputValueDefinitions, err := reverse(parser,
1085
		lexer.PAREN_L, parseInputValueDef, lexer.PAREN_R,
1086
		true,
1087
	)
1088
	if err != nil {
1089
		return inputValueDefinitions, err
1090
	}
1091
	for _, iInputValueDefinition := range iInputValueDefinitions {
1092
		if iInputValueDefinition != nil {
1093
			inputValueDefinitions = append(inputValueDefinitions, iInputValueDefinition.(*ast.InputValueDefinition))
1094
		}
1095
	}
1096
	return inputValueDefinitions, err
1097
}
1098

1099
/**
1100
 * InputValueDefinition : Description? Name : Type DefaultValue? Directives?
1101
 */
1102
func parseInputValueDef(parser *Parser) (interface{}, error) {
1103
	var (
1104
		description *ast.StringValue
1105
		name        *ast.Name
1106
		ttype       ast.Type
1107
		directives  []*ast.Directive
1108
		err         error
1109
	)
1110
	start := parser.Token.Start
1111
	if description, err = parseDescription(parser); err != nil {
1112
		return nil, err
1113
	}
1114
	if name, err = parseName(parser); err != nil {
1115
		return nil, err
1116
	}
1117
	if _, err = expect(parser, lexer.COLON); err != nil {
1118
		return nil, err
1119
	}
1120
	if ttype, err = parseType(parser); err != nil {
1121
		return nil, err
1122
	}
1123
	var defaultValue ast.Value
1124
	if skp, err := skip(parser, lexer.EQUALS); err != nil {
1125
		return nil, err
1126
	} else if skp {
1127
		val, err := parseConstValue(parser)
1128
		if err != nil {
1129
			return nil, err
1130
		}
1131
		if val, ok := val.(ast.Value); ok {
1132
			defaultValue = val
1133
		}
1134
	}
1135
	if directives, err = parseDirectives(parser); err != nil {
1136
		return nil, err
1137
	}
1138
	return ast.NewInputValueDefinition(&ast.InputValueDefinition{
1139
		Name:         name,
1140
		Description:  description,
1141
		Type:         ttype,
1142
		DefaultValue: defaultValue,
1143
		Directives:   directives,
1144
		Loc:          loc(parser, start),
1145
	}), nil
1146
}
1147

1148
/**
1149
 * InterfaceTypeDefinition :
1150
 *   Description?
1151
 *   interface Name Directives? { FieldDefinition+ }
1152
 */
1153
func parseInterfaceTypeDefinition(parser *Parser) (ast.Node, error) {
1154
	start := parser.Token.Start
1155
	description, err := parseDescription(parser)
1156
	if err != nil {
1157
		return nil, err
1158
	}
1159
	_, err = expectKeyWord(parser, lexer.INTERFACE)
1160
	if err != nil {
1161
		return nil, err
1162
	}
1163
	name, err := parseName(parser)
1164
	if err != nil {
1165
		return nil, err
1166
	}
1167
	directives, err := parseDirectives(parser)
1168
	if err != nil {
1169
		return nil, err
1170
	}
1171
	iFields, err := reverse(parser,
1172
		lexer.BRACE_L, parseFieldDefinition, lexer.BRACE_R,
1173
		false,
1174
	)
1175
	if err != nil {
1176
		return nil, err
1177
	}
1178
	fields := []*ast.FieldDefinition{}
1179
	for _, iField := range iFields {
1180
		if iField != nil {
1181
			fields = append(fields, iField.(*ast.FieldDefinition))
1182
		}
1183
	}
1184
	return ast.NewInterfaceDefinition(&ast.InterfaceDefinition{
1185
		Name:        name,
1186
		Description: description,
1187
		Directives:  directives,
1188
		Loc:         loc(parser, start),
1189
		Fields:      fields,
1190
	}), nil
1191
}
1192

1193
/**
1194
 * UnionTypeDefinition : Description? union Name Directives? = UnionMembers
1195
 */
1196
func parseUnionTypeDefinition(parser *Parser) (ast.Node, error) {
1197
	start := parser.Token.Start
1198
	description, err := parseDescription(parser)
1199
	if err != nil {
1200
		return nil, err
1201
	}
1202
	_, err = expectKeyWord(parser, lexer.UNION)
1203
	if err != nil {
1204
		return nil, err
1205
	}
1206
	name, err := parseName(parser)
1207
	if err != nil {
1208
		return nil, err
1209
	}
1210
	directives, err := parseDirectives(parser)
1211
	if err != nil {
1212
		return nil, err
1213
	}
1214
	_, err = expect(parser, lexer.EQUALS)
1215
	if err != nil {
1216
		return nil, err
1217
	}
1218
	types, err := parseUnionMembers(parser)
1219
	if err != nil {
1220
		return nil, err
1221
	}
1222
	return ast.NewUnionDefinition(&ast.UnionDefinition{
1223
		Name:        name,
1224
		Description: description,
1225
		Directives:  directives,
1226
		Loc:         loc(parser, start),
1227
		Types:       types,
1228
	}), nil
1229
}
1230

1231
/**
1232
 * UnionMembers :
1233
 *   - NamedType
1234
 *   - UnionMembers | NamedType
1235
 */
1236
func parseUnionMembers(parser *Parser) ([]*ast.Named, error) {
1237
	members := []*ast.Named{}
1238
	for {
1239
		member, err := parseNamed(parser)
1240
		if err != nil {
1241
			return members, err
1242
		}
1243
		members = append(members, member)
1244
		if skp, err := skip(parser, lexer.PIPE); err != nil {
1245
			return nil, err
1246
		} else if !skp {
1247
			break
1248
		}
1249
	}
1250
	return members, nil
1251
}
1252

1253
/**
1254
 * EnumTypeDefinition : Description? enum Name Directives? { EnumValueDefinition+ }
1255
 */
1256
func parseEnumTypeDefinition(parser *Parser) (ast.Node, error) {
1257
	start := parser.Token.Start
1258
	description, err := parseDescription(parser)
1259
	if err != nil {
1260
		return nil, err
1261
	}
1262
	_, err = expectKeyWord(parser, lexer.ENUM)
1263
	if err != nil {
1264
		return nil, err
1265
	}
1266
	name, err := parseName(parser)
1267
	if err != nil {
1268
		return nil, err
1269
	}
1270
	directives, err := parseDirectives(parser)
1271
	if err != nil {
1272
		return nil, err
1273
	}
1274
	iEnumValueDefs, err := reverse(parser,
1275
		lexer.BRACE_L, parseEnumValueDefinition, lexer.BRACE_R,
1276
		false,
1277
	)
1278
	if err != nil {
1279
		return nil, err
1280
	}
1281
	values := []*ast.EnumValueDefinition{}
1282
	for _, iEnumValueDef := range iEnumValueDefs {
1283
		if iEnumValueDef != nil {
1284
			values = append(values, iEnumValueDef.(*ast.EnumValueDefinition))
1285
		}
1286
	}
1287
	return ast.NewEnumDefinition(&ast.EnumDefinition{
1288
		Name:        name,
1289
		Description: description,
1290
		Directives:  directives,
1291
		Loc:         loc(parser, start),
1292
		Values:      values,
1293
	}), nil
1294
}
1295

1296
/**
1297
 * EnumValueDefinition : Description? EnumValue Directives?
1298
 *
1299
 * EnumValue : Name
1300
 */
1301
func parseEnumValueDefinition(parser *Parser) (interface{}, error) {
1302
	start := parser.Token.Start
1303
	description, err := parseDescription(parser)
1304
	if err != nil {
1305
		return nil, err
1306
	}
1307
	name, err := parseName(parser)
1308
	if err != nil {
1309
		return nil, err
1310
	}
1311
	directives, err := parseDirectives(parser)
1312
	if err != nil {
1313
		return nil, err
1314
	}
1315
	return ast.NewEnumValueDefinition(&ast.EnumValueDefinition{
1316
		Name:        name,
1317
		Description: description,
1318
		Directives:  directives,
1319
		Loc:         loc(parser, start),
1320
	}), nil
1321
}
1322

1323
/**
1324
 * InputObjectTypeDefinition :
1325
 *   - Description? input Name Directives? { InputValueDefinition+ }
1326
 */
1327
func parseInputObjectTypeDefinition(parser *Parser) (ast.Node, error) {
1328
	start := parser.Token.Start
1329
	description, err := parseDescription(parser)
1330
	if err != nil {
1331
		return nil, err
1332
	}
1333
	_, err = expectKeyWord(parser, lexer.INPUT)
1334
	if err != nil {
1335
		return nil, err
1336
	}
1337
	name, err := parseName(parser)
1338
	if err != nil {
1339
		return nil, err
1340
	}
1341
	directives, err := parseDirectives(parser)
1342
	if err != nil {
1343
		return nil, err
1344
	}
1345
	iInputValueDefinitions, err := reverse(parser,
1346
		lexer.BRACE_L, parseInputValueDef, lexer.BRACE_R,
1347
		false,
1348
	)
1349
	if err != nil {
1350
		return nil, err
1351
	}
1352
	fields := []*ast.InputValueDefinition{}
1353
	for _, iInputValueDefinition := range iInputValueDefinitions {
1354
		if iInputValueDefinition != nil {
1355
			fields = append(fields, iInputValueDefinition.(*ast.InputValueDefinition))
1356
		}
1357
	}
1358
	return ast.NewInputObjectDefinition(&ast.InputObjectDefinition{
1359
		Name:        name,
1360
		Description: description,
1361
		Directives:  directives,
1362
		Loc:         loc(parser, start),
1363
		Fields:      fields,
1364
	}), nil
1365
}
1366

1367
/**
1368
 * TypeExtensionDefinition : extend ObjectTypeDefinition
1369
 */
1370
func parseTypeExtensionDefinition(parser *Parser) (ast.Node, error) {
1371
	start := parser.Token.Start
1372
	_, err := expectKeyWord(parser, lexer.EXTEND)
1373
	if err != nil {
1374
		return nil, err
1375
	}
1376

1377
	definition, err := parseObjectTypeDefinition(parser)
1378
	if err != nil {
1379
		return nil, err
1380
	}
1381
	return ast.NewTypeExtensionDefinition(&ast.TypeExtensionDefinition{
1382
		Loc:        loc(parser, start),
1383
		Definition: definition.(*ast.ObjectDefinition),
1384
	}), nil
1385
}
1386

1387
/**
1388
 * DirectiveDefinition :
1389
 *   - directive @ Name ArgumentsDefinition? on DirectiveLocations
1390
 */
1391
func parseDirectiveDefinition(parser *Parser) (ast.Node, error) {
1392
	var (
1393
		err         error
1394
		description *ast.StringValue
1395
		name        *ast.Name
1396
		args        []*ast.InputValueDefinition
1397
		locations   []*ast.Name
1398
	)
1399
	start := parser.Token.Start
1400
	if description, err = parseDescription(parser); err != nil {
1401
		return nil, err
1402
	}
1403
	if _, err = expectKeyWord(parser, lexer.DIRECTIVE); err != nil {
1404
		return nil, err
1405
	}
1406
	if _, err = expect(parser, lexer.AT); err != nil {
1407
		return nil, err
1408
	}
1409
	if name, err = parseName(parser); err != nil {
1410
		return nil, err
1411
	}
1412
	if args, err = parseArgumentDefs(parser); err != nil {
1413
		return nil, err
1414
	}
1415
	if _, err = expectKeyWord(parser, "on"); err != nil {
1416
		return nil, err
1417
	}
1418
	if locations, err = parseDirectiveLocations(parser); err != nil {
1419
		return nil, err
1420
	}
1421

1422
	return ast.NewDirectiveDefinition(&ast.DirectiveDefinition{
1423
		Loc:         loc(parser, start),
1424
		Name:        name,
1425
		Description: description,
1426
		Arguments:   args,
1427
		Locations:   locations,
1428
	}), nil
1429
}
1430

1431
/**
1432
 * DirectiveLocations :
1433
 *   - Name
1434
 *   - DirectiveLocations | Name
1435
 */
1436
func parseDirectiveLocations(parser *Parser) ([]*ast.Name, error) {
1437
	locations := []*ast.Name{}
1438
	for {
1439
		if name, err := parseName(parser); err != nil {
1440
			return locations, err
1441
		} else {
1442
			locations = append(locations, name)
1443
		}
1444

1445
		if hasPipe, err := skip(parser, lexer.PIPE); err != nil {
1446
			return locations, err
1447
		} else if !hasPipe {
1448
			break
1449
		}
1450
	}
1451
	return locations, nil
1452
}
1453

1454
func parseStringLiteral(parser *Parser) (*ast.StringValue, error) {
1455
	token := parser.Token
1456
	if err := advance(parser); err != nil {
1457
		return nil, err
1458
	}
1459
	return ast.NewStringValue(&ast.StringValue{
1460
		Value: token.Value,
1461
		Loc:   loc(parser, token.Start),
1462
	}), nil
1463
}
1464

1465
/**
1466
 * Description : StringValue
1467
 */
1468
func parseDescription(parser *Parser) (*ast.StringValue, error) {
1469
	if peekDescription(parser) {
1470
		return parseStringLiteral(parser)
1471
	}
1472
	return nil, nil
1473
}
1474

1475
/* Core parsing utility functions */
1476

1477
// Returns a location object, used to identify the place in
1478
// the source that created a given parsed object.
1479
func loc(parser *Parser, start int) *ast.Location {
1480
	if parser.Options.NoLocation {
1481
		return nil
1482
	}
1483
	if parser.Options.NoSource {
1484
		return ast.NewLocation(&ast.Location{
1485
			Start: start,
1486
			End:   parser.PrevEnd,
1487
		})
1488
	}
1489
	return ast.NewLocation(&ast.Location{
1490
		Start:  start,
1491
		End:    parser.PrevEnd,
1492
		Source: parser.Source,
1493
	})
1494
}
1495

1496
// Moves the internal parser object to the next lexed token.
1497
func advance(parser *Parser) error {
1498
	parser.PrevEnd = parser.Token.End
1499
	token, err := parser.LexToken(parser.PrevEnd)
1500
	if err != nil {
1501
		return err
1502
	}
1503
	parser.Token = token
1504
	return nil
1505
}
1506

1507
// lookahead retrieves the next token
1508
func lookahead(parser *Parser) (lexer.Token, error) {
1509
	return parser.LexToken(parser.Token.End)
1510
}
1511

1512
// Determines if the next token is of a given kind
1513
func peek(parser *Parser, Kind lexer.TokenKind) bool {
1514
	return parser.Token.Kind == Kind
1515
}
1516

1517
// peekDescription determines if the next token is a string value
1518
func peekDescription(parser *Parser) bool {
1519
	return peek(parser, lexer.STRING) || peek(parser, lexer.BLOCK_STRING)
1520
}
1521

1522
// If the next token is of the given kind, return true after advancing
1523
// the parser. Otherwise, do not change the parser state and return false.
1524
func skip(parser *Parser, Kind lexer.TokenKind) (bool, error) {
1525
	if parser.Token.Kind == Kind {
1526
		return true, advance(parser)
1527
	}
1528
	return false, nil
1529
}
1530

1531
// If the next token is of the given kind, return that token after advancing
1532
// the parser. Otherwise, do not change the parser state and return error.
1533
func expect(parser *Parser, kind lexer.TokenKind) (lexer.Token, error) {
1534
	token := parser.Token
1535
	if token.Kind == kind {
1536
		return token, advance(parser)
1537
	}
1538
	descp := fmt.Sprintf("Expected %s, found %s", kind, lexer.GetTokenDesc(token))
1539
	return token, gqlerrors.NewSyntaxError(parser.Source, token.Start, descp)
1540
}
1541

1542
// If the next token is a keyword with the given value, return that token after
1543
// advancing the parser. Otherwise, do not change the parser state and return false.
1544
func expectKeyWord(parser *Parser, value string) (lexer.Token, error) {
1545
	token := parser.Token
1546
	if token.Kind == lexer.NAME && token.Value == value {
1547
		return token, advance(parser)
1548
	}
1549
	descp := fmt.Sprintf("Expected \"%s\", found %s", value, lexer.GetTokenDesc(token))
1550
	return token, gqlerrors.NewSyntaxError(parser.Source, token.Start, descp)
1551
}
1552

1553
// Helper function for creating an error when an unexpected lexed token
1554
// is encountered.
1555
func unexpected(parser *Parser, atToken lexer.Token) error {
1556
	var token = atToken
1557
	if (atToken == lexer.Token{}) {
1558
		token = parser.Token
1559
	}
1560
	description := fmt.Sprintf("Unexpected %v", lexer.GetTokenDesc(token))
1561
	return gqlerrors.NewSyntaxError(parser.Source, token.Start, description)
1562
}
1563

1564
func unexpectedEmpty(parser *Parser, beginLoc int, openKind, closeKind lexer.TokenKind) error {
1565
	description := fmt.Sprintf("Unexpected empty IN %s%s", openKind, closeKind)
1566
	return gqlerrors.NewSyntaxError(parser.Source, beginLoc, description)
1567
}
1568

1569
//  Returns list of parse nodes, determined by
1570
// the parseFn. This list begins with a lex token of openKind
1571
// and ends with a lex token of closeKind. Advances the parser
1572
// to the next lex token after the closing token.
1573
// if zinteger is true, len(nodes) > 0
1574
func reverse(parser *Parser, openKind lexer.TokenKind, parseFn parseFn, closeKind lexer.TokenKind, zinteger bool) ([]interface{}, error) {
1575
	token, err := expect(parser, openKind)
1576
	if err != nil {
1577
		return nil, err
1578
	}
1579
	var nodes []interface{}
1580
	for {
1581
		if skp, err := skip(parser, closeKind); err != nil {
1582
			return nil, err
1583
		} else if skp {
1584
			break
1585
		}
1586
		node, err := parseFn(parser)
1587
		if err != nil {
1588
			return nodes, err
1589
		}
1590
		nodes = append(nodes, node)
1591
	}
1592
	if zinteger && len(nodes) == 0 {
1593
		return nodes, unexpectedEmpty(parser, token.Start, openKind, closeKind)
1594
	}
1595
	return nodes, nil
1596
}
1597