apollo_parser/parser/grammar/
enum_.rs1#![allow(clippy::needless_return)]
2
3use crate::parser::grammar::description;
4use crate::parser::grammar::directive;
5use crate::parser::grammar::name;
6use crate::parser::grammar::value;
7use crate::parser::grammar::value::Constness;
8use crate::Parser;
9use crate::SyntaxKind;
10use crate::TokenKind;
11use crate::S;
12use crate::T;
13use std::ops::ControlFlow;
14
15pub(crate) fn enum_type_definition(p: &mut Parser) {
20    let _g = p.start_node(SyntaxKind::ENUM_TYPE_DEFINITION);
21
22    if let Some(TokenKind::StringValue) = p.peek() {
23        description::description(p);
24    }
25
26    if let Some("enum") = p.peek_data() {
27        p.bump(SyntaxKind::enum_KW);
28    }
29
30    match p.peek() {
31        Some(TokenKind::Name) => name::name(p),
32        _ => p.err("expected a Name"),
33    }
34
35    if let Some(T![@]) = p.peek() {
36        directive::directives(p, Constness::Const);
37    }
38
39    if let Some(T!['{']) = p.peek() {
40        enum_values_definition(p);
41    }
42}
43
44pub(crate) fn enum_type_extension(p: &mut Parser) {
50    let _g = p.start_node(SyntaxKind::ENUM_TYPE_EXTENSION);
51    p.bump(SyntaxKind::extend_KW);
52    p.bump(SyntaxKind::enum_KW);
53
54    let mut meets_requirements = false;
55
56    match p.peek() {
57        Some(TokenKind::Name) => name::name(p),
58        _ => p.err("expected a Name"),
59    }
60
61    if let Some(T![@]) = p.peek() {
62        meets_requirements = true;
63        directive::directives(p, Constness::Const);
64    }
65
66    if let Some(T!['{']) = p.peek() {
67        meets_requirements = true;
68        enum_values_definition(p);
69    }
70
71    if !meets_requirements {
72        p.err("expected Directive or Enum Values Definition");
73    }
74}
75
76pub(crate) fn enum_values_definition(p: &mut Parser) {
81    let _g = p.start_node(SyntaxKind::ENUM_VALUES_DEFINITION);
82    p.bump(S!['{']);
83
84    match p.peek() {
85        Some(TokenKind::Name | TokenKind::StringValue) => enum_value_definition(p),
86        _ => p.err("expected Enum Value Definition"),
87    }
88
89    p.peek_while(|p, kind| match kind {
90        TokenKind::Name | TokenKind::StringValue => {
91            enum_value_definition(p);
92            ControlFlow::Continue(())
93        }
94        _ => ControlFlow::Break(()),
95    });
96
97    p.expect(T!['}'], S!['}']);
98}
99
100pub(crate) fn enum_value_definition(p: &mut Parser) {
105    if let Some(TokenKind::Name | TokenKind::StringValue) = p.peek() {
106        let _guard = p.start_node(SyntaxKind::ENUM_VALUE_DEFINITION);
107
108        if let Some(TokenKind::StringValue) = p.peek() {
109            description::description(p);
110        }
111
112        value::enum_value(p);
113
114        if let Some(T![@]) = p.peek() {
115            directive::directives(p, Constness::Const);
116        }
117    }
118}