cynic_parser/type_system/
definitions.rs

1use crate::AstLookup;
2
3use super::{
4    DefinitionId, Description, Directive, DirectiveDefinition, EnumDefinition,
5    InputObjectDefinition, InterfaceDefinition, ObjectDefinition, ScalarDefinition,
6    SchemaDefinition, TypeSystemId, UnionDefinition,
7    ids::*,
8    iter::{IdReader, Iter},
9};
10
11#[derive(Clone, Copy)]
12pub enum DefinitionRecord {
13    Schema(SchemaDefinitionId),
14    Scalar(ScalarDefinitionId),
15    Object(ObjectDefinitionId),
16    Interface(InterfaceDefinitionId),
17    Union(UnionDefinitionId),
18    Enum(EnumDefinitionId),
19    InputObject(InputObjectDefinitionId),
20    SchemaExtension(SchemaDefinitionId),
21    ScalarExtension(ScalarDefinitionId),
22    ObjectExtension(ObjectDefinitionId),
23    InterfaceExtension(InterfaceDefinitionId),
24    UnionExtension(UnionDefinitionId),
25    EnumExtension(EnumDefinitionId),
26    InputObjectExtension(InputObjectDefinitionId),
27    Directive(DirectiveDefinitionId),
28}
29
30#[derive(Clone, Copy)]
31pub enum Definition<'a> {
32    Schema(SchemaDefinition<'a>),
33    SchemaExtension(SchemaDefinition<'a>),
34    Type(TypeDefinition<'a>),
35    TypeExtension(TypeDefinition<'a>),
36    Directive(DirectiveDefinition<'a>),
37}
38
39impl Definition<'_> {
40    pub fn span(&self) -> crate::Span {
41        match self {
42            Definition::Schema(def) | Definition::SchemaExtension(def) => def.span(),
43            Definition::Type(ty) | Definition::TypeExtension(ty) => ty.span(),
44            Definition::Directive(def) => def.span(),
45        }
46    }
47}
48
49impl<'a> Definition<'a> {
50    pub fn is_schema(&self) -> bool {
51        matches!(self, Definition::Schema(_))
52    }
53
54    pub fn as_schema(self) -> Option<SchemaDefinition<'a>> {
55        match self {
56            Self::Schema(inner) => Some(inner),
57            _ => None,
58        }
59    }
60
61    pub fn is_schema_extension(&self) -> bool {
62        matches!(self, Definition::SchemaExtension(_))
63    }
64
65    pub fn as_schema_extension(self) -> Option<SchemaDefinition<'a>> {
66        match self {
67            Self::SchemaExtension(inner) => Some(inner),
68            _ => None,
69        }
70    }
71
72    pub fn is_type(&self) -> bool {
73        matches!(self, Definition::Type(_))
74    }
75
76    pub fn as_type(self) -> Option<TypeDefinition<'a>> {
77        match self {
78            Self::Type(inner) => Some(inner),
79            _ => None,
80        }
81    }
82
83    pub fn is_type_extension(&self) -> bool {
84        matches!(self, Definition::TypeExtension(_))
85    }
86
87    pub fn as_type_extension(self) -> Option<TypeDefinition<'a>> {
88        match self {
89            Self::TypeExtension(inner) => Some(inner),
90            _ => None,
91        }
92    }
93
94    pub fn is_directive(&self) -> bool {
95        matches!(self, Definition::Directive(_))
96    }
97
98    pub fn as_directive(self) -> Option<DirectiveDefinition<'a>> {
99        match self {
100            Self::Directive(inner) => Some(inner),
101            _ => None,
102        }
103    }
104}
105
106#[derive(Clone, Copy)]
107pub enum TypeDefinition<'a> {
108    Scalar(ScalarDefinition<'a>),
109    Object(ObjectDefinition<'a>),
110    Interface(InterfaceDefinition<'a>),
111    Union(UnionDefinition<'a>),
112    Enum(EnumDefinition<'a>),
113    InputObject(InputObjectDefinition<'a>),
114}
115
116impl<'a> TypeDefinition<'a> {
117    pub fn name(&self) -> &'a str {
118        match self {
119            TypeDefinition::Scalar(inner) => inner.name(),
120            TypeDefinition::Object(inner) => inner.name(),
121            TypeDefinition::Interface(inner) => inner.name(),
122            TypeDefinition::Union(inner) => inner.name(),
123            TypeDefinition::Enum(inner) => inner.name(),
124            TypeDefinition::InputObject(inner) => inner.name(),
125        }
126    }
127
128    pub fn directives(&self) -> Iter<'a, Directive<'a>> {
129        match self {
130            TypeDefinition::Scalar(inner) => inner.directives(),
131            TypeDefinition::Object(inner) => inner.directives(),
132            TypeDefinition::Interface(inner) => inner.directives(),
133            TypeDefinition::Union(inner) => inner.directives(),
134            TypeDefinition::Enum(inner) => inner.directives(),
135            TypeDefinition::InputObject(inner) => inner.directives(),
136        }
137    }
138
139    pub fn span(&self) -> crate::Span {
140        match self {
141            TypeDefinition::Scalar(inner) => inner.span(),
142            TypeDefinition::Object(inner) => inner.span(),
143            TypeDefinition::Interface(inner) => inner.span(),
144            TypeDefinition::Union(inner) => inner.span(),
145            TypeDefinition::Enum(inner) => inner.span(),
146            TypeDefinition::InputObject(inner) => inner.span(),
147        }
148    }
149
150    pub fn description(&self) -> Option<Description<'a>> {
151        match self {
152            TypeDefinition::Scalar(inner) => inner.description(),
153            TypeDefinition::Object(inner) => inner.description(),
154            TypeDefinition::Interface(inner) => inner.description(),
155            TypeDefinition::Union(inner) => inner.description(),
156            TypeDefinition::Enum(inner) => inner.description(),
157            TypeDefinition::InputObject(inner) => inner.description(),
158        }
159    }
160}
161
162impl TypeSystemId for DefinitionId {
163    type Reader<'a> = Definition<'a>;
164
165    fn read(self, document: &super::TypeSystemDocument) -> Self::Reader<'_> {
166        match document.lookup(self) {
167            DefinitionRecord::Schema(id) => Definition::Schema(document.read(*id)),
168            DefinitionRecord::Scalar(id) => {
169                Definition::Type(TypeDefinition::Scalar(document.read(*id)))
170            }
171            DefinitionRecord::Object(id) => {
172                Definition::Type(TypeDefinition::Object(document.read(*id)))
173            }
174            DefinitionRecord::Interface(id) => {
175                Definition::Type(TypeDefinition::Interface(document.read(*id)))
176            }
177            DefinitionRecord::Union(id) => {
178                Definition::Type(TypeDefinition::Union(document.read(*id)))
179            }
180            DefinitionRecord::Enum(id) => {
181                Definition::Type(TypeDefinition::Enum(document.read(*id)))
182            }
183            DefinitionRecord::InputObject(id) => {
184                Definition::Type(TypeDefinition::InputObject(document.read(*id)))
185            }
186            DefinitionRecord::SchemaExtension(id) => {
187                Definition::SchemaExtension(document.read(*id))
188            }
189            DefinitionRecord::ScalarExtension(id) => {
190                Definition::TypeExtension(TypeDefinition::Scalar(document.read(*id)))
191            }
192            DefinitionRecord::ObjectExtension(id) => {
193                Definition::TypeExtension(TypeDefinition::Object(document.read(*id)))
194            }
195            DefinitionRecord::InterfaceExtension(id) => {
196                Definition::TypeExtension(TypeDefinition::Interface(document.read(*id)))
197            }
198            DefinitionRecord::UnionExtension(id) => {
199                Definition::TypeExtension(TypeDefinition::Union(document.read(*id)))
200            }
201            DefinitionRecord::EnumExtension(id) => {
202                Definition::TypeExtension(TypeDefinition::Enum(document.read(*id)))
203            }
204            DefinitionRecord::InputObjectExtension(id) => {
205                Definition::TypeExtension(TypeDefinition::InputObject(document.read(*id)))
206            }
207            DefinitionRecord::Directive(id) => Definition::Directive(document.read(*id)),
208        }
209    }
210}
211
212impl IdReader for Definition<'_> {
213    type Id = DefinitionId;
214    type Reader<'a> = Definition<'a>;
215
216    fn new(id: Self::Id, document: &'_ super::TypeSystemDocument) -> Self::Reader<'_> {
217        document.read(id)
218    }
219}
cynic_parser/type_system/definitions.rs

cynic_parser/type_system/
definitions.rs
