mago_codex/metadata/
flags.rs

1use serde::Deserialize;
2use serde::Serialize;
3
4#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
5pub struct MetadataFlags(u64);
6
7impl MetadataFlags {
8    pub const ABSTRACT: MetadataFlags = MetadataFlags(1 << 0);
9    pub const FINAL: MetadataFlags = MetadataFlags(1 << 1);
10    pub const READONLY: MetadataFlags = MetadataFlags(1 << 3);
11    pub const DEPRECATED: MetadataFlags = MetadataFlags(1 << 4);
12    pub const ENUM_INTERFACE: MetadataFlags = MetadataFlags(1 << 5);
13    pub const POPULATED: MetadataFlags = MetadataFlags(1 << 6);
14    pub const INTERNAL: MetadataFlags = MetadataFlags(1 << 7);
15    pub const CONSISTENT_CONSTRUCTOR: MetadataFlags = MetadataFlags(1 << 11);
16    pub const CONSISTENT_TEMPLATES: MetadataFlags = MetadataFlags(1 << 12);
17    pub const UNCHECKED: MetadataFlags = MetadataFlags(1 << 13);
18    pub const USER_DEFINED: MetadataFlags = MetadataFlags(1 << 14);
19    pub const BUILTIN: MetadataFlags = MetadataFlags(1 << 15);
20    pub const HAS_YIELD: MetadataFlags = MetadataFlags(1 << 16);
21    pub const MUST_USE: MetadataFlags = MetadataFlags(1 << 17);
22    pub const HAS_THROW: MetadataFlags = MetadataFlags(1 << 18);
23    pub const PURE: MetadataFlags = MetadataFlags(1 << 19);
24    pub const IGNORE_NULLABLE_RETURN: MetadataFlags = MetadataFlags(1 << 20);
25    pub const IGNORE_FALSABLE_RETURN: MetadataFlags = MetadataFlags(1 << 21);
26    pub const INHERITS_DOCS: MetadataFlags = MetadataFlags(1 << 22);
27    pub const NO_NAMED_ARGUMENTS: MetadataFlags = MetadataFlags(1 << 23);
28    pub const BACKED_ENUM_CASE: MetadataFlags = MetadataFlags(1 << 24);
29    pub const UNIT_ENUM_CASE: MetadataFlags = MetadataFlags(1 << 25);
30    pub const BY_REFERENCE: MetadataFlags = MetadataFlags(1 << 26);
31    pub const VARIADIC: MetadataFlags = MetadataFlags(1 << 27);
32    pub const PROMOTED_PROPERTY: MetadataFlags = MetadataFlags(1 << 28);
33    pub const HAS_DEFAULT: MetadataFlags = MetadataFlags(1 << 29);
34    pub const VIRTUAL_PROPERTY: MetadataFlags = MetadataFlags(1 << 30);
35    pub const ASYMMETRIC_PROPERTY: MetadataFlags = MetadataFlags(1 << 31);
36    pub const STATIC: MetadataFlags = MetadataFlags(1 << 32);
37    pub const WRITEONLY: MetadataFlags = MetadataFlags(1 << 33);
38    pub const MAGIC_PROPERTY: MetadataFlags = MetadataFlags(1 << 34);
39    pub const MAGIC_METHOD: MetadataFlags = MetadataFlags(1 << 35);
40    pub const API: MetadataFlags = MetadataFlags(1 << 36);
41    pub const MUTATION_FREE: MetadataFlags = MetadataFlags(1 << 37);
42    pub const EXTERNAL_MUTATION_FREE: MetadataFlags = MetadataFlags(1 << 38);
43    pub const SUSPENDS_FIBER: MetadataFlags = MetadataFlags(1 << 39);
44    pub const EXPERIMENTAL: MetadataFlags = MetadataFlags(1 << 40);
45    pub const POLYFILL: MetadataFlags = MetadataFlags(1 << 41);
46}
47
48impl MetadataFlags {
49    #[inline]
50    #[must_use]
51    pub const fn empty() -> Self {
52        MetadataFlags(0)
53    }
54
55    #[inline]
56    pub const fn insert(&mut self, other: MetadataFlags) {
57        self.0 |= other.0;
58    }
59
60    #[inline]
61    pub const fn set(&mut self, other: MetadataFlags, value: bool) {
62        if value {
63            self.insert(other);
64        } else {
65            self.0 &= !other.0;
66        }
67    }
68
69    #[inline]
70    pub const fn contains(self, other: MetadataFlags) -> bool {
71        (self.0 & other.0) == other.0
72    }
73
74    #[inline]
75    pub const fn remove(&mut self, other: MetadataFlags) {
76        self.0 &= !other.0;
77    }
78
79    #[inline]
80    pub const fn intersects(self, other: MetadataFlags) -> bool {
81        (self.0 & other.0) != 0
82    }
83
84    #[inline]
85    #[must_use]
86    pub const fn union(&self, other: MetadataFlags) -> MetadataFlags {
87        MetadataFlags(self.0 | other.0)
88    }
89
90    #[inline]
91    #[must_use]
92    pub const fn intersection(&self, other: MetadataFlags) -> MetadataFlags {
93        MetadataFlags(self.0 & other.0)
94    }
95}
96
97impl MetadataFlags {
98    #[inline]
99    #[must_use]
100    pub const fn is_deprecated(self) -> bool {
101        self.contains(Self::DEPRECATED)
102    }
103
104    #[inline]
105    #[must_use]
106    pub const fn is_abstract(self) -> bool {
107        self.contains(Self::ABSTRACT)
108    }
109
110    #[inline]
111    #[must_use]
112    pub const fn is_final(self) -> bool {
113        self.contains(Self::FINAL)
114    }
115
116    #[inline]
117    #[must_use]
118    pub const fn has_yield(self) -> bool {
119        self.contains(Self::HAS_YIELD)
120    }
121
122    #[inline]
123    #[must_use]
124    pub const fn must_use(self) -> bool {
125        self.contains(Self::MUST_USE)
126    }
127
128    #[inline]
129    #[must_use]
130    pub const fn is_pure(self) -> bool {
131        self.contains(Self::PURE)
132    }
133
134    #[inline]
135    #[must_use]
136    pub const fn has_consistent_constructor(self) -> bool {
137        self.contains(Self::CONSISTENT_CONSTRUCTOR)
138    }
139
140    #[inline]
141    #[must_use]
142    pub const fn has_consistent_templates(self) -> bool {
143        self.contains(Self::CONSISTENT_TEMPLATES)
144    }
145
146    #[inline]
147    #[must_use]
148    pub const fn is_user_defined(self) -> bool {
149        self.contains(Self::USER_DEFINED)
150    }
151
152    #[inline]
153    #[must_use]
154    pub const fn is_built_in(self) -> bool {
155        self.contains(Self::BUILTIN)
156    }
157
158    #[inline]
159    #[must_use]
160    pub const fn is_internal(self) -> bool {
161        self.contains(Self::INTERNAL)
162    }
163
164    #[inline]
165    #[must_use]
166    pub const fn is_populated(self) -> bool {
167        self.contains(Self::POPULATED)
168    }
169
170    #[inline]
171    #[must_use]
172    pub const fn is_readonly(self) -> bool {
173        self.contains(Self::READONLY)
174    }
175
176    #[inline]
177    #[must_use]
178    pub const fn is_writeonly(self) -> bool {
179        self.contains(Self::WRITEONLY)
180    }
181
182    #[inline]
183    #[must_use]
184    pub const fn is_enum_interface(self) -> bool {
185        self.contains(Self::ENUM_INTERFACE)
186    }
187
188    #[inline]
189    #[must_use]
190    pub const fn is_unchecked(self) -> bool {
191        self.contains(Self::UNCHECKED)
192    }
193
194    #[inline]
195    #[must_use]
196    pub const fn ignore_nullable_return(self) -> bool {
197        self.contains(Self::IGNORE_NULLABLE_RETURN)
198    }
199
200    #[inline]
201    #[must_use]
202    pub const fn ignore_falsable_return(self) -> bool {
203        self.contains(Self::IGNORE_FALSABLE_RETURN)
204    }
205
206    #[inline]
207    #[must_use]
208    pub const fn inherits_docs(self) -> bool {
209        self.contains(Self::INHERITS_DOCS)
210    }
211
212    #[inline]
213    #[must_use]
214    pub const fn forbids_named_arguments(self) -> bool {
215        self.contains(Self::NO_NAMED_ARGUMENTS)
216    }
217
218    #[inline]
219    #[must_use]
220    pub const fn has_throw(self) -> bool {
221        self.contains(Self::HAS_THROW)
222    }
223
224    #[inline]
225    #[must_use]
226    pub const fn is_backed_enum_case(self) -> bool {
227        self.contains(Self::BACKED_ENUM_CASE)
228    }
229
230    #[inline]
231    #[must_use]
232    pub const fn is_unit_enum_case(self) -> bool {
233        self.contains(Self::UNIT_ENUM_CASE)
234    }
235
236    #[inline]
237    #[must_use]
238    pub const fn is_by_reference(self) -> bool {
239        self.contains(Self::BY_REFERENCE)
240    }
241
242    #[inline]
243    #[must_use]
244    pub const fn is_variadic(self) -> bool {
245        self.contains(Self::VARIADIC)
246    }
247
248    #[inline]
249    #[must_use]
250    pub const fn is_promoted_property(self) -> bool {
251        self.contains(Self::PROMOTED_PROPERTY)
252    }
253
254    #[inline]
255    #[must_use]
256    pub const fn has_default(self) -> bool {
257        self.contains(Self::HAS_DEFAULT)
258    }
259
260    #[inline]
261    #[must_use]
262    pub const fn is_virtual_property(self) -> bool {
263        self.contains(Self::VIRTUAL_PROPERTY)
264    }
265
266    #[inline]
267    #[must_use]
268    pub const fn is_magic_property(self) -> bool {
269        self.contains(Self::MAGIC_PROPERTY)
270    }
271
272    #[inline]
273    #[must_use]
274    pub const fn is_magic_method(self) -> bool {
275        self.contains(Self::MAGIC_METHOD)
276    }
277
278    #[inline]
279    #[must_use]
280    pub const fn is_asymmetric_property(self) -> bool {
281        self.contains(Self::ASYMMETRIC_PROPERTY)
282    }
283
284    #[inline]
285    #[must_use]
286    pub const fn is_static(self) -> bool {
287        self.contains(Self::STATIC)
288    }
289
290    #[inline]
291    #[must_use]
292    pub const fn is_public_api(self) -> bool {
293        self.contains(Self::API)
294    }
295
296    #[inline]
297    #[must_use]
298    pub const fn is_experimental(self) -> bool {
299        self.contains(Self::EXPERIMENTAL)
300    }
301
302    #[inline]
303    #[must_use]
304    pub const fn is_mutation_free(self) -> bool {
305        self.contains(Self::MUTATION_FREE)
306    }
307
308    #[inline]
309    #[must_use]
310    pub const fn is_external_mutation_free(self) -> bool {
311        self.contains(Self::EXTERNAL_MUTATION_FREE)
312    }
313
314    #[inline]
315    #[must_use]
316    pub const fn suspends_fiber(self) -> bool {
317        self.contains(Self::SUSPENDS_FIBER)
318    }
319
320    #[inline]
321    #[must_use]
322    pub const fn is_polyfill(self) -> bool {
323        self.contains(Self::POLYFILL)
324    }
325}
326
327impl std::ops::BitOr for MetadataFlags {
328    type Output = Self;
329
330    #[inline]
331    fn bitor(self, rhs: Self) -> Self::Output {
332        MetadataFlags(self.0 | rhs.0)
333    }
334}
335
336impl std::ops::BitAnd for MetadataFlags {
337    type Output = Self;
338
339    #[inline]
340    fn bitand(self, rhs: Self) -> Self::Output {
341        MetadataFlags(self.0 & rhs.0)
342    }
343}
344
345impl std::ops::BitXor for MetadataFlags {
346    type Output = Self;
347
348    #[inline]
349    fn bitxor(self, rhs: Self) -> Self::Output {
350        MetadataFlags(self.0 ^ rhs.0)
351    }
352}
353
354impl std::ops::Not for MetadataFlags {
355    type Output = Self;
356
357    #[inline]
358    fn not(self) -> Self::Output {
359        MetadataFlags(!self.0)
360    }
361}
362
363impl std::ops::BitOrAssign for MetadataFlags {
364    #[inline]
365    fn bitor_assign(&mut self, rhs: Self) {
366        self.0 |= rhs.0;
367    }
368}
369
370impl std::ops::BitAndAssign for MetadataFlags {
371    #[inline]
372    fn bitand_assign(&mut self, rhs: Self) {
373        self.0 &= rhs.0;
374    }
375}
376
377impl std::ops::BitXorAssign for MetadataFlags {
378    #[inline]
379    fn bitxor_assign(&mut self, rhs: Self) {
380        self.0 ^= rhs.0;
381    }
382}
mago_codex/metadata/flags.rs

mago_codex/metadata/
flags.rs
