webidl_utils/extend/
non_any.rs1use crate::extend::ExtendMayBeNull;
2use weedle::common::Identifier;
3use weedle::term::*;
4use weedle::types::*;
5
6pub trait ExtendNonAnyType<'a> {
8 fn is_optional(&self) -> bool;
9 fn is_required(&self) -> bool;
10 fn promise(p: PromiseType<'a>) -> Self;
11 fn integer(i: IntegerType) -> Self;
12 fn integer_opt(i: IntegerType) -> Self;
13 fn floating_point(f: FloatingPointType) -> Self;
14 fn floating_point_opt(f: FloatingPointType) -> Self;
15 fn boolean() -> Self;
16 fn boolean_opt() -> Self;
17 fn byte() -> Self;
18 fn byte_opt() -> Self;
19 fn octet() -> Self;
20 fn octet_opt() -> Self;
21 fn byte_string() -> Self;
22 fn byte_string_opt() -> Self;
23 fn dom_string() -> Self;
24 fn dom_string_opt() -> Self;
25 fn usv_string() -> Self;
26 fn usv_string_opt() -> Self;
27 fn sequence(s: SequenceType<'a>) -> Self;
28 fn sequence_opt(s: SequenceType<'a>) -> Self;
29 fn object() -> Self;
30 fn object_opt() -> Self;
31 fn symbol() -> Self;
32 fn symbol_opt() -> Self;
33 fn error() -> Self;
34 fn error_opt() -> Self;
35 fn array_buffer() -> Self;
36 fn array_buffer_opt() -> Self;
37 fn data_view() -> Self;
38 fn data_view_opt() -> Self;
39 fn int8_array() -> Self;
40 fn int8_array_opt() -> Self;
41 fn int16_array() -> Self;
42 fn int16_array_opt() -> Self;
43 fn int32_array() -> Self;
44 fn int32_array_opt() -> Self;
45 fn uint8_array() -> Self;
46 fn uint8_array_opt() -> Self;
47 fn uint16_array() -> Self;
48 fn uint16_array_opt() -> Self;
49 fn uint32_array() -> Self;
50 fn uint32_array_opt() -> Self;
51 fn uint8_clamped_array() -> Self;
52 fn uint8_clamped_array_opt() -> Self;
53 fn float32_array() -> Self;
54 fn float32_array_opt() -> Self;
55 fn float64_array() -> Self;
56 fn float64_array_opt() -> Self;
57 fn array_buffer_view() -> Self;
58 fn array_buffer_view_opt() -> Self;
59 fn buffer_source() -> Self;
60 fn buffer_source_opt() -> Self;
61 fn frozen_array(f: FrozenArrayType<'a>) -> Self;
62 fn frozen_array_opt(f: FrozenArrayType<'a>) -> Self;
63 fn record(r: RecordType<'a>) -> Self;
64 fn record_opt(r: RecordType<'a>) -> Self;
65 fn identifier(i: &'a str) -> Self;
66 fn identifier_opt(i: &'a str) -> Self;
67}
68
69impl<'a> ExtendNonAnyType<'a> for NonAnyType<'a> {
70 fn is_optional(&self) -> bool {
71 match self {
72 Self::Promise(_) => false,
73 Self::Integer(t) => t.is_optional(),
74 Self::FloatingPoint(t) => t.is_optional(),
75 Self::Boolean(t) => t.is_optional(),
76 Self::Byte(t) => t.is_optional(),
77 Self::Octet(t) => t.is_optional(),
78 Self::ByteString(t) => t.is_optional(),
79 Self::DOMString(t) => t.is_optional(),
80 Self::USVString(t) => t.is_optional(),
81 Self::Sequence(t) => t.is_optional(),
82 Self::Object(t) => t.is_optional(),
83 Self::Symbol(t) => t.is_optional(),
84 Self::Error(t) => t.is_optional(),
85 Self::ArrayBuffer(t) => t.is_optional(),
86 Self::DataView(t) => t.is_optional(),
87 Self::Int8Array(t) => t.is_optional(),
88 Self::Int16Array(t) => t.is_optional(),
89 Self::Int32Array(t) => t.is_optional(),
90 Self::Uint8Array(t) => t.is_optional(),
91 Self::Uint16Array(t) => t.is_optional(),
92 Self::Uint32Array(t) => t.is_optional(),
93 Self::Uint8ClampedArray(t) => t.is_optional(),
94 Self::Float32Array(t) => t.is_optional(),
95 Self::Float64Array(t) => t.is_optional(),
96 Self::ArrayBufferView(t) => t.is_optional(),
97 Self::BufferSource(t) => t.is_optional(),
98 Self::FrozenArrayType(t) => t.is_optional(),
99 Self::RecordType(t) => t.is_optional(),
100 Self::Identifier(t) => t.is_optional(),
101 }
102 }
103
104 fn is_required(&self) -> bool {
105 !self.is_optional()
106 }
107
108 fn promise(p: PromiseType<'a>) -> Self {
109 Self::Promise(p)
110 }
111
112 fn integer(i: IntegerType) -> Self {
113 Self::Integer(MayBeNull::new_required(i))
114 }
115
116 fn integer_opt(i: IntegerType) -> Self {
117 Self::Integer(MayBeNull::new_optional(i))
118 }
119
120 fn floating_point(f: FloatingPointType) -> Self {
121 Self::FloatingPoint(MayBeNull::new_required(f))
122 }
123
124 fn floating_point_opt(f: FloatingPointType) -> Self {
125 Self::FloatingPoint(MayBeNull::new_optional(f))
126 }
127
128 fn boolean() -> Self {
129 Self::Boolean(MayBeNull::new_required(Boolean))
130 }
131
132 fn boolean_opt() -> Self {
133 Self::Boolean(MayBeNull::new_optional(Boolean))
134 }
135
136 fn byte() -> Self {
137 Self::Byte(MayBeNull::new_required(Byte))
138 }
139
140 fn byte_opt() -> Self {
141 Self::Byte(MayBeNull::new_optional(Byte))
142 }
143
144 fn octet() -> Self {
145 Self::Octet(MayBeNull::new_required(Octet))
146 }
147
148 fn octet_opt() -> Self {
149 Self::Octet(MayBeNull::new_optional(Octet))
150 }
151
152 fn byte_string() -> Self {
153 Self::ByteString(MayBeNull::new_required(ByteString))
154 }
155
156 fn byte_string_opt() -> Self {
157 Self::ByteString(MayBeNull::new_optional(ByteString))
158 }
159
160 fn dom_string() -> Self {
161 Self::DOMString(MayBeNull::new_required(DOMString))
162 }
163
164 fn dom_string_opt() -> Self {
165 Self::DOMString(MayBeNull::new_optional(DOMString))
166 }
167
168 fn usv_string() -> Self {
169 Self::USVString(MayBeNull::new_required(USVString))
170 }
171
172 fn usv_string_opt() -> Self {
173 Self::USVString(MayBeNull::new_optional(USVString))
174 }
175
176 fn sequence(s: SequenceType<'a>) -> Self {
177 Self::Sequence(MayBeNull::new_required(s))
178 }
179
180 fn sequence_opt(s: SequenceType<'a>) -> Self {
181 Self::Sequence(MayBeNull::new_optional(s))
182 }
183
184 fn object() -> Self {
185 Self::Object(MayBeNull::new_required(Object))
186 }
187
188 fn object_opt() -> Self {
189 Self::Object(MayBeNull::new_optional(Object))
190 }
191
192 fn symbol() -> Self {
193 Self::Symbol(MayBeNull::new_required(Symbol))
194 }
195
196 fn symbol_opt() -> Self {
197 Self::Symbol(MayBeNull::new_optional(Symbol))
198 }
199
200 fn error() -> Self {
201 Self::Error(MayBeNull::new_required(Error))
202 }
203
204 fn error_opt() -> Self {
205 Self::Error(MayBeNull::new_optional(Error))
206 }
207
208 fn array_buffer() -> Self {
209 Self::ArrayBuffer(MayBeNull::new_required(ArrayBuffer))
210 }
211
212 fn array_buffer_opt() -> Self {
213 Self::ArrayBuffer(MayBeNull::new_optional(ArrayBuffer))
214 }
215
216 fn data_view() -> Self {
217 Self::DataView(MayBeNull::new_required(DataView))
218 }
219
220 fn data_view_opt() -> Self {
221 Self::DataView(MayBeNull::new_optional(DataView))
222 }
223
224 fn int8_array() -> Self {
225 Self::Int8Array(MayBeNull::new_required(Int8Array))
226 }
227
228 fn int8_array_opt() -> Self {
229 Self::Int8Array(MayBeNull::new_optional(Int8Array))
230 }
231
232 fn int16_array() -> Self {
233 Self::Int16Array(MayBeNull::new_required(Int16Array))
234 }
235
236 fn int16_array_opt() -> Self {
237 Self::Int16Array(MayBeNull::new_optional(Int16Array))
238 }
239
240 fn int32_array() -> Self {
241 Self::Int32Array(MayBeNull::new_required(Int32Array))
242 }
243
244 fn int32_array_opt() -> Self {
245 Self::Int32Array(MayBeNull::new_optional(Int32Array))
246 }
247
248 fn uint8_array() -> Self {
249 Self::Uint8Array(MayBeNull::new_required(Uint8Array))
250 }
251
252 fn uint8_array_opt() -> Self {
253 Self::Uint8Array(MayBeNull::new_optional(Uint8Array))
254 }
255
256 fn uint16_array() -> Self {
257 Self::Uint16Array(MayBeNull::new_required(Uint16Array))
258 }
259
260 fn uint16_array_opt() -> Self {
261 Self::Uint16Array(MayBeNull::new_optional(Uint16Array))
262 }
263
264 fn uint32_array() -> Self {
265 Self::Uint32Array(MayBeNull::new_required(Uint32Array))
266 }
267
268 fn uint32_array_opt() -> Self {
269 Self::Uint32Array(MayBeNull::new_optional(Uint32Array))
270 }
271
272 fn uint8_clamped_array() -> Self {
273 Self::Uint8ClampedArray(MayBeNull::new_required(Uint8ClampedArray))
274 }
275
276 fn uint8_clamped_array_opt() -> Self {
277 Self::Uint8ClampedArray(MayBeNull::new_optional(Uint8ClampedArray))
278 }
279
280 fn float32_array() -> Self {
281 Self::Float32Array(MayBeNull::new_required(Float32Array))
282 }
283
284 fn float32_array_opt() -> Self {
285 Self::Float32Array(MayBeNull::new_optional(Float32Array))
286 }
287
288 fn float64_array() -> Self {
289 Self::Float64Array(MayBeNull::new_required(Float64Array))
290 }
291
292 fn float64_array_opt() -> Self {
293 Self::Float64Array(MayBeNull::new_optional(Float64Array))
294 }
295
296 fn array_buffer_view() -> Self {
297 Self::ArrayBufferView(MayBeNull::new_required(ArrayBufferView))
298 }
299
300 fn array_buffer_view_opt() -> Self {
301 Self::ArrayBufferView(MayBeNull::new_optional(ArrayBufferView))
302 }
303
304 fn buffer_source() -> Self {
305 Self::BufferSource(MayBeNull::new_required(BufferSource))
306 }
307
308 fn buffer_source_opt() -> Self {
309 Self::BufferSource(MayBeNull::new_optional(BufferSource))
310 }
311
312 fn frozen_array(f: FrozenArrayType<'a>) -> Self {
313 Self::FrozenArrayType(MayBeNull::new_required(f))
314 }
315
316 fn frozen_array_opt(f: FrozenArrayType<'a>) -> Self {
317 Self::FrozenArrayType(MayBeNull::new_optional(f))
318 }
319
320 fn record(r: RecordType<'a>) -> Self {
321 Self::RecordType(MayBeNull::new_required(r))
322 }
323
324 fn record_opt(r: RecordType<'a>) -> Self {
325 Self::RecordType(MayBeNull::new_optional(r))
326 }
327
328 fn identifier(i: &'a str) -> Self {
329 Self::Identifier(MayBeNull::new_required(Identifier(i)))
330 }
331
332 fn identifier_opt(i: &'a str) -> Self {
333 Self::Identifier(MayBeNull::new_optional(Identifier(i)))
334 }
335}
336
337#[cfg(test)]
338mod extend_non_any {
339 use crate::extend::{
340 ExtendFloatingPointTypeNew, ExtendFrozenArrayType, ExtendIntegerTypeNew, ExtendNonAnyType,
341 ExtendPromiseType, ExtendRecordKeyType, ExtendRecordType, ExtendSequenceType, ExtendType,
342 };
343 use weedle::types::{
344 FloatType, FloatingPointType, FrozenArrayType, IntegerType, LongType, NonAnyType,
345 PromiseType, RecordKeyType, RecordType, ReturnType, SequenceType, SingleType, Type,
346 };
347
348 #[test]
349 fn test_required() {
350 let promise = PromiseType::new(ReturnType::Type(Type::Single(SingleType::NonAny(
351 NonAnyType::boolean(),
352 ))));
353 let integer = IntegerType::Long(LongType::new_unsigned());
354 let float = FloatingPointType::Float(FloatType::new_unrestricted());
355
356 assert!(NonAnyType::promise(promise).is_required());
357 assert!(NonAnyType::integer(integer).is_required());
358 assert!(NonAnyType::floating_point(float).is_required());
359 assert!(NonAnyType::boolean().is_required());
360 assert!(NonAnyType::byte().is_required());
361 assert!(NonAnyType::octet().is_required());
362 assert!(NonAnyType::byte_string().is_required());
363 assert!(NonAnyType::dom_string().is_required());
364 assert!(NonAnyType::usv_string().is_required());
365 assert!(NonAnyType::object().is_required());
366 assert!(NonAnyType::symbol().is_required());
367 assert!(NonAnyType::error().is_required());
368 assert!(NonAnyType::array_buffer().is_required());
369 assert!(NonAnyType::data_view().is_required());
370 assert!(NonAnyType::int8_array().is_required());
371 assert!(NonAnyType::int16_array().is_required());
372 assert!(NonAnyType::int32_array().is_required());
373 assert!(NonAnyType::uint8_array().is_required());
374 assert!(NonAnyType::uint16_array().is_required());
375 assert!(NonAnyType::uint32_array().is_required());
376 assert!(NonAnyType::uint8_clamped_array().is_required());
377 assert!(NonAnyType::float32_array().is_required());
378 assert!(NonAnyType::float64_array().is_required());
379 assert!(NonAnyType::array_buffer_view().is_required());
380 assert!(NonAnyType::buffer_source().is_required());
381
382 let seq = SequenceType::new(Type::single_any());
383 let frozen = FrozenArrayType::new(Type::single_any());
384 let record = RecordType::new(RecordKeyType::byte(), Type::single_any());
385 assert!(NonAnyType::sequence(seq).is_required());
386 assert!(NonAnyType::frozen_array(frozen).is_required());
387 assert!(NonAnyType::record(record).is_required());
388 assert!(NonAnyType::identifier("FooBar").is_required());
389 }
390
391 #[test]
392 fn test_optional() {
393 let integer = IntegerType::Long(LongType::new_unsigned());
394 let float = FloatingPointType::Float(FloatType::new_unrestricted());
395
396 assert!(NonAnyType::integer_opt(integer).is_optional());
397 assert!(NonAnyType::floating_point_opt(float).is_optional());
398 assert!(NonAnyType::boolean_opt().is_optional());
399 assert!(NonAnyType::byte_opt().is_optional());
400 assert!(NonAnyType::octet_opt().is_optional());
401 assert!(NonAnyType::byte_string_opt().is_optional());
402 assert!(NonAnyType::dom_string_opt().is_optional());
403 assert!(NonAnyType::usv_string_opt().is_optional());
404 assert!(NonAnyType::object_opt().is_optional());
405 assert!(NonAnyType::symbol_opt().is_optional());
406 assert!(NonAnyType::error_opt().is_optional());
407 assert!(NonAnyType::array_buffer_opt().is_optional());
408 assert!(NonAnyType::data_view_opt().is_optional());
409 assert!(NonAnyType::int8_array_opt().is_optional());
410 assert!(NonAnyType::int16_array_opt().is_optional());
411 assert!(NonAnyType::int32_array_opt().is_optional());
412 assert!(NonAnyType::uint8_array_opt().is_optional());
413 assert!(NonAnyType::uint16_array_opt().is_optional());
414 assert!(NonAnyType::uint32_array_opt().is_optional());
415 assert!(NonAnyType::uint8_clamped_array_opt().is_optional());
416 assert!(NonAnyType::float32_array_opt().is_optional());
417 assert!(NonAnyType::float64_array_opt().is_optional());
418 assert!(NonAnyType::array_buffer_view_opt().is_optional());
419 assert!(NonAnyType::buffer_source_opt().is_optional());
420
421 let seq = SequenceType::new(Type::single_any());
422 let frozen = FrozenArrayType::new(Type::single_any());
423 let record = RecordType::new(RecordKeyType::byte(), Type::single_any());
424 assert!(NonAnyType::sequence_opt(seq).is_optional());
425 assert!(NonAnyType::frozen_array_opt(frozen).is_optional());
426 assert!(NonAnyType::record_opt(record).is_optional());
427 assert!(NonAnyType::identifier_opt("FooBar").is_optional());
428 }
429}