bluejay_parser/ast/definition/
enum_value_definition.rs1use crate::ast::DepthLimiter;
2use crate::lexical_token::{Name, StringValue};
3use crate::{
4 ast::{
5 definition::{Context, Directives},
6 ConstDirectives, FromTokens, ParseError, Tokens, TryFromTokens,
7 },
8 HasSpan,
9};
10use bluejay_core::definition::{EnumValueDefinition as CoreEnumValueDefinition, HasDirectives};
11
12#[derive(Debug)]
13pub struct EnumValueDefinition<'a, C: Context> {
14 description: Option<StringValue<'a>>,
15 name: Name<'a>,
16 directives: Option<Directives<'a, C>>,
17}
18
19impl<'a, C: Context> EnumValueDefinition<'a, C> {
20 pub fn name_token(&self) -> &Name<'a> {
21 &self.name
22 }
23}
24
25impl<C: Context> CoreEnumValueDefinition for EnumValueDefinition<'_, C> {
26 fn description(&self) -> Option<&str> {
27 self.description.as_ref().map(AsRef::as_ref)
28 }
29
30 fn name(&self) -> &str {
31 self.name.as_ref()
32 }
33}
34
35impl<'a, C: Context> FromTokens<'a> for EnumValueDefinition<'a, C> {
36 fn from_tokens(
37 tokens: &mut impl Tokens<'a>,
38 depth_limiter: DepthLimiter,
39 ) -> Result<Self, ParseError> {
40 let description = tokens.next_if_string_value();
41 let name = tokens.expect_name()?;
42 if matches!(name.as_str(), "null" | "true" | "false") {
43 return Err(ParseError::InvalidEnumValue {
44 span: name.span().clone(),
45 value: name.as_str().to_string(),
46 });
47 }
48
49 let directives =
50 ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
51 Ok(Self {
52 description,
53 name,
54 directives: directives.map(Directives::from),
55 })
56 }
57}
58
59impl<'a, C: Context> HasDirectives for EnumValueDefinition<'a, C> {
60 type Directives = Directives<'a, C>;
61
62 fn directives(&self) -> Option<&Self::Directives> {
63 self.directives.as_ref()
64 }
65}