1#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
4
5use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
6use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
7use crate::codegen::GenericBindings::FunctionBinding::Function;
8use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
9use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
10use crate::import::base::*;
11use crate::record::Record;
12
13
14#[repr(usize)]
15#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
16pub enum TestEnum {
17 _empty,
18 Foo,
19 Bar
20}
21pub mod TestEnumValues {
22
23 use crate::utils::find_enum_value;
24 use js::conversions::ConversionResult;
25 use js::conversions::FromJSValConvertible;
26 use js::conversions::ToJSValConvertible;
27 use js::context::RawJSContext;
28 use js::rust::HandleValue;
29 use js::rust::MutableHandleValue;
30 use js::jsval::JSVal;
31
32 pub(crate) const pairs: &[(&str, super::TestEnum)] = &[
33 ("", super::TestEnum::_empty),
34 ("foo", super::TestEnum::Foo),
35 ("bar", super::TestEnum::Bar),
36 ];
37
38 impl super::TestEnum {
39 pub fn as_str(&self) -> &'static str {
40 pairs[*self as usize].0
41 }
42 }
43
44 impl Default for super::TestEnum {
45 fn default() -> super::TestEnum {
46 pairs[0].1
47 }
48 }
49
50 impl std::str::FromStr for super::TestEnum {
51 type Err = ();
52
53 fn from_str(s: &str) -> Result<Self, Self::Err> {
54 pairs
55 .iter()
56 .find(|&&(key, _)| s == key)
57 .map(|&(_, ev)| ev)
58 .ok_or(())
59 }
60 }
61
62 impl ToJSValConvertible for super::TestEnum {
63 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
64 pairs[*self as usize].0.to_jsval(cx, rval);
65 }
66 }
67
68 impl FromJSValConvertible for super::TestEnum {
69 type Config = ();
70 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
71 -> Result<ConversionResult<super::TestEnum>, ()> {
72 match find_enum_value(cx, value, pairs) {
73 Err(_) => Err(()),
74 Ok((None, search)) => {
75 Ok(ConversionResult::Failure(
76 format!("'{}' is not a valid enum value for enumeration 'TestEnum'.", search).into()
77 ))
78 }
79 Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
80 }
81 }
82 }
83 } pub use self::GenericUnionTypes::StringOrURLOrBlob as TestTypedef;
86
87pub type TestTypedefNullableUnion<D> = Option<GenericUnionTypes::StringOrURLOrBlob::<D>>;
88
89pub type TestTypedefString = DOMString;
90
91pub type TestTypedefInterface<D> = DomRoot<<D as DomTypes>::Blob>;
92
93pub type PromiseUndefined<D> = Rc<<D as DomTypes>::Promise>;
94
95pub use self::GenericUnionTypes::USVStringOrUndefined as UnionWithUndefinedVariant;
96
97#[derive(JSTraceable)]
98#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
99pub struct TestDictionary<D: DomTypes> {
100 pub anyValue: RootedTraceableBox<Heap<JSVal>>,
101 pub booleanValue: Option<bool>,
102 pub byteValue: Option<i8>,
103 pub dict: RootedTraceableBox<crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryDefaults>,
104 pub doubleValue: Option<Finite<f64>>,
105 pub elementSequence: Option<Vec<DomRoot<D::Element>>>,
106 pub enumValue: Option<TestEnum>,
107 pub floatValue: Option<Finite<f32>>,
108 pub interfaceValue: Option<DomRoot<D::Blob>>,
109 pub longLongValue: Option<i64>,
110 pub longValue: Option<i32>,
111 pub noCallbackImport: Option<Rc<SimpleCallback<D>>>,
112 pub noCallbackImport2: Option<Rc<callbackWithOnlyOneOptionalArg<D>>>,
113 pub nonRequiredNullable: Option<Option<DOMString>>,
114 pub nonRequiredNullable2: Option<Option<DOMString>>,
115 pub objectValue: Option<RootedTraceableBox<Heap<*mut JSObject>>>,
116 pub octetValue: Option<u8>,
117 pub requiredValue: bool,
118 pub seqDict: Option<Vec<RootedTraceableBox<crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryDefaults>>>,
119 pub shortValue: Option<i16>,
120 pub stringValue: Option<DOMString>,
121 pub type_: Option<DOMString>,
122 pub unrestrictedDoubleValue: Option<f64>,
123 pub unrestrictedFloatValue: Option<f32>,
124 pub unsignedLongLongValue: Option<u64>,
125 pub unsignedLongValue: Option<u32>,
126 pub unsignedShortValue: Option<u16>,
127 pub usvstringValue: Option<USVString>,
128}
129
130impl<D: DomTypes> TestDictionary<D> {
131
132 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
133 -> Result<ConversionResult<RootedTraceableBox<TestDictionary<D>>>, ()> {
134 unsafe {
135 let object = if val.get().is_null_or_undefined() {
136 ptr::null_mut()
137 } else if val.get().is_object() {
138 val.get().to_object()
139 } else {
140 return Ok(ConversionResult::Failure("Value is not an object.".into()));
141 };
142 rooted!(&in(cx) let object = object);
143 let dictionary = RootedTraceableBox::new(TestDictionary {
144 anyValue: {
145 rooted!(&in(cx) let mut rval = UndefinedValue());
146 if get_dictionary_property(cx.raw_cx(), object.handle(), "anyValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
147 RootedTraceableBox::from_box(Heap::boxed(rval.handle().get()))
148 } else {
149 RootedTraceableBox::from_box(Heap::boxed(UndefinedValue()))
150 }
151 },
152 booleanValue: {
153 rooted!(&in(cx) let mut rval = UndefinedValue());
154 if get_dictionary_property(cx.raw_cx(), object.handle(), "booleanValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
155 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
156 Ok(ConversionResult::Success(value)) => value,
157 Ok(ConversionResult::Failure(error)) => {
158 throw_type_error(cx.raw_cx(), &error);
159 return Err(());
160
161 }
162 _ => {
163 return Err(());
164
165 },
166 }
167 )
168 } else {
169 None
170 }
171 },
172 byteValue: {
173 rooted!(&in(cx) let mut rval = UndefinedValue());
174 if get_dictionary_property(cx.raw_cx(), object.handle(), "byteValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
175 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
176 Ok(ConversionResult::Success(value)) => value,
177 Ok(ConversionResult::Failure(error)) => {
178 throw_type_error(cx.raw_cx(), &error);
179 return Err(());
180
181 }
182 _ => {
183 return Err(());
184
185 },
186 }
187 )
188 } else {
189 None
190 }
191 },
192 dict: {
193 rooted!(&in(cx) let mut rval = UndefinedValue());
194 if get_dictionary_property(cx.raw_cx(), object.handle(), "dict", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
195 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
196 Ok(ConversionResult::Success(value)) => value,
197 Ok(ConversionResult::Failure(error)) => {
198 throw_type_error(cx.raw_cx(), &error);
199 return Err(());
200
201 }
202 _ => {
203 return Err(());
204
205 },
206 }
207
208 } else {
209 crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryDefaults::empty()
210 }
211 },
212 doubleValue: {
213 rooted!(&in(cx) let mut rval = UndefinedValue());
214 if get_dictionary_property(cx.raw_cx(), object.handle(), "doubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
215 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
216 Ok(ConversionResult::Success(value)) => value,
217 Ok(ConversionResult::Failure(error)) => {
218 throw_type_error(cx.raw_cx(), &error);
219 return Err(());
220
221 }
222 _ => {
223 return Err(());
224
225 },
226 }
227 )
228 } else {
229 None
230 }
231 },
232 elementSequence: {
233 rooted!(&in(cx) let mut rval = UndefinedValue());
234 if get_dictionary_property(cx.raw_cx(), object.handle(), "elementSequence", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
235 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
236 Ok(ConversionResult::Success(value)) => value,
237 Ok(ConversionResult::Failure(error)) => {
238 throw_type_error(cx.raw_cx(), &error);
239 return Err(());
240
241 }
242 _ => {
243 return Err(());
244
245 },
246 }
247 )
248 } else {
249 None
250 }
251 },
252 enumValue: {
253 rooted!(&in(cx) let mut rval = UndefinedValue());
254 if get_dictionary_property(cx.raw_cx(), object.handle(), "enumValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
255 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
256 Ok(ConversionResult::Success(value)) => value,
257 Ok(ConversionResult::Failure(error)) => {
258 throw_type_error(cx.raw_cx(), &error); return Err(());
259
260 }
261 _ => {
262 return Err(());
263
264 },
265 }
266 )
267 } else {
268 None
269 }
270 },
271 floatValue: {
272 rooted!(&in(cx) let mut rval = UndefinedValue());
273 if get_dictionary_property(cx.raw_cx(), object.handle(), "floatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
274 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
275 Ok(ConversionResult::Success(value)) => value,
276 Ok(ConversionResult::Failure(error)) => {
277 throw_type_error(cx.raw_cx(), &error);
278 return Err(());
279
280 }
281 _ => {
282 return Err(());
283
284 },
285 }
286 )
287 } else {
288 None
289 }
290 },
291 interfaceValue: {
292 rooted!(&in(cx) let mut rval = UndefinedValue());
293 if get_dictionary_property(cx.raw_cx(), object.handle(), "interfaceValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
294 Some(if rval.handle().get().is_object() {
295 match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
296 Ok(val) => val,
297 Err(()) => {
298 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
299 return Err(());
300
301 }
302 }
303
304 } else {
305 throw_type_error(cx.raw_cx(), "Value is not an object.");
306 return Err(());
307
308 })
309 } else {
310 None
311 }
312 },
313 longLongValue: {
314 rooted!(&in(cx) let mut rval = UndefinedValue());
315 if get_dictionary_property(cx.raw_cx(), object.handle(), "longLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
316 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
317 Ok(ConversionResult::Success(value)) => value,
318 Ok(ConversionResult::Failure(error)) => {
319 throw_type_error(cx.raw_cx(), &error);
320 return Err(());
321
322 }
323 _ => {
324 return Err(());
325
326 },
327 }
328 )
329 } else {
330 None
331 }
332 },
333 longValue: {
334 rooted!(&in(cx) let mut rval = UndefinedValue());
335 if get_dictionary_property(cx.raw_cx(), object.handle(), "longValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
336 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
337 Ok(ConversionResult::Success(value)) => value,
338 Ok(ConversionResult::Failure(error)) => {
339 throw_type_error(cx.raw_cx(), &error);
340 return Err(());
341
342 }
343 _ => {
344 return Err(());
345
346 },
347 }
348 )
349 } else {
350 None
351 }
352 },
353 noCallbackImport: {
354 rooted!(&in(cx) let mut rval = UndefinedValue());
355 if get_dictionary_property(cx.raw_cx(), object.handle(), "noCallbackImport", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
356 Some(if rval.handle().get().is_object() {
357 if IsCallable(rval.handle().get().to_object()) {
358 SimpleCallback::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), rval.handle().get().to_object())
359 } else {
360 throw_type_error(cx.raw_cx(), "Value is not callable.");
361 return Err(());
362
363 }
364 } else {
365 throw_type_error(cx.raw_cx(), "Value is not an object.");
366 return Err(());
367
368 })
369 } else {
370 None
371 }
372 },
373 noCallbackImport2: {
374 rooted!(&in(cx) let mut rval = UndefinedValue());
375 if get_dictionary_property(cx.raw_cx(), object.handle(), "noCallbackImport2", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
376 Some(if rval.handle().get().is_object() {
377 if IsCallable(rval.handle().get().to_object()) {
378 callbackWithOnlyOneOptionalArg::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), rval.handle().get().to_object())
379 } else {
380 throw_type_error(cx.raw_cx(), "Value is not callable.");
381 return Err(());
382
383 }
384 } else {
385 throw_type_error(cx.raw_cx(), "Value is not an object.");
386 return Err(());
387
388 })
389 } else {
390 None
391 }
392 },
393 nonRequiredNullable: {
394 rooted!(&in(cx) let mut rval = UndefinedValue());
395 if get_dictionary_property(cx.raw_cx(), object.handle(), "nonRequiredNullable", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
396 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
397 Ok(ConversionResult::Success(value)) => value,
398 Ok(ConversionResult::Failure(error)) => {
399 throw_type_error(cx.raw_cx(), &error);
400 return Err(());
401
402 }
403 _ => {
404 return Err(());
405
406 },
407 }
408 )
409 } else {
410 None
411 }
412 },
413 nonRequiredNullable2: {
414 rooted!(&in(cx) let mut rval = UndefinedValue());
415 if get_dictionary_property(cx.raw_cx(), object.handle(), "nonRequiredNullable2", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
416 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
417 Ok(ConversionResult::Success(value)) => value,
418 Ok(ConversionResult::Failure(error)) => {
419 throw_type_error(cx.raw_cx(), &error);
420 return Err(());
421
422 }
423 _ => {
424 return Err(());
425
426 },
427 }
428 )
429 } else {
430 None
431 }
432 },
433 objectValue: {
434 rooted!(&in(cx) let mut rval = UndefinedValue());
435 if get_dictionary_property(cx.raw_cx(), object.handle(), "objectValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
436 Some(if rval.handle().get().is_object() {
437 RootedTraceableBox::from_box(Heap::boxed(rval.handle().get().to_object()))
438 } else {
439 throw_type_error(cx.raw_cx(), "Value is not an object.");
440 return Err(());
441
442 })
443 } else {
444 None
445 }
446 },
447 octetValue: {
448 rooted!(&in(cx) let mut rval = UndefinedValue());
449 if get_dictionary_property(cx.raw_cx(), object.handle(), "octetValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
450 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
451 Ok(ConversionResult::Success(value)) => value,
452 Ok(ConversionResult::Failure(error)) => {
453 throw_type_error(cx.raw_cx(), &error);
454 return Err(());
455
456 }
457 _ => {
458 return Err(());
459
460 },
461 }
462 )
463 } else {
464 None
465 }
466 },
467 requiredValue: {
468 rooted!(&in(cx) let mut rval = UndefinedValue());
469 if get_dictionary_property(cx.raw_cx(), object.handle(), "requiredValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
470 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
471 Ok(ConversionResult::Success(value)) => value,
472 Ok(ConversionResult::Failure(error)) => {
473 throw_type_error(cx.raw_cx(), &error);
474 return Err(());
475
476 }
477 _ => {
478 return Err(());
479
480 },
481 }
482
483 } else {
484 throw_type_error(cx.raw_cx(), "Missing required member \"requiredValue\".");
485 return Err(());
486 }
487 },
488 seqDict: {
489 rooted!(&in(cx) let mut rval = UndefinedValue());
490 if get_dictionary_property(cx.raw_cx(), object.handle(), "seqDict", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
491 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
492 Ok(ConversionResult::Success(value)) => value,
493 Ok(ConversionResult::Failure(error)) => {
494 throw_type_error(cx.raw_cx(), &error);
495 return Err(());
496
497 }
498 _ => {
499 return Err(());
500
501 },
502 }
503 )
504 } else {
505 None
506 }
507 },
508 shortValue: {
509 rooted!(&in(cx) let mut rval = UndefinedValue());
510 if get_dictionary_property(cx.raw_cx(), object.handle(), "shortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
511 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
512 Ok(ConversionResult::Success(value)) => value,
513 Ok(ConversionResult::Failure(error)) => {
514 throw_type_error(cx.raw_cx(), &error);
515 return Err(());
516
517 }
518 _ => {
519 return Err(());
520
521 },
522 }
523 )
524 } else {
525 None
526 }
527 },
528 stringValue: {
529 rooted!(&in(cx) let mut rval = UndefinedValue());
530 if get_dictionary_property(cx.raw_cx(), object.handle(), "stringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
531 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
532 Ok(ConversionResult::Success(value)) => value,
533 Ok(ConversionResult::Failure(error)) => {
534 throw_type_error(cx.raw_cx(), &error);
535 return Err(());
536
537 }
538 _ => {
539 return Err(());
540
541 },
542 }
543 )
544 } else {
545 None
546 }
547 },
548 type_: {
549 rooted!(&in(cx) let mut rval = UndefinedValue());
550 if get_dictionary_property(cx.raw_cx(), object.handle(), "type", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
551 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
552 Ok(ConversionResult::Success(value)) => value,
553 Ok(ConversionResult::Failure(error)) => {
554 throw_type_error(cx.raw_cx(), &error);
555 return Err(());
556
557 }
558 _ => {
559 return Err(());
560
561 },
562 }
563 )
564 } else {
565 None
566 }
567 },
568 unrestrictedDoubleValue: {
569 rooted!(&in(cx) let mut rval = UndefinedValue());
570 if get_dictionary_property(cx.raw_cx(), object.handle(), "unrestrictedDoubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
571 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
572 Ok(ConversionResult::Success(value)) => value,
573 Ok(ConversionResult::Failure(error)) => {
574 throw_type_error(cx.raw_cx(), &error);
575 return Err(());
576
577 }
578 _ => {
579 return Err(());
580
581 },
582 }
583 )
584 } else {
585 None
586 }
587 },
588 unrestrictedFloatValue: {
589 rooted!(&in(cx) let mut rval = UndefinedValue());
590 if get_dictionary_property(cx.raw_cx(), object.handle(), "unrestrictedFloatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
591 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
592 Ok(ConversionResult::Success(value)) => value,
593 Ok(ConversionResult::Failure(error)) => {
594 throw_type_error(cx.raw_cx(), &error);
595 return Err(());
596
597 }
598 _ => {
599 return Err(());
600
601 },
602 }
603 )
604 } else {
605 None
606 }
607 },
608 unsignedLongLongValue: {
609 rooted!(&in(cx) let mut rval = UndefinedValue());
610 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedLongLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
611 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
612 Ok(ConversionResult::Success(value)) => value,
613 Ok(ConversionResult::Failure(error)) => {
614 throw_type_error(cx.raw_cx(), &error);
615 return Err(());
616
617 }
618 _ => {
619 return Err(());
620
621 },
622 }
623 )
624 } else {
625 None
626 }
627 },
628 unsignedLongValue: {
629 rooted!(&in(cx) let mut rval = UndefinedValue());
630 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
631 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
632 Ok(ConversionResult::Success(value)) => value,
633 Ok(ConversionResult::Failure(error)) => {
634 throw_type_error(cx.raw_cx(), &error);
635 return Err(());
636
637 }
638 _ => {
639 return Err(());
640
641 },
642 }
643 )
644 } else {
645 None
646 }
647 },
648 unsignedShortValue: {
649 rooted!(&in(cx) let mut rval = UndefinedValue());
650 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedShortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
651 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
652 Ok(ConversionResult::Success(value)) => value,
653 Ok(ConversionResult::Failure(error)) => {
654 throw_type_error(cx.raw_cx(), &error);
655 return Err(());
656
657 }
658 _ => {
659 return Err(());
660
661 },
662 }
663 )
664 } else {
665 None
666 }
667 },
668 usvstringValue: {
669 rooted!(&in(cx) let mut rval = UndefinedValue());
670 if get_dictionary_property(cx.raw_cx(), object.handle(), "usvstringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
671 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
672 Ok(ConversionResult::Success(value)) => value,
673 Ok(ConversionResult::Failure(error)) => {
674 throw_type_error(cx.raw_cx(), &error);
675 return Err(());
676
677 }
678 _ => {
679 return Err(());
680
681 },
682 }
683 )
684 } else {
685 None
686 }
687 },
688 });
689 Ok(ConversionResult::Success(dictionary))
690 }
691 }
692}
693
694impl<D: DomTypes> FromJSValConvertible for RootedTraceableBox<TestDictionary<D>> {
695 type Config = ();
696 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
697 -> Result<ConversionResult<RootedTraceableBox<TestDictionary<D>>>, ()> {
698 TestDictionary::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
699 }
700}
701
702impl<D: DomTypes> TestDictionary<D> {
703 #[allow(clippy::wrong_self_convention)]
704 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
705 let anyValue = &self.anyValue;
706 rooted!(in(cx) let mut anyValue_js = UndefinedValue());
707 anyValue.to_jsval(cx, anyValue_js.handle_mut());
708 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "anyValue", anyValue_js.handle()).unwrap();
709 if let Some(ref booleanValue) = self.booleanValue {
710 rooted!(in(cx) let mut booleanValue_js = UndefinedValue());
711 booleanValue.to_jsval(cx, booleanValue_js.handle_mut());
712 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "booleanValue", booleanValue_js.handle()).unwrap();
713 }
714 if let Some(ref byteValue) = self.byteValue {
715 rooted!(in(cx) let mut byteValue_js = UndefinedValue());
716 byteValue.to_jsval(cx, byteValue_js.handle_mut());
717 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "byteValue", byteValue_js.handle()).unwrap();
718 }
719 let dict = &self.dict;
720 rooted!(in(cx) let mut dict_js = UndefinedValue());
721 dict.to_jsval(cx, dict_js.handle_mut());
722 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "dict", dict_js.handle()).unwrap();
723 if let Some(ref doubleValue) = self.doubleValue {
724 rooted!(in(cx) let mut doubleValue_js = UndefinedValue());
725 doubleValue.to_jsval(cx, doubleValue_js.handle_mut());
726 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "doubleValue", doubleValue_js.handle()).unwrap();
727 }
728 if let Some(ref elementSequence) = self.elementSequence {
729 rooted!(in(cx) let mut elementSequence_js = UndefinedValue());
730 elementSequence.to_jsval(cx, elementSequence_js.handle_mut());
731 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "elementSequence", elementSequence_js.handle()).unwrap();
732 }
733 if let Some(ref enumValue) = self.enumValue {
734 rooted!(in(cx) let mut enumValue_js = UndefinedValue());
735 enumValue.to_jsval(cx, enumValue_js.handle_mut());
736 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "enumValue", enumValue_js.handle()).unwrap();
737 }
738 if let Some(ref floatValue) = self.floatValue {
739 rooted!(in(cx) let mut floatValue_js = UndefinedValue());
740 floatValue.to_jsval(cx, floatValue_js.handle_mut());
741 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "floatValue", floatValue_js.handle()).unwrap();
742 }
743 if let Some(ref interfaceValue) = self.interfaceValue {
744 rooted!(in(cx) let mut interfaceValue_js = UndefinedValue());
745 interfaceValue.to_jsval(cx, interfaceValue_js.handle_mut());
746 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "interfaceValue", interfaceValue_js.handle()).unwrap();
747 }
748 if let Some(ref longLongValue) = self.longLongValue {
749 rooted!(in(cx) let mut longLongValue_js = UndefinedValue());
750 longLongValue.to_jsval(cx, longLongValue_js.handle_mut());
751 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "longLongValue", longLongValue_js.handle()).unwrap();
752 }
753 if let Some(ref longValue) = self.longValue {
754 rooted!(in(cx) let mut longValue_js = UndefinedValue());
755 longValue.to_jsval(cx, longValue_js.handle_mut());
756 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "longValue", longValue_js.handle()).unwrap();
757 }
758 if let Some(ref noCallbackImport) = self.noCallbackImport {
759 rooted!(in(cx) let mut noCallbackImport_js = UndefinedValue());
760 noCallbackImport.to_jsval(cx, noCallbackImport_js.handle_mut());
761 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "noCallbackImport", noCallbackImport_js.handle()).unwrap();
762 }
763 if let Some(ref noCallbackImport2) = self.noCallbackImport2 {
764 rooted!(in(cx) let mut noCallbackImport2_js = UndefinedValue());
765 noCallbackImport2.to_jsval(cx, noCallbackImport2_js.handle_mut());
766 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "noCallbackImport2", noCallbackImport2_js.handle()).unwrap();
767 }
768 if let Some(ref nonRequiredNullable) = self.nonRequiredNullable {
769 rooted!(in(cx) let mut nonRequiredNullable_js = UndefinedValue());
770 nonRequiredNullable.to_jsval(cx, nonRequiredNullable_js.handle_mut());
771 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nonRequiredNullable", nonRequiredNullable_js.handle()).unwrap();
772 }
773 if let Some(ref nonRequiredNullable2) = self.nonRequiredNullable2 {
774 rooted!(in(cx) let mut nonRequiredNullable2_js = UndefinedValue());
775 nonRequiredNullable2.to_jsval(cx, nonRequiredNullable2_js.handle_mut());
776 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nonRequiredNullable2", nonRequiredNullable2_js.handle()).unwrap();
777 }
778 if let Some(ref objectValue) = self.objectValue {
779 rooted!(in(cx) let mut objectValue_js = UndefinedValue());
780 objectValue.to_jsval(cx, objectValue_js.handle_mut());
781 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "objectValue", objectValue_js.handle()).unwrap();
782 }
783 if let Some(ref octetValue) = self.octetValue {
784 rooted!(in(cx) let mut octetValue_js = UndefinedValue());
785 octetValue.to_jsval(cx, octetValue_js.handle_mut());
786 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "octetValue", octetValue_js.handle()).unwrap();
787 }
788 let requiredValue = &self.requiredValue;
789 rooted!(in(cx) let mut requiredValue_js = UndefinedValue());
790 requiredValue.to_jsval(cx, requiredValue_js.handle_mut());
791 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "requiredValue", requiredValue_js.handle()).unwrap();
792 if let Some(ref seqDict) = self.seqDict {
793 rooted!(in(cx) let mut seqDict_js = UndefinedValue());
794 seqDict.to_jsval(cx, seqDict_js.handle_mut());
795 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "seqDict", seqDict_js.handle()).unwrap();
796 }
797 if let Some(ref shortValue) = self.shortValue {
798 rooted!(in(cx) let mut shortValue_js = UndefinedValue());
799 shortValue.to_jsval(cx, shortValue_js.handle_mut());
800 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "shortValue", shortValue_js.handle()).unwrap();
801 }
802 if let Some(ref stringValue) = self.stringValue {
803 rooted!(in(cx) let mut stringValue_js = UndefinedValue());
804 stringValue.to_jsval(cx, stringValue_js.handle_mut());
805 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stringValue", stringValue_js.handle()).unwrap();
806 }
807 if let Some(ref type_) = self.type_ {
808 rooted!(in(cx) let mut type__js = UndefinedValue());
809 type_.to_jsval(cx, type__js.handle_mut());
810 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "type", type__js.handle()).unwrap();
811 }
812 if let Some(ref unrestrictedDoubleValue) = self.unrestrictedDoubleValue {
813 rooted!(in(cx) let mut unrestrictedDoubleValue_js = UndefinedValue());
814 unrestrictedDoubleValue.to_jsval(cx, unrestrictedDoubleValue_js.handle_mut());
815 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unrestrictedDoubleValue", unrestrictedDoubleValue_js.handle()).unwrap();
816 }
817 if let Some(ref unrestrictedFloatValue) = self.unrestrictedFloatValue {
818 rooted!(in(cx) let mut unrestrictedFloatValue_js = UndefinedValue());
819 unrestrictedFloatValue.to_jsval(cx, unrestrictedFloatValue_js.handle_mut());
820 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unrestrictedFloatValue", unrestrictedFloatValue_js.handle()).unwrap();
821 }
822 if let Some(ref unsignedLongLongValue) = self.unsignedLongLongValue {
823 rooted!(in(cx) let mut unsignedLongLongValue_js = UndefinedValue());
824 unsignedLongLongValue.to_jsval(cx, unsignedLongLongValue_js.handle_mut());
825 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedLongLongValue", unsignedLongLongValue_js.handle()).unwrap();
826 }
827 if let Some(ref unsignedLongValue) = self.unsignedLongValue {
828 rooted!(in(cx) let mut unsignedLongValue_js = UndefinedValue());
829 unsignedLongValue.to_jsval(cx, unsignedLongValue_js.handle_mut());
830 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedLongValue", unsignedLongValue_js.handle()).unwrap();
831 }
832 if let Some(ref unsignedShortValue) = self.unsignedShortValue {
833 rooted!(in(cx) let mut unsignedShortValue_js = UndefinedValue());
834 unsignedShortValue.to_jsval(cx, unsignedShortValue_js.handle_mut());
835 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedShortValue", unsignedShortValue_js.handle()).unwrap();
836 }
837 if let Some(ref usvstringValue) = self.usvstringValue {
838 rooted!(in(cx) let mut usvstringValue_js = UndefinedValue());
839 usvstringValue.to_jsval(cx, usvstringValue_js.handle_mut());
840 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usvstringValue", usvstringValue_js.handle()).unwrap();
841 }
842 }
843}
844
845impl<D: DomTypes> ToJSValConvertible for TestDictionary<D> {
846 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
847 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
848 self.to_jsobject(cx, obj.handle_mut());
849 rval.set(ObjectOrNullValue(obj.get()))
850 }
851}
852
853
854#[derive(JSTraceable)]
855pub struct TestDictionaryParent {
856 pub parentStringMember: Option<DOMString>,
857}
858impl Default for TestDictionaryParent {
859 fn default() -> Self {
860 Self::empty()
861 }
862}
863
864impl TestDictionaryParent {
865 pub fn empty() -> Self {
866 Self {
867 parentStringMember: None,
868 }
869 }
870 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
871 -> Result<ConversionResult<TestDictionaryParent>, ()> {
872 unsafe {
873 let object = if val.get().is_null_or_undefined() {
874 ptr::null_mut()
875 } else if val.get().is_object() {
876 val.get().to_object()
877 } else {
878 return Ok(ConversionResult::Failure("Value is not an object.".into()));
879 };
880 rooted!(&in(cx) let object = object);
881 let dictionary = TestDictionaryParent {
882 parentStringMember: {
883 rooted!(&in(cx) let mut rval = UndefinedValue());
884 if get_dictionary_property(cx.raw_cx(), object.handle(), "parentStringMember", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
885 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
886 Ok(ConversionResult::Success(value)) => value,
887 Ok(ConversionResult::Failure(error)) => {
888 throw_type_error(cx.raw_cx(), &error);
889 return Err(());
890
891 }
892 _ => {
893 return Err(());
894
895 },
896 }
897 )
898 } else {
899 None
900 }
901 },
902 };
903 Ok(ConversionResult::Success(dictionary))
904 }
905 }
906}
907
908impl FromJSValConvertible for TestDictionaryParent {
909 type Config = ();
910 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
911 -> Result<ConversionResult<TestDictionaryParent>, ()> {
912 TestDictionaryParent::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
913 }
914}
915
916impl TestDictionaryParent {
917 #[allow(clippy::wrong_self_convention)]
918 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
919 if let Some(ref parentStringMember) = self.parentStringMember {
920 rooted!(in(cx) let mut parentStringMember_js = UndefinedValue());
921 parentStringMember.to_jsval(cx, parentStringMember_js.handle_mut());
922 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "parentStringMember", parentStringMember_js.handle()).unwrap();
923 }
924 }
925}
926
927impl ToJSValConvertible for TestDictionaryParent {
928 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
929 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
930 self.to_jsobject(cx, obj.handle_mut());
931 rval.set(ObjectOrNullValue(obj.get()))
932 }
933}
934
935
936#[derive(JSTraceable)]
937pub struct TestDictionaryWithParent {
938 pub parent: crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryParent,
939 pub stringMember: Option<DOMString>,
940}
941impl Default for TestDictionaryWithParent {
942 fn default() -> Self {
943 Self::empty()
944 }
945}
946
947impl TestDictionaryWithParent {
948 pub fn empty() -> Self {
949 Self {
950 parent: crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryParent::empty(),
951 stringMember: None,
952 }
953 }
954 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
955 -> Result<ConversionResult<TestDictionaryWithParent>, ()> {
956 unsafe {
957 let object = if val.get().is_null_or_undefined() {
958 ptr::null_mut()
959 } else if val.get().is_object() {
960 val.get().to_object()
961 } else {
962 return Ok(ConversionResult::Failure("Value is not an object.".into()));
963 };
964 rooted!(&in(cx) let object = object);
965 let dictionary = TestDictionaryWithParent {
966 parent: {
967 match crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryParent::new(cx, val, can_gc)? {
968 ConversionResult::Success(v) => v,
969 ConversionResult::Failure(error) => {
970 throw_type_error(cx.raw_cx(), &error);
971 return Err(());
972 }
973 }
974 },
975 stringMember: {
976 rooted!(&in(cx) let mut rval = UndefinedValue());
977 if get_dictionary_property(cx.raw_cx(), object.handle(), "stringMember", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
978 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
979 Ok(ConversionResult::Success(value)) => value,
980 Ok(ConversionResult::Failure(error)) => {
981 throw_type_error(cx.raw_cx(), &error);
982 return Err(());
983
984 }
985 _ => {
986 return Err(());
987
988 },
989 }
990 )
991 } else {
992 None
993 }
994 },
995 };
996 Ok(ConversionResult::Success(dictionary))
997 }
998 }
999}
1000
1001impl FromJSValConvertible for TestDictionaryWithParent {
1002 type Config = ();
1003 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
1004 -> Result<ConversionResult<TestDictionaryWithParent>, ()> {
1005 TestDictionaryWithParent::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
1006 }
1007}
1008
1009impl TestDictionaryWithParent {
1010 #[allow(clippy::wrong_self_convention)]
1011 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
1012 self.parent.to_jsobject(cx, obj.reborrow());
1013 if let Some(ref stringMember) = self.stringMember {
1014 rooted!(in(cx) let mut stringMember_js = UndefinedValue());
1015 stringMember.to_jsval(cx, stringMember_js.handle_mut());
1016 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stringMember", stringMember_js.handle()).unwrap();
1017 }
1018 }
1019}
1020
1021impl ToJSValConvertible for TestDictionaryWithParent {
1022 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
1023 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
1024 self.to_jsobject(cx, obj.handle_mut());
1025 rval.set(ObjectOrNullValue(obj.get()))
1026 }
1027}
1028
1029
1030#[derive(JSTraceable)]
1031#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
1032pub struct TestDictionaryDefaults {
1033 pub UnrestrictedDoubleValue: f64,
1034 pub anyValue: RootedTraceableBox<Heap<JSVal>>,
1035 pub arrayValue: Vec<RootedTraceableBox<Heap<*mut JSObject>>>,
1036 pub booleanValue: bool,
1037 pub byteValue: i8,
1038 pub bytestringValue: ByteString,
1039 pub doubleValue: Finite<f64>,
1040 pub enumValue: TestEnum,
1041 pub floatValue: Finite<f32>,
1042 pub longLongValue: i64,
1043 pub longValue: i32,
1044 pub nullableBooleanValue: Option<bool>,
1045 pub nullableByteValue: Option<i8>,
1046 pub nullableBytestringValue: Option<ByteString>,
1047 pub nullableDoubleValue: Option<Finite<f64>>,
1048 pub nullableFloatValue: Option<Finite<f32>>,
1049 pub nullableLongLongValue: Option<i64>,
1050 pub nullableLongValue: Option<i32>,
1051 pub nullableObjectValue: RootedTraceableBox<Heap<*mut JSObject>>,
1052 pub nullableOctetValue: Option<u8>,
1053 pub nullableShortValue: Option<i16>,
1054 pub nullableStringValue: Option<DOMString>,
1055 pub nullableUnrestrictedDoubleValue: Option<f64>,
1056 pub nullableUnrestrictedFloatValue: Option<f32>,
1057 pub nullableUnsignedLongLongValue: Option<u64>,
1058 pub nullableUnsignedLongValue: Option<u32>,
1059 pub nullableUnsignedShortValue: Option<u16>,
1060 pub nullableUsvstringValue: Option<USVString>,
1061 pub octetValue: u8,
1062 pub shortValue: i16,
1063 pub stringValue: DOMString,
1064 pub unrestrictedFloatValue: f32,
1065 pub unsignedLongLongValue: u64,
1066 pub unsignedLongValue: u32,
1067 pub unsignedShortValue: u16,
1068 pub usvstringValue: USVString,
1069}
1070impl Default for TestDictionaryDefaults {
1071 fn default() -> Self {
1072 Self {
1073 UnrestrictedDoubleValue: Default::default(),
1074 anyValue: Default::default(),
1075 arrayValue: Default::default(),
1076 booleanValue: Default::default(),
1077 byteValue: Default::default(),
1078 bytestringValue: Default::default(),
1079 doubleValue: Default::default(),
1080 enumValue: Default::default(),
1081 floatValue: Default::default(),
1082 longLongValue: Default::default(),
1083 longValue: Default::default(),
1084 nullableBooleanValue: Default::default(),
1085 nullableByteValue: Default::default(),
1086 nullableBytestringValue: Default::default(),
1087 nullableDoubleValue: Default::default(),
1088 nullableFloatValue: Default::default(),
1089 nullableLongLongValue: Default::default(),
1090 nullableLongValue: Default::default(),
1091 nullableObjectValue: Default::default(),
1092 nullableOctetValue: Default::default(),
1093 nullableShortValue: Default::default(),
1094 nullableStringValue: Default::default(),
1095 nullableUnrestrictedDoubleValue: Default::default(),
1096 nullableUnrestrictedFloatValue: Default::default(),
1097 nullableUnsignedLongLongValue: Default::default(),
1098 nullableUnsignedLongValue: Default::default(),
1099 nullableUnsignedShortValue: Default::default(),
1100 nullableUsvstringValue: Default::default(),
1101 octetValue: Default::default(),
1102 shortValue: Default::default(),
1103 stringValue: Default::default(),
1104 unrestrictedFloatValue: Default::default(),
1105 unsignedLongLongValue: Default::default(),
1106 unsignedLongValue: Default::default(),
1107 unsignedShortValue: Default::default(),
1108 usvstringValue: Default::default(), }
1109 }
1110}
1111
1112impl TestDictionaryDefaults {
1113 pub fn empty() -> RootedTraceableBox<Self> {
1114 let mut dictionary = RootedTraceableBox::new(Self::default());
1115 dictionary.UnrestrictedDoubleValue = 7.0;
1116 dictionary.anyValue = RootedTraceableBox::from_box(Heap::boxed(NullValue()));
1117 dictionary.arrayValue = Vec::new();
1118 dictionary.booleanValue = false;
1119 dictionary.byteValue = 7;
1120 dictionary.bytestringValue = ByteString::new(b"foo".to_vec());
1121 dictionary.doubleValue = Finite::wrap(7.0);
1122 dictionary.enumValue = TestEnum::Bar;
1123 dictionary.floatValue = Finite::wrap(7.0);
1124 dictionary.longLongValue = 7;
1125 dictionary.longValue = 7;
1126 dictionary.nullableBooleanValue = Some(false);
1127 dictionary.nullableByteValue = Some(7);
1128 dictionary.nullableBytestringValue = Some(ByteString::new(b"foo".to_vec()));
1129 dictionary.nullableDoubleValue = Some(Finite::wrap(7.0));
1130 dictionary.nullableFloatValue = Some(Finite::wrap(7.0));
1131 dictionary.nullableLongLongValue = Some(7);
1132 dictionary.nullableLongValue = Some(7);
1133 dictionary.nullableObjectValue = RootedTraceableBox::new(Heap::default());
1134 dictionary.nullableOctetValue = Some(7);
1135 dictionary.nullableShortValue = Some(7);
1136 dictionary.nullableStringValue = Some(DOMString::from("foo"));
1137 dictionary.nullableUnrestrictedDoubleValue = Some(7.0);
1138 dictionary.nullableUnrestrictedFloatValue = Some(7.0);
1139 dictionary.nullableUnsignedLongLongValue = Some(7);
1140 dictionary.nullableUnsignedLongValue = Some(7);
1141 dictionary.nullableUnsignedShortValue = Some(7);
1142 dictionary.nullableUsvstringValue = Some(USVString("foo".to_owned()));
1143 dictionary.octetValue = 7;
1144 dictionary.shortValue = 7;
1145 dictionary.stringValue = DOMString::from("foo");
1146 dictionary.unrestrictedFloatValue = 7.0;
1147 dictionary.unsignedLongLongValue = 7;
1148 dictionary.unsignedLongValue = 7;
1149 dictionary.unsignedShortValue = 7;
1150 dictionary.usvstringValue = USVString("foo".to_owned());
1151 dictionary
1152 }
1153 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
1154 -> Result<ConversionResult<RootedTraceableBox<TestDictionaryDefaults>>, ()> {
1155 unsafe {
1156 let object = if val.get().is_null_or_undefined() {
1157 ptr::null_mut()
1158 } else if val.get().is_object() {
1159 val.get().to_object()
1160 } else {
1161 return Ok(ConversionResult::Failure("Value is not an object.".into()));
1162 };
1163 rooted!(&in(cx) let object = object);
1164 let dictionary = RootedTraceableBox::new(TestDictionaryDefaults {
1165 UnrestrictedDoubleValue: {
1166 rooted!(&in(cx) let mut rval = UndefinedValue());
1167 if get_dictionary_property(cx.raw_cx(), object.handle(), "UnrestrictedDoubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1168 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1169 Ok(ConversionResult::Success(value)) => value,
1170 Ok(ConversionResult::Failure(error)) => {
1171 throw_type_error(cx.raw_cx(), &error);
1172 return Err(());
1173
1174 }
1175 _ => {
1176 return Err(());
1177
1178 },
1179 }
1180
1181 } else {
1182 7.0
1183 }
1184 },
1185 anyValue: {
1186 rooted!(&in(cx) let mut rval = UndefinedValue());
1187 if get_dictionary_property(cx.raw_cx(), object.handle(), "anyValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1188 RootedTraceableBox::from_box(Heap::boxed(rval.handle().get()))
1189 } else {
1190 RootedTraceableBox::from_box(Heap::boxed(NullValue()))
1191 }
1192 },
1193 arrayValue: {
1194 rooted!(&in(cx) let mut rval = UndefinedValue());
1195 if get_dictionary_property(cx.raw_cx(), object.handle(), "arrayValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1196 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1197 Ok(ConversionResult::Success(value)) => value,
1198 Ok(ConversionResult::Failure(error)) => {
1199 throw_type_error(cx.raw_cx(), &error);
1200 return Err(());
1201
1202 }
1203 _ => {
1204 return Err(());
1205
1206 },
1207 }
1208
1209 } else {
1210 Vec::new()
1211 }
1212 },
1213 booleanValue: {
1214 rooted!(&in(cx) let mut rval = UndefinedValue());
1215 if get_dictionary_property(cx.raw_cx(), object.handle(), "booleanValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1216 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1217 Ok(ConversionResult::Success(value)) => value,
1218 Ok(ConversionResult::Failure(error)) => {
1219 throw_type_error(cx.raw_cx(), &error);
1220 return Err(());
1221
1222 }
1223 _ => {
1224 return Err(());
1225
1226 },
1227 }
1228
1229 } else {
1230 false
1231 }
1232 },
1233 byteValue: {
1234 rooted!(&in(cx) let mut rval = UndefinedValue());
1235 if get_dictionary_property(cx.raw_cx(), object.handle(), "byteValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1236 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1237 Ok(ConversionResult::Success(value)) => value,
1238 Ok(ConversionResult::Failure(error)) => {
1239 throw_type_error(cx.raw_cx(), &error);
1240 return Err(());
1241
1242 }
1243 _ => {
1244 return Err(());
1245
1246 },
1247 }
1248
1249 } else {
1250 7
1251 }
1252 },
1253 bytestringValue: {
1254 rooted!(&in(cx) let mut rval = UndefinedValue());
1255 if get_dictionary_property(cx.raw_cx(), object.handle(), "bytestringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1256 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1257 Ok(ConversionResult::Success(value)) => value,
1258 Ok(ConversionResult::Failure(error)) => {
1259 throw_type_error(cx.raw_cx(), &error);
1260 return Err(());
1261
1262 }
1263 _ => {
1264 return Err(());
1265
1266 },
1267 }
1268
1269 } else {
1270 ByteString::new(b"foo".to_vec())
1271 }
1272 },
1273 doubleValue: {
1274 rooted!(&in(cx) let mut rval = UndefinedValue());
1275 if get_dictionary_property(cx.raw_cx(), object.handle(), "doubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1276 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1277 Ok(ConversionResult::Success(value)) => value,
1278 Ok(ConversionResult::Failure(error)) => {
1279 throw_type_error(cx.raw_cx(), &error);
1280 return Err(());
1281
1282 }
1283 _ => {
1284 return Err(());
1285
1286 },
1287 }
1288
1289 } else {
1290 Finite::wrap(7.0)
1291 }
1292 },
1293 enumValue: {
1294 rooted!(&in(cx) let mut rval = UndefinedValue());
1295 if get_dictionary_property(cx.raw_cx(), object.handle(), "enumValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1296 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1297 Ok(ConversionResult::Success(value)) => value,
1298 Ok(ConversionResult::Failure(error)) => {
1299 throw_type_error(cx.raw_cx(), &error); return Err(());
1300
1301 }
1302 _ => {
1303 return Err(());
1304
1305 },
1306 }
1307
1308 } else {
1309 TestEnum::Bar
1310 }
1311 },
1312 floatValue: {
1313 rooted!(&in(cx) let mut rval = UndefinedValue());
1314 if get_dictionary_property(cx.raw_cx(), object.handle(), "floatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1315 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1316 Ok(ConversionResult::Success(value)) => value,
1317 Ok(ConversionResult::Failure(error)) => {
1318 throw_type_error(cx.raw_cx(), &error);
1319 return Err(());
1320
1321 }
1322 _ => {
1323 return Err(());
1324
1325 },
1326 }
1327
1328 } else {
1329 Finite::wrap(7.0)
1330 }
1331 },
1332 longLongValue: {
1333 rooted!(&in(cx) let mut rval = UndefinedValue());
1334 if get_dictionary_property(cx.raw_cx(), object.handle(), "longLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1335 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1336 Ok(ConversionResult::Success(value)) => value,
1337 Ok(ConversionResult::Failure(error)) => {
1338 throw_type_error(cx.raw_cx(), &error);
1339 return Err(());
1340
1341 }
1342 _ => {
1343 return Err(());
1344
1345 },
1346 }
1347
1348 } else {
1349 7
1350 }
1351 },
1352 longValue: {
1353 rooted!(&in(cx) let mut rval = UndefinedValue());
1354 if get_dictionary_property(cx.raw_cx(), object.handle(), "longValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1355 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1356 Ok(ConversionResult::Success(value)) => value,
1357 Ok(ConversionResult::Failure(error)) => {
1358 throw_type_error(cx.raw_cx(), &error);
1359 return Err(());
1360
1361 }
1362 _ => {
1363 return Err(());
1364
1365 },
1366 }
1367
1368 } else {
1369 7
1370 }
1371 },
1372 nullableBooleanValue: {
1373 rooted!(&in(cx) let mut rval = UndefinedValue());
1374 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableBooleanValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1375 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1376 Ok(ConversionResult::Success(value)) => value,
1377 Ok(ConversionResult::Failure(error)) => {
1378 throw_type_error(cx.raw_cx(), &error);
1379 return Err(());
1380
1381 }
1382 _ => {
1383 return Err(());
1384
1385 },
1386 }
1387
1388 } else {
1389 Some(false)
1390 }
1391 },
1392 nullableByteValue: {
1393 rooted!(&in(cx) let mut rval = UndefinedValue());
1394 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableByteValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1395 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1396 Ok(ConversionResult::Success(value)) => value,
1397 Ok(ConversionResult::Failure(error)) => {
1398 throw_type_error(cx.raw_cx(), &error);
1399 return Err(());
1400
1401 }
1402 _ => {
1403 return Err(());
1404
1405 },
1406 }
1407
1408 } else {
1409 Some(7)
1410 }
1411 },
1412 nullableBytestringValue: {
1413 rooted!(&in(cx) let mut rval = UndefinedValue());
1414 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableBytestringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1415 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1416 Ok(ConversionResult::Success(value)) => value,
1417 Ok(ConversionResult::Failure(error)) => {
1418 throw_type_error(cx.raw_cx(), &error);
1419 return Err(());
1420
1421 }
1422 _ => {
1423 return Err(());
1424
1425 },
1426 }
1427
1428 } else {
1429 Some(ByteString::new(b"foo".to_vec()))
1430 }
1431 },
1432 nullableDoubleValue: {
1433 rooted!(&in(cx) let mut rval = UndefinedValue());
1434 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableDoubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1435 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1436 Ok(ConversionResult::Success(value)) => value,
1437 Ok(ConversionResult::Failure(error)) => {
1438 throw_type_error(cx.raw_cx(), &error);
1439 return Err(());
1440
1441 }
1442 _ => {
1443 return Err(());
1444
1445 },
1446 }
1447
1448 } else {
1449 Some(Finite::wrap(7.0))
1450 }
1451 },
1452 nullableFloatValue: {
1453 rooted!(&in(cx) let mut rval = UndefinedValue());
1454 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableFloatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1455 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1456 Ok(ConversionResult::Success(value)) => value,
1457 Ok(ConversionResult::Failure(error)) => {
1458 throw_type_error(cx.raw_cx(), &error);
1459 return Err(());
1460
1461 }
1462 _ => {
1463 return Err(());
1464
1465 },
1466 }
1467
1468 } else {
1469 Some(Finite::wrap(7.0))
1470 }
1471 },
1472 nullableLongLongValue: {
1473 rooted!(&in(cx) let mut rval = UndefinedValue());
1474 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableLongLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1475 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1476 Ok(ConversionResult::Success(value)) => value,
1477 Ok(ConversionResult::Failure(error)) => {
1478 throw_type_error(cx.raw_cx(), &error);
1479 return Err(());
1480
1481 }
1482 _ => {
1483 return Err(());
1484
1485 },
1486 }
1487
1488 } else {
1489 Some(7)
1490 }
1491 },
1492 nullableLongValue: {
1493 rooted!(&in(cx) let mut rval = UndefinedValue());
1494 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1495 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1496 Ok(ConversionResult::Success(value)) => value,
1497 Ok(ConversionResult::Failure(error)) => {
1498 throw_type_error(cx.raw_cx(), &error);
1499 return Err(());
1500
1501 }
1502 _ => {
1503 return Err(());
1504
1505 },
1506 }
1507
1508 } else {
1509 Some(7)
1510 }
1511 },
1512 nullableObjectValue: {
1513 rooted!(&in(cx) let mut rval = UndefinedValue());
1514 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableObjectValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1515 if rval.handle().get().is_object() {
1516 RootedTraceableBox::from_box(Heap::boxed(rval.handle().get().to_object()))
1517 } else if rval.handle().get().is_null_or_undefined() {
1518 RootedTraceableBox::new(Heap::default())
1519 } else {
1520 throw_type_error(cx.raw_cx(), "Value is not an object.");
1521 return Err(());
1522
1523 }
1524 } else {
1525 RootedTraceableBox::new(Heap::default())
1526 }
1527 },
1528 nullableOctetValue: {
1529 rooted!(&in(cx) let mut rval = UndefinedValue());
1530 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableOctetValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1531 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1532 Ok(ConversionResult::Success(value)) => value,
1533 Ok(ConversionResult::Failure(error)) => {
1534 throw_type_error(cx.raw_cx(), &error);
1535 return Err(());
1536
1537 }
1538 _ => {
1539 return Err(());
1540
1541 },
1542 }
1543
1544 } else {
1545 Some(7)
1546 }
1547 },
1548 nullableShortValue: {
1549 rooted!(&in(cx) let mut rval = UndefinedValue());
1550 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableShortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1551 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1552 Ok(ConversionResult::Success(value)) => value,
1553 Ok(ConversionResult::Failure(error)) => {
1554 throw_type_error(cx.raw_cx(), &error);
1555 return Err(());
1556
1557 }
1558 _ => {
1559 return Err(());
1560
1561 },
1562 }
1563
1564 } else {
1565 Some(7)
1566 }
1567 },
1568 nullableStringValue: {
1569 rooted!(&in(cx) let mut rval = UndefinedValue());
1570 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableStringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1571 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
1572 Ok(ConversionResult::Success(value)) => value,
1573 Ok(ConversionResult::Failure(error)) => {
1574 throw_type_error(cx.raw_cx(), &error);
1575 return Err(());
1576
1577 }
1578 _ => {
1579 return Err(());
1580
1581 },
1582 }
1583
1584 } else {
1585 Some(DOMString::from("foo"))
1586 }
1587 },
1588 nullableUnrestrictedDoubleValue: {
1589 rooted!(&in(cx) let mut rval = UndefinedValue());
1590 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUnrestrictedDoubleValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1591 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1592 Ok(ConversionResult::Success(value)) => value,
1593 Ok(ConversionResult::Failure(error)) => {
1594 throw_type_error(cx.raw_cx(), &error);
1595 return Err(());
1596
1597 }
1598 _ => {
1599 return Err(());
1600
1601 },
1602 }
1603
1604 } else {
1605 Some(7.0)
1606 }
1607 },
1608 nullableUnrestrictedFloatValue: {
1609 rooted!(&in(cx) let mut rval = UndefinedValue());
1610 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUnrestrictedFloatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1611 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1612 Ok(ConversionResult::Success(value)) => value,
1613 Ok(ConversionResult::Failure(error)) => {
1614 throw_type_error(cx.raw_cx(), &error);
1615 return Err(());
1616
1617 }
1618 _ => {
1619 return Err(());
1620
1621 },
1622 }
1623
1624 } else {
1625 Some(7.0)
1626 }
1627 },
1628 nullableUnsignedLongLongValue: {
1629 rooted!(&in(cx) let mut rval = UndefinedValue());
1630 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUnsignedLongLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1631 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1632 Ok(ConversionResult::Success(value)) => value,
1633 Ok(ConversionResult::Failure(error)) => {
1634 throw_type_error(cx.raw_cx(), &error);
1635 return Err(());
1636
1637 }
1638 _ => {
1639 return Err(());
1640
1641 },
1642 }
1643
1644 } else {
1645 Some(7)
1646 }
1647 },
1648 nullableUnsignedLongValue: {
1649 rooted!(&in(cx) let mut rval = UndefinedValue());
1650 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUnsignedLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1651 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1652 Ok(ConversionResult::Success(value)) => value,
1653 Ok(ConversionResult::Failure(error)) => {
1654 throw_type_error(cx.raw_cx(), &error);
1655 return Err(());
1656
1657 }
1658 _ => {
1659 return Err(());
1660
1661 },
1662 }
1663
1664 } else {
1665 Some(7)
1666 }
1667 },
1668 nullableUnsignedShortValue: {
1669 rooted!(&in(cx) let mut rval = UndefinedValue());
1670 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUnsignedShortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1671 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1672 Ok(ConversionResult::Success(value)) => value,
1673 Ok(ConversionResult::Failure(error)) => {
1674 throw_type_error(cx.raw_cx(), &error);
1675 return Err(());
1676
1677 }
1678 _ => {
1679 return Err(());
1680
1681 },
1682 }
1683
1684 } else {
1685 Some(7)
1686 }
1687 },
1688 nullableUsvstringValue: {
1689 rooted!(&in(cx) let mut rval = UndefinedValue());
1690 if get_dictionary_property(cx.raw_cx(), object.handle(), "nullableUsvstringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1691 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1692 Ok(ConversionResult::Success(value)) => value,
1693 Ok(ConversionResult::Failure(error)) => {
1694 throw_type_error(cx.raw_cx(), &error);
1695 return Err(());
1696
1697 }
1698 _ => {
1699 return Err(());
1700
1701 },
1702 }
1703
1704 } else {
1705 Some(USVString("foo".to_owned()))
1706 }
1707 },
1708 octetValue: {
1709 rooted!(&in(cx) let mut rval = UndefinedValue());
1710 if get_dictionary_property(cx.raw_cx(), object.handle(), "octetValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1711 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1712 Ok(ConversionResult::Success(value)) => value,
1713 Ok(ConversionResult::Failure(error)) => {
1714 throw_type_error(cx.raw_cx(), &error);
1715 return Err(());
1716
1717 }
1718 _ => {
1719 return Err(());
1720
1721 },
1722 }
1723
1724 } else {
1725 7
1726 }
1727 },
1728 shortValue: {
1729 rooted!(&in(cx) let mut rval = UndefinedValue());
1730 if get_dictionary_property(cx.raw_cx(), object.handle(), "shortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1731 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1732 Ok(ConversionResult::Success(value)) => value,
1733 Ok(ConversionResult::Failure(error)) => {
1734 throw_type_error(cx.raw_cx(), &error);
1735 return Err(());
1736
1737 }
1738 _ => {
1739 return Err(());
1740
1741 },
1742 }
1743
1744 } else {
1745 7
1746 }
1747 },
1748 stringValue: {
1749 rooted!(&in(cx) let mut rval = UndefinedValue());
1750 if get_dictionary_property(cx.raw_cx(), object.handle(), "stringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1751 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
1752 Ok(ConversionResult::Success(value)) => value,
1753 Ok(ConversionResult::Failure(error)) => {
1754 throw_type_error(cx.raw_cx(), &error);
1755 return Err(());
1756
1757 }
1758 _ => {
1759 return Err(());
1760
1761 },
1762 }
1763
1764 } else {
1765 DOMString::from("foo")
1766 }
1767 },
1768 unrestrictedFloatValue: {
1769 rooted!(&in(cx) let mut rval = UndefinedValue());
1770 if get_dictionary_property(cx.raw_cx(), object.handle(), "unrestrictedFloatValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1771 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1772 Ok(ConversionResult::Success(value)) => value,
1773 Ok(ConversionResult::Failure(error)) => {
1774 throw_type_error(cx.raw_cx(), &error);
1775 return Err(());
1776
1777 }
1778 _ => {
1779 return Err(());
1780
1781 },
1782 }
1783
1784 } else {
1785 7.0
1786 }
1787 },
1788 unsignedLongLongValue: {
1789 rooted!(&in(cx) let mut rval = UndefinedValue());
1790 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedLongLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1791 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1792 Ok(ConversionResult::Success(value)) => value,
1793 Ok(ConversionResult::Failure(error)) => {
1794 throw_type_error(cx.raw_cx(), &error);
1795 return Err(());
1796
1797 }
1798 _ => {
1799 return Err(());
1800
1801 },
1802 }
1803
1804 } else {
1805 7
1806 }
1807 },
1808 unsignedLongValue: {
1809 rooted!(&in(cx) let mut rval = UndefinedValue());
1810 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedLongValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1811 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1812 Ok(ConversionResult::Success(value)) => value,
1813 Ok(ConversionResult::Failure(error)) => {
1814 throw_type_error(cx.raw_cx(), &error);
1815 return Err(());
1816
1817 }
1818 _ => {
1819 return Err(());
1820
1821 },
1822 }
1823
1824 } else {
1825 7
1826 }
1827 },
1828 unsignedShortValue: {
1829 rooted!(&in(cx) let mut rval = UndefinedValue());
1830 if get_dictionary_property(cx.raw_cx(), object.handle(), "unsignedShortValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1831 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Default) {
1832 Ok(ConversionResult::Success(value)) => value,
1833 Ok(ConversionResult::Failure(error)) => {
1834 throw_type_error(cx.raw_cx(), &error);
1835 return Err(());
1836
1837 }
1838 _ => {
1839 return Err(());
1840
1841 },
1842 }
1843
1844 } else {
1845 7
1846 }
1847 },
1848 usvstringValue: {
1849 rooted!(&in(cx) let mut rval = UndefinedValue());
1850 if get_dictionary_property(cx.raw_cx(), object.handle(), "usvstringValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
1851 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
1852 Ok(ConversionResult::Success(value)) => value,
1853 Ok(ConversionResult::Failure(error)) => {
1854 throw_type_error(cx.raw_cx(), &error);
1855 return Err(());
1856
1857 }
1858 _ => {
1859 return Err(());
1860
1861 },
1862 }
1863
1864 } else {
1865 USVString("foo".to_owned())
1866 }
1867 },
1868 });
1869 Ok(ConversionResult::Success(dictionary))
1870 }
1871 }
1872}
1873
1874impl FromJSValConvertible for RootedTraceableBox<TestDictionaryDefaults> {
1875 type Config = ();
1876 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
1877 -> Result<ConversionResult<RootedTraceableBox<TestDictionaryDefaults>>, ()> {
1878 TestDictionaryDefaults::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
1879 }
1880}
1881
1882impl TestDictionaryDefaults {
1883 #[allow(clippy::wrong_self_convention)]
1884 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
1885 let UnrestrictedDoubleValue = &self.UnrestrictedDoubleValue;
1886 rooted!(in(cx) let mut UnrestrictedDoubleValue_js = UndefinedValue());
1887 UnrestrictedDoubleValue.to_jsval(cx, UnrestrictedDoubleValue_js.handle_mut());
1888 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "UnrestrictedDoubleValue", UnrestrictedDoubleValue_js.handle()).unwrap();
1889 let anyValue = &self.anyValue;
1890 rooted!(in(cx) let mut anyValue_js = UndefinedValue());
1891 anyValue.to_jsval(cx, anyValue_js.handle_mut());
1892 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "anyValue", anyValue_js.handle()).unwrap();
1893 let arrayValue = &self.arrayValue;
1894 rooted!(in(cx) let mut arrayValue_js = UndefinedValue());
1895 arrayValue.to_jsval(cx, arrayValue_js.handle_mut());
1896 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "arrayValue", arrayValue_js.handle()).unwrap();
1897 let booleanValue = &self.booleanValue;
1898 rooted!(in(cx) let mut booleanValue_js = UndefinedValue());
1899 booleanValue.to_jsval(cx, booleanValue_js.handle_mut());
1900 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "booleanValue", booleanValue_js.handle()).unwrap();
1901 let byteValue = &self.byteValue;
1902 rooted!(in(cx) let mut byteValue_js = UndefinedValue());
1903 byteValue.to_jsval(cx, byteValue_js.handle_mut());
1904 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "byteValue", byteValue_js.handle()).unwrap();
1905 let bytestringValue = &self.bytestringValue;
1906 rooted!(in(cx) let mut bytestringValue_js = UndefinedValue());
1907 bytestringValue.to_jsval(cx, bytestringValue_js.handle_mut());
1908 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "bytestringValue", bytestringValue_js.handle()).unwrap();
1909 let doubleValue = &self.doubleValue;
1910 rooted!(in(cx) let mut doubleValue_js = UndefinedValue());
1911 doubleValue.to_jsval(cx, doubleValue_js.handle_mut());
1912 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "doubleValue", doubleValue_js.handle()).unwrap();
1913 let enumValue = &self.enumValue;
1914 rooted!(in(cx) let mut enumValue_js = UndefinedValue());
1915 enumValue.to_jsval(cx, enumValue_js.handle_mut());
1916 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "enumValue", enumValue_js.handle()).unwrap();
1917 let floatValue = &self.floatValue;
1918 rooted!(in(cx) let mut floatValue_js = UndefinedValue());
1919 floatValue.to_jsval(cx, floatValue_js.handle_mut());
1920 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "floatValue", floatValue_js.handle()).unwrap();
1921 let longLongValue = &self.longLongValue;
1922 rooted!(in(cx) let mut longLongValue_js = UndefinedValue());
1923 longLongValue.to_jsval(cx, longLongValue_js.handle_mut());
1924 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "longLongValue", longLongValue_js.handle()).unwrap();
1925 let longValue = &self.longValue;
1926 rooted!(in(cx) let mut longValue_js = UndefinedValue());
1927 longValue.to_jsval(cx, longValue_js.handle_mut());
1928 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "longValue", longValue_js.handle()).unwrap();
1929 let nullableBooleanValue = &self.nullableBooleanValue;
1930 rooted!(in(cx) let mut nullableBooleanValue_js = UndefinedValue());
1931 nullableBooleanValue.to_jsval(cx, nullableBooleanValue_js.handle_mut());
1932 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableBooleanValue", nullableBooleanValue_js.handle()).unwrap();
1933 let nullableByteValue = &self.nullableByteValue;
1934 rooted!(in(cx) let mut nullableByteValue_js = UndefinedValue());
1935 nullableByteValue.to_jsval(cx, nullableByteValue_js.handle_mut());
1936 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableByteValue", nullableByteValue_js.handle()).unwrap();
1937 let nullableBytestringValue = &self.nullableBytestringValue;
1938 rooted!(in(cx) let mut nullableBytestringValue_js = UndefinedValue());
1939 nullableBytestringValue.to_jsval(cx, nullableBytestringValue_js.handle_mut());
1940 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableBytestringValue", nullableBytestringValue_js.handle()).unwrap();
1941 let nullableDoubleValue = &self.nullableDoubleValue;
1942 rooted!(in(cx) let mut nullableDoubleValue_js = UndefinedValue());
1943 nullableDoubleValue.to_jsval(cx, nullableDoubleValue_js.handle_mut());
1944 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableDoubleValue", nullableDoubleValue_js.handle()).unwrap();
1945 let nullableFloatValue = &self.nullableFloatValue;
1946 rooted!(in(cx) let mut nullableFloatValue_js = UndefinedValue());
1947 nullableFloatValue.to_jsval(cx, nullableFloatValue_js.handle_mut());
1948 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableFloatValue", nullableFloatValue_js.handle()).unwrap();
1949 let nullableLongLongValue = &self.nullableLongLongValue;
1950 rooted!(in(cx) let mut nullableLongLongValue_js = UndefinedValue());
1951 nullableLongLongValue.to_jsval(cx, nullableLongLongValue_js.handle_mut());
1952 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableLongLongValue", nullableLongLongValue_js.handle()).unwrap();
1953 let nullableLongValue = &self.nullableLongValue;
1954 rooted!(in(cx) let mut nullableLongValue_js = UndefinedValue());
1955 nullableLongValue.to_jsval(cx, nullableLongValue_js.handle_mut());
1956 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableLongValue", nullableLongValue_js.handle()).unwrap();
1957 let nullableObjectValue = &self.nullableObjectValue;
1958 rooted!(in(cx) let mut nullableObjectValue_js = UndefinedValue());
1959 nullableObjectValue.to_jsval(cx, nullableObjectValue_js.handle_mut());
1960 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableObjectValue", nullableObjectValue_js.handle()).unwrap();
1961 let nullableOctetValue = &self.nullableOctetValue;
1962 rooted!(in(cx) let mut nullableOctetValue_js = UndefinedValue());
1963 nullableOctetValue.to_jsval(cx, nullableOctetValue_js.handle_mut());
1964 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableOctetValue", nullableOctetValue_js.handle()).unwrap();
1965 let nullableShortValue = &self.nullableShortValue;
1966 rooted!(in(cx) let mut nullableShortValue_js = UndefinedValue());
1967 nullableShortValue.to_jsval(cx, nullableShortValue_js.handle_mut());
1968 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableShortValue", nullableShortValue_js.handle()).unwrap();
1969 let nullableStringValue = &self.nullableStringValue;
1970 rooted!(in(cx) let mut nullableStringValue_js = UndefinedValue());
1971 nullableStringValue.to_jsval(cx, nullableStringValue_js.handle_mut());
1972 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableStringValue", nullableStringValue_js.handle()).unwrap();
1973 let nullableUnrestrictedDoubleValue = &self.nullableUnrestrictedDoubleValue;
1974 rooted!(in(cx) let mut nullableUnrestrictedDoubleValue_js = UndefinedValue());
1975 nullableUnrestrictedDoubleValue.to_jsval(cx, nullableUnrestrictedDoubleValue_js.handle_mut());
1976 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUnrestrictedDoubleValue", nullableUnrestrictedDoubleValue_js.handle()).unwrap();
1977 let nullableUnrestrictedFloatValue = &self.nullableUnrestrictedFloatValue;
1978 rooted!(in(cx) let mut nullableUnrestrictedFloatValue_js = UndefinedValue());
1979 nullableUnrestrictedFloatValue.to_jsval(cx, nullableUnrestrictedFloatValue_js.handle_mut());
1980 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUnrestrictedFloatValue", nullableUnrestrictedFloatValue_js.handle()).unwrap();
1981 let nullableUnsignedLongLongValue = &self.nullableUnsignedLongLongValue;
1982 rooted!(in(cx) let mut nullableUnsignedLongLongValue_js = UndefinedValue());
1983 nullableUnsignedLongLongValue.to_jsval(cx, nullableUnsignedLongLongValue_js.handle_mut());
1984 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUnsignedLongLongValue", nullableUnsignedLongLongValue_js.handle()).unwrap();
1985 let nullableUnsignedLongValue = &self.nullableUnsignedLongValue;
1986 rooted!(in(cx) let mut nullableUnsignedLongValue_js = UndefinedValue());
1987 nullableUnsignedLongValue.to_jsval(cx, nullableUnsignedLongValue_js.handle_mut());
1988 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUnsignedLongValue", nullableUnsignedLongValue_js.handle()).unwrap();
1989 let nullableUnsignedShortValue = &self.nullableUnsignedShortValue;
1990 rooted!(in(cx) let mut nullableUnsignedShortValue_js = UndefinedValue());
1991 nullableUnsignedShortValue.to_jsval(cx, nullableUnsignedShortValue_js.handle_mut());
1992 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUnsignedShortValue", nullableUnsignedShortValue_js.handle()).unwrap();
1993 let nullableUsvstringValue = &self.nullableUsvstringValue;
1994 rooted!(in(cx) let mut nullableUsvstringValue_js = UndefinedValue());
1995 nullableUsvstringValue.to_jsval(cx, nullableUsvstringValue_js.handle_mut());
1996 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "nullableUsvstringValue", nullableUsvstringValue_js.handle()).unwrap();
1997 let octetValue = &self.octetValue;
1998 rooted!(in(cx) let mut octetValue_js = UndefinedValue());
1999 octetValue.to_jsval(cx, octetValue_js.handle_mut());
2000 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "octetValue", octetValue_js.handle()).unwrap();
2001 let shortValue = &self.shortValue;
2002 rooted!(in(cx) let mut shortValue_js = UndefinedValue());
2003 shortValue.to_jsval(cx, shortValue_js.handle_mut());
2004 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "shortValue", shortValue_js.handle()).unwrap();
2005 let stringValue = &self.stringValue;
2006 rooted!(in(cx) let mut stringValue_js = UndefinedValue());
2007 stringValue.to_jsval(cx, stringValue_js.handle_mut());
2008 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stringValue", stringValue_js.handle()).unwrap();
2009 let unrestrictedFloatValue = &self.unrestrictedFloatValue;
2010 rooted!(in(cx) let mut unrestrictedFloatValue_js = UndefinedValue());
2011 unrestrictedFloatValue.to_jsval(cx, unrestrictedFloatValue_js.handle_mut());
2012 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unrestrictedFloatValue", unrestrictedFloatValue_js.handle()).unwrap();
2013 let unsignedLongLongValue = &self.unsignedLongLongValue;
2014 rooted!(in(cx) let mut unsignedLongLongValue_js = UndefinedValue());
2015 unsignedLongLongValue.to_jsval(cx, unsignedLongLongValue_js.handle_mut());
2016 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedLongLongValue", unsignedLongLongValue_js.handle()).unwrap();
2017 let unsignedLongValue = &self.unsignedLongValue;
2018 rooted!(in(cx) let mut unsignedLongValue_js = UndefinedValue());
2019 unsignedLongValue.to_jsval(cx, unsignedLongValue_js.handle_mut());
2020 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedLongValue", unsignedLongValue_js.handle()).unwrap();
2021 let unsignedShortValue = &self.unsignedShortValue;
2022 rooted!(in(cx) let mut unsignedShortValue_js = UndefinedValue());
2023 unsignedShortValue.to_jsval(cx, unsignedShortValue_js.handle_mut());
2024 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "unsignedShortValue", unsignedShortValue_js.handle()).unwrap();
2025 let usvstringValue = &self.usvstringValue;
2026 rooted!(in(cx) let mut usvstringValue_js = UndefinedValue());
2027 usvstringValue.to_jsval(cx, usvstringValue_js.handle_mut());
2028 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usvstringValue", usvstringValue_js.handle()).unwrap();
2029 }
2030}
2031
2032impl ToJSValConvertible for TestDictionaryDefaults {
2033 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
2034 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
2035 self.to_jsobject(cx, obj.handle_mut());
2036 rval.set(ObjectOrNullValue(obj.get()))
2037 }
2038}
2039
2040
2041#[derive(JSTraceable)]
2042pub struct TestURLLike {
2043 pub href: DOMString,
2044}
2045
2046impl TestURLLike {
2047
2048 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
2049 -> Result<ConversionResult<TestURLLike>, ()> {
2050 unsafe {
2051 let object = if val.get().is_null_or_undefined() {
2052 ptr::null_mut()
2053 } else if val.get().is_object() {
2054 val.get().to_object()
2055 } else {
2056 return Ok(ConversionResult::Failure("Value is not an object.".into()));
2057 };
2058 rooted!(&in(cx) let object = object);
2059 let dictionary = TestURLLike {
2060 href: {
2061 rooted!(&in(cx) let mut rval = UndefinedValue());
2062 if get_dictionary_property(cx.raw_cx(), object.handle(), "href", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
2063 match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), StringificationBehavior::Default) {
2064 Ok(ConversionResult::Success(value)) => value,
2065 Ok(ConversionResult::Failure(error)) => {
2066 throw_type_error(cx.raw_cx(), &error);
2067 return Err(());
2068
2069 }
2070 _ => {
2071 return Err(());
2072
2073 },
2074 }
2075
2076 } else {
2077 throw_type_error(cx.raw_cx(), "Missing required member \"href\".");
2078 return Err(());
2079 }
2080 },
2081 };
2082 Ok(ConversionResult::Success(dictionary))
2083 }
2084 }
2085}
2086
2087impl FromJSValConvertible for TestURLLike {
2088 type Config = ();
2089 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
2090 -> Result<ConversionResult<TestURLLike>, ()> {
2091 TestURLLike::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
2092 }
2093}
2094
2095impl TestURLLike {
2096 #[allow(clippy::wrong_self_convention)]
2097 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
2098 let href = &self.href;
2099 rooted!(in(cx) let mut href_js = UndefinedValue());
2100 href.to_jsval(cx, href_js.handle_mut());
2101 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "href", href_js.handle()).unwrap();
2102 }
2103}
2104
2105impl ToJSValConvertible for TestURLLike {
2106 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
2107 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
2108 self.to_jsobject(cx, obj.handle_mut());
2109 rval.set(ObjectOrNullValue(obj.get()))
2110 }
2111}
2112
2113
2114#[derive(JSTraceable)]
2115pub struct NotUsedAnyWhereElse {
2116
2117}
2118impl Default for NotUsedAnyWhereElse {
2119 fn default() -> Self {
2120 Self::empty()
2121 }
2122}
2123
2124impl NotUsedAnyWhereElse {
2125 pub fn empty() -> Self {
2126 Self {
2127 }
2128 }
2129 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
2130 -> Result<ConversionResult<NotUsedAnyWhereElse>, ()> {
2131 {
2132 let object = if val.get().is_null_or_undefined() {
2133 ptr::null_mut()
2134 } else if val.get().is_object() {
2135 val.get().to_object()
2136 } else {
2137 return Ok(ConversionResult::Failure("Value is not an object.".into()));
2138 };
2139 rooted!(&in(cx) let object = object);
2140 let dictionary = NotUsedAnyWhereElse {
2141 };
2142 Ok(ConversionResult::Success(dictionary))
2143 }
2144 }
2145}
2146
2147impl FromJSValConvertible for NotUsedAnyWhereElse {
2148 type Config = ();
2149 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
2150 -> Result<ConversionResult<NotUsedAnyWhereElse>, ()> {
2151 NotUsedAnyWhereElse::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
2152 }
2153}
2154
2155impl NotUsedAnyWhereElse {
2156 #[allow(clippy::wrong_self_convention)]
2157 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
2158 }
2159}
2160
2161impl ToJSValConvertible for NotUsedAnyWhereElse {
2162 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
2163 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
2164 self.to_jsobject(cx, obj.handle_mut());
2165 rval.set(ObjectOrNullValue(obj.get()))
2166 }
2167}
2168
2169
2170#[derive(JSTraceable)]
2171pub struct RecordFieldWithUnionInside {
2172 pub recordWithUnionField: Option<Record<USVString, GenericUnionTypes::USVStringOrNotUsedAnyWhereElse>>,
2173}
2174impl Default for RecordFieldWithUnionInside {
2175 fn default() -> Self {
2176 Self::empty()
2177 }
2178}
2179
2180impl RecordFieldWithUnionInside {
2181 pub fn empty() -> Self {
2182 Self {
2183 recordWithUnionField: None,
2184 }
2185 }
2186 pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
2187 -> Result<ConversionResult<RecordFieldWithUnionInside>, ()> {
2188 unsafe {
2189 let object = if val.get().is_null_or_undefined() {
2190 ptr::null_mut()
2191 } else if val.get().is_object() {
2192 val.get().to_object()
2193 } else {
2194 return Ok(ConversionResult::Failure("Value is not an object.".into()));
2195 };
2196 rooted!(&in(cx) let object = object);
2197 let dictionary = RecordFieldWithUnionInside {
2198 recordWithUnionField: {
2199 rooted!(&in(cx) let mut rval = UndefinedValue());
2200 if get_dictionary_property(cx.raw_cx(), object.handle(), "recordWithUnionField", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
2201 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
2202 Ok(ConversionResult::Success(value)) => value,
2203 Ok(ConversionResult::Failure(error)) => {
2204 throw_type_error(cx.raw_cx(), &error);
2205 return Err(());
2206
2207 }
2208 _ => {
2209 return Err(());
2210
2211 },
2212 }
2213 )
2214 } else {
2215 None
2216 }
2217 },
2218 };
2219 Ok(ConversionResult::Success(dictionary))
2220 }
2221 }
2222}
2223
2224impl FromJSValConvertible for RecordFieldWithUnionInside {
2225 type Config = ();
2226 unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
2227 -> Result<ConversionResult<RecordFieldWithUnionInside>, ()> {
2228 RecordFieldWithUnionInside::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
2229 }
2230}
2231
2232impl RecordFieldWithUnionInside {
2233 #[allow(clippy::wrong_self_convention)]
2234 pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
2235 if let Some(ref recordWithUnionField) = self.recordWithUnionField {
2236 rooted!(in(cx) let mut recordWithUnionField_js = UndefinedValue());
2237 recordWithUnionField.to_jsval(cx, recordWithUnionField_js.handle_mut());
2238 set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "recordWithUnionField", recordWithUnionField_js.handle()).unwrap();
2239 }
2240 }
2241}
2242
2243impl ToJSValConvertible for RecordFieldWithUnionInside {
2244 unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
2245 rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
2246 self.to_jsobject(cx, obj.handle_mut());
2247 rval.set(ObjectOrNullValue(obj.get()))
2248 }
2249}
2250
2251
2252#[derive(JSTraceable, MallocSizeOf, PartialEq)]
2253#[cfg_attr(crown, allow(crown::unrooted_must_root))]
2254#[cfg_attr(crown, crown::unrooted_must_root_lint::allow_unrooted_interior)]
2255pub struct SimpleCallback<D: DomTypes> {
2256 pub parent: CallbackFunction<D>,
2257}
2258
2259impl<D: DomTypes> SimpleCallback<D> {
2260
2261 pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<SimpleCallback<D>> {
2262 let mut ret = Rc::new(SimpleCallback {
2263 parent: CallbackFunction::new()
2264 });
2265 match Rc::get_mut(&mut ret) {
2267 Some(ref mut callback) => callback.parent.init(aCx, aCallback),
2268 None => unreachable!(),
2269 };
2270 ret
2271 }
2272
2273 pub fn Call_<T: ThisReflector>(&self, thisObj: &T, value: HandleValue, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<()> {
2274 let s = CallSetup::<D>::new(self, aExceptionHandling);
2275 rooted!(in(*s.get_context()) let mut thisValue: JSVal);
2276 let wrap_result = wrap_call_this_value(s.get_context(), thisObj, thisValue.handle_mut());
2277 if !wrap_result {
2278 return Err(JSFailed);
2279 }
2280 unsafe { self.Call(s.get_context(), thisValue.handle(), value, can_gc) }
2281 }
2282
2283 pub fn Call__<>(&self, value: HandleValue, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<()> {
2284 let s = CallSetup::<D>::new(self, aExceptionHandling);
2285
2286 unsafe { self.Call(s.get_context(), HandleValue::undefined(), value, can_gc) }
2287 }
2288
2289 unsafe fn Call<>(&self, cx: SafeJSContext, aThisObj: HandleValue, value: HandleValue, can_gc: CanGc) -> Fallible<()> {
2290 rooted!(&in(cx) let mut rval = UndefinedValue());
2291 rooted_vec!(let mut argv);
2292 argv.extend((0..1).map(|_| Heap::default()));
2293
2294 let argc = 1;
2295
2296 rooted!(&in(cx) let mut argv_root = UndefinedValue());
2297 (value).to_jsval(cx.raw_cx(), argv_root.handle_mut());
2298 {
2299 let arg = &mut argv[0];
2300 *arg = Heap::default();
2301 arg.set(argv_root.get());
2302 }
2303
2304 rooted!(&in(cx) let callable = ObjectValue(self.callback()));
2305 rooted!(&in(cx) let rootedThis = aThisObj.get());
2306 let ok = Call(
2307 cx.raw_cx(), rootedThis.handle(), callable.handle(),
2308 &HandleValueArray {
2309 length_: argc as ::libc::size_t,
2310 elements_: argv.as_ptr() as *const JSVal
2311 }, rval.handle_mut());
2312 maybe_resume_unwind();
2313 if !ok {
2314 return Err(JSFailed);
2315 }
2316
2317 Ok(())
2318
2319 }
2320}
2321
2322impl<D: DomTypes> CallbackContainer<D> for SimpleCallback<D> {
2323 unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<SimpleCallback<D>> {
2324 SimpleCallback::new(cx, callback)
2325 }
2326
2327 fn callback_holder(&self) -> &CallbackObject<D> {
2328 self.parent.callback_holder()
2329 }
2330}
2331
2332impl<D: DomTypes> ToJSValConvertible for SimpleCallback<D> {
2333 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2334 self.callback().to_jsval(cx, rval);
2335 }
2336}
2337
2338
2339#[derive(JSTraceable, MallocSizeOf, PartialEq)]
2340#[cfg_attr(crown, allow(crown::unrooted_must_root))]
2341#[cfg_attr(crown, crown::unrooted_must_root_lint::allow_unrooted_interior)]
2342pub struct callbackWithOnlyOneOptionalArg<D: DomTypes> {
2343 pub parent: CallbackFunction<D>,
2344}
2345
2346impl<D: DomTypes> callbackWithOnlyOneOptionalArg<D> {
2347
2348 pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<callbackWithOnlyOneOptionalArg<D>> {
2349 let mut ret = Rc::new(callbackWithOnlyOneOptionalArg {
2350 parent: CallbackFunction::new()
2351 });
2352 match Rc::get_mut(&mut ret) {
2354 Some(ref mut callback) => callback.parent.init(aCx, aCallback),
2355 None => unreachable!(),
2356 };
2357 ret
2358 }
2359
2360 pub fn Call_<T: ThisReflector>(&self, thisObj: &T, reason: Option<HandleValue>, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<Rc<D::Promise>> {
2361 let s = CallSetup::<D>::new(self, aExceptionHandling);
2362 rooted!(in(*s.get_context()) let mut thisValue: JSVal);
2363 let wrap_result = wrap_call_this_value(s.get_context(), thisObj, thisValue.handle_mut());
2364 if !wrap_result {
2365 return Err(JSFailed);
2366 }
2367 unsafe { self.Call(s.get_context(), thisValue.handle(), reason, can_gc) }
2368 }
2369
2370 pub fn Call__<>(&self, reason: Option<HandleValue>, aExceptionHandling: ExceptionHandling, can_gc: CanGc) -> Fallible<Rc<D::Promise>> {
2371 let s = CallSetup::<D>::new(self, aExceptionHandling);
2372
2373 unsafe { self.Call(s.get_context(), HandleValue::undefined(), reason, can_gc) }
2374 }
2375
2376 unsafe fn Call<>(&self, cx: SafeJSContext, aThisObj: HandleValue, reason: Option<HandleValue>, can_gc: CanGc) -> Fallible<Rc<D::Promise>> {
2377 rooted!(&in(cx) let mut rval = UndefinedValue());
2378 rooted_vec!(let mut argv);
2379 argv.extend((0..1).map(|_| Heap::default()));
2380
2381 let mut argc = 1;
2382
2383 if let Some(reason) = reason {
2384 rooted!(&in(cx) let mut argv_root = UndefinedValue());
2385 (reason).to_jsval(cx.raw_cx(), argv_root.handle_mut());
2386 {
2387 let arg = &mut argv[0];
2388 *arg = Heap::default();
2389 arg.set(argv_root.get());
2390 }
2391 } else if argc == 1 {
2392 argc -= 1;
2394 } else {
2395 argv[0] = Heap::default();
2396 }
2397
2398 rooted!(&in(cx) let callable = ObjectValue(self.callback()));
2399 rooted!(&in(cx) let rootedThis = aThisObj.get());
2400 let ok = Call(
2401 cx.raw_cx(), rootedThis.handle(), callable.handle(),
2402 &HandleValueArray {
2403 length_: argc as ::libc::size_t,
2404 elements_: argv.as_ptr() as *const JSVal
2405 }, rval.handle_mut());
2406 maybe_resume_unwind();
2407 if !ok {
2408 return Err(JSFailed);
2409 }
2410 let retval: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
2411 Ok(ConversionResult::Success(value)) => value,
2412 Ok(ConversionResult::Failure(error)) => {
2413 throw_type_error(cx.raw_cx(), &error);
2414 return Err(JSFailed);
2415
2416 }
2417 _ => {
2418 return Err(JSFailed);
2419
2420 },
2421 }
2422 ;
2423 Ok(retval)
2424
2425 }
2426}
2427
2428impl<D: DomTypes> CallbackContainer<D> for callbackWithOnlyOneOptionalArg<D> {
2429 unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<callbackWithOnlyOneOptionalArg<D>> {
2430 callbackWithOnlyOneOptionalArg::new(cx, callback)
2431 }
2432
2433 fn callback_holder(&self) -> &CallbackObject<D> {
2434 self.parent.callback_holder()
2435 }
2436}
2437
2438impl<D: DomTypes> ToJSValConvertible for callbackWithOnlyOneOptionalArg<D> {
2439 unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
2440 self.callback().to_jsval(cx, rval);
2441 }
2442}
2443
2444
2445pub use self::TestBinding_Binding::{TestBindingConstants, Wrap as TestBindingWrap, TestBindingMethods, GetProtoObject as TestBindingGetProtoObject, GetConstructorObject as TestBindingGetConstructorObject, DefineDOMInterface as TestBindingDefineDOMInterface};
2446pub mod TestBinding_Binding {
2447use crate::codegen::GenericBindings::ElementBinding::Element_Binding;
2448use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
2449use crate::codegen::GenericBindings::FunctionBinding::Function;
2450use crate::codegen::GenericBindings::NodeBinding::Node_Binding;
2451use crate::codegen::GenericBindings::TestBindingBinding::SimpleCallback;
2452use crate::codegen::GenericBindings::TestBindingBinding::TestDictionary;
2453use crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryDefaults;
2454use crate::codegen::GenericBindings::TestBindingBinding::TestDictionaryWithParent;
2455use crate::codegen::GenericBindings::TestBindingBinding::TestEnum;
2456use crate::codegen::GenericBindings::TestBindingBinding::TestEnumValues;
2457use crate::codegen::GenericBindings::TestBindingBinding::TestURLLike;
2458use crate::codegen::GenericBindings::TestBindingBinding::callbackWithOnlyOneOptionalArg;
2459use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
2460use crate::import::module::*;
2461use crate::record::Record;
2462
2463unsafe extern "C" fn get_booleanAttribute<D: DomTypes>
2464(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2465 let mut result = false;
2466 wrap_panic(&mut || result = (|| {
2467 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2468 let this = &*(this as *const D::TestBinding);
2469 let result: bool = this.BooleanAttribute();
2470
2471 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2472 return true;
2473 })());
2474 result
2475}
2476
2477unsafe extern "C" fn set_booleanAttribute<D: DomTypes>
2478(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2479 let mut result = false;
2480 wrap_panic(&mut || result = (|| {
2481 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2482 let this = &*(this as *const D::TestBinding);
2483 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
2484 Ok(ConversionResult::Success(value)) => value,
2485 Ok(ConversionResult::Failure(error)) => {
2486 throw_type_error(cx.raw_cx(), &error);
2487 return false;
2488
2489 }
2490 _ => {
2491 return false;
2492
2493 },
2494 }
2495 ;
2496 let result: () = this.SetBooleanAttribute(arg0);
2497
2498 true
2499 })());
2500 result
2501}
2502
2503
2504static booleanAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2505
2506pub(crate) fn init_booleanAttribute_getterinfo<D: DomTypes>() {
2507 booleanAttribute_getterinfo.set(JSJitInfo {
2508 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2509 getter: Some(get_booleanAttribute::<D>)
2510 },
2511 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2512 protoID: PrototypeList::ID::TestBinding as u16,
2513 },
2514 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2515 _bitfield_align_1: [],
2516 _bitfield_1: __BindgenBitfieldUnit::new(
2517 new_jsjitinfo_bitfield_1!(
2518 JSJitInfo_OpType::Getter as u8,
2519 JSJitInfo_AliasSet::AliasEverything as u8,
2520 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
2521 true,
2522 false,
2523 false,
2524 false,
2525 false,
2526 false,
2527 0,
2528 ).to_ne_bytes()
2529 ),
2530});
2531}
2532static booleanAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2533
2534pub(crate) fn init_booleanAttribute_setterinfo<D: DomTypes>() {
2535 booleanAttribute_setterinfo.set(JSJitInfo {
2536 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2537 setter: Some(set_booleanAttribute::<D>)
2538 },
2539 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2540 protoID: PrototypeList::ID::TestBinding as u16,
2541 },
2542 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2543 _bitfield_align_1: [],
2544 _bitfield_1: __BindgenBitfieldUnit::new(
2545 new_jsjitinfo_bitfield_1!(
2546 JSJitInfo_OpType::Setter as u8,
2547 JSJitInfo_AliasSet::AliasEverything as u8,
2548 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2549 false,
2550 false,
2551 false,
2552 false,
2553 false,
2554 false,
2555 0,
2556 ).to_ne_bytes()
2557 ),
2558});
2559}
2560unsafe extern "C" fn get_byteAttribute<D: DomTypes>
2561(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2562 let mut result = false;
2563 wrap_panic(&mut || result = (|| {
2564 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2565 let this = &*(this as *const D::TestBinding);
2566 let result: i8 = this.ByteAttribute();
2567
2568 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2569 return true;
2570 })());
2571 result
2572}
2573
2574unsafe extern "C" fn set_byteAttribute<D: DomTypes>
2575(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2576 let mut result = false;
2577 wrap_panic(&mut || result = (|| {
2578 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2579 let this = &*(this as *const D::TestBinding);
2580 let arg0: i8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2581 Ok(ConversionResult::Success(value)) => value,
2582 Ok(ConversionResult::Failure(error)) => {
2583 throw_type_error(cx.raw_cx(), &error);
2584 return false;
2585
2586 }
2587 _ => {
2588 return false;
2589
2590 },
2591 }
2592 ;
2593 let result: () = this.SetByteAttribute(arg0);
2594
2595 true
2596 })());
2597 result
2598}
2599
2600
2601static byteAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2602
2603pub(crate) fn init_byteAttribute_getterinfo<D: DomTypes>() {
2604 byteAttribute_getterinfo.set(JSJitInfo {
2605 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2606 getter: Some(get_byteAttribute::<D>)
2607 },
2608 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2609 protoID: PrototypeList::ID::TestBinding as u16,
2610 },
2611 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2612 _bitfield_align_1: [],
2613 _bitfield_1: __BindgenBitfieldUnit::new(
2614 new_jsjitinfo_bitfield_1!(
2615 JSJitInfo_OpType::Getter as u8,
2616 JSJitInfo_AliasSet::AliasEverything as u8,
2617 JSValueType::JSVAL_TYPE_INT32 as u8,
2618 true,
2619 false,
2620 false,
2621 false,
2622 false,
2623 false,
2624 0,
2625 ).to_ne_bytes()
2626 ),
2627});
2628}
2629static byteAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2630
2631pub(crate) fn init_byteAttribute_setterinfo<D: DomTypes>() {
2632 byteAttribute_setterinfo.set(JSJitInfo {
2633 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2634 setter: Some(set_byteAttribute::<D>)
2635 },
2636 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2637 protoID: PrototypeList::ID::TestBinding as u16,
2638 },
2639 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2640 _bitfield_align_1: [],
2641 _bitfield_1: __BindgenBitfieldUnit::new(
2642 new_jsjitinfo_bitfield_1!(
2643 JSJitInfo_OpType::Setter as u8,
2644 JSJitInfo_AliasSet::AliasEverything as u8,
2645 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2646 false,
2647 false,
2648 false,
2649 false,
2650 false,
2651 false,
2652 0,
2653 ).to_ne_bytes()
2654 ),
2655});
2656}
2657unsafe extern "C" fn get_octetAttribute<D: DomTypes>
2658(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2659 let mut result = false;
2660 wrap_panic(&mut || result = (|| {
2661 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2662 let this = &*(this as *const D::TestBinding);
2663 let result: u8 = this.OctetAttribute();
2664
2665 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2666 return true;
2667 })());
2668 result
2669}
2670
2671unsafe extern "C" fn set_octetAttribute<D: DomTypes>
2672(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2673 let mut result = false;
2674 wrap_panic(&mut || result = (|| {
2675 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2676 let this = &*(this as *const D::TestBinding);
2677 let arg0: u8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2678 Ok(ConversionResult::Success(value)) => value,
2679 Ok(ConversionResult::Failure(error)) => {
2680 throw_type_error(cx.raw_cx(), &error);
2681 return false;
2682
2683 }
2684 _ => {
2685 return false;
2686
2687 },
2688 }
2689 ;
2690 let result: () = this.SetOctetAttribute(arg0);
2691
2692 true
2693 })());
2694 result
2695}
2696
2697
2698static octetAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2699
2700pub(crate) fn init_octetAttribute_getterinfo<D: DomTypes>() {
2701 octetAttribute_getterinfo.set(JSJitInfo {
2702 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2703 getter: Some(get_octetAttribute::<D>)
2704 },
2705 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2706 protoID: PrototypeList::ID::TestBinding as u16,
2707 },
2708 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2709 _bitfield_align_1: [],
2710 _bitfield_1: __BindgenBitfieldUnit::new(
2711 new_jsjitinfo_bitfield_1!(
2712 JSJitInfo_OpType::Getter as u8,
2713 JSJitInfo_AliasSet::AliasEverything as u8,
2714 JSValueType::JSVAL_TYPE_INT32 as u8,
2715 true,
2716 false,
2717 false,
2718 false,
2719 false,
2720 false,
2721 0,
2722 ).to_ne_bytes()
2723 ),
2724});
2725}
2726static octetAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2727
2728pub(crate) fn init_octetAttribute_setterinfo<D: DomTypes>() {
2729 octetAttribute_setterinfo.set(JSJitInfo {
2730 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2731 setter: Some(set_octetAttribute::<D>)
2732 },
2733 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2734 protoID: PrototypeList::ID::TestBinding as u16,
2735 },
2736 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2737 _bitfield_align_1: [],
2738 _bitfield_1: __BindgenBitfieldUnit::new(
2739 new_jsjitinfo_bitfield_1!(
2740 JSJitInfo_OpType::Setter as u8,
2741 JSJitInfo_AliasSet::AliasEverything as u8,
2742 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2743 false,
2744 false,
2745 false,
2746 false,
2747 false,
2748 false,
2749 0,
2750 ).to_ne_bytes()
2751 ),
2752});
2753}
2754unsafe extern "C" fn get_shortAttribute<D: DomTypes>
2755(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2756 let mut result = false;
2757 wrap_panic(&mut || result = (|| {
2758 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2759 let this = &*(this as *const D::TestBinding);
2760 let result: i16 = this.ShortAttribute();
2761
2762 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2763 return true;
2764 })());
2765 result
2766}
2767
2768unsafe extern "C" fn set_shortAttribute<D: DomTypes>
2769(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2770 let mut result = false;
2771 wrap_panic(&mut || result = (|| {
2772 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2773 let this = &*(this as *const D::TestBinding);
2774 let arg0: i16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2775 Ok(ConversionResult::Success(value)) => value,
2776 Ok(ConversionResult::Failure(error)) => {
2777 throw_type_error(cx.raw_cx(), &error);
2778 return false;
2779
2780 }
2781 _ => {
2782 return false;
2783
2784 },
2785 }
2786 ;
2787 let result: () = this.SetShortAttribute(arg0);
2788
2789 true
2790 })());
2791 result
2792}
2793
2794
2795static shortAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2796
2797pub(crate) fn init_shortAttribute_getterinfo<D: DomTypes>() {
2798 shortAttribute_getterinfo.set(JSJitInfo {
2799 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2800 getter: Some(get_shortAttribute::<D>)
2801 },
2802 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2803 protoID: PrototypeList::ID::TestBinding as u16,
2804 },
2805 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2806 _bitfield_align_1: [],
2807 _bitfield_1: __BindgenBitfieldUnit::new(
2808 new_jsjitinfo_bitfield_1!(
2809 JSJitInfo_OpType::Getter as u8,
2810 JSJitInfo_AliasSet::AliasEverything as u8,
2811 JSValueType::JSVAL_TYPE_INT32 as u8,
2812 true,
2813 false,
2814 false,
2815 false,
2816 false,
2817 false,
2818 0,
2819 ).to_ne_bytes()
2820 ),
2821});
2822}
2823static shortAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2824
2825pub(crate) fn init_shortAttribute_setterinfo<D: DomTypes>() {
2826 shortAttribute_setterinfo.set(JSJitInfo {
2827 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2828 setter: Some(set_shortAttribute::<D>)
2829 },
2830 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2831 protoID: PrototypeList::ID::TestBinding as u16,
2832 },
2833 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2834 _bitfield_align_1: [],
2835 _bitfield_1: __BindgenBitfieldUnit::new(
2836 new_jsjitinfo_bitfield_1!(
2837 JSJitInfo_OpType::Setter as u8,
2838 JSJitInfo_AliasSet::AliasEverything as u8,
2839 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2840 false,
2841 false,
2842 false,
2843 false,
2844 false,
2845 false,
2846 0,
2847 ).to_ne_bytes()
2848 ),
2849});
2850}
2851unsafe extern "C" fn get_unsignedShortAttribute<D: DomTypes>
2852(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2853 let mut result = false;
2854 wrap_panic(&mut || result = (|| {
2855 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2856 let this = &*(this as *const D::TestBinding);
2857 let result: u16 = this.UnsignedShortAttribute();
2858
2859 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2860 return true;
2861 })());
2862 result
2863}
2864
2865unsafe extern "C" fn set_unsignedShortAttribute<D: DomTypes>
2866(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2867 let mut result = false;
2868 wrap_panic(&mut || result = (|| {
2869 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2870 let this = &*(this as *const D::TestBinding);
2871 let arg0: u16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2872 Ok(ConversionResult::Success(value)) => value,
2873 Ok(ConversionResult::Failure(error)) => {
2874 throw_type_error(cx.raw_cx(), &error);
2875 return false;
2876
2877 }
2878 _ => {
2879 return false;
2880
2881 },
2882 }
2883 ;
2884 let result: () = this.SetUnsignedShortAttribute(arg0);
2885
2886 true
2887 })());
2888 result
2889}
2890
2891
2892static unsignedShortAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2893
2894pub(crate) fn init_unsignedShortAttribute_getterinfo<D: DomTypes>() {
2895 unsignedShortAttribute_getterinfo.set(JSJitInfo {
2896 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2897 getter: Some(get_unsignedShortAttribute::<D>)
2898 },
2899 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2900 protoID: PrototypeList::ID::TestBinding as u16,
2901 },
2902 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2903 _bitfield_align_1: [],
2904 _bitfield_1: __BindgenBitfieldUnit::new(
2905 new_jsjitinfo_bitfield_1!(
2906 JSJitInfo_OpType::Getter as u8,
2907 JSJitInfo_AliasSet::AliasEverything as u8,
2908 JSValueType::JSVAL_TYPE_INT32 as u8,
2909 true,
2910 false,
2911 false,
2912 false,
2913 false,
2914 false,
2915 0,
2916 ).to_ne_bytes()
2917 ),
2918});
2919}
2920static unsignedShortAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2921
2922pub(crate) fn init_unsignedShortAttribute_setterinfo<D: DomTypes>() {
2923 unsignedShortAttribute_setterinfo.set(JSJitInfo {
2924 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2925 setter: Some(set_unsignedShortAttribute::<D>)
2926 },
2927 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2928 protoID: PrototypeList::ID::TestBinding as u16,
2929 },
2930 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
2931 _bitfield_align_1: [],
2932 _bitfield_1: __BindgenBitfieldUnit::new(
2933 new_jsjitinfo_bitfield_1!(
2934 JSJitInfo_OpType::Setter as u8,
2935 JSJitInfo_AliasSet::AliasEverything as u8,
2936 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
2937 false,
2938 false,
2939 false,
2940 false,
2941 false,
2942 false,
2943 0,
2944 ).to_ne_bytes()
2945 ),
2946});
2947}
2948unsafe extern "C" fn get_longAttribute<D: DomTypes>
2949(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
2950 let mut result = false;
2951 wrap_panic(&mut || result = (|| {
2952 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2953 let this = &*(this as *const D::TestBinding);
2954 let result: i32 = this.LongAttribute();
2955
2956 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
2957 return true;
2958 })());
2959 result
2960}
2961
2962unsafe extern "C" fn set_longAttribute<D: DomTypes>
2963(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
2964 let mut result = false;
2965 wrap_panic(&mut || result = (|| {
2966 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
2967 let this = &*(this as *const D::TestBinding);
2968 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
2969 Ok(ConversionResult::Success(value)) => value,
2970 Ok(ConversionResult::Failure(error)) => {
2971 throw_type_error(cx.raw_cx(), &error);
2972 return false;
2973
2974 }
2975 _ => {
2976 return false;
2977
2978 },
2979 }
2980 ;
2981 let result: () = this.SetLongAttribute(arg0);
2982
2983 true
2984 })());
2985 result
2986}
2987
2988
2989static longAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
2990
2991pub(crate) fn init_longAttribute_getterinfo<D: DomTypes>() {
2992 longAttribute_getterinfo.set(JSJitInfo {
2993 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
2994 getter: Some(get_longAttribute::<D>)
2995 },
2996 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
2997 protoID: PrototypeList::ID::TestBinding as u16,
2998 },
2999 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3000 _bitfield_align_1: [],
3001 _bitfield_1: __BindgenBitfieldUnit::new(
3002 new_jsjitinfo_bitfield_1!(
3003 JSJitInfo_OpType::Getter as u8,
3004 JSJitInfo_AliasSet::AliasEverything as u8,
3005 JSValueType::JSVAL_TYPE_INT32 as u8,
3006 true,
3007 false,
3008 false,
3009 false,
3010 false,
3011 false,
3012 0,
3013 ).to_ne_bytes()
3014 ),
3015});
3016}
3017static longAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3018
3019pub(crate) fn init_longAttribute_setterinfo<D: DomTypes>() {
3020 longAttribute_setterinfo.set(JSJitInfo {
3021 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3022 setter: Some(set_longAttribute::<D>)
3023 },
3024 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3025 protoID: PrototypeList::ID::TestBinding as u16,
3026 },
3027 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3028 _bitfield_align_1: [],
3029 _bitfield_1: __BindgenBitfieldUnit::new(
3030 new_jsjitinfo_bitfield_1!(
3031 JSJitInfo_OpType::Setter as u8,
3032 JSJitInfo_AliasSet::AliasEverything as u8,
3033 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3034 false,
3035 false,
3036 false,
3037 false,
3038 false,
3039 false,
3040 0,
3041 ).to_ne_bytes()
3042 ),
3043});
3044}
3045unsafe extern "C" fn get_unsignedLongAttribute<D: DomTypes>
3046(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3047 let mut result = false;
3048 wrap_panic(&mut || result = (|| {
3049 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3050 let this = &*(this as *const D::TestBinding);
3051 let result: u32 = this.UnsignedLongAttribute();
3052
3053 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3054 return true;
3055 })());
3056 result
3057}
3058
3059unsafe extern "C" fn set_unsignedLongAttribute<D: DomTypes>
3060(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3061 let mut result = false;
3062 wrap_panic(&mut || result = (|| {
3063 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3064 let this = &*(this as *const D::TestBinding);
3065 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3066 Ok(ConversionResult::Success(value)) => value,
3067 Ok(ConversionResult::Failure(error)) => {
3068 throw_type_error(cx.raw_cx(), &error);
3069 return false;
3070
3071 }
3072 _ => {
3073 return false;
3074
3075 },
3076 }
3077 ;
3078 let result: () = this.SetUnsignedLongAttribute(arg0);
3079
3080 true
3081 })());
3082 result
3083}
3084
3085
3086static unsignedLongAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3087
3088pub(crate) fn init_unsignedLongAttribute_getterinfo<D: DomTypes>() {
3089 unsignedLongAttribute_getterinfo.set(JSJitInfo {
3090 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3091 getter: Some(get_unsignedLongAttribute::<D>)
3092 },
3093 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3094 protoID: PrototypeList::ID::TestBinding as u16,
3095 },
3096 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3097 _bitfield_align_1: [],
3098 _bitfield_1: __BindgenBitfieldUnit::new(
3099 new_jsjitinfo_bitfield_1!(
3100 JSJitInfo_OpType::Getter as u8,
3101 JSJitInfo_AliasSet::AliasEverything as u8,
3102 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3103 true,
3104 false,
3105 false,
3106 false,
3107 false,
3108 false,
3109 0,
3110 ).to_ne_bytes()
3111 ),
3112});
3113}
3114static unsignedLongAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3115
3116pub(crate) fn init_unsignedLongAttribute_setterinfo<D: DomTypes>() {
3117 unsignedLongAttribute_setterinfo.set(JSJitInfo {
3118 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3119 setter: Some(set_unsignedLongAttribute::<D>)
3120 },
3121 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3122 protoID: PrototypeList::ID::TestBinding as u16,
3123 },
3124 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3125 _bitfield_align_1: [],
3126 _bitfield_1: __BindgenBitfieldUnit::new(
3127 new_jsjitinfo_bitfield_1!(
3128 JSJitInfo_OpType::Setter as u8,
3129 JSJitInfo_AliasSet::AliasEverything as u8,
3130 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3131 false,
3132 false,
3133 false,
3134 false,
3135 false,
3136 false,
3137 0,
3138 ).to_ne_bytes()
3139 ),
3140});
3141}
3142unsafe extern "C" fn get_longLongAttribute<D: DomTypes>
3143(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3144 let mut result = false;
3145 wrap_panic(&mut || result = (|| {
3146 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3147 let this = &*(this as *const D::TestBinding);
3148 let result: i64 = this.LongLongAttribute();
3149
3150 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3151 return true;
3152 })());
3153 result
3154}
3155
3156unsafe extern "C" fn set_longLongAttribute<D: DomTypes>
3157(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3158 let mut result = false;
3159 wrap_panic(&mut || result = (|| {
3160 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3161 let this = &*(this as *const D::TestBinding);
3162 let arg0: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3163 Ok(ConversionResult::Success(value)) => value,
3164 Ok(ConversionResult::Failure(error)) => {
3165 throw_type_error(cx.raw_cx(), &error);
3166 return false;
3167
3168 }
3169 _ => {
3170 return false;
3171
3172 },
3173 }
3174 ;
3175 let result: () = this.SetLongLongAttribute(arg0);
3176
3177 true
3178 })());
3179 result
3180}
3181
3182
3183static longLongAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3184
3185pub(crate) fn init_longLongAttribute_getterinfo<D: DomTypes>() {
3186 longLongAttribute_getterinfo.set(JSJitInfo {
3187 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3188 getter: Some(get_longLongAttribute::<D>)
3189 },
3190 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3191 protoID: PrototypeList::ID::TestBinding as u16,
3192 },
3193 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3194 _bitfield_align_1: [],
3195 _bitfield_1: __BindgenBitfieldUnit::new(
3196 new_jsjitinfo_bitfield_1!(
3197 JSJitInfo_OpType::Getter as u8,
3198 JSJitInfo_AliasSet::AliasEverything as u8,
3199 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3200 true,
3201 false,
3202 false,
3203 false,
3204 false,
3205 false,
3206 0,
3207 ).to_ne_bytes()
3208 ),
3209});
3210}
3211static longLongAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3212
3213pub(crate) fn init_longLongAttribute_setterinfo<D: DomTypes>() {
3214 longLongAttribute_setterinfo.set(JSJitInfo {
3215 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3216 setter: Some(set_longLongAttribute::<D>)
3217 },
3218 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3219 protoID: PrototypeList::ID::TestBinding as u16,
3220 },
3221 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3222 _bitfield_align_1: [],
3223 _bitfield_1: __BindgenBitfieldUnit::new(
3224 new_jsjitinfo_bitfield_1!(
3225 JSJitInfo_OpType::Setter as u8,
3226 JSJitInfo_AliasSet::AliasEverything as u8,
3227 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3228 false,
3229 false,
3230 false,
3231 false,
3232 false,
3233 false,
3234 0,
3235 ).to_ne_bytes()
3236 ),
3237});
3238}
3239unsafe extern "C" fn get_unsignedLongLongAttribute<D: DomTypes>
3240(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3241 let mut result = false;
3242 wrap_panic(&mut || result = (|| {
3243 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3244 let this = &*(this as *const D::TestBinding);
3245 let result: u64 = this.UnsignedLongLongAttribute();
3246
3247 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3248 return true;
3249 })());
3250 result
3251}
3252
3253unsafe extern "C" fn set_unsignedLongLongAttribute<D: DomTypes>
3254(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3255 let mut result = false;
3256 wrap_panic(&mut || result = (|| {
3257 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3258 let this = &*(this as *const D::TestBinding);
3259 let arg0: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
3260 Ok(ConversionResult::Success(value)) => value,
3261 Ok(ConversionResult::Failure(error)) => {
3262 throw_type_error(cx.raw_cx(), &error);
3263 return false;
3264
3265 }
3266 _ => {
3267 return false;
3268
3269 },
3270 }
3271 ;
3272 let result: () = this.SetUnsignedLongLongAttribute(arg0);
3273
3274 true
3275 })());
3276 result
3277}
3278
3279
3280static unsignedLongLongAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3281
3282pub(crate) fn init_unsignedLongLongAttribute_getterinfo<D: DomTypes>() {
3283 unsignedLongLongAttribute_getterinfo.set(JSJitInfo {
3284 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3285 getter: Some(get_unsignedLongLongAttribute::<D>)
3286 },
3287 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3288 protoID: PrototypeList::ID::TestBinding as u16,
3289 },
3290 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3291 _bitfield_align_1: [],
3292 _bitfield_1: __BindgenBitfieldUnit::new(
3293 new_jsjitinfo_bitfield_1!(
3294 JSJitInfo_OpType::Getter as u8,
3295 JSJitInfo_AliasSet::AliasEverything as u8,
3296 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3297 true,
3298 false,
3299 false,
3300 false,
3301 false,
3302 false,
3303 0,
3304 ).to_ne_bytes()
3305 ),
3306});
3307}
3308static unsignedLongLongAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3309
3310pub(crate) fn init_unsignedLongLongAttribute_setterinfo<D: DomTypes>() {
3311 unsignedLongLongAttribute_setterinfo.set(JSJitInfo {
3312 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3313 setter: Some(set_unsignedLongLongAttribute::<D>)
3314 },
3315 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3316 protoID: PrototypeList::ID::TestBinding as u16,
3317 },
3318 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3319 _bitfield_align_1: [],
3320 _bitfield_1: __BindgenBitfieldUnit::new(
3321 new_jsjitinfo_bitfield_1!(
3322 JSJitInfo_OpType::Setter as u8,
3323 JSJitInfo_AliasSet::AliasEverything as u8,
3324 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3325 false,
3326 false,
3327 false,
3328 false,
3329 false,
3330 false,
3331 0,
3332 ).to_ne_bytes()
3333 ),
3334});
3335}
3336unsafe extern "C" fn get_unrestrictedFloatAttribute<D: DomTypes>
3337(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3338 let mut result = false;
3339 wrap_panic(&mut || result = (|| {
3340 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3341 let this = &*(this as *const D::TestBinding);
3342 let result: f32 = this.UnrestrictedFloatAttribute();
3343
3344 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3345 return true;
3346 })());
3347 result
3348}
3349
3350unsafe extern "C" fn set_unrestrictedFloatAttribute<D: DomTypes>
3351(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3352 let mut result = false;
3353 wrap_panic(&mut || result = (|| {
3354 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3355 let this = &*(this as *const D::TestBinding);
3356 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3357 Ok(ConversionResult::Success(value)) => value,
3358 Ok(ConversionResult::Failure(error)) => {
3359 throw_type_error(cx.raw_cx(), &error);
3360 return false;
3361
3362 }
3363 _ => {
3364 return false;
3365
3366 },
3367 }
3368 ;
3369 let result: () = this.SetUnrestrictedFloatAttribute(arg0);
3370
3371 true
3372 })());
3373 result
3374}
3375
3376
3377static unrestrictedFloatAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3378
3379pub(crate) fn init_unrestrictedFloatAttribute_getterinfo<D: DomTypes>() {
3380 unrestrictedFloatAttribute_getterinfo.set(JSJitInfo {
3381 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3382 getter: Some(get_unrestrictedFloatAttribute::<D>)
3383 },
3384 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3385 protoID: PrototypeList::ID::TestBinding as u16,
3386 },
3387 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3388 _bitfield_align_1: [],
3389 _bitfield_1: __BindgenBitfieldUnit::new(
3390 new_jsjitinfo_bitfield_1!(
3391 JSJitInfo_OpType::Getter as u8,
3392 JSJitInfo_AliasSet::AliasEverything as u8,
3393 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3394 true,
3395 false,
3396 false,
3397 false,
3398 false,
3399 false,
3400 0,
3401 ).to_ne_bytes()
3402 ),
3403});
3404}
3405static unrestrictedFloatAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3406
3407pub(crate) fn init_unrestrictedFloatAttribute_setterinfo<D: DomTypes>() {
3408 unrestrictedFloatAttribute_setterinfo.set(JSJitInfo {
3409 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3410 setter: Some(set_unrestrictedFloatAttribute::<D>)
3411 },
3412 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3413 protoID: PrototypeList::ID::TestBinding as u16,
3414 },
3415 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3416 _bitfield_align_1: [],
3417 _bitfield_1: __BindgenBitfieldUnit::new(
3418 new_jsjitinfo_bitfield_1!(
3419 JSJitInfo_OpType::Setter as u8,
3420 JSJitInfo_AliasSet::AliasEverything as u8,
3421 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3422 false,
3423 false,
3424 false,
3425 false,
3426 false,
3427 false,
3428 0,
3429 ).to_ne_bytes()
3430 ),
3431});
3432}
3433unsafe extern "C" fn get_floatAttribute<D: DomTypes>
3434(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3435 let mut result = false;
3436 wrap_panic(&mut || result = (|| {
3437 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3438 let this = &*(this as *const D::TestBinding);
3439 let result: Finite<f32> = this.FloatAttribute();
3440
3441 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3442 return true;
3443 })());
3444 result
3445}
3446
3447unsafe extern "C" fn set_floatAttribute<D: DomTypes>
3448(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3449 let mut result = false;
3450 wrap_panic(&mut || result = (|| {
3451 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3452 let this = &*(this as *const D::TestBinding);
3453 let arg0: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3454 Ok(ConversionResult::Success(value)) => value,
3455 Ok(ConversionResult::Failure(error)) => {
3456 throw_type_error(cx.raw_cx(), &error);
3457 return false;
3458
3459 }
3460 _ => {
3461 return false;
3462
3463 },
3464 }
3465 ;
3466 let result: () = this.SetFloatAttribute(arg0);
3467
3468 true
3469 })());
3470 result
3471}
3472
3473
3474static floatAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3475
3476pub(crate) fn init_floatAttribute_getterinfo<D: DomTypes>() {
3477 floatAttribute_getterinfo.set(JSJitInfo {
3478 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3479 getter: Some(get_floatAttribute::<D>)
3480 },
3481 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3482 protoID: PrototypeList::ID::TestBinding as u16,
3483 },
3484 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3485 _bitfield_align_1: [],
3486 _bitfield_1: __BindgenBitfieldUnit::new(
3487 new_jsjitinfo_bitfield_1!(
3488 JSJitInfo_OpType::Getter as u8,
3489 JSJitInfo_AliasSet::AliasEverything as u8,
3490 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3491 true,
3492 false,
3493 false,
3494 false,
3495 false,
3496 false,
3497 0,
3498 ).to_ne_bytes()
3499 ),
3500});
3501}
3502static floatAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3503
3504pub(crate) fn init_floatAttribute_setterinfo<D: DomTypes>() {
3505 floatAttribute_setterinfo.set(JSJitInfo {
3506 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3507 setter: Some(set_floatAttribute::<D>)
3508 },
3509 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3510 protoID: PrototypeList::ID::TestBinding as u16,
3511 },
3512 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3513 _bitfield_align_1: [],
3514 _bitfield_1: __BindgenBitfieldUnit::new(
3515 new_jsjitinfo_bitfield_1!(
3516 JSJitInfo_OpType::Setter as u8,
3517 JSJitInfo_AliasSet::AliasEverything as u8,
3518 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3519 false,
3520 false,
3521 false,
3522 false,
3523 false,
3524 false,
3525 0,
3526 ).to_ne_bytes()
3527 ),
3528});
3529}
3530unsafe extern "C" fn get_unrestrictedDoubleAttribute<D: DomTypes>
3531(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3532 let mut result = false;
3533 wrap_panic(&mut || result = (|| {
3534 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3535 let this = &*(this as *const D::TestBinding);
3536 let result: f64 = this.UnrestrictedDoubleAttribute();
3537
3538 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3539 return true;
3540 })());
3541 result
3542}
3543
3544unsafe extern "C" fn set_unrestrictedDoubleAttribute<D: DomTypes>
3545(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3546 let mut result = false;
3547 wrap_panic(&mut || result = (|| {
3548 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3549 let this = &*(this as *const D::TestBinding);
3550 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3551 Ok(ConversionResult::Success(value)) => value,
3552 Ok(ConversionResult::Failure(error)) => {
3553 throw_type_error(cx.raw_cx(), &error);
3554 return false;
3555
3556 }
3557 _ => {
3558 return false;
3559
3560 },
3561 }
3562 ;
3563 let result: () = this.SetUnrestrictedDoubleAttribute(arg0);
3564
3565 true
3566 })());
3567 result
3568}
3569
3570
3571static unrestrictedDoubleAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3572
3573pub(crate) fn init_unrestrictedDoubleAttribute_getterinfo<D: DomTypes>() {
3574 unrestrictedDoubleAttribute_getterinfo.set(JSJitInfo {
3575 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3576 getter: Some(get_unrestrictedDoubleAttribute::<D>)
3577 },
3578 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3579 protoID: PrototypeList::ID::TestBinding as u16,
3580 },
3581 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3582 _bitfield_align_1: [],
3583 _bitfield_1: __BindgenBitfieldUnit::new(
3584 new_jsjitinfo_bitfield_1!(
3585 JSJitInfo_OpType::Getter as u8,
3586 JSJitInfo_AliasSet::AliasEverything as u8,
3587 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3588 true,
3589 false,
3590 false,
3591 false,
3592 false,
3593 false,
3594 0,
3595 ).to_ne_bytes()
3596 ),
3597});
3598}
3599static unrestrictedDoubleAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3600
3601pub(crate) fn init_unrestrictedDoubleAttribute_setterinfo<D: DomTypes>() {
3602 unrestrictedDoubleAttribute_setterinfo.set(JSJitInfo {
3603 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3604 setter: Some(set_unrestrictedDoubleAttribute::<D>)
3605 },
3606 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3607 protoID: PrototypeList::ID::TestBinding as u16,
3608 },
3609 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3610 _bitfield_align_1: [],
3611 _bitfield_1: __BindgenBitfieldUnit::new(
3612 new_jsjitinfo_bitfield_1!(
3613 JSJitInfo_OpType::Setter as u8,
3614 JSJitInfo_AliasSet::AliasEverything as u8,
3615 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3616 false,
3617 false,
3618 false,
3619 false,
3620 false,
3621 false,
3622 0,
3623 ).to_ne_bytes()
3624 ),
3625});
3626}
3627unsafe extern "C" fn get_doubleAttribute<D: DomTypes>
3628(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3629 let mut result = false;
3630 wrap_panic(&mut || result = (|| {
3631 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3632 let this = &*(this as *const D::TestBinding);
3633 let result: Finite<f64> = this.DoubleAttribute();
3634
3635 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3636 return true;
3637 })());
3638 result
3639}
3640
3641unsafe extern "C" fn set_doubleAttribute<D: DomTypes>
3642(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3643 let mut result = false;
3644 wrap_panic(&mut || result = (|| {
3645 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3646 let this = &*(this as *const D::TestBinding);
3647 let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3648 Ok(ConversionResult::Success(value)) => value,
3649 Ok(ConversionResult::Failure(error)) => {
3650 throw_type_error(cx.raw_cx(), &error);
3651 return false;
3652
3653 }
3654 _ => {
3655 return false;
3656
3657 },
3658 }
3659 ;
3660 let result: () = this.SetDoubleAttribute(arg0);
3661
3662 true
3663 })());
3664 result
3665}
3666
3667
3668static doubleAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3669
3670pub(crate) fn init_doubleAttribute_getterinfo<D: DomTypes>() {
3671 doubleAttribute_getterinfo.set(JSJitInfo {
3672 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3673 getter: Some(get_doubleAttribute::<D>)
3674 },
3675 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3676 protoID: PrototypeList::ID::TestBinding as u16,
3677 },
3678 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3679 _bitfield_align_1: [],
3680 _bitfield_1: __BindgenBitfieldUnit::new(
3681 new_jsjitinfo_bitfield_1!(
3682 JSJitInfo_OpType::Getter as u8,
3683 JSJitInfo_AliasSet::AliasEverything as u8,
3684 JSValueType::JSVAL_TYPE_DOUBLE as u8,
3685 true,
3686 false,
3687 false,
3688 false,
3689 false,
3690 false,
3691 0,
3692 ).to_ne_bytes()
3693 ),
3694});
3695}
3696static doubleAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3697
3698pub(crate) fn init_doubleAttribute_setterinfo<D: DomTypes>() {
3699 doubleAttribute_setterinfo.set(JSJitInfo {
3700 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3701 setter: Some(set_doubleAttribute::<D>)
3702 },
3703 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3704 protoID: PrototypeList::ID::TestBinding as u16,
3705 },
3706 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3707 _bitfield_align_1: [],
3708 _bitfield_1: __BindgenBitfieldUnit::new(
3709 new_jsjitinfo_bitfield_1!(
3710 JSJitInfo_OpType::Setter as u8,
3711 JSJitInfo_AliasSet::AliasEverything as u8,
3712 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3713 false,
3714 false,
3715 false,
3716 false,
3717 false,
3718 false,
3719 0,
3720 ).to_ne_bytes()
3721 ),
3722});
3723}
3724unsafe extern "C" fn get_stringAttribute<D: DomTypes>
3725(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3726 let mut result = false;
3727 wrap_panic(&mut || result = (|| {
3728 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3729 let this = &*(this as *const D::TestBinding);
3730 let result: DOMString = this.StringAttribute();
3731
3732 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3733 return true;
3734 })());
3735 result
3736}
3737
3738unsafe extern "C" fn set_stringAttribute<D: DomTypes>
3739(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3740 let mut result = false;
3741 wrap_panic(&mut || result = (|| {
3742 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3743 let this = &*(this as *const D::TestBinding);
3744 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
3745 Ok(ConversionResult::Success(value)) => value,
3746 Ok(ConversionResult::Failure(error)) => {
3747 throw_type_error(cx.raw_cx(), &error);
3748 return false;
3749
3750 }
3751 _ => {
3752 return false;
3753
3754 },
3755 }
3756 ;
3757 let result: () = this.SetStringAttribute(arg0);
3758
3759 true
3760 })());
3761 result
3762}
3763
3764
3765static stringAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3766
3767pub(crate) fn init_stringAttribute_getterinfo<D: DomTypes>() {
3768 stringAttribute_getterinfo.set(JSJitInfo {
3769 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3770 getter: Some(get_stringAttribute::<D>)
3771 },
3772 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3773 protoID: PrototypeList::ID::TestBinding as u16,
3774 },
3775 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3776 _bitfield_align_1: [],
3777 _bitfield_1: __BindgenBitfieldUnit::new(
3778 new_jsjitinfo_bitfield_1!(
3779 JSJitInfo_OpType::Getter as u8,
3780 JSJitInfo_AliasSet::AliasEverything as u8,
3781 JSValueType::JSVAL_TYPE_STRING as u8,
3782 true,
3783 false,
3784 false,
3785 false,
3786 false,
3787 false,
3788 0,
3789 ).to_ne_bytes()
3790 ),
3791});
3792}
3793static stringAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3794
3795pub(crate) fn init_stringAttribute_setterinfo<D: DomTypes>() {
3796 stringAttribute_setterinfo.set(JSJitInfo {
3797 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3798 setter: Some(set_stringAttribute::<D>)
3799 },
3800 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3801 protoID: PrototypeList::ID::TestBinding as u16,
3802 },
3803 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3804 _bitfield_align_1: [],
3805 _bitfield_1: __BindgenBitfieldUnit::new(
3806 new_jsjitinfo_bitfield_1!(
3807 JSJitInfo_OpType::Setter as u8,
3808 JSJitInfo_AliasSet::AliasEverything as u8,
3809 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3810 false,
3811 false,
3812 false,
3813 false,
3814 false,
3815 false,
3816 0,
3817 ).to_ne_bytes()
3818 ),
3819});
3820}
3821unsafe extern "C" fn get_usvstringAttribute<D: DomTypes>
3822(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3823 let mut result = false;
3824 wrap_panic(&mut || result = (|| {
3825 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3826 let this = &*(this as *const D::TestBinding);
3827 let result: USVString = this.UsvstringAttribute();
3828
3829 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3830 return true;
3831 })());
3832 result
3833}
3834
3835unsafe extern "C" fn set_usvstringAttribute<D: DomTypes>
3836(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3837 let mut result = false;
3838 wrap_panic(&mut || result = (|| {
3839 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3840 let this = &*(this as *const D::TestBinding);
3841 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3842 Ok(ConversionResult::Success(value)) => value,
3843 Ok(ConversionResult::Failure(error)) => {
3844 throw_type_error(cx.raw_cx(), &error);
3845 return false;
3846
3847 }
3848 _ => {
3849 return false;
3850
3851 },
3852 }
3853 ;
3854 let result: () = this.SetUsvstringAttribute(arg0);
3855
3856 true
3857 })());
3858 result
3859}
3860
3861
3862static usvstringAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3863
3864pub(crate) fn init_usvstringAttribute_getterinfo<D: DomTypes>() {
3865 usvstringAttribute_getterinfo.set(JSJitInfo {
3866 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3867 getter: Some(get_usvstringAttribute::<D>)
3868 },
3869 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3870 protoID: PrototypeList::ID::TestBinding as u16,
3871 },
3872 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3873 _bitfield_align_1: [],
3874 _bitfield_1: __BindgenBitfieldUnit::new(
3875 new_jsjitinfo_bitfield_1!(
3876 JSJitInfo_OpType::Getter as u8,
3877 JSJitInfo_AliasSet::AliasEverything as u8,
3878 JSValueType::JSVAL_TYPE_STRING as u8,
3879 true,
3880 false,
3881 false,
3882 false,
3883 false,
3884 false,
3885 0,
3886 ).to_ne_bytes()
3887 ),
3888});
3889}
3890static usvstringAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3891
3892pub(crate) fn init_usvstringAttribute_setterinfo<D: DomTypes>() {
3893 usvstringAttribute_setterinfo.set(JSJitInfo {
3894 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3895 setter: Some(set_usvstringAttribute::<D>)
3896 },
3897 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3898 protoID: PrototypeList::ID::TestBinding as u16,
3899 },
3900 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3901 _bitfield_align_1: [],
3902 _bitfield_1: __BindgenBitfieldUnit::new(
3903 new_jsjitinfo_bitfield_1!(
3904 JSJitInfo_OpType::Setter as u8,
3905 JSJitInfo_AliasSet::AliasEverything as u8,
3906 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
3907 false,
3908 false,
3909 false,
3910 false,
3911 false,
3912 false,
3913 0,
3914 ).to_ne_bytes()
3915 ),
3916});
3917}
3918unsafe extern "C" fn get_byteStringAttribute<D: DomTypes>
3919(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
3920 let mut result = false;
3921 wrap_panic(&mut || result = (|| {
3922 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3923 let this = &*(this as *const D::TestBinding);
3924 let result: ByteString = this.ByteStringAttribute();
3925
3926 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
3927 return true;
3928 })());
3929 result
3930}
3931
3932unsafe extern "C" fn set_byteStringAttribute<D: DomTypes>
3933(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
3934 let mut result = false;
3935 wrap_panic(&mut || result = (|| {
3936 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
3937 let this = &*(this as *const D::TestBinding);
3938 let arg0: ByteString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
3939 Ok(ConversionResult::Success(value)) => value,
3940 Ok(ConversionResult::Failure(error)) => {
3941 throw_type_error(cx.raw_cx(), &error);
3942 return false;
3943
3944 }
3945 _ => {
3946 return false;
3947
3948 },
3949 }
3950 ;
3951 let result: () = this.SetByteStringAttribute(arg0);
3952
3953 true
3954 })());
3955 result
3956}
3957
3958
3959static byteStringAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3960
3961pub(crate) fn init_byteStringAttribute_getterinfo<D: DomTypes>() {
3962 byteStringAttribute_getterinfo.set(JSJitInfo {
3963 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3964 getter: Some(get_byteStringAttribute::<D>)
3965 },
3966 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3967 protoID: PrototypeList::ID::TestBinding as u16,
3968 },
3969 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3970 _bitfield_align_1: [],
3971 _bitfield_1: __BindgenBitfieldUnit::new(
3972 new_jsjitinfo_bitfield_1!(
3973 JSJitInfo_OpType::Getter as u8,
3974 JSJitInfo_AliasSet::AliasEverything as u8,
3975 JSValueType::JSVAL_TYPE_STRING as u8,
3976 true,
3977 false,
3978 false,
3979 false,
3980 false,
3981 false,
3982 0,
3983 ).to_ne_bytes()
3984 ),
3985});
3986}
3987static byteStringAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
3988
3989pub(crate) fn init_byteStringAttribute_setterinfo<D: DomTypes>() {
3990 byteStringAttribute_setterinfo.set(JSJitInfo {
3991 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
3992 setter: Some(set_byteStringAttribute::<D>)
3993 },
3994 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
3995 protoID: PrototypeList::ID::TestBinding as u16,
3996 },
3997 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
3998 _bitfield_align_1: [],
3999 _bitfield_1: __BindgenBitfieldUnit::new(
4000 new_jsjitinfo_bitfield_1!(
4001 JSJitInfo_OpType::Setter as u8,
4002 JSJitInfo_AliasSet::AliasEverything as u8,
4003 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4004 false,
4005 false,
4006 false,
4007 false,
4008 false,
4009 false,
4010 0,
4011 ).to_ne_bytes()
4012 ),
4013});
4014}
4015unsafe extern "C" fn get_enumAttribute<D: DomTypes>
4016(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4017 let mut result = false;
4018 wrap_panic(&mut || result = (|| {
4019 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4020 let this = &*(this as *const D::TestBinding);
4021 let result: TestEnum = this.EnumAttribute();
4022
4023 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4024 return true;
4025 })());
4026 result
4027}
4028
4029unsafe extern "C" fn set_enumAttribute<D: DomTypes>
4030(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4031 let mut result = false;
4032 wrap_panic(&mut || result = (|| {
4033 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4034 let this = &*(this as *const D::TestBinding);
4035 let arg0: TestEnum = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4036 Ok(ConversionResult::Success(value)) => value,
4037 Ok(ConversionResult::Failure(error)) => {
4038 return true;
4039 }
4040 _ => {
4041 return false;
4042
4043 },
4044 }
4045 ;
4046 let result: () = this.SetEnumAttribute(arg0);
4047
4048 true
4049 })());
4050 result
4051}
4052
4053
4054static enumAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4055
4056pub(crate) fn init_enumAttribute_getterinfo<D: DomTypes>() {
4057 enumAttribute_getterinfo.set(JSJitInfo {
4058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4059 getter: Some(get_enumAttribute::<D>)
4060 },
4061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4062 protoID: PrototypeList::ID::TestBinding as u16,
4063 },
4064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4065 _bitfield_align_1: [],
4066 _bitfield_1: __BindgenBitfieldUnit::new(
4067 new_jsjitinfo_bitfield_1!(
4068 JSJitInfo_OpType::Getter as u8,
4069 JSJitInfo_AliasSet::AliasEverything as u8,
4070 JSValueType::JSVAL_TYPE_STRING as u8,
4071 true,
4072 false,
4073 false,
4074 false,
4075 false,
4076 false,
4077 0,
4078 ).to_ne_bytes()
4079 ),
4080});
4081}
4082static enumAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4083
4084pub(crate) fn init_enumAttribute_setterinfo<D: DomTypes>() {
4085 enumAttribute_setterinfo.set(JSJitInfo {
4086 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4087 setter: Some(set_enumAttribute::<D>)
4088 },
4089 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4090 protoID: PrototypeList::ID::TestBinding as u16,
4091 },
4092 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4093 _bitfield_align_1: [],
4094 _bitfield_1: __BindgenBitfieldUnit::new(
4095 new_jsjitinfo_bitfield_1!(
4096 JSJitInfo_OpType::Setter as u8,
4097 JSJitInfo_AliasSet::AliasEverything as u8,
4098 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4099 false,
4100 false,
4101 false,
4102 false,
4103 false,
4104 false,
4105 0,
4106 ).to_ne_bytes()
4107 ),
4108});
4109}
4110unsafe extern "C" fn get_interfaceAttribute<D: DomTypes>
4111(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4112 let mut result = false;
4113 wrap_panic(&mut || result = (|| {
4114 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4115 let this = &*(this as *const D::TestBinding);
4116 let result: DomRoot<D::Blob> = this.InterfaceAttribute(CanGc::note());
4117
4118 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4119 return true;
4120 })());
4121 result
4122}
4123
4124unsafe extern "C" fn set_interfaceAttribute<D: DomTypes>
4125(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4126 let mut result = false;
4127 wrap_panic(&mut || result = (|| {
4128 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4129 let this = &*(this as *const D::TestBinding);
4130 let arg0: DomRoot<D::Blob> = if HandleValue::from_raw(args.get(0)).get().is_object() {
4131 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
4132 Ok(val) => val,
4133 Err(()) => {
4134 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
4135 return false;
4136
4137 }
4138 }
4139
4140 } else {
4141 throw_type_error(cx.raw_cx(), "Value is not an object.");
4142 return false;
4143
4144 };
4145 let result: () = this.SetInterfaceAttribute(&arg0);
4146
4147 true
4148 })());
4149 result
4150}
4151
4152
4153static interfaceAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4154
4155pub(crate) fn init_interfaceAttribute_getterinfo<D: DomTypes>() {
4156 interfaceAttribute_getterinfo.set(JSJitInfo {
4157 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4158 getter: Some(get_interfaceAttribute::<D>)
4159 },
4160 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4161 protoID: PrototypeList::ID::TestBinding as u16,
4162 },
4163 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4164 _bitfield_align_1: [],
4165 _bitfield_1: __BindgenBitfieldUnit::new(
4166 new_jsjitinfo_bitfield_1!(
4167 JSJitInfo_OpType::Getter as u8,
4168 JSJitInfo_AliasSet::AliasEverything as u8,
4169 JSValueType::JSVAL_TYPE_OBJECT as u8,
4170 true,
4171 false,
4172 false,
4173 false,
4174 false,
4175 false,
4176 0,
4177 ).to_ne_bytes()
4178 ),
4179});
4180}
4181static interfaceAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4182
4183pub(crate) fn init_interfaceAttribute_setterinfo<D: DomTypes>() {
4184 interfaceAttribute_setterinfo.set(JSJitInfo {
4185 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4186 setter: Some(set_interfaceAttribute::<D>)
4187 },
4188 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4189 protoID: PrototypeList::ID::TestBinding as u16,
4190 },
4191 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4192 _bitfield_align_1: [],
4193 _bitfield_1: __BindgenBitfieldUnit::new(
4194 new_jsjitinfo_bitfield_1!(
4195 JSJitInfo_OpType::Setter as u8,
4196 JSJitInfo_AliasSet::AliasEverything as u8,
4197 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4198 false,
4199 false,
4200 false,
4201 false,
4202 false,
4203 false,
4204 0,
4205 ).to_ne_bytes()
4206 ),
4207});
4208}
4209unsafe extern "C" fn get_unionAttribute<D: DomTypes>
4210(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4211 let mut result = false;
4212 wrap_panic(&mut || result = (|| {
4213 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4214 let this = &*(this as *const D::TestBinding);
4215 let result: GenericUnionTypes::HTMLElementOrLong::<D> = this.UnionAttribute();
4216
4217 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4218 return true;
4219 })());
4220 result
4221}
4222
4223unsafe extern "C" fn set_unionAttribute<D: DomTypes>
4224(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4225 let mut result = false;
4226 wrap_panic(&mut || result = (|| {
4227 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4228 let this = &*(this as *const D::TestBinding);
4229 let arg0: GenericUnionTypes::HTMLElementOrLong::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4230 Ok(ConversionResult::Success(value)) => value,
4231 Ok(ConversionResult::Failure(error)) => {
4232 throw_type_error(cx.raw_cx(), &error);
4233 return false;
4234
4235 }
4236 _ => {
4237 return false;
4238
4239 },
4240 }
4241 ;
4242 let result: () = this.SetUnionAttribute(arg0);
4243
4244 true
4245 })());
4246 result
4247}
4248
4249
4250static unionAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4251
4252pub(crate) fn init_unionAttribute_getterinfo<D: DomTypes>() {
4253 unionAttribute_getterinfo.set(JSJitInfo {
4254 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4255 getter: Some(get_unionAttribute::<D>)
4256 },
4257 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4258 protoID: PrototypeList::ID::TestBinding as u16,
4259 },
4260 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4261 _bitfield_align_1: [],
4262 _bitfield_1: __BindgenBitfieldUnit::new(
4263 new_jsjitinfo_bitfield_1!(
4264 JSJitInfo_OpType::Getter as u8,
4265 JSJitInfo_AliasSet::AliasEverything as u8,
4266 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4267 true,
4268 false,
4269 false,
4270 false,
4271 false,
4272 false,
4273 0,
4274 ).to_ne_bytes()
4275 ),
4276});
4277}
4278static unionAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4279
4280pub(crate) fn init_unionAttribute_setterinfo<D: DomTypes>() {
4281 unionAttribute_setterinfo.set(JSJitInfo {
4282 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4283 setter: Some(set_unionAttribute::<D>)
4284 },
4285 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4286 protoID: PrototypeList::ID::TestBinding as u16,
4287 },
4288 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4289 _bitfield_align_1: [],
4290 _bitfield_1: __BindgenBitfieldUnit::new(
4291 new_jsjitinfo_bitfield_1!(
4292 JSJitInfo_OpType::Setter as u8,
4293 JSJitInfo_AliasSet::AliasEverything as u8,
4294 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4295 false,
4296 false,
4297 false,
4298 false,
4299 false,
4300 false,
4301 0,
4302 ).to_ne_bytes()
4303 ),
4304});
4305}
4306unsafe extern "C" fn get_union2Attribute<D: DomTypes>
4307(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4308 let mut result = false;
4309 wrap_panic(&mut || result = (|| {
4310 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4311 let this = &*(this as *const D::TestBinding);
4312 let result: GenericUnionTypes::EventOrString::<D> = this.Union2Attribute();
4313
4314 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4315 return true;
4316 })());
4317 result
4318}
4319
4320unsafe extern "C" fn set_union2Attribute<D: DomTypes>
4321(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4322 let mut result = false;
4323 wrap_panic(&mut || result = (|| {
4324 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4325 let this = &*(this as *const D::TestBinding);
4326 let arg0: GenericUnionTypes::EventOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4327 Ok(ConversionResult::Success(value)) => value,
4328 Ok(ConversionResult::Failure(error)) => {
4329 throw_type_error(cx.raw_cx(), &error);
4330 return false;
4331
4332 }
4333 _ => {
4334 return false;
4335
4336 },
4337 }
4338 ;
4339 let result: () = this.SetUnion2Attribute(arg0);
4340
4341 true
4342 })());
4343 result
4344}
4345
4346
4347static union2Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4348
4349pub(crate) fn init_union2Attribute_getterinfo<D: DomTypes>() {
4350 union2Attribute_getterinfo.set(JSJitInfo {
4351 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4352 getter: Some(get_union2Attribute::<D>)
4353 },
4354 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4355 protoID: PrototypeList::ID::TestBinding as u16,
4356 },
4357 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4358 _bitfield_align_1: [],
4359 _bitfield_1: __BindgenBitfieldUnit::new(
4360 new_jsjitinfo_bitfield_1!(
4361 JSJitInfo_OpType::Getter as u8,
4362 JSJitInfo_AliasSet::AliasEverything as u8,
4363 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4364 true,
4365 false,
4366 false,
4367 false,
4368 false,
4369 false,
4370 0,
4371 ).to_ne_bytes()
4372 ),
4373});
4374}
4375static union2Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4376
4377pub(crate) fn init_union2Attribute_setterinfo<D: DomTypes>() {
4378 union2Attribute_setterinfo.set(JSJitInfo {
4379 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4380 setter: Some(set_union2Attribute::<D>)
4381 },
4382 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4383 protoID: PrototypeList::ID::TestBinding as u16,
4384 },
4385 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4386 _bitfield_align_1: [],
4387 _bitfield_1: __BindgenBitfieldUnit::new(
4388 new_jsjitinfo_bitfield_1!(
4389 JSJitInfo_OpType::Setter as u8,
4390 JSJitInfo_AliasSet::AliasEverything as u8,
4391 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4392 false,
4393 false,
4394 false,
4395 false,
4396 false,
4397 false,
4398 0,
4399 ).to_ne_bytes()
4400 ),
4401});
4402}
4403unsafe extern "C" fn get_union3Attribute<D: DomTypes>
4404(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4405 let mut result = false;
4406 wrap_panic(&mut || result = (|| {
4407 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4408 let this = &*(this as *const D::TestBinding);
4409 let result: GenericUnionTypes::EventOrUSVString::<D> = this.Union3Attribute();
4410
4411 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4412 return true;
4413 })());
4414 result
4415}
4416
4417unsafe extern "C" fn set_union3Attribute<D: DomTypes>
4418(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4419 let mut result = false;
4420 wrap_panic(&mut || result = (|| {
4421 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4422 let this = &*(this as *const D::TestBinding);
4423 let arg0: GenericUnionTypes::EventOrUSVString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4424 Ok(ConversionResult::Success(value)) => value,
4425 Ok(ConversionResult::Failure(error)) => {
4426 throw_type_error(cx.raw_cx(), &error);
4427 return false;
4428
4429 }
4430 _ => {
4431 return false;
4432
4433 },
4434 }
4435 ;
4436 let result: () = this.SetUnion3Attribute(arg0);
4437
4438 true
4439 })());
4440 result
4441}
4442
4443
4444static union3Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4445
4446pub(crate) fn init_union3Attribute_getterinfo<D: DomTypes>() {
4447 union3Attribute_getterinfo.set(JSJitInfo {
4448 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4449 getter: Some(get_union3Attribute::<D>)
4450 },
4451 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4452 protoID: PrototypeList::ID::TestBinding as u16,
4453 },
4454 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4455 _bitfield_align_1: [],
4456 _bitfield_1: __BindgenBitfieldUnit::new(
4457 new_jsjitinfo_bitfield_1!(
4458 JSJitInfo_OpType::Getter as u8,
4459 JSJitInfo_AliasSet::AliasEverything as u8,
4460 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4461 true,
4462 false,
4463 false,
4464 false,
4465 false,
4466 false,
4467 0,
4468 ).to_ne_bytes()
4469 ),
4470});
4471}
4472static union3Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4473
4474pub(crate) fn init_union3Attribute_setterinfo<D: DomTypes>() {
4475 union3Attribute_setterinfo.set(JSJitInfo {
4476 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4477 setter: Some(set_union3Attribute::<D>)
4478 },
4479 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4480 protoID: PrototypeList::ID::TestBinding as u16,
4481 },
4482 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4483 _bitfield_align_1: [],
4484 _bitfield_1: __BindgenBitfieldUnit::new(
4485 new_jsjitinfo_bitfield_1!(
4486 JSJitInfo_OpType::Setter as u8,
4487 JSJitInfo_AliasSet::AliasEverything as u8,
4488 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4489 false,
4490 false,
4491 false,
4492 false,
4493 false,
4494 false,
4495 0,
4496 ).to_ne_bytes()
4497 ),
4498});
4499}
4500unsafe extern "C" fn get_union4Attribute<D: DomTypes>
4501(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4502 let mut result = false;
4503 wrap_panic(&mut || result = (|| {
4504 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4505 let this = &*(this as *const D::TestBinding);
4506 let result: GenericUnionTypes::StringOrUnsignedLong = this.Union4Attribute();
4507
4508 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4509 return true;
4510 })());
4511 result
4512}
4513
4514unsafe extern "C" fn set_union4Attribute<D: DomTypes>
4515(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4516 let mut result = false;
4517 wrap_panic(&mut || result = (|| {
4518 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4519 let this = &*(this as *const D::TestBinding);
4520 let arg0: GenericUnionTypes::StringOrUnsignedLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4521 Ok(ConversionResult::Success(value)) => value,
4522 Ok(ConversionResult::Failure(error)) => {
4523 throw_type_error(cx.raw_cx(), &error);
4524 return false;
4525
4526 }
4527 _ => {
4528 return false;
4529
4530 },
4531 }
4532 ;
4533 let result: () = this.SetUnion4Attribute(arg0);
4534
4535 true
4536 })());
4537 result
4538}
4539
4540
4541static union4Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4542
4543pub(crate) fn init_union4Attribute_getterinfo<D: DomTypes>() {
4544 union4Attribute_getterinfo.set(JSJitInfo {
4545 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4546 getter: Some(get_union4Attribute::<D>)
4547 },
4548 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4549 protoID: PrototypeList::ID::TestBinding as u16,
4550 },
4551 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4552 _bitfield_align_1: [],
4553 _bitfield_1: __BindgenBitfieldUnit::new(
4554 new_jsjitinfo_bitfield_1!(
4555 JSJitInfo_OpType::Getter as u8,
4556 JSJitInfo_AliasSet::AliasEverything as u8,
4557 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4558 true,
4559 false,
4560 false,
4561 false,
4562 false,
4563 false,
4564 0,
4565 ).to_ne_bytes()
4566 ),
4567});
4568}
4569static union4Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4570
4571pub(crate) fn init_union4Attribute_setterinfo<D: DomTypes>() {
4572 union4Attribute_setterinfo.set(JSJitInfo {
4573 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4574 setter: Some(set_union4Attribute::<D>)
4575 },
4576 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4577 protoID: PrototypeList::ID::TestBinding as u16,
4578 },
4579 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4580 _bitfield_align_1: [],
4581 _bitfield_1: __BindgenBitfieldUnit::new(
4582 new_jsjitinfo_bitfield_1!(
4583 JSJitInfo_OpType::Setter as u8,
4584 JSJitInfo_AliasSet::AliasEverything as u8,
4585 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4586 false,
4587 false,
4588 false,
4589 false,
4590 false,
4591 false,
4592 0,
4593 ).to_ne_bytes()
4594 ),
4595});
4596}
4597unsafe extern "C" fn get_union5Attribute<D: DomTypes>
4598(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4599 let mut result = false;
4600 wrap_panic(&mut || result = (|| {
4601 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4602 let this = &*(this as *const D::TestBinding);
4603 let result: GenericUnionTypes::StringOrBoolean = this.Union5Attribute();
4604
4605 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4606 return true;
4607 })());
4608 result
4609}
4610
4611unsafe extern "C" fn set_union5Attribute<D: DomTypes>
4612(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4613 let mut result = false;
4614 wrap_panic(&mut || result = (|| {
4615 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4616 let this = &*(this as *const D::TestBinding);
4617 let arg0: GenericUnionTypes::StringOrBoolean = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4618 Ok(ConversionResult::Success(value)) => value,
4619 Ok(ConversionResult::Failure(error)) => {
4620 throw_type_error(cx.raw_cx(), &error);
4621 return false;
4622
4623 }
4624 _ => {
4625 return false;
4626
4627 },
4628 }
4629 ;
4630 let result: () = this.SetUnion5Attribute(arg0);
4631
4632 true
4633 })());
4634 result
4635}
4636
4637
4638static union5Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4639
4640pub(crate) fn init_union5Attribute_getterinfo<D: DomTypes>() {
4641 union5Attribute_getterinfo.set(JSJitInfo {
4642 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4643 getter: Some(get_union5Attribute::<D>)
4644 },
4645 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4646 protoID: PrototypeList::ID::TestBinding as u16,
4647 },
4648 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4649 _bitfield_align_1: [],
4650 _bitfield_1: __BindgenBitfieldUnit::new(
4651 new_jsjitinfo_bitfield_1!(
4652 JSJitInfo_OpType::Getter as u8,
4653 JSJitInfo_AliasSet::AliasEverything as u8,
4654 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4655 true,
4656 false,
4657 false,
4658 false,
4659 false,
4660 false,
4661 0,
4662 ).to_ne_bytes()
4663 ),
4664});
4665}
4666static union5Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4667
4668pub(crate) fn init_union5Attribute_setterinfo<D: DomTypes>() {
4669 union5Attribute_setterinfo.set(JSJitInfo {
4670 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4671 setter: Some(set_union5Attribute::<D>)
4672 },
4673 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4674 protoID: PrototypeList::ID::TestBinding as u16,
4675 },
4676 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4677 _bitfield_align_1: [],
4678 _bitfield_1: __BindgenBitfieldUnit::new(
4679 new_jsjitinfo_bitfield_1!(
4680 JSJitInfo_OpType::Setter as u8,
4681 JSJitInfo_AliasSet::AliasEverything as u8,
4682 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4683 false,
4684 false,
4685 false,
4686 false,
4687 false,
4688 false,
4689 0,
4690 ).to_ne_bytes()
4691 ),
4692});
4693}
4694unsafe extern "C" fn get_union6Attribute<D: DomTypes>
4695(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4696 let mut result = false;
4697 wrap_panic(&mut || result = (|| {
4698 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4699 let this = &*(this as *const D::TestBinding);
4700 let result: GenericUnionTypes::UnsignedLongOrBoolean = this.Union6Attribute();
4701
4702 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4703 return true;
4704 })());
4705 result
4706}
4707
4708unsafe extern "C" fn set_union6Attribute<D: DomTypes>
4709(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4710 let mut result = false;
4711 wrap_panic(&mut || result = (|| {
4712 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4713 let this = &*(this as *const D::TestBinding);
4714 let arg0: GenericUnionTypes::UnsignedLongOrBoolean = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4715 Ok(ConversionResult::Success(value)) => value,
4716 Ok(ConversionResult::Failure(error)) => {
4717 throw_type_error(cx.raw_cx(), &error);
4718 return false;
4719
4720 }
4721 _ => {
4722 return false;
4723
4724 },
4725 }
4726 ;
4727 let result: () = this.SetUnion6Attribute(arg0);
4728
4729 true
4730 })());
4731 result
4732}
4733
4734
4735static union6Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4736
4737pub(crate) fn init_union6Attribute_getterinfo<D: DomTypes>() {
4738 union6Attribute_getterinfo.set(JSJitInfo {
4739 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4740 getter: Some(get_union6Attribute::<D>)
4741 },
4742 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4743 protoID: PrototypeList::ID::TestBinding as u16,
4744 },
4745 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4746 _bitfield_align_1: [],
4747 _bitfield_1: __BindgenBitfieldUnit::new(
4748 new_jsjitinfo_bitfield_1!(
4749 JSJitInfo_OpType::Getter as u8,
4750 JSJitInfo_AliasSet::AliasEverything as u8,
4751 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4752 true,
4753 false,
4754 false,
4755 false,
4756 false,
4757 false,
4758 0,
4759 ).to_ne_bytes()
4760 ),
4761});
4762}
4763static union6Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4764
4765pub(crate) fn init_union6Attribute_setterinfo<D: DomTypes>() {
4766 union6Attribute_setterinfo.set(JSJitInfo {
4767 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4768 setter: Some(set_union6Attribute::<D>)
4769 },
4770 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4771 protoID: PrototypeList::ID::TestBinding as u16,
4772 },
4773 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4774 _bitfield_align_1: [],
4775 _bitfield_1: __BindgenBitfieldUnit::new(
4776 new_jsjitinfo_bitfield_1!(
4777 JSJitInfo_OpType::Setter as u8,
4778 JSJitInfo_AliasSet::AliasEverything as u8,
4779 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4780 false,
4781 false,
4782 false,
4783 false,
4784 false,
4785 false,
4786 0,
4787 ).to_ne_bytes()
4788 ),
4789});
4790}
4791unsafe extern "C" fn get_union7Attribute<D: DomTypes>
4792(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4793 let mut result = false;
4794 wrap_panic(&mut || result = (|| {
4795 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4796 let this = &*(this as *const D::TestBinding);
4797 let result: GenericUnionTypes::BlobOrBoolean::<D> = this.Union7Attribute();
4798
4799 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4800 return true;
4801 })());
4802 result
4803}
4804
4805unsafe extern "C" fn set_union7Attribute<D: DomTypes>
4806(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4807 let mut result = false;
4808 wrap_panic(&mut || result = (|| {
4809 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4810 let this = &*(this as *const D::TestBinding);
4811 let arg0: GenericUnionTypes::BlobOrBoolean::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4812 Ok(ConversionResult::Success(value)) => value,
4813 Ok(ConversionResult::Failure(error)) => {
4814 throw_type_error(cx.raw_cx(), &error);
4815 return false;
4816
4817 }
4818 _ => {
4819 return false;
4820
4821 },
4822 }
4823 ;
4824 let result: () = this.SetUnion7Attribute(arg0);
4825
4826 true
4827 })());
4828 result
4829}
4830
4831
4832static union7Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4833
4834pub(crate) fn init_union7Attribute_getterinfo<D: DomTypes>() {
4835 union7Attribute_getterinfo.set(JSJitInfo {
4836 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4837 getter: Some(get_union7Attribute::<D>)
4838 },
4839 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4840 protoID: PrototypeList::ID::TestBinding as u16,
4841 },
4842 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4843 _bitfield_align_1: [],
4844 _bitfield_1: __BindgenBitfieldUnit::new(
4845 new_jsjitinfo_bitfield_1!(
4846 JSJitInfo_OpType::Getter as u8,
4847 JSJitInfo_AliasSet::AliasEverything as u8,
4848 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4849 true,
4850 false,
4851 false,
4852 false,
4853 false,
4854 false,
4855 0,
4856 ).to_ne_bytes()
4857 ),
4858});
4859}
4860static union7Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4861
4862pub(crate) fn init_union7Attribute_setterinfo<D: DomTypes>() {
4863 union7Attribute_setterinfo.set(JSJitInfo {
4864 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4865 setter: Some(set_union7Attribute::<D>)
4866 },
4867 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4868 protoID: PrototypeList::ID::TestBinding as u16,
4869 },
4870 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4871 _bitfield_align_1: [],
4872 _bitfield_1: __BindgenBitfieldUnit::new(
4873 new_jsjitinfo_bitfield_1!(
4874 JSJitInfo_OpType::Setter as u8,
4875 JSJitInfo_AliasSet::AliasEverything as u8,
4876 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4877 false,
4878 false,
4879 false,
4880 false,
4881 false,
4882 false,
4883 0,
4884 ).to_ne_bytes()
4885 ),
4886});
4887}
4888unsafe extern "C" fn get_union8Attribute<D: DomTypes>
4889(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4890 let mut result = false;
4891 wrap_panic(&mut || result = (|| {
4892 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4893 let this = &*(this as *const D::TestBinding);
4894 let result: GenericUnionTypes::BlobOrUnsignedLong::<D> = this.Union8Attribute();
4895
4896 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4897 return true;
4898 })());
4899 result
4900}
4901
4902unsafe extern "C" fn set_union8Attribute<D: DomTypes>
4903(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
4904 let mut result = false;
4905 wrap_panic(&mut || result = (|| {
4906 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4907 let this = &*(this as *const D::TestBinding);
4908 let arg0: GenericUnionTypes::BlobOrUnsignedLong::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
4909 Ok(ConversionResult::Success(value)) => value,
4910 Ok(ConversionResult::Failure(error)) => {
4911 throw_type_error(cx.raw_cx(), &error);
4912 return false;
4913
4914 }
4915 _ => {
4916 return false;
4917
4918 },
4919 }
4920 ;
4921 let result: () = this.SetUnion8Attribute(arg0);
4922
4923 true
4924 })());
4925 result
4926}
4927
4928
4929static union8Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4930
4931pub(crate) fn init_union8Attribute_getterinfo<D: DomTypes>() {
4932 union8Attribute_getterinfo.set(JSJitInfo {
4933 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4934 getter: Some(get_union8Attribute::<D>)
4935 },
4936 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4937 protoID: PrototypeList::ID::TestBinding as u16,
4938 },
4939 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4940 _bitfield_align_1: [],
4941 _bitfield_1: __BindgenBitfieldUnit::new(
4942 new_jsjitinfo_bitfield_1!(
4943 JSJitInfo_OpType::Getter as u8,
4944 JSJitInfo_AliasSet::AliasEverything as u8,
4945 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
4946 true,
4947 false,
4948 false,
4949 false,
4950 false,
4951 false,
4952 0,
4953 ).to_ne_bytes()
4954 ),
4955});
4956}
4957static union8Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
4958
4959pub(crate) fn init_union8Attribute_setterinfo<D: DomTypes>() {
4960 union8Attribute_setterinfo.set(JSJitInfo {
4961 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
4962 setter: Some(set_union8Attribute::<D>)
4963 },
4964 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
4965 protoID: PrototypeList::ID::TestBinding as u16,
4966 },
4967 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
4968 _bitfield_align_1: [],
4969 _bitfield_1: __BindgenBitfieldUnit::new(
4970 new_jsjitinfo_bitfield_1!(
4971 JSJitInfo_OpType::Setter as u8,
4972 JSJitInfo_AliasSet::AliasEverything as u8,
4973 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
4974 false,
4975 false,
4976 false,
4977 false,
4978 false,
4979 false,
4980 0,
4981 ).to_ne_bytes()
4982 ),
4983});
4984}
4985unsafe extern "C" fn get_union9Attribute<D: DomTypes>
4986(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
4987 let mut result = false;
4988 wrap_panic(&mut || result = (|| {
4989 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
4990 let this = &*(this as *const D::TestBinding);
4991 let result: GenericUnionTypes::ByteStringOrLong = this.Union9Attribute();
4992
4993 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
4994 return true;
4995 })());
4996 result
4997}
4998
4999unsafe extern "C" fn set_union9Attribute<D: DomTypes>
5000(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5001 let mut result = false;
5002 wrap_panic(&mut || result = (|| {
5003 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5004 let this = &*(this as *const D::TestBinding);
5005 let arg0: GenericUnionTypes::ByteStringOrLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
5006 Ok(ConversionResult::Success(value)) => value,
5007 Ok(ConversionResult::Failure(error)) => {
5008 throw_type_error(cx.raw_cx(), &error);
5009 return false;
5010
5011 }
5012 _ => {
5013 return false;
5014
5015 },
5016 }
5017 ;
5018 let result: () = this.SetUnion9Attribute(arg0);
5019
5020 true
5021 })());
5022 result
5023}
5024
5025
5026static union9Attribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5027
5028pub(crate) fn init_union9Attribute_getterinfo<D: DomTypes>() {
5029 union9Attribute_getterinfo.set(JSJitInfo {
5030 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5031 getter: Some(get_union9Attribute::<D>)
5032 },
5033 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5034 protoID: PrototypeList::ID::TestBinding as u16,
5035 },
5036 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5037 _bitfield_align_1: [],
5038 _bitfield_1: __BindgenBitfieldUnit::new(
5039 new_jsjitinfo_bitfield_1!(
5040 JSJitInfo_OpType::Getter as u8,
5041 JSJitInfo_AliasSet::AliasEverything as u8,
5042 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5043 true,
5044 false,
5045 false,
5046 false,
5047 false,
5048 false,
5049 0,
5050 ).to_ne_bytes()
5051 ),
5052});
5053}
5054static union9Attribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5055
5056pub(crate) fn init_union9Attribute_setterinfo<D: DomTypes>() {
5057 union9Attribute_setterinfo.set(JSJitInfo {
5058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5059 setter: Some(set_union9Attribute::<D>)
5060 },
5061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5062 protoID: PrototypeList::ID::TestBinding as u16,
5063 },
5064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5065 _bitfield_align_1: [],
5066 _bitfield_1: __BindgenBitfieldUnit::new(
5067 new_jsjitinfo_bitfield_1!(
5068 JSJitInfo_OpType::Setter as u8,
5069 JSJitInfo_AliasSet::AliasEverything as u8,
5070 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5071 false,
5072 false,
5073 false,
5074 false,
5075 false,
5076 false,
5077 0,
5078 ).to_ne_bytes()
5079 ),
5080});
5081}
5082unsafe extern "C" fn get_arrayAttribute<D: DomTypes>
5083(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5084 let mut result = false;
5085 wrap_panic(&mut || result = (|| {
5086 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5087 let this = &*(this as *const D::TestBinding);
5088 let result: Uint8ClampedArray = this.ArrayAttribute(SafeJSContext::from_ptr(cx.raw_cx()));
5089
5090 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5091 return true;
5092 })());
5093 result
5094}
5095
5096
5097static arrayAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5098
5099pub(crate) fn init_arrayAttribute_getterinfo<D: DomTypes>() {
5100 arrayAttribute_getterinfo.set(JSJitInfo {
5101 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5102 getter: Some(get_arrayAttribute::<D>)
5103 },
5104 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5105 protoID: PrototypeList::ID::TestBinding as u16,
5106 },
5107 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5108 _bitfield_align_1: [],
5109 _bitfield_1: __BindgenBitfieldUnit::new(
5110 new_jsjitinfo_bitfield_1!(
5111 JSJitInfo_OpType::Getter as u8,
5112 JSJitInfo_AliasSet::AliasEverything as u8,
5113 JSValueType::JSVAL_TYPE_OBJECT as u8,
5114 true,
5115 false,
5116 false,
5117 false,
5118 false,
5119 false,
5120 0,
5121 ).to_ne_bytes()
5122 ),
5123});
5124}
5125unsafe extern "C" fn get_anyAttribute<D: DomTypes>
5126(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5127 let mut result = false;
5128 wrap_panic(&mut || result = (|| {
5129 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5130 let this = &*(this as *const D::TestBinding);
5131 rooted!(&in(cx) let mut retval: JSVal);
5132 let result: () = this.AnyAttribute(SafeJSContext::from_ptr(cx.raw_cx()), retval.handle_mut());
5133
5134 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5135 return true;
5136 })());
5137 result
5138}
5139
5140unsafe extern "C" fn set_anyAttribute<D: DomTypes>
5141(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5142 let mut result = false;
5143 wrap_panic(&mut || result = {
5144 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5145 let this = &*(this as *const D::TestBinding);
5146 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
5147 let result: () = this.SetAnyAttribute(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
5148
5149 true
5150 });
5151 result
5152}
5153
5154
5155static anyAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5156
5157pub(crate) fn init_anyAttribute_getterinfo<D: DomTypes>() {
5158 anyAttribute_getterinfo.set(JSJitInfo {
5159 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5160 getter: Some(get_anyAttribute::<D>)
5161 },
5162 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5163 protoID: PrototypeList::ID::TestBinding as u16,
5164 },
5165 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5166 _bitfield_align_1: [],
5167 _bitfield_1: __BindgenBitfieldUnit::new(
5168 new_jsjitinfo_bitfield_1!(
5169 JSJitInfo_OpType::Getter as u8,
5170 JSJitInfo_AliasSet::AliasEverything as u8,
5171 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5172 true,
5173 false,
5174 false,
5175 false,
5176 false,
5177 false,
5178 0,
5179 ).to_ne_bytes()
5180 ),
5181});
5182}
5183static anyAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5184
5185pub(crate) fn init_anyAttribute_setterinfo<D: DomTypes>() {
5186 anyAttribute_setterinfo.set(JSJitInfo {
5187 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5188 setter: Some(set_anyAttribute::<D>)
5189 },
5190 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5191 protoID: PrototypeList::ID::TestBinding as u16,
5192 },
5193 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5194 _bitfield_align_1: [],
5195 _bitfield_1: __BindgenBitfieldUnit::new(
5196 new_jsjitinfo_bitfield_1!(
5197 JSJitInfo_OpType::Setter as u8,
5198 JSJitInfo_AliasSet::AliasEverything as u8,
5199 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5200 false,
5201 false,
5202 false,
5203 false,
5204 false,
5205 false,
5206 0,
5207 ).to_ne_bytes()
5208 ),
5209});
5210}
5211unsafe extern "C" fn get_objectAttribute<D: DomTypes>
5212(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5213 let mut result = false;
5214 wrap_panic(&mut || result = (|| {
5215 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5216 let this = &*(this as *const D::TestBinding);
5217 let result: NonNull<JSObject> = this.ObjectAttribute(SafeJSContext::from_ptr(cx.raw_cx()));
5218
5219 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5220 return true;
5221 })());
5222 result
5223}
5224
5225unsafe extern "C" fn set_objectAttribute<D: DomTypes>
5226(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5227 let mut result = false;
5228 wrap_panic(&mut || result = (|| {
5229 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5230 let this = &*(this as *const D::TestBinding);
5231 let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
5232 HandleValue::from_raw(args.get(0)).get().to_object()
5233 } else {
5234 throw_type_error(cx.raw_cx(), "Value is not an object.");
5235 return false;
5236
5237 };
5238 let result: () = this.SetObjectAttribute(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
5239
5240 true
5241 })());
5242 result
5243}
5244
5245
5246static objectAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5247
5248pub(crate) fn init_objectAttribute_getterinfo<D: DomTypes>() {
5249 objectAttribute_getterinfo.set(JSJitInfo {
5250 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5251 getter: Some(get_objectAttribute::<D>)
5252 },
5253 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5254 protoID: PrototypeList::ID::TestBinding as u16,
5255 },
5256 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5257 _bitfield_align_1: [],
5258 _bitfield_1: __BindgenBitfieldUnit::new(
5259 new_jsjitinfo_bitfield_1!(
5260 JSJitInfo_OpType::Getter as u8,
5261 JSJitInfo_AliasSet::AliasEverything as u8,
5262 JSValueType::JSVAL_TYPE_OBJECT as u8,
5263 true,
5264 false,
5265 false,
5266 false,
5267 false,
5268 false,
5269 0,
5270 ).to_ne_bytes()
5271 ),
5272});
5273}
5274static objectAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5275
5276pub(crate) fn init_objectAttribute_setterinfo<D: DomTypes>() {
5277 objectAttribute_setterinfo.set(JSJitInfo {
5278 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5279 setter: Some(set_objectAttribute::<D>)
5280 },
5281 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5282 protoID: PrototypeList::ID::TestBinding as u16,
5283 },
5284 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5285 _bitfield_align_1: [],
5286 _bitfield_1: __BindgenBitfieldUnit::new(
5287 new_jsjitinfo_bitfield_1!(
5288 JSJitInfo_OpType::Setter as u8,
5289 JSJitInfo_AliasSet::AliasEverything as u8,
5290 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5291 false,
5292 false,
5293 false,
5294 false,
5295 false,
5296 false,
5297 0,
5298 ).to_ne_bytes()
5299 ),
5300});
5301}
5302unsafe extern "C" fn get_booleanAttributeNullable<D: DomTypes>
5303(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5304 let mut result = false;
5305 wrap_panic(&mut || result = (|| {
5306 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5307 let this = &*(this as *const D::TestBinding);
5308 let result: Option<bool> = this.GetBooleanAttributeNullable();
5309
5310 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5311 return true;
5312 })());
5313 result
5314}
5315
5316unsafe extern "C" fn set_booleanAttributeNullable<D: DomTypes>
5317(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5318 let mut result = false;
5319 wrap_panic(&mut || result = (|| {
5320 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5321 let this = &*(this as *const D::TestBinding);
5322 let arg0: Option<bool> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
5323 Ok(ConversionResult::Success(value)) => value,
5324 Ok(ConversionResult::Failure(error)) => {
5325 throw_type_error(cx.raw_cx(), &error);
5326 return false;
5327
5328 }
5329 _ => {
5330 return false;
5331
5332 },
5333 }
5334 ;
5335 let result: () = this.SetBooleanAttributeNullable(arg0);
5336
5337 true
5338 })());
5339 result
5340}
5341
5342
5343static booleanAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5344
5345pub(crate) fn init_booleanAttributeNullable_getterinfo<D: DomTypes>() {
5346 booleanAttributeNullable_getterinfo.set(JSJitInfo {
5347 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5348 getter: Some(get_booleanAttributeNullable::<D>)
5349 },
5350 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5351 protoID: PrototypeList::ID::TestBinding as u16,
5352 },
5353 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5354 _bitfield_align_1: [],
5355 _bitfield_1: __BindgenBitfieldUnit::new(
5356 new_jsjitinfo_bitfield_1!(
5357 JSJitInfo_OpType::Getter as u8,
5358 JSJitInfo_AliasSet::AliasEverything as u8,
5359 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5360 true,
5361 false,
5362 false,
5363 false,
5364 false,
5365 false,
5366 0,
5367 ).to_ne_bytes()
5368 ),
5369});
5370}
5371static booleanAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5372
5373pub(crate) fn init_booleanAttributeNullable_setterinfo<D: DomTypes>() {
5374 booleanAttributeNullable_setterinfo.set(JSJitInfo {
5375 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5376 setter: Some(set_booleanAttributeNullable::<D>)
5377 },
5378 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5379 protoID: PrototypeList::ID::TestBinding as u16,
5380 },
5381 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5382 _bitfield_align_1: [],
5383 _bitfield_1: __BindgenBitfieldUnit::new(
5384 new_jsjitinfo_bitfield_1!(
5385 JSJitInfo_OpType::Setter as u8,
5386 JSJitInfo_AliasSet::AliasEverything as u8,
5387 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5388 false,
5389 false,
5390 false,
5391 false,
5392 false,
5393 false,
5394 0,
5395 ).to_ne_bytes()
5396 ),
5397});
5398}
5399unsafe extern "C" fn get_byteAttributeNullable<D: DomTypes>
5400(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5401 let mut result = false;
5402 wrap_panic(&mut || result = (|| {
5403 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5404 let this = &*(this as *const D::TestBinding);
5405 let result: Option<i8> = this.GetByteAttributeNullable();
5406
5407 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5408 return true;
5409 })());
5410 result
5411}
5412
5413unsafe extern "C" fn set_byteAttributeNullable<D: DomTypes>
5414(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5415 let mut result = false;
5416 wrap_panic(&mut || result = (|| {
5417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5418 let this = &*(this as *const D::TestBinding);
5419 let arg0: Option<i8> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5420 Ok(ConversionResult::Success(value)) => value,
5421 Ok(ConversionResult::Failure(error)) => {
5422 throw_type_error(cx.raw_cx(), &error);
5423 return false;
5424
5425 }
5426 _ => {
5427 return false;
5428
5429 },
5430 }
5431 ;
5432 let result: () = this.SetByteAttributeNullable(arg0);
5433
5434 true
5435 })());
5436 result
5437}
5438
5439
5440static byteAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5441
5442pub(crate) fn init_byteAttributeNullable_getterinfo<D: DomTypes>() {
5443 byteAttributeNullable_getterinfo.set(JSJitInfo {
5444 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5445 getter: Some(get_byteAttributeNullable::<D>)
5446 },
5447 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5448 protoID: PrototypeList::ID::TestBinding as u16,
5449 },
5450 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5451 _bitfield_align_1: [],
5452 _bitfield_1: __BindgenBitfieldUnit::new(
5453 new_jsjitinfo_bitfield_1!(
5454 JSJitInfo_OpType::Getter as u8,
5455 JSJitInfo_AliasSet::AliasEverything as u8,
5456 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5457 true,
5458 false,
5459 false,
5460 false,
5461 false,
5462 false,
5463 0,
5464 ).to_ne_bytes()
5465 ),
5466});
5467}
5468static byteAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5469
5470pub(crate) fn init_byteAttributeNullable_setterinfo<D: DomTypes>() {
5471 byteAttributeNullable_setterinfo.set(JSJitInfo {
5472 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5473 setter: Some(set_byteAttributeNullable::<D>)
5474 },
5475 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5476 protoID: PrototypeList::ID::TestBinding as u16,
5477 },
5478 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5479 _bitfield_align_1: [],
5480 _bitfield_1: __BindgenBitfieldUnit::new(
5481 new_jsjitinfo_bitfield_1!(
5482 JSJitInfo_OpType::Setter as u8,
5483 JSJitInfo_AliasSet::AliasEverything as u8,
5484 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5485 false,
5486 false,
5487 false,
5488 false,
5489 false,
5490 false,
5491 0,
5492 ).to_ne_bytes()
5493 ),
5494});
5495}
5496unsafe extern "C" fn get_octetAttributeNullable<D: DomTypes>
5497(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5498 let mut result = false;
5499 wrap_panic(&mut || result = (|| {
5500 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5501 let this = &*(this as *const D::TestBinding);
5502 let result: Option<u8> = this.GetOctetAttributeNullable();
5503
5504 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5505 return true;
5506 })());
5507 result
5508}
5509
5510unsafe extern "C" fn set_octetAttributeNullable<D: DomTypes>
5511(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5512 let mut result = false;
5513 wrap_panic(&mut || result = (|| {
5514 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5515 let this = &*(this as *const D::TestBinding);
5516 let arg0: Option<u8> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5517 Ok(ConversionResult::Success(value)) => value,
5518 Ok(ConversionResult::Failure(error)) => {
5519 throw_type_error(cx.raw_cx(), &error);
5520 return false;
5521
5522 }
5523 _ => {
5524 return false;
5525
5526 },
5527 }
5528 ;
5529 let result: () = this.SetOctetAttributeNullable(arg0);
5530
5531 true
5532 })());
5533 result
5534}
5535
5536
5537static octetAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5538
5539pub(crate) fn init_octetAttributeNullable_getterinfo<D: DomTypes>() {
5540 octetAttributeNullable_getterinfo.set(JSJitInfo {
5541 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5542 getter: Some(get_octetAttributeNullable::<D>)
5543 },
5544 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5545 protoID: PrototypeList::ID::TestBinding as u16,
5546 },
5547 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5548 _bitfield_align_1: [],
5549 _bitfield_1: __BindgenBitfieldUnit::new(
5550 new_jsjitinfo_bitfield_1!(
5551 JSJitInfo_OpType::Getter as u8,
5552 JSJitInfo_AliasSet::AliasEverything as u8,
5553 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5554 true,
5555 false,
5556 false,
5557 false,
5558 false,
5559 false,
5560 0,
5561 ).to_ne_bytes()
5562 ),
5563});
5564}
5565static octetAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5566
5567pub(crate) fn init_octetAttributeNullable_setterinfo<D: DomTypes>() {
5568 octetAttributeNullable_setterinfo.set(JSJitInfo {
5569 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5570 setter: Some(set_octetAttributeNullable::<D>)
5571 },
5572 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5573 protoID: PrototypeList::ID::TestBinding as u16,
5574 },
5575 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5576 _bitfield_align_1: [],
5577 _bitfield_1: __BindgenBitfieldUnit::new(
5578 new_jsjitinfo_bitfield_1!(
5579 JSJitInfo_OpType::Setter as u8,
5580 JSJitInfo_AliasSet::AliasEverything as u8,
5581 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5582 false,
5583 false,
5584 false,
5585 false,
5586 false,
5587 false,
5588 0,
5589 ).to_ne_bytes()
5590 ),
5591});
5592}
5593unsafe extern "C" fn get_shortAttributeNullable<D: DomTypes>
5594(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5595 let mut result = false;
5596 wrap_panic(&mut || result = (|| {
5597 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5598 let this = &*(this as *const D::TestBinding);
5599 let result: Option<i16> = this.GetShortAttributeNullable();
5600
5601 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5602 return true;
5603 })());
5604 result
5605}
5606
5607unsafe extern "C" fn set_shortAttributeNullable<D: DomTypes>
5608(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5609 let mut result = false;
5610 wrap_panic(&mut || result = (|| {
5611 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5612 let this = &*(this as *const D::TestBinding);
5613 let arg0: Option<i16> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5614 Ok(ConversionResult::Success(value)) => value,
5615 Ok(ConversionResult::Failure(error)) => {
5616 throw_type_error(cx.raw_cx(), &error);
5617 return false;
5618
5619 }
5620 _ => {
5621 return false;
5622
5623 },
5624 }
5625 ;
5626 let result: () = this.SetShortAttributeNullable(arg0);
5627
5628 true
5629 })());
5630 result
5631}
5632
5633
5634static shortAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5635
5636pub(crate) fn init_shortAttributeNullable_getterinfo<D: DomTypes>() {
5637 shortAttributeNullable_getterinfo.set(JSJitInfo {
5638 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5639 getter: Some(get_shortAttributeNullable::<D>)
5640 },
5641 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5642 protoID: PrototypeList::ID::TestBinding as u16,
5643 },
5644 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5645 _bitfield_align_1: [],
5646 _bitfield_1: __BindgenBitfieldUnit::new(
5647 new_jsjitinfo_bitfield_1!(
5648 JSJitInfo_OpType::Getter as u8,
5649 JSJitInfo_AliasSet::AliasEverything as u8,
5650 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5651 true,
5652 false,
5653 false,
5654 false,
5655 false,
5656 false,
5657 0,
5658 ).to_ne_bytes()
5659 ),
5660});
5661}
5662static shortAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5663
5664pub(crate) fn init_shortAttributeNullable_setterinfo<D: DomTypes>() {
5665 shortAttributeNullable_setterinfo.set(JSJitInfo {
5666 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5667 setter: Some(set_shortAttributeNullable::<D>)
5668 },
5669 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5670 protoID: PrototypeList::ID::TestBinding as u16,
5671 },
5672 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5673 _bitfield_align_1: [],
5674 _bitfield_1: __BindgenBitfieldUnit::new(
5675 new_jsjitinfo_bitfield_1!(
5676 JSJitInfo_OpType::Setter as u8,
5677 JSJitInfo_AliasSet::AliasEverything as u8,
5678 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5679 false,
5680 false,
5681 false,
5682 false,
5683 false,
5684 false,
5685 0,
5686 ).to_ne_bytes()
5687 ),
5688});
5689}
5690unsafe extern "C" fn get_unsignedShortAttributeNullable<D: DomTypes>
5691(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5692 let mut result = false;
5693 wrap_panic(&mut || result = (|| {
5694 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5695 let this = &*(this as *const D::TestBinding);
5696 let result: Option<u16> = this.GetUnsignedShortAttributeNullable();
5697
5698 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5699 return true;
5700 })());
5701 result
5702}
5703
5704unsafe extern "C" fn set_unsignedShortAttributeNullable<D: DomTypes>
5705(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5706 let mut result = false;
5707 wrap_panic(&mut || result = (|| {
5708 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5709 let this = &*(this as *const D::TestBinding);
5710 let arg0: Option<u16> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5711 Ok(ConversionResult::Success(value)) => value,
5712 Ok(ConversionResult::Failure(error)) => {
5713 throw_type_error(cx.raw_cx(), &error);
5714 return false;
5715
5716 }
5717 _ => {
5718 return false;
5719
5720 },
5721 }
5722 ;
5723 let result: () = this.SetUnsignedShortAttributeNullable(arg0);
5724
5725 true
5726 })());
5727 result
5728}
5729
5730
5731static unsignedShortAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5732
5733pub(crate) fn init_unsignedShortAttributeNullable_getterinfo<D: DomTypes>() {
5734 unsignedShortAttributeNullable_getterinfo.set(JSJitInfo {
5735 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5736 getter: Some(get_unsignedShortAttributeNullable::<D>)
5737 },
5738 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5739 protoID: PrototypeList::ID::TestBinding as u16,
5740 },
5741 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5742 _bitfield_align_1: [],
5743 _bitfield_1: __BindgenBitfieldUnit::new(
5744 new_jsjitinfo_bitfield_1!(
5745 JSJitInfo_OpType::Getter as u8,
5746 JSJitInfo_AliasSet::AliasEverything as u8,
5747 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5748 true,
5749 false,
5750 false,
5751 false,
5752 false,
5753 false,
5754 0,
5755 ).to_ne_bytes()
5756 ),
5757});
5758}
5759static unsignedShortAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5760
5761pub(crate) fn init_unsignedShortAttributeNullable_setterinfo<D: DomTypes>() {
5762 unsignedShortAttributeNullable_setterinfo.set(JSJitInfo {
5763 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5764 setter: Some(set_unsignedShortAttributeNullable::<D>)
5765 },
5766 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5767 protoID: PrototypeList::ID::TestBinding as u16,
5768 },
5769 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5770 _bitfield_align_1: [],
5771 _bitfield_1: __BindgenBitfieldUnit::new(
5772 new_jsjitinfo_bitfield_1!(
5773 JSJitInfo_OpType::Setter as u8,
5774 JSJitInfo_AliasSet::AliasEverything as u8,
5775 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5776 false,
5777 false,
5778 false,
5779 false,
5780 false,
5781 false,
5782 0,
5783 ).to_ne_bytes()
5784 ),
5785});
5786}
5787unsafe extern "C" fn get_longAttributeNullable<D: DomTypes>
5788(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5789 let mut result = false;
5790 wrap_panic(&mut || result = (|| {
5791 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5792 let this = &*(this as *const D::TestBinding);
5793 let result: Option<i32> = this.GetLongAttributeNullable();
5794
5795 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5796 return true;
5797 })());
5798 result
5799}
5800
5801unsafe extern "C" fn set_longAttributeNullable<D: DomTypes>
5802(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5803 let mut result = false;
5804 wrap_panic(&mut || result = (|| {
5805 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5806 let this = &*(this as *const D::TestBinding);
5807 let arg0: Option<i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5808 Ok(ConversionResult::Success(value)) => value,
5809 Ok(ConversionResult::Failure(error)) => {
5810 throw_type_error(cx.raw_cx(), &error);
5811 return false;
5812
5813 }
5814 _ => {
5815 return false;
5816
5817 },
5818 }
5819 ;
5820 let result: () = this.SetLongAttributeNullable(arg0);
5821
5822 true
5823 })());
5824 result
5825}
5826
5827
5828static longAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5829
5830pub(crate) fn init_longAttributeNullable_getterinfo<D: DomTypes>() {
5831 longAttributeNullable_getterinfo.set(JSJitInfo {
5832 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5833 getter: Some(get_longAttributeNullable::<D>)
5834 },
5835 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5836 protoID: PrototypeList::ID::TestBinding as u16,
5837 },
5838 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5839 _bitfield_align_1: [],
5840 _bitfield_1: __BindgenBitfieldUnit::new(
5841 new_jsjitinfo_bitfield_1!(
5842 JSJitInfo_OpType::Getter as u8,
5843 JSJitInfo_AliasSet::AliasEverything as u8,
5844 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5845 true,
5846 false,
5847 false,
5848 false,
5849 false,
5850 false,
5851 0,
5852 ).to_ne_bytes()
5853 ),
5854});
5855}
5856static longAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5857
5858pub(crate) fn init_longAttributeNullable_setterinfo<D: DomTypes>() {
5859 longAttributeNullable_setterinfo.set(JSJitInfo {
5860 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5861 setter: Some(set_longAttributeNullable::<D>)
5862 },
5863 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5864 protoID: PrototypeList::ID::TestBinding as u16,
5865 },
5866 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5867 _bitfield_align_1: [],
5868 _bitfield_1: __BindgenBitfieldUnit::new(
5869 new_jsjitinfo_bitfield_1!(
5870 JSJitInfo_OpType::Setter as u8,
5871 JSJitInfo_AliasSet::AliasEverything as u8,
5872 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5873 false,
5874 false,
5875 false,
5876 false,
5877 false,
5878 false,
5879 0,
5880 ).to_ne_bytes()
5881 ),
5882});
5883}
5884unsafe extern "C" fn get_unsignedLongAttributeNullable<D: DomTypes>
5885(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5886 let mut result = false;
5887 wrap_panic(&mut || result = (|| {
5888 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5889 let this = &*(this as *const D::TestBinding);
5890 let result: Option<u32> = this.GetUnsignedLongAttributeNullable();
5891
5892 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5893 return true;
5894 })());
5895 result
5896}
5897
5898unsafe extern "C" fn set_unsignedLongAttributeNullable<D: DomTypes>
5899(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5900 let mut result = false;
5901 wrap_panic(&mut || result = (|| {
5902 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5903 let this = &*(this as *const D::TestBinding);
5904 let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
5905 Ok(ConversionResult::Success(value)) => value,
5906 Ok(ConversionResult::Failure(error)) => {
5907 throw_type_error(cx.raw_cx(), &error);
5908 return false;
5909
5910 }
5911 _ => {
5912 return false;
5913
5914 },
5915 }
5916 ;
5917 let result: () = this.SetUnsignedLongAttributeNullable(arg0);
5918
5919 true
5920 })());
5921 result
5922}
5923
5924
5925static unsignedLongAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5926
5927pub(crate) fn init_unsignedLongAttributeNullable_getterinfo<D: DomTypes>() {
5928 unsignedLongAttributeNullable_getterinfo.set(JSJitInfo {
5929 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5930 getter: Some(get_unsignedLongAttributeNullable::<D>)
5931 },
5932 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5933 protoID: PrototypeList::ID::TestBinding as u16,
5934 },
5935 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5936 _bitfield_align_1: [],
5937 _bitfield_1: __BindgenBitfieldUnit::new(
5938 new_jsjitinfo_bitfield_1!(
5939 JSJitInfo_OpType::Getter as u8,
5940 JSJitInfo_AliasSet::AliasEverything as u8,
5941 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
5942 true,
5943 false,
5944 false,
5945 false,
5946 false,
5947 false,
5948 0,
5949 ).to_ne_bytes()
5950 ),
5951});
5952}
5953static unsignedLongAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
5954
5955pub(crate) fn init_unsignedLongAttributeNullable_setterinfo<D: DomTypes>() {
5956 unsignedLongAttributeNullable_setterinfo.set(JSJitInfo {
5957 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
5958 setter: Some(set_unsignedLongAttributeNullable::<D>)
5959 },
5960 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
5961 protoID: PrototypeList::ID::TestBinding as u16,
5962 },
5963 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
5964 _bitfield_align_1: [],
5965 _bitfield_1: __BindgenBitfieldUnit::new(
5966 new_jsjitinfo_bitfield_1!(
5967 JSJitInfo_OpType::Setter as u8,
5968 JSJitInfo_AliasSet::AliasEverything as u8,
5969 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
5970 false,
5971 false,
5972 false,
5973 false,
5974 false,
5975 false,
5976 0,
5977 ).to_ne_bytes()
5978 ),
5979});
5980}
5981unsafe extern "C" fn get_longLongAttributeNullable<D: DomTypes>
5982(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
5983 let mut result = false;
5984 wrap_panic(&mut || result = (|| {
5985 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
5986 let this = &*(this as *const D::TestBinding);
5987 let result: Option<i64> = this.GetLongLongAttributeNullable();
5988
5989 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
5990 return true;
5991 })());
5992 result
5993}
5994
5995unsafe extern "C" fn set_longLongAttributeNullable<D: DomTypes>
5996(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
5997 let mut result = false;
5998 wrap_panic(&mut || result = (|| {
5999 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6000 let this = &*(this as *const D::TestBinding);
6001 let arg0: Option<i64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6002 Ok(ConversionResult::Success(value)) => value,
6003 Ok(ConversionResult::Failure(error)) => {
6004 throw_type_error(cx.raw_cx(), &error);
6005 return false;
6006
6007 }
6008 _ => {
6009 return false;
6010
6011 },
6012 }
6013 ;
6014 let result: () = this.SetLongLongAttributeNullable(arg0);
6015
6016 true
6017 })());
6018 result
6019}
6020
6021
6022static longLongAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6023
6024pub(crate) fn init_longLongAttributeNullable_getterinfo<D: DomTypes>() {
6025 longLongAttributeNullable_getterinfo.set(JSJitInfo {
6026 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6027 getter: Some(get_longLongAttributeNullable::<D>)
6028 },
6029 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6030 protoID: PrototypeList::ID::TestBinding as u16,
6031 },
6032 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6033 _bitfield_align_1: [],
6034 _bitfield_1: __BindgenBitfieldUnit::new(
6035 new_jsjitinfo_bitfield_1!(
6036 JSJitInfo_OpType::Getter as u8,
6037 JSJitInfo_AliasSet::AliasEverything as u8,
6038 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6039 true,
6040 false,
6041 false,
6042 false,
6043 false,
6044 false,
6045 0,
6046 ).to_ne_bytes()
6047 ),
6048});
6049}
6050static longLongAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6051
6052pub(crate) fn init_longLongAttributeNullable_setterinfo<D: DomTypes>() {
6053 longLongAttributeNullable_setterinfo.set(JSJitInfo {
6054 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6055 setter: Some(set_longLongAttributeNullable::<D>)
6056 },
6057 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6058 protoID: PrototypeList::ID::TestBinding as u16,
6059 },
6060 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6061 _bitfield_align_1: [],
6062 _bitfield_1: __BindgenBitfieldUnit::new(
6063 new_jsjitinfo_bitfield_1!(
6064 JSJitInfo_OpType::Setter as u8,
6065 JSJitInfo_AliasSet::AliasEverything as u8,
6066 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6067 false,
6068 false,
6069 false,
6070 false,
6071 false,
6072 false,
6073 0,
6074 ).to_ne_bytes()
6075 ),
6076});
6077}
6078unsafe extern "C" fn get_unsignedLongLongAttributeNullable<D: DomTypes>
6079(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6080 let mut result = false;
6081 wrap_panic(&mut || result = (|| {
6082 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6083 let this = &*(this as *const D::TestBinding);
6084 let result: Option<u64> = this.GetUnsignedLongLongAttributeNullable();
6085
6086 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6087 return true;
6088 })());
6089 result
6090}
6091
6092unsafe extern "C" fn set_unsignedLongLongAttributeNullable<D: DomTypes>
6093(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6094 let mut result = false;
6095 wrap_panic(&mut || result = (|| {
6096 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6097 let this = &*(this as *const D::TestBinding);
6098 let arg0: Option<u64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
6099 Ok(ConversionResult::Success(value)) => value,
6100 Ok(ConversionResult::Failure(error)) => {
6101 throw_type_error(cx.raw_cx(), &error);
6102 return false;
6103
6104 }
6105 _ => {
6106 return false;
6107
6108 },
6109 }
6110 ;
6111 let result: () = this.SetUnsignedLongLongAttributeNullable(arg0);
6112
6113 true
6114 })());
6115 result
6116}
6117
6118
6119static unsignedLongLongAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6120
6121pub(crate) fn init_unsignedLongLongAttributeNullable_getterinfo<D: DomTypes>() {
6122 unsignedLongLongAttributeNullable_getterinfo.set(JSJitInfo {
6123 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6124 getter: Some(get_unsignedLongLongAttributeNullable::<D>)
6125 },
6126 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6127 protoID: PrototypeList::ID::TestBinding as u16,
6128 },
6129 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6130 _bitfield_align_1: [],
6131 _bitfield_1: __BindgenBitfieldUnit::new(
6132 new_jsjitinfo_bitfield_1!(
6133 JSJitInfo_OpType::Getter as u8,
6134 JSJitInfo_AliasSet::AliasEverything as u8,
6135 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6136 true,
6137 false,
6138 false,
6139 false,
6140 false,
6141 false,
6142 0,
6143 ).to_ne_bytes()
6144 ),
6145});
6146}
6147static unsignedLongLongAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6148
6149pub(crate) fn init_unsignedLongLongAttributeNullable_setterinfo<D: DomTypes>() {
6150 unsignedLongLongAttributeNullable_setterinfo.set(JSJitInfo {
6151 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6152 setter: Some(set_unsignedLongLongAttributeNullable::<D>)
6153 },
6154 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6155 protoID: PrototypeList::ID::TestBinding as u16,
6156 },
6157 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6158 _bitfield_align_1: [],
6159 _bitfield_1: __BindgenBitfieldUnit::new(
6160 new_jsjitinfo_bitfield_1!(
6161 JSJitInfo_OpType::Setter as u8,
6162 JSJitInfo_AliasSet::AliasEverything as u8,
6163 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6164 false,
6165 false,
6166 false,
6167 false,
6168 false,
6169 false,
6170 0,
6171 ).to_ne_bytes()
6172 ),
6173});
6174}
6175unsafe extern "C" fn get_unrestrictedFloatAttributeNullable<D: DomTypes>
6176(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6177 let mut result = false;
6178 wrap_panic(&mut || result = (|| {
6179 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6180 let this = &*(this as *const D::TestBinding);
6181 let result: Option<f32> = this.GetUnrestrictedFloatAttributeNullable();
6182
6183 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6184 return true;
6185 })());
6186 result
6187}
6188
6189unsafe extern "C" fn set_unrestrictedFloatAttributeNullable<D: DomTypes>
6190(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6191 let mut result = false;
6192 wrap_panic(&mut || result = (|| {
6193 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6194 let this = &*(this as *const D::TestBinding);
6195 let arg0: Option<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6196 Ok(ConversionResult::Success(value)) => value,
6197 Ok(ConversionResult::Failure(error)) => {
6198 throw_type_error(cx.raw_cx(), &error);
6199 return false;
6200
6201 }
6202 _ => {
6203 return false;
6204
6205 },
6206 }
6207 ;
6208 let result: () = this.SetUnrestrictedFloatAttributeNullable(arg0);
6209
6210 true
6211 })());
6212 result
6213}
6214
6215
6216static unrestrictedFloatAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6217
6218pub(crate) fn init_unrestrictedFloatAttributeNullable_getterinfo<D: DomTypes>() {
6219 unrestrictedFloatAttributeNullable_getterinfo.set(JSJitInfo {
6220 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6221 getter: Some(get_unrestrictedFloatAttributeNullable::<D>)
6222 },
6223 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6224 protoID: PrototypeList::ID::TestBinding as u16,
6225 },
6226 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6227 _bitfield_align_1: [],
6228 _bitfield_1: __BindgenBitfieldUnit::new(
6229 new_jsjitinfo_bitfield_1!(
6230 JSJitInfo_OpType::Getter as u8,
6231 JSJitInfo_AliasSet::AliasEverything as u8,
6232 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6233 true,
6234 false,
6235 false,
6236 false,
6237 false,
6238 false,
6239 0,
6240 ).to_ne_bytes()
6241 ),
6242});
6243}
6244static unrestrictedFloatAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6245
6246pub(crate) fn init_unrestrictedFloatAttributeNullable_setterinfo<D: DomTypes>() {
6247 unrestrictedFloatAttributeNullable_setterinfo.set(JSJitInfo {
6248 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6249 setter: Some(set_unrestrictedFloatAttributeNullable::<D>)
6250 },
6251 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6252 protoID: PrototypeList::ID::TestBinding as u16,
6253 },
6254 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6255 _bitfield_align_1: [],
6256 _bitfield_1: __BindgenBitfieldUnit::new(
6257 new_jsjitinfo_bitfield_1!(
6258 JSJitInfo_OpType::Setter as u8,
6259 JSJitInfo_AliasSet::AliasEverything as u8,
6260 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6261 false,
6262 false,
6263 false,
6264 false,
6265 false,
6266 false,
6267 0,
6268 ).to_ne_bytes()
6269 ),
6270});
6271}
6272unsafe extern "C" fn get_floatAttributeNullable<D: DomTypes>
6273(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6274 let mut result = false;
6275 wrap_panic(&mut || result = (|| {
6276 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6277 let this = &*(this as *const D::TestBinding);
6278 let result: Option<Finite<f32>> = this.GetFloatAttributeNullable();
6279
6280 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6281 return true;
6282 })());
6283 result
6284}
6285
6286unsafe extern "C" fn set_floatAttributeNullable<D: DomTypes>
6287(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6288 let mut result = false;
6289 wrap_panic(&mut || result = (|| {
6290 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6291 let this = &*(this as *const D::TestBinding);
6292 let arg0: Option<Finite<f32>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6293 Ok(ConversionResult::Success(value)) => value,
6294 Ok(ConversionResult::Failure(error)) => {
6295 throw_type_error(cx.raw_cx(), &error);
6296 return false;
6297
6298 }
6299 _ => {
6300 return false;
6301
6302 },
6303 }
6304 ;
6305 let result: () = this.SetFloatAttributeNullable(arg0);
6306
6307 true
6308 })());
6309 result
6310}
6311
6312
6313static floatAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6314
6315pub(crate) fn init_floatAttributeNullable_getterinfo<D: DomTypes>() {
6316 floatAttributeNullable_getterinfo.set(JSJitInfo {
6317 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6318 getter: Some(get_floatAttributeNullable::<D>)
6319 },
6320 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6321 protoID: PrototypeList::ID::TestBinding as u16,
6322 },
6323 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6324 _bitfield_align_1: [],
6325 _bitfield_1: __BindgenBitfieldUnit::new(
6326 new_jsjitinfo_bitfield_1!(
6327 JSJitInfo_OpType::Getter as u8,
6328 JSJitInfo_AliasSet::AliasEverything as u8,
6329 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6330 true,
6331 false,
6332 false,
6333 false,
6334 false,
6335 false,
6336 0,
6337 ).to_ne_bytes()
6338 ),
6339});
6340}
6341static floatAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6342
6343pub(crate) fn init_floatAttributeNullable_setterinfo<D: DomTypes>() {
6344 floatAttributeNullable_setterinfo.set(JSJitInfo {
6345 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6346 setter: Some(set_floatAttributeNullable::<D>)
6347 },
6348 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6349 protoID: PrototypeList::ID::TestBinding as u16,
6350 },
6351 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6352 _bitfield_align_1: [],
6353 _bitfield_1: __BindgenBitfieldUnit::new(
6354 new_jsjitinfo_bitfield_1!(
6355 JSJitInfo_OpType::Setter as u8,
6356 JSJitInfo_AliasSet::AliasEverything as u8,
6357 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6358 false,
6359 false,
6360 false,
6361 false,
6362 false,
6363 false,
6364 0,
6365 ).to_ne_bytes()
6366 ),
6367});
6368}
6369unsafe extern "C" fn get_unrestrictedDoubleAttributeNullable<D: DomTypes>
6370(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6371 let mut result = false;
6372 wrap_panic(&mut || result = (|| {
6373 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6374 let this = &*(this as *const D::TestBinding);
6375 let result: Option<f64> = this.GetUnrestrictedDoubleAttributeNullable();
6376
6377 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6378 return true;
6379 })());
6380 result
6381}
6382
6383unsafe extern "C" fn set_unrestrictedDoubleAttributeNullable<D: DomTypes>
6384(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6385 let mut result = false;
6386 wrap_panic(&mut || result = (|| {
6387 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6388 let this = &*(this as *const D::TestBinding);
6389 let arg0: Option<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6390 Ok(ConversionResult::Success(value)) => value,
6391 Ok(ConversionResult::Failure(error)) => {
6392 throw_type_error(cx.raw_cx(), &error);
6393 return false;
6394
6395 }
6396 _ => {
6397 return false;
6398
6399 },
6400 }
6401 ;
6402 let result: () = this.SetUnrestrictedDoubleAttributeNullable(arg0);
6403
6404 true
6405 })());
6406 result
6407}
6408
6409
6410static unrestrictedDoubleAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6411
6412pub(crate) fn init_unrestrictedDoubleAttributeNullable_getterinfo<D: DomTypes>() {
6413 unrestrictedDoubleAttributeNullable_getterinfo.set(JSJitInfo {
6414 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6415 getter: Some(get_unrestrictedDoubleAttributeNullable::<D>)
6416 },
6417 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6418 protoID: PrototypeList::ID::TestBinding as u16,
6419 },
6420 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6421 _bitfield_align_1: [],
6422 _bitfield_1: __BindgenBitfieldUnit::new(
6423 new_jsjitinfo_bitfield_1!(
6424 JSJitInfo_OpType::Getter as u8,
6425 JSJitInfo_AliasSet::AliasEverything as u8,
6426 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6427 true,
6428 false,
6429 false,
6430 false,
6431 false,
6432 false,
6433 0,
6434 ).to_ne_bytes()
6435 ),
6436});
6437}
6438static unrestrictedDoubleAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6439
6440pub(crate) fn init_unrestrictedDoubleAttributeNullable_setterinfo<D: DomTypes>() {
6441 unrestrictedDoubleAttributeNullable_setterinfo.set(JSJitInfo {
6442 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6443 setter: Some(set_unrestrictedDoubleAttributeNullable::<D>)
6444 },
6445 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6446 protoID: PrototypeList::ID::TestBinding as u16,
6447 },
6448 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6449 _bitfield_align_1: [],
6450 _bitfield_1: __BindgenBitfieldUnit::new(
6451 new_jsjitinfo_bitfield_1!(
6452 JSJitInfo_OpType::Setter as u8,
6453 JSJitInfo_AliasSet::AliasEverything as u8,
6454 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6455 false,
6456 false,
6457 false,
6458 false,
6459 false,
6460 false,
6461 0,
6462 ).to_ne_bytes()
6463 ),
6464});
6465}
6466unsafe extern "C" fn get_doubleAttributeNullable<D: DomTypes>
6467(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6468 let mut result = false;
6469 wrap_panic(&mut || result = (|| {
6470 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6471 let this = &*(this as *const D::TestBinding);
6472 let result: Option<Finite<f64>> = this.GetDoubleAttributeNullable();
6473
6474 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6475 return true;
6476 })());
6477 result
6478}
6479
6480unsafe extern "C" fn set_doubleAttributeNullable<D: DomTypes>
6481(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6482 let mut result = false;
6483 wrap_panic(&mut || result = (|| {
6484 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6485 let this = &*(this as *const D::TestBinding);
6486 let arg0: Option<Finite<f64>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6487 Ok(ConversionResult::Success(value)) => value,
6488 Ok(ConversionResult::Failure(error)) => {
6489 throw_type_error(cx.raw_cx(), &error);
6490 return false;
6491
6492 }
6493 _ => {
6494 return false;
6495
6496 },
6497 }
6498 ;
6499 let result: () = this.SetDoubleAttributeNullable(arg0);
6500
6501 true
6502 })());
6503 result
6504}
6505
6506
6507static doubleAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6508
6509pub(crate) fn init_doubleAttributeNullable_getterinfo<D: DomTypes>() {
6510 doubleAttributeNullable_getterinfo.set(JSJitInfo {
6511 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6512 getter: Some(get_doubleAttributeNullable::<D>)
6513 },
6514 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6515 protoID: PrototypeList::ID::TestBinding as u16,
6516 },
6517 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6518 _bitfield_align_1: [],
6519 _bitfield_1: __BindgenBitfieldUnit::new(
6520 new_jsjitinfo_bitfield_1!(
6521 JSJitInfo_OpType::Getter as u8,
6522 JSJitInfo_AliasSet::AliasEverything as u8,
6523 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6524 true,
6525 false,
6526 false,
6527 false,
6528 false,
6529 false,
6530 0,
6531 ).to_ne_bytes()
6532 ),
6533});
6534}
6535static doubleAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6536
6537pub(crate) fn init_doubleAttributeNullable_setterinfo<D: DomTypes>() {
6538 doubleAttributeNullable_setterinfo.set(JSJitInfo {
6539 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6540 setter: Some(set_doubleAttributeNullable::<D>)
6541 },
6542 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6543 protoID: PrototypeList::ID::TestBinding as u16,
6544 },
6545 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6546 _bitfield_align_1: [],
6547 _bitfield_1: __BindgenBitfieldUnit::new(
6548 new_jsjitinfo_bitfield_1!(
6549 JSJitInfo_OpType::Setter as u8,
6550 JSJitInfo_AliasSet::AliasEverything as u8,
6551 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6552 false,
6553 false,
6554 false,
6555 false,
6556 false,
6557 false,
6558 0,
6559 ).to_ne_bytes()
6560 ),
6561});
6562}
6563unsafe extern "C" fn get_stringAttributeNullable<D: DomTypes>
6564(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6565 let mut result = false;
6566 wrap_panic(&mut || result = (|| {
6567 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6568 let this = &*(this as *const D::TestBinding);
6569 let result: Option<DOMString> = this.GetStringAttributeNullable();
6570
6571 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6572 return true;
6573 })());
6574 result
6575}
6576
6577unsafe extern "C" fn set_stringAttributeNullable<D: DomTypes>
6578(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6579 let mut result = false;
6580 wrap_panic(&mut || result = (|| {
6581 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6582 let this = &*(this as *const D::TestBinding);
6583 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
6584 Ok(ConversionResult::Success(value)) => value,
6585 Ok(ConversionResult::Failure(error)) => {
6586 throw_type_error(cx.raw_cx(), &error);
6587 return false;
6588
6589 }
6590 _ => {
6591 return false;
6592
6593 },
6594 }
6595 ;
6596 let result: () = this.SetStringAttributeNullable(arg0);
6597
6598 true
6599 })());
6600 result
6601}
6602
6603
6604static stringAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6605
6606pub(crate) fn init_stringAttributeNullable_getterinfo<D: DomTypes>() {
6607 stringAttributeNullable_getterinfo.set(JSJitInfo {
6608 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6609 getter: Some(get_stringAttributeNullable::<D>)
6610 },
6611 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6612 protoID: PrototypeList::ID::TestBinding as u16,
6613 },
6614 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6615 _bitfield_align_1: [],
6616 _bitfield_1: __BindgenBitfieldUnit::new(
6617 new_jsjitinfo_bitfield_1!(
6618 JSJitInfo_OpType::Getter as u8,
6619 JSJitInfo_AliasSet::AliasEverything as u8,
6620 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6621 true,
6622 false,
6623 false,
6624 false,
6625 false,
6626 false,
6627 0,
6628 ).to_ne_bytes()
6629 ),
6630});
6631}
6632static stringAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6633
6634pub(crate) fn init_stringAttributeNullable_setterinfo<D: DomTypes>() {
6635 stringAttributeNullable_setterinfo.set(JSJitInfo {
6636 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6637 setter: Some(set_stringAttributeNullable::<D>)
6638 },
6639 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6640 protoID: PrototypeList::ID::TestBinding as u16,
6641 },
6642 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6643 _bitfield_align_1: [],
6644 _bitfield_1: __BindgenBitfieldUnit::new(
6645 new_jsjitinfo_bitfield_1!(
6646 JSJitInfo_OpType::Setter as u8,
6647 JSJitInfo_AliasSet::AliasEverything as u8,
6648 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6649 false,
6650 false,
6651 false,
6652 false,
6653 false,
6654 false,
6655 0,
6656 ).to_ne_bytes()
6657 ),
6658});
6659}
6660unsafe extern "C" fn get_usvstringAttributeNullable<D: DomTypes>
6661(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6662 let mut result = false;
6663 wrap_panic(&mut || result = (|| {
6664 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6665 let this = &*(this as *const D::TestBinding);
6666 let result: Option<USVString> = this.GetUsvstringAttributeNullable();
6667
6668 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6669 return true;
6670 })());
6671 result
6672}
6673
6674unsafe extern "C" fn set_usvstringAttributeNullable<D: DomTypes>
6675(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6676 let mut result = false;
6677 wrap_panic(&mut || result = (|| {
6678 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6679 let this = &*(this as *const D::TestBinding);
6680 let arg0: Option<USVString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6681 Ok(ConversionResult::Success(value)) => value,
6682 Ok(ConversionResult::Failure(error)) => {
6683 throw_type_error(cx.raw_cx(), &error);
6684 return false;
6685
6686 }
6687 _ => {
6688 return false;
6689
6690 },
6691 }
6692 ;
6693 let result: () = this.SetUsvstringAttributeNullable(arg0);
6694
6695 true
6696 })());
6697 result
6698}
6699
6700
6701static usvstringAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6702
6703pub(crate) fn init_usvstringAttributeNullable_getterinfo<D: DomTypes>() {
6704 usvstringAttributeNullable_getterinfo.set(JSJitInfo {
6705 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6706 getter: Some(get_usvstringAttributeNullable::<D>)
6707 },
6708 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6709 protoID: PrototypeList::ID::TestBinding as u16,
6710 },
6711 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6712 _bitfield_align_1: [],
6713 _bitfield_1: __BindgenBitfieldUnit::new(
6714 new_jsjitinfo_bitfield_1!(
6715 JSJitInfo_OpType::Getter as u8,
6716 JSJitInfo_AliasSet::AliasEverything as u8,
6717 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6718 true,
6719 false,
6720 false,
6721 false,
6722 false,
6723 false,
6724 0,
6725 ).to_ne_bytes()
6726 ),
6727});
6728}
6729static usvstringAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6730
6731pub(crate) fn init_usvstringAttributeNullable_setterinfo<D: DomTypes>() {
6732 usvstringAttributeNullable_setterinfo.set(JSJitInfo {
6733 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6734 setter: Some(set_usvstringAttributeNullable::<D>)
6735 },
6736 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6737 protoID: PrototypeList::ID::TestBinding as u16,
6738 },
6739 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6740 _bitfield_align_1: [],
6741 _bitfield_1: __BindgenBitfieldUnit::new(
6742 new_jsjitinfo_bitfield_1!(
6743 JSJitInfo_OpType::Setter as u8,
6744 JSJitInfo_AliasSet::AliasEverything as u8,
6745 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6746 false,
6747 false,
6748 false,
6749 false,
6750 false,
6751 false,
6752 0,
6753 ).to_ne_bytes()
6754 ),
6755});
6756}
6757unsafe extern "C" fn get_byteStringAttributeNullable<D: DomTypes>
6758(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6759 let mut result = false;
6760 wrap_panic(&mut || result = (|| {
6761 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6762 let this = &*(this as *const D::TestBinding);
6763 let result: Option<ByteString> = this.GetByteStringAttributeNullable();
6764
6765 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6766 return true;
6767 })());
6768 result
6769}
6770
6771unsafe extern "C" fn set_byteStringAttributeNullable<D: DomTypes>
6772(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6773 let mut result = false;
6774 wrap_panic(&mut || result = (|| {
6775 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6776 let this = &*(this as *const D::TestBinding);
6777 let arg0: Option<ByteString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
6778 Ok(ConversionResult::Success(value)) => value,
6779 Ok(ConversionResult::Failure(error)) => {
6780 throw_type_error(cx.raw_cx(), &error);
6781 return false;
6782
6783 }
6784 _ => {
6785 return false;
6786
6787 },
6788 }
6789 ;
6790 let result: () = this.SetByteStringAttributeNullable(arg0);
6791
6792 true
6793 })());
6794 result
6795}
6796
6797
6798static byteStringAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6799
6800pub(crate) fn init_byteStringAttributeNullable_getterinfo<D: DomTypes>() {
6801 byteStringAttributeNullable_getterinfo.set(JSJitInfo {
6802 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6803 getter: Some(get_byteStringAttributeNullable::<D>)
6804 },
6805 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6806 protoID: PrototypeList::ID::TestBinding as u16,
6807 },
6808 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6809 _bitfield_align_1: [],
6810 _bitfield_1: __BindgenBitfieldUnit::new(
6811 new_jsjitinfo_bitfield_1!(
6812 JSJitInfo_OpType::Getter as u8,
6813 JSJitInfo_AliasSet::AliasEverything as u8,
6814 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6815 true,
6816 false,
6817 false,
6818 false,
6819 false,
6820 false,
6821 0,
6822 ).to_ne_bytes()
6823 ),
6824});
6825}
6826static byteStringAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6827
6828pub(crate) fn init_byteStringAttributeNullable_setterinfo<D: DomTypes>() {
6829 byteStringAttributeNullable_setterinfo.set(JSJitInfo {
6830 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6831 setter: Some(set_byteStringAttributeNullable::<D>)
6832 },
6833 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6834 protoID: PrototypeList::ID::TestBinding as u16,
6835 },
6836 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6837 _bitfield_align_1: [],
6838 _bitfield_1: __BindgenBitfieldUnit::new(
6839 new_jsjitinfo_bitfield_1!(
6840 JSJitInfo_OpType::Setter as u8,
6841 JSJitInfo_AliasSet::AliasEverything as u8,
6842 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6843 false,
6844 false,
6845 false,
6846 false,
6847 false,
6848 false,
6849 0,
6850 ).to_ne_bytes()
6851 ),
6852});
6853}
6854unsafe extern "C" fn get_enumAttributeNullable<D: DomTypes>
6855(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6856 let mut result = false;
6857 wrap_panic(&mut || result = (|| {
6858 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6859 let this = &*(this as *const D::TestBinding);
6860 let result: Option<TestEnum> = this.GetEnumAttributeNullable();
6861
6862 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6863 return true;
6864 })());
6865 result
6866}
6867
6868
6869static enumAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6870
6871pub(crate) fn init_enumAttributeNullable_getterinfo<D: DomTypes>() {
6872 enumAttributeNullable_getterinfo.set(JSJitInfo {
6873 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6874 getter: Some(get_enumAttributeNullable::<D>)
6875 },
6876 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6877 protoID: PrototypeList::ID::TestBinding as u16,
6878 },
6879 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6880 _bitfield_align_1: [],
6881 _bitfield_1: __BindgenBitfieldUnit::new(
6882 new_jsjitinfo_bitfield_1!(
6883 JSJitInfo_OpType::Getter as u8,
6884 JSJitInfo_AliasSet::AliasEverything as u8,
6885 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6886 true,
6887 false,
6888 false,
6889 false,
6890 false,
6891 false,
6892 0,
6893 ).to_ne_bytes()
6894 ),
6895});
6896}
6897unsafe extern "C" fn get_interfaceAttributeNullable<D: DomTypes>
6898(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
6899 let mut result = false;
6900 wrap_panic(&mut || result = (|| {
6901 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6902 let this = &*(this as *const D::TestBinding);
6903 let result: Option<DomRoot<D::Blob>> = this.GetInterfaceAttributeNullable(CanGc::note());
6904
6905 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
6906 return true;
6907 })());
6908 result
6909}
6910
6911unsafe extern "C" fn set_interfaceAttributeNullable<D: DomTypes>
6912(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
6913 let mut result = false;
6914 wrap_panic(&mut || result = (|| {
6915 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
6916 let this = &*(this as *const D::TestBinding);
6917 let arg0: Option<DomRoot<D::Blob>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
6918 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
6919 Ok(val) => val,
6920 Err(()) => {
6921 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
6922 return false;
6923
6924 }
6925 }
6926 )
6927 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
6928 None
6929 } else {
6930 throw_type_error(cx.raw_cx(), "Value is not an object.");
6931 return false;
6932
6933 };
6934 let result: () = this.SetInterfaceAttributeNullable(arg0.as_deref());
6935
6936 true
6937 })());
6938 result
6939}
6940
6941
6942static interfaceAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6943
6944pub(crate) fn init_interfaceAttributeNullable_getterinfo<D: DomTypes>() {
6945 interfaceAttributeNullable_getterinfo.set(JSJitInfo {
6946 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6947 getter: Some(get_interfaceAttributeNullable::<D>)
6948 },
6949 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6950 protoID: PrototypeList::ID::TestBinding as u16,
6951 },
6952 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6953 _bitfield_align_1: [],
6954 _bitfield_1: __BindgenBitfieldUnit::new(
6955 new_jsjitinfo_bitfield_1!(
6956 JSJitInfo_OpType::Getter as u8,
6957 JSJitInfo_AliasSet::AliasEverything as u8,
6958 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
6959 true,
6960 false,
6961 false,
6962 false,
6963 false,
6964 false,
6965 0,
6966 ).to_ne_bytes()
6967 ),
6968});
6969}
6970static interfaceAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
6971
6972pub(crate) fn init_interfaceAttributeNullable_setterinfo<D: DomTypes>() {
6973 interfaceAttributeNullable_setterinfo.set(JSJitInfo {
6974 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
6975 setter: Some(set_interfaceAttributeNullable::<D>)
6976 },
6977 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
6978 protoID: PrototypeList::ID::TestBinding as u16,
6979 },
6980 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
6981 _bitfield_align_1: [],
6982 _bitfield_1: __BindgenBitfieldUnit::new(
6983 new_jsjitinfo_bitfield_1!(
6984 JSJitInfo_OpType::Setter as u8,
6985 JSJitInfo_AliasSet::AliasEverything as u8,
6986 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
6987 false,
6988 false,
6989 false,
6990 false,
6991 false,
6992 false,
6993 0,
6994 ).to_ne_bytes()
6995 ),
6996});
6997}
6998unsafe extern "C" fn get_interfaceAttributeWeak<D: DomTypes>
6999(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7000 let mut result = false;
7001 wrap_panic(&mut || result = (|| {
7002 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7003 let this = &*(this as *const D::TestBinding);
7004 let result: Option<DomRoot<D::URL>> = this.GetInterfaceAttributeWeak();
7005
7006 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7007 return true;
7008 })());
7009 result
7010}
7011
7012unsafe extern "C" fn set_interfaceAttributeWeak<D: DomTypes>
7013(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7014 let mut result = false;
7015 wrap_panic(&mut || result = (|| {
7016 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7017 let this = &*(this as *const D::TestBinding);
7018 let arg0: Option<DomRoot<D::URL>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
7019 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
7020 Ok(val) => val,
7021 Err(()) => {
7022 throw_type_error(cx.raw_cx(), "value does not implement interface URL.");
7023 return false;
7024
7025 }
7026 }
7027 )
7028 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7029 None
7030 } else {
7031 throw_type_error(cx.raw_cx(), "Value is not an object.");
7032 return false;
7033
7034 };
7035 let result: () = this.SetInterfaceAttributeWeak(arg0.as_deref());
7036
7037 true
7038 })());
7039 result
7040}
7041
7042
7043static interfaceAttributeWeak_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7044
7045pub(crate) fn init_interfaceAttributeWeak_getterinfo<D: DomTypes>() {
7046 interfaceAttributeWeak_getterinfo.set(JSJitInfo {
7047 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7048 getter: Some(get_interfaceAttributeWeak::<D>)
7049 },
7050 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7051 protoID: PrototypeList::ID::TestBinding as u16,
7052 },
7053 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7054 _bitfield_align_1: [],
7055 _bitfield_1: __BindgenBitfieldUnit::new(
7056 new_jsjitinfo_bitfield_1!(
7057 JSJitInfo_OpType::Getter as u8,
7058 JSJitInfo_AliasSet::AliasEverything as u8,
7059 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7060 true,
7061 false,
7062 false,
7063 false,
7064 false,
7065 false,
7066 0,
7067 ).to_ne_bytes()
7068 ),
7069});
7070}
7071static interfaceAttributeWeak_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7072
7073pub(crate) fn init_interfaceAttributeWeak_setterinfo<D: DomTypes>() {
7074 interfaceAttributeWeak_setterinfo.set(JSJitInfo {
7075 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7076 setter: Some(set_interfaceAttributeWeak::<D>)
7077 },
7078 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7079 protoID: PrototypeList::ID::TestBinding as u16,
7080 },
7081 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7082 _bitfield_align_1: [],
7083 _bitfield_1: __BindgenBitfieldUnit::new(
7084 new_jsjitinfo_bitfield_1!(
7085 JSJitInfo_OpType::Setter as u8,
7086 JSJitInfo_AliasSet::AliasEverything as u8,
7087 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7088 false,
7089 false,
7090 false,
7091 false,
7092 false,
7093 false,
7094 0,
7095 ).to_ne_bytes()
7096 ),
7097});
7098}
7099unsafe extern "C" fn get_objectAttributeNullable<D: DomTypes>
7100(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7101 let mut result = false;
7102 wrap_panic(&mut || result = (|| {
7103 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7104 let this = &*(this as *const D::TestBinding);
7105 let result: Option<NonNull<JSObject>> = this.GetObjectAttributeNullable(SafeJSContext::from_ptr(cx.raw_cx()));
7106
7107 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7108 return true;
7109 })());
7110 result
7111}
7112
7113unsafe extern "C" fn set_objectAttributeNullable<D: DomTypes>
7114(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7115 let mut result = false;
7116 wrap_panic(&mut || result = (|| {
7117 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7118 let this = &*(this as *const D::TestBinding);
7119 let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
7120 HandleValue::from_raw(args.get(0)).get().to_object()
7121 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
7122 ptr::null_mut()
7123 } else {
7124 throw_type_error(cx.raw_cx(), "Value is not an object.");
7125 return false;
7126
7127 };
7128 let result: () = this.SetObjectAttributeNullable(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
7129
7130 true
7131 })());
7132 result
7133}
7134
7135
7136static objectAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7137
7138pub(crate) fn init_objectAttributeNullable_getterinfo<D: DomTypes>() {
7139 objectAttributeNullable_getterinfo.set(JSJitInfo {
7140 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7141 getter: Some(get_objectAttributeNullable::<D>)
7142 },
7143 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7144 protoID: PrototypeList::ID::TestBinding as u16,
7145 },
7146 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7147 _bitfield_align_1: [],
7148 _bitfield_1: __BindgenBitfieldUnit::new(
7149 new_jsjitinfo_bitfield_1!(
7150 JSJitInfo_OpType::Getter as u8,
7151 JSJitInfo_AliasSet::AliasEverything as u8,
7152 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7153 true,
7154 false,
7155 false,
7156 false,
7157 false,
7158 false,
7159 0,
7160 ).to_ne_bytes()
7161 ),
7162});
7163}
7164static objectAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7165
7166pub(crate) fn init_objectAttributeNullable_setterinfo<D: DomTypes>() {
7167 objectAttributeNullable_setterinfo.set(JSJitInfo {
7168 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7169 setter: Some(set_objectAttributeNullable::<D>)
7170 },
7171 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7172 protoID: PrototypeList::ID::TestBinding as u16,
7173 },
7174 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7175 _bitfield_align_1: [],
7176 _bitfield_1: __BindgenBitfieldUnit::new(
7177 new_jsjitinfo_bitfield_1!(
7178 JSJitInfo_OpType::Setter as u8,
7179 JSJitInfo_AliasSet::AliasEverything as u8,
7180 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7181 false,
7182 false,
7183 false,
7184 false,
7185 false,
7186 false,
7187 0,
7188 ).to_ne_bytes()
7189 ),
7190});
7191}
7192unsafe extern "C" fn get_unionAttributeNullable<D: DomTypes>
7193(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7194 let mut result = false;
7195 wrap_panic(&mut || result = (|| {
7196 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7197 let this = &*(this as *const D::TestBinding);
7198 let result: Option<GenericUnionTypes::HTMLElementOrLong::<D>> = this.GetUnionAttributeNullable();
7199
7200 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7201 return true;
7202 })());
7203 result
7204}
7205
7206unsafe extern "C" fn set_unionAttributeNullable<D: DomTypes>
7207(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7208 let mut result = false;
7209 wrap_panic(&mut || result = (|| {
7210 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7211 let this = &*(this as *const D::TestBinding);
7212 let arg0: Option<GenericUnionTypes::HTMLElementOrLong::<D> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7213 Ok(ConversionResult::Success(value)) => value,
7214 Ok(ConversionResult::Failure(error)) => {
7215 throw_type_error(cx.raw_cx(), &error);
7216 return false;
7217
7218 }
7219 _ => {
7220 return false;
7221
7222 },
7223 }
7224 ;
7225 let result: () = this.SetUnionAttributeNullable(arg0);
7226
7227 true
7228 })());
7229 result
7230}
7231
7232
7233static unionAttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7234
7235pub(crate) fn init_unionAttributeNullable_getterinfo<D: DomTypes>() {
7236 unionAttributeNullable_getterinfo.set(JSJitInfo {
7237 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7238 getter: Some(get_unionAttributeNullable::<D>)
7239 },
7240 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7241 protoID: PrototypeList::ID::TestBinding as u16,
7242 },
7243 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7244 _bitfield_align_1: [],
7245 _bitfield_1: __BindgenBitfieldUnit::new(
7246 new_jsjitinfo_bitfield_1!(
7247 JSJitInfo_OpType::Getter as u8,
7248 JSJitInfo_AliasSet::AliasEverything as u8,
7249 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7250 true,
7251 false,
7252 false,
7253 false,
7254 false,
7255 false,
7256 0,
7257 ).to_ne_bytes()
7258 ),
7259});
7260}
7261static unionAttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7262
7263pub(crate) fn init_unionAttributeNullable_setterinfo<D: DomTypes>() {
7264 unionAttributeNullable_setterinfo.set(JSJitInfo {
7265 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7266 setter: Some(set_unionAttributeNullable::<D>)
7267 },
7268 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7269 protoID: PrototypeList::ID::TestBinding as u16,
7270 },
7271 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7272 _bitfield_align_1: [],
7273 _bitfield_1: __BindgenBitfieldUnit::new(
7274 new_jsjitinfo_bitfield_1!(
7275 JSJitInfo_OpType::Setter as u8,
7276 JSJitInfo_AliasSet::AliasEverything as u8,
7277 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7278 false,
7279 false,
7280 false,
7281 false,
7282 false,
7283 false,
7284 0,
7285 ).to_ne_bytes()
7286 ),
7287});
7288}
7289unsafe extern "C" fn get_union2AttributeNullable<D: DomTypes>
7290(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7291 let mut result = false;
7292 wrap_panic(&mut || result = (|| {
7293 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7294 let this = &*(this as *const D::TestBinding);
7295 let result: Option<GenericUnionTypes::EventOrString::<D>> = this.GetUnion2AttributeNullable();
7296
7297 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7298 return true;
7299 })());
7300 result
7301}
7302
7303unsafe extern "C" fn set_union2AttributeNullable<D: DomTypes>
7304(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7305 let mut result = false;
7306 wrap_panic(&mut || result = (|| {
7307 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7308 let this = &*(this as *const D::TestBinding);
7309 let arg0: Option<GenericUnionTypes::EventOrString::<D> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7310 Ok(ConversionResult::Success(value)) => value,
7311 Ok(ConversionResult::Failure(error)) => {
7312 throw_type_error(cx.raw_cx(), &error);
7313 return false;
7314
7315 }
7316 _ => {
7317 return false;
7318
7319 },
7320 }
7321 ;
7322 let result: () = this.SetUnion2AttributeNullable(arg0);
7323
7324 true
7325 })());
7326 result
7327}
7328
7329
7330static union2AttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7331
7332pub(crate) fn init_union2AttributeNullable_getterinfo<D: DomTypes>() {
7333 union2AttributeNullable_getterinfo.set(JSJitInfo {
7334 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7335 getter: Some(get_union2AttributeNullable::<D>)
7336 },
7337 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7338 protoID: PrototypeList::ID::TestBinding as u16,
7339 },
7340 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7341 _bitfield_align_1: [],
7342 _bitfield_1: __BindgenBitfieldUnit::new(
7343 new_jsjitinfo_bitfield_1!(
7344 JSJitInfo_OpType::Getter as u8,
7345 JSJitInfo_AliasSet::AliasEverything as u8,
7346 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7347 true,
7348 false,
7349 false,
7350 false,
7351 false,
7352 false,
7353 0,
7354 ).to_ne_bytes()
7355 ),
7356});
7357}
7358static union2AttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7359
7360pub(crate) fn init_union2AttributeNullable_setterinfo<D: DomTypes>() {
7361 union2AttributeNullable_setterinfo.set(JSJitInfo {
7362 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7363 setter: Some(set_union2AttributeNullable::<D>)
7364 },
7365 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7366 protoID: PrototypeList::ID::TestBinding as u16,
7367 },
7368 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7369 _bitfield_align_1: [],
7370 _bitfield_1: __BindgenBitfieldUnit::new(
7371 new_jsjitinfo_bitfield_1!(
7372 JSJitInfo_OpType::Setter as u8,
7373 JSJitInfo_AliasSet::AliasEverything as u8,
7374 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7375 false,
7376 false,
7377 false,
7378 false,
7379 false,
7380 false,
7381 0,
7382 ).to_ne_bytes()
7383 ),
7384});
7385}
7386unsafe extern "C" fn get_union3AttributeNullable<D: DomTypes>
7387(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7388 let mut result = false;
7389 wrap_panic(&mut || result = (|| {
7390 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7391 let this = &*(this as *const D::TestBinding);
7392 let result: Option<GenericUnionTypes::BlobOrBoolean::<D>> = this.GetUnion3AttributeNullable();
7393
7394 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7395 return true;
7396 })());
7397 result
7398}
7399
7400unsafe extern "C" fn set_union3AttributeNullable<D: DomTypes>
7401(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7402 let mut result = false;
7403 wrap_panic(&mut || result = (|| {
7404 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7405 let this = &*(this as *const D::TestBinding);
7406 let arg0: Option<GenericUnionTypes::BlobOrBoolean::<D> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7407 Ok(ConversionResult::Success(value)) => value,
7408 Ok(ConversionResult::Failure(error)) => {
7409 throw_type_error(cx.raw_cx(), &error);
7410 return false;
7411
7412 }
7413 _ => {
7414 return false;
7415
7416 },
7417 }
7418 ;
7419 let result: () = this.SetUnion3AttributeNullable(arg0);
7420
7421 true
7422 })());
7423 result
7424}
7425
7426
7427static union3AttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7428
7429pub(crate) fn init_union3AttributeNullable_getterinfo<D: DomTypes>() {
7430 union3AttributeNullable_getterinfo.set(JSJitInfo {
7431 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7432 getter: Some(get_union3AttributeNullable::<D>)
7433 },
7434 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7435 protoID: PrototypeList::ID::TestBinding as u16,
7436 },
7437 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7438 _bitfield_align_1: [],
7439 _bitfield_1: __BindgenBitfieldUnit::new(
7440 new_jsjitinfo_bitfield_1!(
7441 JSJitInfo_OpType::Getter as u8,
7442 JSJitInfo_AliasSet::AliasEverything as u8,
7443 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7444 true,
7445 false,
7446 false,
7447 false,
7448 false,
7449 false,
7450 0,
7451 ).to_ne_bytes()
7452 ),
7453});
7454}
7455static union3AttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7456
7457pub(crate) fn init_union3AttributeNullable_setterinfo<D: DomTypes>() {
7458 union3AttributeNullable_setterinfo.set(JSJitInfo {
7459 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7460 setter: Some(set_union3AttributeNullable::<D>)
7461 },
7462 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7463 protoID: PrototypeList::ID::TestBinding as u16,
7464 },
7465 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7466 _bitfield_align_1: [],
7467 _bitfield_1: __BindgenBitfieldUnit::new(
7468 new_jsjitinfo_bitfield_1!(
7469 JSJitInfo_OpType::Setter as u8,
7470 JSJitInfo_AliasSet::AliasEverything as u8,
7471 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7472 false,
7473 false,
7474 false,
7475 false,
7476 false,
7477 false,
7478 0,
7479 ).to_ne_bytes()
7480 ),
7481});
7482}
7483unsafe extern "C" fn get_union4AttributeNullable<D: DomTypes>
7484(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7485 let mut result = false;
7486 wrap_panic(&mut || result = (|| {
7487 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7488 let this = &*(this as *const D::TestBinding);
7489 let result: Option<GenericUnionTypes::UnsignedLongOrBoolean> = this.GetUnion4AttributeNullable();
7490
7491 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7492 return true;
7493 })());
7494 result
7495}
7496
7497unsafe extern "C" fn set_union4AttributeNullable<D: DomTypes>
7498(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7499 let mut result = false;
7500 wrap_panic(&mut || result = (|| {
7501 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7502 let this = &*(this as *const D::TestBinding);
7503 let arg0: Option<GenericUnionTypes::UnsignedLongOrBoolean > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7504 Ok(ConversionResult::Success(value)) => value,
7505 Ok(ConversionResult::Failure(error)) => {
7506 throw_type_error(cx.raw_cx(), &error);
7507 return false;
7508
7509 }
7510 _ => {
7511 return false;
7512
7513 },
7514 }
7515 ;
7516 let result: () = this.SetUnion4AttributeNullable(arg0);
7517
7518 true
7519 })());
7520 result
7521}
7522
7523
7524static union4AttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7525
7526pub(crate) fn init_union4AttributeNullable_getterinfo<D: DomTypes>() {
7527 union4AttributeNullable_getterinfo.set(JSJitInfo {
7528 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7529 getter: Some(get_union4AttributeNullable::<D>)
7530 },
7531 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7532 protoID: PrototypeList::ID::TestBinding as u16,
7533 },
7534 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7535 _bitfield_align_1: [],
7536 _bitfield_1: __BindgenBitfieldUnit::new(
7537 new_jsjitinfo_bitfield_1!(
7538 JSJitInfo_OpType::Getter as u8,
7539 JSJitInfo_AliasSet::AliasEverything as u8,
7540 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7541 true,
7542 false,
7543 false,
7544 false,
7545 false,
7546 false,
7547 0,
7548 ).to_ne_bytes()
7549 ),
7550});
7551}
7552static union4AttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7553
7554pub(crate) fn init_union4AttributeNullable_setterinfo<D: DomTypes>() {
7555 union4AttributeNullable_setterinfo.set(JSJitInfo {
7556 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7557 setter: Some(set_union4AttributeNullable::<D>)
7558 },
7559 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7560 protoID: PrototypeList::ID::TestBinding as u16,
7561 },
7562 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7563 _bitfield_align_1: [],
7564 _bitfield_1: __BindgenBitfieldUnit::new(
7565 new_jsjitinfo_bitfield_1!(
7566 JSJitInfo_OpType::Setter as u8,
7567 JSJitInfo_AliasSet::AliasEverything as u8,
7568 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7569 false,
7570 false,
7571 false,
7572 false,
7573 false,
7574 false,
7575 0,
7576 ).to_ne_bytes()
7577 ),
7578});
7579}
7580unsafe extern "C" fn get_union5AttributeNullable<D: DomTypes>
7581(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7582 let mut result = false;
7583 wrap_panic(&mut || result = (|| {
7584 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7585 let this = &*(this as *const D::TestBinding);
7586 let result: Option<GenericUnionTypes::StringOrBoolean> = this.GetUnion5AttributeNullable();
7587
7588 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7589 return true;
7590 })());
7591 result
7592}
7593
7594unsafe extern "C" fn set_union5AttributeNullable<D: DomTypes>
7595(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7596 let mut result = false;
7597 wrap_panic(&mut || result = (|| {
7598 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7599 let this = &*(this as *const D::TestBinding);
7600 let arg0: Option<GenericUnionTypes::StringOrBoolean > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7601 Ok(ConversionResult::Success(value)) => value,
7602 Ok(ConversionResult::Failure(error)) => {
7603 throw_type_error(cx.raw_cx(), &error);
7604 return false;
7605
7606 }
7607 _ => {
7608 return false;
7609
7610 },
7611 }
7612 ;
7613 let result: () = this.SetUnion5AttributeNullable(arg0);
7614
7615 true
7616 })());
7617 result
7618}
7619
7620
7621static union5AttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7622
7623pub(crate) fn init_union5AttributeNullable_getterinfo<D: DomTypes>() {
7624 union5AttributeNullable_getterinfo.set(JSJitInfo {
7625 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7626 getter: Some(get_union5AttributeNullable::<D>)
7627 },
7628 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7629 protoID: PrototypeList::ID::TestBinding as u16,
7630 },
7631 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7632 _bitfield_align_1: [],
7633 _bitfield_1: __BindgenBitfieldUnit::new(
7634 new_jsjitinfo_bitfield_1!(
7635 JSJitInfo_OpType::Getter as u8,
7636 JSJitInfo_AliasSet::AliasEverything as u8,
7637 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7638 true,
7639 false,
7640 false,
7641 false,
7642 false,
7643 false,
7644 0,
7645 ).to_ne_bytes()
7646 ),
7647});
7648}
7649static union5AttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7650
7651pub(crate) fn init_union5AttributeNullable_setterinfo<D: DomTypes>() {
7652 union5AttributeNullable_setterinfo.set(JSJitInfo {
7653 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7654 setter: Some(set_union5AttributeNullable::<D>)
7655 },
7656 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7657 protoID: PrototypeList::ID::TestBinding as u16,
7658 },
7659 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7660 _bitfield_align_1: [],
7661 _bitfield_1: __BindgenBitfieldUnit::new(
7662 new_jsjitinfo_bitfield_1!(
7663 JSJitInfo_OpType::Setter as u8,
7664 JSJitInfo_AliasSet::AliasEverything as u8,
7665 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7666 false,
7667 false,
7668 false,
7669 false,
7670 false,
7671 false,
7672 0,
7673 ).to_ne_bytes()
7674 ),
7675});
7676}
7677unsafe extern "C" fn get_union6AttributeNullable<D: DomTypes>
7678(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7679 let mut result = false;
7680 wrap_panic(&mut || result = (|| {
7681 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7682 let this = &*(this as *const D::TestBinding);
7683 let result: Option<GenericUnionTypes::ByteStringOrLong> = this.GetUnion6AttributeNullable();
7684
7685 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7686 return true;
7687 })());
7688 result
7689}
7690
7691unsafe extern "C" fn set_union6AttributeNullable<D: DomTypes>
7692(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7693 let mut result = false;
7694 wrap_panic(&mut || result = (|| {
7695 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7696 let this = &*(this as *const D::TestBinding);
7697 let arg0: Option<GenericUnionTypes::ByteStringOrLong > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
7698 Ok(ConversionResult::Success(value)) => value,
7699 Ok(ConversionResult::Failure(error)) => {
7700 throw_type_error(cx.raw_cx(), &error);
7701 return false;
7702
7703 }
7704 _ => {
7705 return false;
7706
7707 },
7708 }
7709 ;
7710 let result: () = this.SetUnion6AttributeNullable(arg0);
7711
7712 true
7713 })());
7714 result
7715}
7716
7717
7718static union6AttributeNullable_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7719
7720pub(crate) fn init_union6AttributeNullable_getterinfo<D: DomTypes>() {
7721 union6AttributeNullable_getterinfo.set(JSJitInfo {
7722 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7723 getter: Some(get_union6AttributeNullable::<D>)
7724 },
7725 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7726 protoID: PrototypeList::ID::TestBinding as u16,
7727 },
7728 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7729 _bitfield_align_1: [],
7730 _bitfield_1: __BindgenBitfieldUnit::new(
7731 new_jsjitinfo_bitfield_1!(
7732 JSJitInfo_OpType::Getter as u8,
7733 JSJitInfo_AliasSet::AliasEverything as u8,
7734 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
7735 true,
7736 false,
7737 false,
7738 false,
7739 false,
7740 false,
7741 0,
7742 ).to_ne_bytes()
7743 ),
7744});
7745}
7746static union6AttributeNullable_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7747
7748pub(crate) fn init_union6AttributeNullable_setterinfo<D: DomTypes>() {
7749 union6AttributeNullable_setterinfo.set(JSJitInfo {
7750 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7751 setter: Some(set_union6AttributeNullable::<D>)
7752 },
7753 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7754 protoID: PrototypeList::ID::TestBinding as u16,
7755 },
7756 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7757 _bitfield_align_1: [],
7758 _bitfield_1: __BindgenBitfieldUnit::new(
7759 new_jsjitinfo_bitfield_1!(
7760 JSJitInfo_OpType::Setter as u8,
7761 JSJitInfo_AliasSet::AliasEverything as u8,
7762 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7763 false,
7764 false,
7765 false,
7766 false,
7767 false,
7768 false,
7769 0,
7770 ).to_ne_bytes()
7771 ),
7772});
7773}
7774unsafe extern "C" fn get_attrToBinaryRename<D: DomTypes>
7775(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7776 let mut result = false;
7777 wrap_panic(&mut || result = (|| {
7778 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7779 let this = &*(this as *const D::TestBinding);
7780 let result: DOMString = this.BinaryRenamedAttribute();
7781
7782 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7783 return true;
7784 })());
7785 result
7786}
7787
7788unsafe extern "C" fn set_attrToBinaryRename<D: DomTypes>
7789(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7790 let mut result = false;
7791 wrap_panic(&mut || result = (|| {
7792 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7793 let this = &*(this as *const D::TestBinding);
7794 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
7795 Ok(ConversionResult::Success(value)) => value,
7796 Ok(ConversionResult::Failure(error)) => {
7797 throw_type_error(cx.raw_cx(), &error);
7798 return false;
7799
7800 }
7801 _ => {
7802 return false;
7803
7804 },
7805 }
7806 ;
7807 let result: () = this.SetBinaryRenamedAttribute(arg0);
7808
7809 true
7810 })());
7811 result
7812}
7813
7814
7815static attrToBinaryRename_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7816
7817pub(crate) fn init_attrToBinaryRename_getterinfo<D: DomTypes>() {
7818 attrToBinaryRename_getterinfo.set(JSJitInfo {
7819 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7820 getter: Some(get_attrToBinaryRename::<D>)
7821 },
7822 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7823 protoID: PrototypeList::ID::TestBinding as u16,
7824 },
7825 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7826 _bitfield_align_1: [],
7827 _bitfield_1: __BindgenBitfieldUnit::new(
7828 new_jsjitinfo_bitfield_1!(
7829 JSJitInfo_OpType::Getter as u8,
7830 JSJitInfo_AliasSet::AliasEverything as u8,
7831 JSValueType::JSVAL_TYPE_STRING as u8,
7832 true,
7833 false,
7834 false,
7835 false,
7836 false,
7837 false,
7838 0,
7839 ).to_ne_bytes()
7840 ),
7841});
7842}
7843static attrToBinaryRename_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7844
7845pub(crate) fn init_attrToBinaryRename_setterinfo<D: DomTypes>() {
7846 attrToBinaryRename_setterinfo.set(JSJitInfo {
7847 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7848 setter: Some(set_attrToBinaryRename::<D>)
7849 },
7850 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7851 protoID: PrototypeList::ID::TestBinding as u16,
7852 },
7853 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7854 _bitfield_align_1: [],
7855 _bitfield_1: __BindgenBitfieldUnit::new(
7856 new_jsjitinfo_bitfield_1!(
7857 JSJitInfo_OpType::Setter as u8,
7858 JSJitInfo_AliasSet::AliasEverything as u8,
7859 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7860 false,
7861 false,
7862 false,
7863 false,
7864 false,
7865 false,
7866 0,
7867 ).to_ne_bytes()
7868 ),
7869});
7870}
7871unsafe extern "C" fn get_attr_to_binary_rename<D: DomTypes>
7872(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7873 let mut result = false;
7874 wrap_panic(&mut || result = (|| {
7875 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7876 let this = &*(this as *const D::TestBinding);
7877 let result: DOMString = this.BinaryRenamedAttribute2();
7878
7879 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7880 return true;
7881 })());
7882 result
7883}
7884
7885unsafe extern "C" fn set_attr_to_binary_rename<D: DomTypes>
7886(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7887 let mut result = false;
7888 wrap_panic(&mut || result = (|| {
7889 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7890 let this = &*(this as *const D::TestBinding);
7891 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
7892 Ok(ConversionResult::Success(value)) => value,
7893 Ok(ConversionResult::Failure(error)) => {
7894 throw_type_error(cx.raw_cx(), &error);
7895 return false;
7896
7897 }
7898 _ => {
7899 return false;
7900
7901 },
7902 }
7903 ;
7904 let result: () = this.SetBinaryRenamedAttribute2(arg0);
7905
7906 true
7907 })());
7908 result
7909}
7910
7911
7912static attr_to_binary_rename_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7913
7914pub(crate) fn init_attr_to_binary_rename_getterinfo<D: DomTypes>() {
7915 attr_to_binary_rename_getterinfo.set(JSJitInfo {
7916 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7917 getter: Some(get_attr_to_binary_rename::<D>)
7918 },
7919 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7920 protoID: PrototypeList::ID::TestBinding as u16,
7921 },
7922 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7923 _bitfield_align_1: [],
7924 _bitfield_1: __BindgenBitfieldUnit::new(
7925 new_jsjitinfo_bitfield_1!(
7926 JSJitInfo_OpType::Getter as u8,
7927 JSJitInfo_AliasSet::AliasEverything as u8,
7928 JSValueType::JSVAL_TYPE_STRING as u8,
7929 true,
7930 false,
7931 false,
7932 false,
7933 false,
7934 false,
7935 0,
7936 ).to_ne_bytes()
7937 ),
7938});
7939}
7940static attr_to_binary_rename_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
7941
7942pub(crate) fn init_attr_to_binary_rename_setterinfo<D: DomTypes>() {
7943 attr_to_binary_rename_setterinfo.set(JSJitInfo {
7944 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
7945 setter: Some(set_attr_to_binary_rename::<D>)
7946 },
7947 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
7948 protoID: PrototypeList::ID::TestBinding as u16,
7949 },
7950 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
7951 _bitfield_align_1: [],
7952 _bitfield_1: __BindgenBitfieldUnit::new(
7953 new_jsjitinfo_bitfield_1!(
7954 JSJitInfo_OpType::Setter as u8,
7955 JSJitInfo_AliasSet::AliasEverything as u8,
7956 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
7957 false,
7958 false,
7959 false,
7960 false,
7961 false,
7962 false,
7963 0,
7964 ).to_ne_bytes()
7965 ),
7966});
7967}
7968unsafe extern "C" fn get_attr_to_automatically_rename<D: DomTypes>
7969(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
7970 let mut result = false;
7971 wrap_panic(&mut || result = (|| {
7972 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7973 let this = &*(this as *const D::TestBinding);
7974 let result: DOMString = this.Attr_to_automatically_rename();
7975
7976 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
7977 return true;
7978 })());
7979 result
7980}
7981
7982unsafe extern "C" fn set_attr_to_automatically_rename<D: DomTypes>
7983(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
7984 let mut result = false;
7985 wrap_panic(&mut || result = (|| {
7986 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
7987 let this = &*(this as *const D::TestBinding);
7988 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
7989 Ok(ConversionResult::Success(value)) => value,
7990 Ok(ConversionResult::Failure(error)) => {
7991 throw_type_error(cx.raw_cx(), &error);
7992 return false;
7993
7994 }
7995 _ => {
7996 return false;
7997
7998 },
7999 }
8000 ;
8001 let result: () = this.SetAttr_to_automatically_rename(arg0);
8002
8003 true
8004 })());
8005 result
8006}
8007
8008
8009static attr_to_automatically_rename_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8010
8011pub(crate) fn init_attr_to_automatically_rename_getterinfo<D: DomTypes>() {
8012 attr_to_automatically_rename_getterinfo.set(JSJitInfo {
8013 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8014 getter: Some(get_attr_to_automatically_rename::<D>)
8015 },
8016 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8017 protoID: PrototypeList::ID::TestBinding as u16,
8018 },
8019 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8020 _bitfield_align_1: [],
8021 _bitfield_1: __BindgenBitfieldUnit::new(
8022 new_jsjitinfo_bitfield_1!(
8023 JSJitInfo_OpType::Getter as u8,
8024 JSJitInfo_AliasSet::AliasEverything as u8,
8025 JSValueType::JSVAL_TYPE_STRING as u8,
8026 true,
8027 false,
8028 false,
8029 false,
8030 false,
8031 false,
8032 0,
8033 ).to_ne_bytes()
8034 ),
8035});
8036}
8037static attr_to_automatically_rename_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8038
8039pub(crate) fn init_attr_to_automatically_rename_setterinfo<D: DomTypes>() {
8040 attr_to_automatically_rename_setterinfo.set(JSJitInfo {
8041 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8042 setter: Some(set_attr_to_automatically_rename::<D>)
8043 },
8044 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8045 protoID: PrototypeList::ID::TestBinding as u16,
8046 },
8047 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8048 _bitfield_align_1: [],
8049 _bitfield_1: __BindgenBitfieldUnit::new(
8050 new_jsjitinfo_bitfield_1!(
8051 JSJitInfo_OpType::Setter as u8,
8052 JSJitInfo_AliasSet::AliasEverything as u8,
8053 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8054 false,
8055 false,
8056 false,
8057 false,
8058 false,
8059 false,
8060 0,
8061 ).to_ne_bytes()
8062 ),
8063});
8064}
8065unsafe extern "C" fn get_forwardedAttribute<D: DomTypes>
8066(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
8067 let mut result = false;
8068 wrap_panic(&mut || result = (|| {
8069 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8070 let this = &*(this as *const D::TestBinding);
8071 let result: DomRoot<D::TestBinding> = this.ForwardedAttribute();
8072
8073 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8074 return true;
8075 })());
8076 result
8077}
8078
8079unsafe extern "C" fn set_forwardedAttribute<D: DomTypes>
8080(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
8081 let mut result = false;
8082 wrap_panic(&mut || result = (|| {
8083
8084 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8085 rooted!(&in(cx) let mut v = UndefinedValue());
8086 if !JS_GetProperty(cx.raw_cx(), HandleObject::from_raw(obj), c"forwardedAttribute".as_ptr(), v.handle_mut()) {
8087 return false;
8088 }
8089 if !v.is_object() {
8090 throw_type_error(cx.raw_cx(), "Value.forwardedAttribute is not an object.");
8091 return false;
8092 }
8093 rooted!(&in(cx) let target_obj = v.to_object());
8094 JS_SetProperty(cx.raw_cx(), target_obj.handle(), c"booleanAttribute".as_ptr(), HandleValue::from_raw(args.get(0)))
8095
8096 })());
8097 result
8098}
8099
8100
8101static forwardedAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8102
8103pub(crate) fn init_forwardedAttribute_getterinfo<D: DomTypes>() {
8104 forwardedAttribute_getterinfo.set(JSJitInfo {
8105 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8106 getter: Some(get_forwardedAttribute::<D>)
8107 },
8108 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8109 protoID: PrototypeList::ID::TestBinding as u16,
8110 },
8111 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8112 _bitfield_align_1: [],
8113 _bitfield_1: __BindgenBitfieldUnit::new(
8114 new_jsjitinfo_bitfield_1!(
8115 JSJitInfo_OpType::Getter as u8,
8116 JSJitInfo_AliasSet::AliasEverything as u8,
8117 JSValueType::JSVAL_TYPE_OBJECT as u8,
8118 true,
8119 false,
8120 false,
8121 false,
8122 false,
8123 false,
8124 0,
8125 ).to_ne_bytes()
8126 ),
8127});
8128}
8129static forwardedAttribute_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8130
8131pub(crate) fn init_forwardedAttribute_setterinfo<D: DomTypes>() {
8132 forwardedAttribute_setterinfo.set(JSJitInfo {
8133 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8134 setter: Some(set_forwardedAttribute::<D>)
8135 },
8136 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8137 protoID: PrototypeList::ID::TestBinding as u16,
8138 },
8139 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8140 _bitfield_align_1: [],
8141 _bitfield_1: __BindgenBitfieldUnit::new(
8142 new_jsjitinfo_bitfield_1!(
8143 JSJitInfo_OpType::Setter as u8,
8144 JSJitInfo_AliasSet::AliasEverything as u8,
8145 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8146 false,
8147 false,
8148 false,
8149 false,
8150 false,
8151 false,
8152 0,
8153 ).to_ne_bytes()
8154 ),
8155});
8156}
8157unsafe extern "C" fn methToBinaryRename<D: DomTypes>
8158(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8159 let mut result = false;
8160 wrap_panic(&mut || result = (|| {
8161 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8162 let this = &*(this as *const D::TestBinding);
8163 let args = &*args;
8164 let argc = args.argc_;
8165 let result: () = this.BinaryRenamedMethod();
8166
8167 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8168 return true;
8169 })());
8170 result
8171}
8172
8173
8174static methToBinaryRename_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8175
8176pub(crate) fn init_methToBinaryRename_methodinfo<D: DomTypes>() {
8177 methToBinaryRename_methodinfo.set(JSJitInfo {
8178 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8179 method: Some(methToBinaryRename::<D>)
8180 },
8181 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8182 protoID: PrototypeList::ID::TestBinding as u16,
8183 },
8184 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8185 _bitfield_align_1: [],
8186 _bitfield_1: __BindgenBitfieldUnit::new(
8187 new_jsjitinfo_bitfield_1!(
8188 JSJitInfo_OpType::Method as u8,
8189 JSJitInfo_AliasSet::AliasEverything as u8,
8190 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8191 true,
8192 false,
8193 false,
8194 false,
8195 false,
8196 false,
8197 0,
8198 ).to_ne_bytes()
8199 ),
8200});
8201}
8202unsafe extern "C" fn receiveVoid<D: DomTypes>
8203(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8204 let mut result = false;
8205 wrap_panic(&mut || result = (|| {
8206 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8207 let this = &*(this as *const D::TestBinding);
8208 let args = &*args;
8209 let argc = args.argc_;
8210 let result: () = this.ReceiveVoid();
8211
8212 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8213 return true;
8214 })());
8215 result
8216}
8217
8218
8219static receiveVoid_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8220
8221pub(crate) fn init_receiveVoid_methodinfo<D: DomTypes>() {
8222 receiveVoid_methodinfo.set(JSJitInfo {
8223 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8224 method: Some(receiveVoid::<D>)
8225 },
8226 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8227 protoID: PrototypeList::ID::TestBinding as u16,
8228 },
8229 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8230 _bitfield_align_1: [],
8231 _bitfield_1: __BindgenBitfieldUnit::new(
8232 new_jsjitinfo_bitfield_1!(
8233 JSJitInfo_OpType::Method as u8,
8234 JSJitInfo_AliasSet::AliasEverything as u8,
8235 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
8236 true,
8237 false,
8238 false,
8239 false,
8240 false,
8241 false,
8242 0,
8243 ).to_ne_bytes()
8244 ),
8245});
8246}
8247unsafe extern "C" fn receiveBoolean<D: DomTypes>
8248(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8249 let mut result = false;
8250 wrap_panic(&mut || result = (|| {
8251 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8252 let this = &*(this as *const D::TestBinding);
8253 let args = &*args;
8254 let argc = args.argc_;
8255 let result: bool = this.ReceiveBoolean();
8256
8257 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8258 return true;
8259 })());
8260 result
8261}
8262
8263
8264static receiveBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8265
8266pub(crate) fn init_receiveBoolean_methodinfo<D: DomTypes>() {
8267 receiveBoolean_methodinfo.set(JSJitInfo {
8268 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8269 method: Some(receiveBoolean::<D>)
8270 },
8271 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8272 protoID: PrototypeList::ID::TestBinding as u16,
8273 },
8274 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8275 _bitfield_align_1: [],
8276 _bitfield_1: __BindgenBitfieldUnit::new(
8277 new_jsjitinfo_bitfield_1!(
8278 JSJitInfo_OpType::Method as u8,
8279 JSJitInfo_AliasSet::AliasEverything as u8,
8280 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
8281 true,
8282 false,
8283 false,
8284 false,
8285 false,
8286 false,
8287 0,
8288 ).to_ne_bytes()
8289 ),
8290});
8291}
8292unsafe extern "C" fn receiveByte<D: DomTypes>
8293(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8294 let mut result = false;
8295 wrap_panic(&mut || result = (|| {
8296 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8297 let this = &*(this as *const D::TestBinding);
8298 let args = &*args;
8299 let argc = args.argc_;
8300 let result: i8 = this.ReceiveByte();
8301
8302 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8303 return true;
8304 })());
8305 result
8306}
8307
8308
8309static receiveByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8310
8311pub(crate) fn init_receiveByte_methodinfo<D: DomTypes>() {
8312 receiveByte_methodinfo.set(JSJitInfo {
8313 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8314 method: Some(receiveByte::<D>)
8315 },
8316 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8317 protoID: PrototypeList::ID::TestBinding as u16,
8318 },
8319 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8320 _bitfield_align_1: [],
8321 _bitfield_1: __BindgenBitfieldUnit::new(
8322 new_jsjitinfo_bitfield_1!(
8323 JSJitInfo_OpType::Method as u8,
8324 JSJitInfo_AliasSet::AliasEverything as u8,
8325 JSValueType::JSVAL_TYPE_INT32 as u8,
8326 true,
8327 false,
8328 false,
8329 false,
8330 false,
8331 false,
8332 0,
8333 ).to_ne_bytes()
8334 ),
8335});
8336}
8337unsafe extern "C" fn receiveOctet<D: DomTypes>
8338(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8339 let mut result = false;
8340 wrap_panic(&mut || result = (|| {
8341 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8342 let this = &*(this as *const D::TestBinding);
8343 let args = &*args;
8344 let argc = args.argc_;
8345 let result: u8 = this.ReceiveOctet();
8346
8347 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8348 return true;
8349 })());
8350 result
8351}
8352
8353
8354static receiveOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8355
8356pub(crate) fn init_receiveOctet_methodinfo<D: DomTypes>() {
8357 receiveOctet_methodinfo.set(JSJitInfo {
8358 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8359 method: Some(receiveOctet::<D>)
8360 },
8361 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8362 protoID: PrototypeList::ID::TestBinding as u16,
8363 },
8364 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8365 _bitfield_align_1: [],
8366 _bitfield_1: __BindgenBitfieldUnit::new(
8367 new_jsjitinfo_bitfield_1!(
8368 JSJitInfo_OpType::Method as u8,
8369 JSJitInfo_AliasSet::AliasEverything as u8,
8370 JSValueType::JSVAL_TYPE_INT32 as u8,
8371 true,
8372 false,
8373 false,
8374 false,
8375 false,
8376 false,
8377 0,
8378 ).to_ne_bytes()
8379 ),
8380});
8381}
8382unsafe extern "C" fn receiveShort<D: DomTypes>
8383(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8384 let mut result = false;
8385 wrap_panic(&mut || result = (|| {
8386 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8387 let this = &*(this as *const D::TestBinding);
8388 let args = &*args;
8389 let argc = args.argc_;
8390 let result: i16 = this.ReceiveShort();
8391
8392 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8393 return true;
8394 })());
8395 result
8396}
8397
8398
8399static receiveShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8400
8401pub(crate) fn init_receiveShort_methodinfo<D: DomTypes>() {
8402 receiveShort_methodinfo.set(JSJitInfo {
8403 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8404 method: Some(receiveShort::<D>)
8405 },
8406 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8407 protoID: PrototypeList::ID::TestBinding as u16,
8408 },
8409 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8410 _bitfield_align_1: [],
8411 _bitfield_1: __BindgenBitfieldUnit::new(
8412 new_jsjitinfo_bitfield_1!(
8413 JSJitInfo_OpType::Method as u8,
8414 JSJitInfo_AliasSet::AliasEverything as u8,
8415 JSValueType::JSVAL_TYPE_INT32 as u8,
8416 true,
8417 false,
8418 false,
8419 false,
8420 false,
8421 false,
8422 0,
8423 ).to_ne_bytes()
8424 ),
8425});
8426}
8427unsafe extern "C" fn receiveUnsignedShort<D: DomTypes>
8428(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8429 let mut result = false;
8430 wrap_panic(&mut || result = (|| {
8431 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8432 let this = &*(this as *const D::TestBinding);
8433 let args = &*args;
8434 let argc = args.argc_;
8435 let result: u16 = this.ReceiveUnsignedShort();
8436
8437 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8438 return true;
8439 })());
8440 result
8441}
8442
8443
8444static receiveUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8445
8446pub(crate) fn init_receiveUnsignedShort_methodinfo<D: DomTypes>() {
8447 receiveUnsignedShort_methodinfo.set(JSJitInfo {
8448 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8449 method: Some(receiveUnsignedShort::<D>)
8450 },
8451 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8452 protoID: PrototypeList::ID::TestBinding as u16,
8453 },
8454 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8455 _bitfield_align_1: [],
8456 _bitfield_1: __BindgenBitfieldUnit::new(
8457 new_jsjitinfo_bitfield_1!(
8458 JSJitInfo_OpType::Method as u8,
8459 JSJitInfo_AliasSet::AliasEverything as u8,
8460 JSValueType::JSVAL_TYPE_INT32 as u8,
8461 true,
8462 false,
8463 false,
8464 false,
8465 false,
8466 false,
8467 0,
8468 ).to_ne_bytes()
8469 ),
8470});
8471}
8472unsafe extern "C" fn receiveLong<D: DomTypes>
8473(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8474 let mut result = false;
8475 wrap_panic(&mut || result = (|| {
8476 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8477 let this = &*(this as *const D::TestBinding);
8478 let args = &*args;
8479 let argc = args.argc_;
8480 let result: i32 = this.ReceiveLong();
8481
8482 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8483 return true;
8484 })());
8485 result
8486}
8487
8488
8489static receiveLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8490
8491pub(crate) fn init_receiveLong_methodinfo<D: DomTypes>() {
8492 receiveLong_methodinfo.set(JSJitInfo {
8493 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8494 method: Some(receiveLong::<D>)
8495 },
8496 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8497 protoID: PrototypeList::ID::TestBinding as u16,
8498 },
8499 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8500 _bitfield_align_1: [],
8501 _bitfield_1: __BindgenBitfieldUnit::new(
8502 new_jsjitinfo_bitfield_1!(
8503 JSJitInfo_OpType::Method as u8,
8504 JSJitInfo_AliasSet::AliasEverything as u8,
8505 JSValueType::JSVAL_TYPE_INT32 as u8,
8506 true,
8507 false,
8508 false,
8509 false,
8510 false,
8511 false,
8512 0,
8513 ).to_ne_bytes()
8514 ),
8515});
8516}
8517unsafe extern "C" fn receiveUnsignedLong<D: DomTypes>
8518(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8519 let mut result = false;
8520 wrap_panic(&mut || result = (|| {
8521 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8522 let this = &*(this as *const D::TestBinding);
8523 let args = &*args;
8524 let argc = args.argc_;
8525 let result: u32 = this.ReceiveUnsignedLong();
8526
8527 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8528 return true;
8529 })());
8530 result
8531}
8532
8533
8534static receiveUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8535
8536pub(crate) fn init_receiveUnsignedLong_methodinfo<D: DomTypes>() {
8537 receiveUnsignedLong_methodinfo.set(JSJitInfo {
8538 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8539 method: Some(receiveUnsignedLong::<D>)
8540 },
8541 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8542 protoID: PrototypeList::ID::TestBinding as u16,
8543 },
8544 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8545 _bitfield_align_1: [],
8546 _bitfield_1: __BindgenBitfieldUnit::new(
8547 new_jsjitinfo_bitfield_1!(
8548 JSJitInfo_OpType::Method as u8,
8549 JSJitInfo_AliasSet::AliasEverything as u8,
8550 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8551 true,
8552 false,
8553 false,
8554 false,
8555 false,
8556 false,
8557 0,
8558 ).to_ne_bytes()
8559 ),
8560});
8561}
8562unsafe extern "C" fn receiveLongLong<D: DomTypes>
8563(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8564 let mut result = false;
8565 wrap_panic(&mut || result = (|| {
8566 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8567 let this = &*(this as *const D::TestBinding);
8568 let args = &*args;
8569 let argc = args.argc_;
8570 let result: i64 = this.ReceiveLongLong();
8571
8572 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8573 return true;
8574 })());
8575 result
8576}
8577
8578
8579static receiveLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8580
8581pub(crate) fn init_receiveLongLong_methodinfo<D: DomTypes>() {
8582 receiveLongLong_methodinfo.set(JSJitInfo {
8583 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8584 method: Some(receiveLongLong::<D>)
8585 },
8586 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8587 protoID: PrototypeList::ID::TestBinding as u16,
8588 },
8589 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8590 _bitfield_align_1: [],
8591 _bitfield_1: __BindgenBitfieldUnit::new(
8592 new_jsjitinfo_bitfield_1!(
8593 JSJitInfo_OpType::Method as u8,
8594 JSJitInfo_AliasSet::AliasEverything as u8,
8595 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8596 true,
8597 false,
8598 false,
8599 false,
8600 false,
8601 false,
8602 0,
8603 ).to_ne_bytes()
8604 ),
8605});
8606}
8607unsafe extern "C" fn receiveUnsignedLongLong<D: DomTypes>
8608(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8609 let mut result = false;
8610 wrap_panic(&mut || result = (|| {
8611 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8612 let this = &*(this as *const D::TestBinding);
8613 let args = &*args;
8614 let argc = args.argc_;
8615 let result: u64 = this.ReceiveUnsignedLongLong();
8616
8617 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8618 return true;
8619 })());
8620 result
8621}
8622
8623
8624static receiveUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8625
8626pub(crate) fn init_receiveUnsignedLongLong_methodinfo<D: DomTypes>() {
8627 receiveUnsignedLongLong_methodinfo.set(JSJitInfo {
8628 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8629 method: Some(receiveUnsignedLongLong::<D>)
8630 },
8631 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8632 protoID: PrototypeList::ID::TestBinding as u16,
8633 },
8634 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8635 _bitfield_align_1: [],
8636 _bitfield_1: __BindgenBitfieldUnit::new(
8637 new_jsjitinfo_bitfield_1!(
8638 JSJitInfo_OpType::Method as u8,
8639 JSJitInfo_AliasSet::AliasEverything as u8,
8640 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8641 true,
8642 false,
8643 false,
8644 false,
8645 false,
8646 false,
8647 0,
8648 ).to_ne_bytes()
8649 ),
8650});
8651}
8652unsafe extern "C" fn receiveUnrestrictedFloat<D: DomTypes>
8653(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8654 let mut result = false;
8655 wrap_panic(&mut || result = (|| {
8656 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8657 let this = &*(this as *const D::TestBinding);
8658 let args = &*args;
8659 let argc = args.argc_;
8660 let result: f32 = this.ReceiveUnrestrictedFloat();
8661
8662 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8663 return true;
8664 })());
8665 result
8666}
8667
8668
8669static receiveUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8670
8671pub(crate) fn init_receiveUnrestrictedFloat_methodinfo<D: DomTypes>() {
8672 receiveUnrestrictedFloat_methodinfo.set(JSJitInfo {
8673 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8674 method: Some(receiveUnrestrictedFloat::<D>)
8675 },
8676 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8677 protoID: PrototypeList::ID::TestBinding as u16,
8678 },
8679 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8680 _bitfield_align_1: [],
8681 _bitfield_1: __BindgenBitfieldUnit::new(
8682 new_jsjitinfo_bitfield_1!(
8683 JSJitInfo_OpType::Method as u8,
8684 JSJitInfo_AliasSet::AliasEverything as u8,
8685 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8686 true,
8687 false,
8688 false,
8689 false,
8690 false,
8691 false,
8692 0,
8693 ).to_ne_bytes()
8694 ),
8695});
8696}
8697unsafe extern "C" fn receiveFloat<D: DomTypes>
8698(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8699 let mut result = false;
8700 wrap_panic(&mut || result = (|| {
8701 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8702 let this = &*(this as *const D::TestBinding);
8703 let args = &*args;
8704 let argc = args.argc_;
8705 let result: Finite<f32> = this.ReceiveFloat();
8706
8707 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8708 return true;
8709 })());
8710 result
8711}
8712
8713
8714static receiveFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8715
8716pub(crate) fn init_receiveFloat_methodinfo<D: DomTypes>() {
8717 receiveFloat_methodinfo.set(JSJitInfo {
8718 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8719 method: Some(receiveFloat::<D>)
8720 },
8721 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8722 protoID: PrototypeList::ID::TestBinding as u16,
8723 },
8724 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8725 _bitfield_align_1: [],
8726 _bitfield_1: __BindgenBitfieldUnit::new(
8727 new_jsjitinfo_bitfield_1!(
8728 JSJitInfo_OpType::Method as u8,
8729 JSJitInfo_AliasSet::AliasEverything as u8,
8730 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8731 true,
8732 false,
8733 false,
8734 false,
8735 false,
8736 false,
8737 0,
8738 ).to_ne_bytes()
8739 ),
8740});
8741}
8742unsafe extern "C" fn receiveUnrestrictedDouble<D: DomTypes>
8743(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8744 let mut result = false;
8745 wrap_panic(&mut || result = (|| {
8746 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8747 let this = &*(this as *const D::TestBinding);
8748 let args = &*args;
8749 let argc = args.argc_;
8750 let result: f64 = this.ReceiveUnrestrictedDouble();
8751
8752 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8753 return true;
8754 })());
8755 result
8756}
8757
8758
8759static receiveUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8760
8761pub(crate) fn init_receiveUnrestrictedDouble_methodinfo<D: DomTypes>() {
8762 receiveUnrestrictedDouble_methodinfo.set(JSJitInfo {
8763 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8764 method: Some(receiveUnrestrictedDouble::<D>)
8765 },
8766 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8767 protoID: PrototypeList::ID::TestBinding as u16,
8768 },
8769 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8770 _bitfield_align_1: [],
8771 _bitfield_1: __BindgenBitfieldUnit::new(
8772 new_jsjitinfo_bitfield_1!(
8773 JSJitInfo_OpType::Method as u8,
8774 JSJitInfo_AliasSet::AliasEverything as u8,
8775 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8776 true,
8777 false,
8778 false,
8779 false,
8780 false,
8781 false,
8782 0,
8783 ).to_ne_bytes()
8784 ),
8785});
8786}
8787unsafe extern "C" fn receiveDouble<D: DomTypes>
8788(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8789 let mut result = false;
8790 wrap_panic(&mut || result = (|| {
8791 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8792 let this = &*(this as *const D::TestBinding);
8793 let args = &*args;
8794 let argc = args.argc_;
8795 let result: Finite<f64> = this.ReceiveDouble();
8796
8797 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8798 return true;
8799 })());
8800 result
8801}
8802
8803
8804static receiveDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8805
8806pub(crate) fn init_receiveDouble_methodinfo<D: DomTypes>() {
8807 receiveDouble_methodinfo.set(JSJitInfo {
8808 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8809 method: Some(receiveDouble::<D>)
8810 },
8811 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8812 protoID: PrototypeList::ID::TestBinding as u16,
8813 },
8814 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8815 _bitfield_align_1: [],
8816 _bitfield_1: __BindgenBitfieldUnit::new(
8817 new_jsjitinfo_bitfield_1!(
8818 JSJitInfo_OpType::Method as u8,
8819 JSJitInfo_AliasSet::AliasEverything as u8,
8820 JSValueType::JSVAL_TYPE_DOUBLE as u8,
8821 true,
8822 false,
8823 false,
8824 false,
8825 false,
8826 false,
8827 0,
8828 ).to_ne_bytes()
8829 ),
8830});
8831}
8832unsafe extern "C" fn receiveString<D: DomTypes>
8833(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8834 let mut result = false;
8835 wrap_panic(&mut || result = (|| {
8836 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8837 let this = &*(this as *const D::TestBinding);
8838 let args = &*args;
8839 let argc = args.argc_;
8840 let result: DOMString = this.ReceiveString();
8841
8842 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8843 return true;
8844 })());
8845 result
8846}
8847
8848
8849static receiveString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8850
8851pub(crate) fn init_receiveString_methodinfo<D: DomTypes>() {
8852 receiveString_methodinfo.set(JSJitInfo {
8853 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8854 method: Some(receiveString::<D>)
8855 },
8856 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8857 protoID: PrototypeList::ID::TestBinding as u16,
8858 },
8859 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8860 _bitfield_align_1: [],
8861 _bitfield_1: __BindgenBitfieldUnit::new(
8862 new_jsjitinfo_bitfield_1!(
8863 JSJitInfo_OpType::Method as u8,
8864 JSJitInfo_AliasSet::AliasEverything as u8,
8865 JSValueType::JSVAL_TYPE_STRING as u8,
8866 true,
8867 false,
8868 false,
8869 false,
8870 false,
8871 false,
8872 0,
8873 ).to_ne_bytes()
8874 ),
8875});
8876}
8877unsafe extern "C" fn receiveUsvstring<D: DomTypes>
8878(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8879 let mut result = false;
8880 wrap_panic(&mut || result = (|| {
8881 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8882 let this = &*(this as *const D::TestBinding);
8883 let args = &*args;
8884 let argc = args.argc_;
8885 let result: USVString = this.ReceiveUsvstring();
8886
8887 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8888 return true;
8889 })());
8890 result
8891}
8892
8893
8894static receiveUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8895
8896pub(crate) fn init_receiveUsvstring_methodinfo<D: DomTypes>() {
8897 receiveUsvstring_methodinfo.set(JSJitInfo {
8898 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8899 method: Some(receiveUsvstring::<D>)
8900 },
8901 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8902 protoID: PrototypeList::ID::TestBinding as u16,
8903 },
8904 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8905 _bitfield_align_1: [],
8906 _bitfield_1: __BindgenBitfieldUnit::new(
8907 new_jsjitinfo_bitfield_1!(
8908 JSJitInfo_OpType::Method as u8,
8909 JSJitInfo_AliasSet::AliasEverything as u8,
8910 JSValueType::JSVAL_TYPE_STRING as u8,
8911 true,
8912 false,
8913 false,
8914 false,
8915 false,
8916 false,
8917 0,
8918 ).to_ne_bytes()
8919 ),
8920});
8921}
8922unsafe extern "C" fn receiveByteString<D: DomTypes>
8923(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8924 let mut result = false;
8925 wrap_panic(&mut || result = (|| {
8926 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8927 let this = &*(this as *const D::TestBinding);
8928 let args = &*args;
8929 let argc = args.argc_;
8930 let result: ByteString = this.ReceiveByteString();
8931
8932 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8933 return true;
8934 })());
8935 result
8936}
8937
8938
8939static receiveByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8940
8941pub(crate) fn init_receiveByteString_methodinfo<D: DomTypes>() {
8942 receiveByteString_methodinfo.set(JSJitInfo {
8943 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8944 method: Some(receiveByteString::<D>)
8945 },
8946 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8947 protoID: PrototypeList::ID::TestBinding as u16,
8948 },
8949 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8950 _bitfield_align_1: [],
8951 _bitfield_1: __BindgenBitfieldUnit::new(
8952 new_jsjitinfo_bitfield_1!(
8953 JSJitInfo_OpType::Method as u8,
8954 JSJitInfo_AliasSet::AliasEverything as u8,
8955 JSValueType::JSVAL_TYPE_STRING as u8,
8956 true,
8957 false,
8958 false,
8959 false,
8960 false,
8961 false,
8962 0,
8963 ).to_ne_bytes()
8964 ),
8965});
8966}
8967unsafe extern "C" fn receiveEnum<D: DomTypes>
8968(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
8969 let mut result = false;
8970 wrap_panic(&mut || result = (|| {
8971 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
8972 let this = &*(this as *const D::TestBinding);
8973 let args = &*args;
8974 let argc = args.argc_;
8975 let result: TestEnum = this.ReceiveEnum();
8976
8977 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
8978 return true;
8979 })());
8980 result
8981}
8982
8983
8984static receiveEnum_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
8985
8986pub(crate) fn init_receiveEnum_methodinfo<D: DomTypes>() {
8987 receiveEnum_methodinfo.set(JSJitInfo {
8988 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
8989 method: Some(receiveEnum::<D>)
8990 },
8991 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
8992 protoID: PrototypeList::ID::TestBinding as u16,
8993 },
8994 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
8995 _bitfield_align_1: [],
8996 _bitfield_1: __BindgenBitfieldUnit::new(
8997 new_jsjitinfo_bitfield_1!(
8998 JSJitInfo_OpType::Method as u8,
8999 JSJitInfo_AliasSet::AliasEverything as u8,
9000 JSValueType::JSVAL_TYPE_STRING as u8,
9001 true,
9002 false,
9003 false,
9004 false,
9005 false,
9006 false,
9007 0,
9008 ).to_ne_bytes()
9009 ),
9010});
9011}
9012unsafe extern "C" fn receiveInterface<D: DomTypes>
9013(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9014 let mut result = false;
9015 wrap_panic(&mut || result = (|| {
9016 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9017 let this = &*(this as *const D::TestBinding);
9018 let args = &*args;
9019 let argc = args.argc_;
9020 let result: DomRoot<D::Blob> = this.ReceiveInterface(CanGc::note());
9021
9022 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9023 return true;
9024 })());
9025 result
9026}
9027
9028
9029static receiveInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9030
9031pub(crate) fn init_receiveInterface_methodinfo<D: DomTypes>() {
9032 receiveInterface_methodinfo.set(JSJitInfo {
9033 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9034 method: Some(receiveInterface::<D>)
9035 },
9036 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9037 protoID: PrototypeList::ID::TestBinding as u16,
9038 },
9039 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9040 _bitfield_align_1: [],
9041 _bitfield_1: __BindgenBitfieldUnit::new(
9042 new_jsjitinfo_bitfield_1!(
9043 JSJitInfo_OpType::Method as u8,
9044 JSJitInfo_AliasSet::AliasEverything as u8,
9045 JSValueType::JSVAL_TYPE_OBJECT as u8,
9046 true,
9047 false,
9048 false,
9049 false,
9050 false,
9051 false,
9052 0,
9053 ).to_ne_bytes()
9054 ),
9055});
9056}
9057unsafe extern "C" fn receiveAny<D: DomTypes>
9058(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9059 let mut result = false;
9060 wrap_panic(&mut || result = (|| {
9061 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9062 let this = &*(this as *const D::TestBinding);
9063 let args = &*args;
9064 let argc = args.argc_;
9065 rooted!(&in(cx) let mut retval: JSVal);
9066 let result: () = this.ReceiveAny(SafeJSContext::from_ptr(cx.raw_cx()), retval.handle_mut());
9067
9068 (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9069 return true;
9070 })());
9071 result
9072}
9073
9074
9075static receiveAny_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9076
9077pub(crate) fn init_receiveAny_methodinfo<D: DomTypes>() {
9078 receiveAny_methodinfo.set(JSJitInfo {
9079 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9080 method: Some(receiveAny::<D>)
9081 },
9082 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9083 protoID: PrototypeList::ID::TestBinding as u16,
9084 },
9085 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9086 _bitfield_align_1: [],
9087 _bitfield_1: __BindgenBitfieldUnit::new(
9088 new_jsjitinfo_bitfield_1!(
9089 JSJitInfo_OpType::Method as u8,
9090 JSJitInfo_AliasSet::AliasEverything as u8,
9091 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9092 true,
9093 false,
9094 false,
9095 false,
9096 false,
9097 false,
9098 0,
9099 ).to_ne_bytes()
9100 ),
9101});
9102}
9103unsafe extern "C" fn receiveObject<D: DomTypes>
9104(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9105 let mut result = false;
9106 wrap_panic(&mut || result = (|| {
9107 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9108 let this = &*(this as *const D::TestBinding);
9109 let args = &*args;
9110 let argc = args.argc_;
9111 let result: NonNull<JSObject> = this.ReceiveObject(SafeJSContext::from_ptr(cx.raw_cx()));
9112
9113 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9114 return true;
9115 })());
9116 result
9117}
9118
9119
9120static receiveObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9121
9122pub(crate) fn init_receiveObject_methodinfo<D: DomTypes>() {
9123 receiveObject_methodinfo.set(JSJitInfo {
9124 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9125 method: Some(receiveObject::<D>)
9126 },
9127 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9128 protoID: PrototypeList::ID::TestBinding as u16,
9129 },
9130 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9131 _bitfield_align_1: [],
9132 _bitfield_1: __BindgenBitfieldUnit::new(
9133 new_jsjitinfo_bitfield_1!(
9134 JSJitInfo_OpType::Method as u8,
9135 JSJitInfo_AliasSet::AliasEverything as u8,
9136 JSValueType::JSVAL_TYPE_OBJECT as u8,
9137 true,
9138 false,
9139 false,
9140 false,
9141 false,
9142 false,
9143 0,
9144 ).to_ne_bytes()
9145 ),
9146});
9147}
9148unsafe extern "C" fn receiveUnion<D: DomTypes>
9149(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9150 let mut result = false;
9151 wrap_panic(&mut || result = (|| {
9152 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9153 let this = &*(this as *const D::TestBinding);
9154 let args = &*args;
9155 let argc = args.argc_;
9156 let result: GenericUnionTypes::HTMLElementOrLong::<D> = this.ReceiveUnion();
9157
9158 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9159 return true;
9160 })());
9161 result
9162}
9163
9164
9165static receiveUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9166
9167pub(crate) fn init_receiveUnion_methodinfo<D: DomTypes>() {
9168 receiveUnion_methodinfo.set(JSJitInfo {
9169 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9170 method: Some(receiveUnion::<D>)
9171 },
9172 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9173 protoID: PrototypeList::ID::TestBinding as u16,
9174 },
9175 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9176 _bitfield_align_1: [],
9177 _bitfield_1: __BindgenBitfieldUnit::new(
9178 new_jsjitinfo_bitfield_1!(
9179 JSJitInfo_OpType::Method as u8,
9180 JSJitInfo_AliasSet::AliasEverything as u8,
9181 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9182 true,
9183 false,
9184 false,
9185 false,
9186 false,
9187 false,
9188 0,
9189 ).to_ne_bytes()
9190 ),
9191});
9192}
9193unsafe extern "C" fn receiveUnion2<D: DomTypes>
9194(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9195 let mut result = false;
9196 wrap_panic(&mut || result = (|| {
9197 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9198 let this = &*(this as *const D::TestBinding);
9199 let args = &*args;
9200 let argc = args.argc_;
9201 let result: GenericUnionTypes::EventOrString::<D> = this.ReceiveUnion2();
9202
9203 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9204 return true;
9205 })());
9206 result
9207}
9208
9209
9210static receiveUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9211
9212pub(crate) fn init_receiveUnion2_methodinfo<D: DomTypes>() {
9213 receiveUnion2_methodinfo.set(JSJitInfo {
9214 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9215 method: Some(receiveUnion2::<D>)
9216 },
9217 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9218 protoID: PrototypeList::ID::TestBinding as u16,
9219 },
9220 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9221 _bitfield_align_1: [],
9222 _bitfield_1: __BindgenBitfieldUnit::new(
9223 new_jsjitinfo_bitfield_1!(
9224 JSJitInfo_OpType::Method as u8,
9225 JSJitInfo_AliasSet::AliasEverything as u8,
9226 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9227 true,
9228 false,
9229 false,
9230 false,
9231 false,
9232 false,
9233 0,
9234 ).to_ne_bytes()
9235 ),
9236});
9237}
9238unsafe extern "C" fn receiveUnion3<D: DomTypes>
9239(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9240 let mut result = false;
9241 wrap_panic(&mut || result = (|| {
9242 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9243 let this = &*(this as *const D::TestBinding);
9244 let args = &*args;
9245 let argc = args.argc_;
9246 let result: GenericUnionTypes::StringOrLongSequence = this.ReceiveUnion3();
9247
9248 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9249 return true;
9250 })());
9251 result
9252}
9253
9254
9255static receiveUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9256
9257pub(crate) fn init_receiveUnion3_methodinfo<D: DomTypes>() {
9258 receiveUnion3_methodinfo.set(JSJitInfo {
9259 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9260 method: Some(receiveUnion3::<D>)
9261 },
9262 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9263 protoID: PrototypeList::ID::TestBinding as u16,
9264 },
9265 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9266 _bitfield_align_1: [],
9267 _bitfield_1: __BindgenBitfieldUnit::new(
9268 new_jsjitinfo_bitfield_1!(
9269 JSJitInfo_OpType::Method as u8,
9270 JSJitInfo_AliasSet::AliasEverything as u8,
9271 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9272 true,
9273 false,
9274 false,
9275 false,
9276 false,
9277 false,
9278 0,
9279 ).to_ne_bytes()
9280 ),
9281});
9282}
9283unsafe extern "C" fn receiveUnion4<D: DomTypes>
9284(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9285 let mut result = false;
9286 wrap_panic(&mut || result = (|| {
9287 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9288 let this = &*(this as *const D::TestBinding);
9289 let args = &*args;
9290 let argc = args.argc_;
9291 let result: GenericUnionTypes::StringOrStringSequence = this.ReceiveUnion4();
9292
9293 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9294 return true;
9295 })());
9296 result
9297}
9298
9299
9300static receiveUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9301
9302pub(crate) fn init_receiveUnion4_methodinfo<D: DomTypes>() {
9303 receiveUnion4_methodinfo.set(JSJitInfo {
9304 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9305 method: Some(receiveUnion4::<D>)
9306 },
9307 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9308 protoID: PrototypeList::ID::TestBinding as u16,
9309 },
9310 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9311 _bitfield_align_1: [],
9312 _bitfield_1: __BindgenBitfieldUnit::new(
9313 new_jsjitinfo_bitfield_1!(
9314 JSJitInfo_OpType::Method as u8,
9315 JSJitInfo_AliasSet::AliasEverything as u8,
9316 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9317 true,
9318 false,
9319 false,
9320 false,
9321 false,
9322 false,
9323 0,
9324 ).to_ne_bytes()
9325 ),
9326});
9327}
9328unsafe extern "C" fn receiveUnion5<D: DomTypes>
9329(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9330 let mut result = false;
9331 wrap_panic(&mut || result = (|| {
9332 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9333 let this = &*(this as *const D::TestBinding);
9334 let args = &*args;
9335 let argc = args.argc_;
9336 let result: GenericUnionTypes::BlobOrBlobSequence::<D> = this.ReceiveUnion5();
9337
9338 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9339 return true;
9340 })());
9341 result
9342}
9343
9344
9345static receiveUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9346
9347pub(crate) fn init_receiveUnion5_methodinfo<D: DomTypes>() {
9348 receiveUnion5_methodinfo.set(JSJitInfo {
9349 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9350 method: Some(receiveUnion5::<D>)
9351 },
9352 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9353 protoID: PrototypeList::ID::TestBinding as u16,
9354 },
9355 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9356 _bitfield_align_1: [],
9357 _bitfield_1: __BindgenBitfieldUnit::new(
9358 new_jsjitinfo_bitfield_1!(
9359 JSJitInfo_OpType::Method as u8,
9360 JSJitInfo_AliasSet::AliasEverything as u8,
9361 JSValueType::JSVAL_TYPE_OBJECT as u8,
9362 true,
9363 false,
9364 false,
9365 false,
9366 false,
9367 false,
9368 0,
9369 ).to_ne_bytes()
9370 ),
9371});
9372}
9373unsafe extern "C" fn receiveUnion6<D: DomTypes>
9374(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9375 let mut result = false;
9376 wrap_panic(&mut || result = (|| {
9377 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9378 let this = &*(this as *const D::TestBinding);
9379 let args = &*args;
9380 let argc = args.argc_;
9381 let result: GenericUnionTypes::StringOrUnsignedLong = this.ReceiveUnion6();
9382
9383 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9384 return true;
9385 })());
9386 result
9387}
9388
9389
9390static receiveUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9391
9392pub(crate) fn init_receiveUnion6_methodinfo<D: DomTypes>() {
9393 receiveUnion6_methodinfo.set(JSJitInfo {
9394 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9395 method: Some(receiveUnion6::<D>)
9396 },
9397 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9398 protoID: PrototypeList::ID::TestBinding as u16,
9399 },
9400 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9401 _bitfield_align_1: [],
9402 _bitfield_1: __BindgenBitfieldUnit::new(
9403 new_jsjitinfo_bitfield_1!(
9404 JSJitInfo_OpType::Method as u8,
9405 JSJitInfo_AliasSet::AliasEverything as u8,
9406 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9407 true,
9408 false,
9409 false,
9410 false,
9411 false,
9412 false,
9413 0,
9414 ).to_ne_bytes()
9415 ),
9416});
9417}
9418unsafe extern "C" fn receiveUnion7<D: DomTypes>
9419(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9420 let mut result = false;
9421 wrap_panic(&mut || result = (|| {
9422 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9423 let this = &*(this as *const D::TestBinding);
9424 let args = &*args;
9425 let argc = args.argc_;
9426 let result: GenericUnionTypes::StringOrBoolean = this.ReceiveUnion7();
9427
9428 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9429 return true;
9430 })());
9431 result
9432}
9433
9434
9435static receiveUnion7_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9436
9437pub(crate) fn init_receiveUnion7_methodinfo<D: DomTypes>() {
9438 receiveUnion7_methodinfo.set(JSJitInfo {
9439 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9440 method: Some(receiveUnion7::<D>)
9441 },
9442 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9443 protoID: PrototypeList::ID::TestBinding as u16,
9444 },
9445 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9446 _bitfield_align_1: [],
9447 _bitfield_1: __BindgenBitfieldUnit::new(
9448 new_jsjitinfo_bitfield_1!(
9449 JSJitInfo_OpType::Method as u8,
9450 JSJitInfo_AliasSet::AliasEverything as u8,
9451 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9452 true,
9453 false,
9454 false,
9455 false,
9456 false,
9457 false,
9458 0,
9459 ).to_ne_bytes()
9460 ),
9461});
9462}
9463unsafe extern "C" fn receiveUnion8<D: DomTypes>
9464(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9465 let mut result = false;
9466 wrap_panic(&mut || result = (|| {
9467 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9468 let this = &*(this as *const D::TestBinding);
9469 let args = &*args;
9470 let argc = args.argc_;
9471 let result: GenericUnionTypes::UnsignedLongOrBoolean = this.ReceiveUnion8();
9472
9473 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9474 return true;
9475 })());
9476 result
9477}
9478
9479
9480static receiveUnion8_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9481
9482pub(crate) fn init_receiveUnion8_methodinfo<D: DomTypes>() {
9483 receiveUnion8_methodinfo.set(JSJitInfo {
9484 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9485 method: Some(receiveUnion8::<D>)
9486 },
9487 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9488 protoID: PrototypeList::ID::TestBinding as u16,
9489 },
9490 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9491 _bitfield_align_1: [],
9492 _bitfield_1: __BindgenBitfieldUnit::new(
9493 new_jsjitinfo_bitfield_1!(
9494 JSJitInfo_OpType::Method as u8,
9495 JSJitInfo_AliasSet::AliasEverything as u8,
9496 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9497 true,
9498 false,
9499 false,
9500 false,
9501 false,
9502 false,
9503 0,
9504 ).to_ne_bytes()
9505 ),
9506});
9507}
9508unsafe extern "C" fn receiveUnion9<D: DomTypes>
9509(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9510 let mut result = false;
9511 wrap_panic(&mut || result = (|| {
9512 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9513 let this = &*(this as *const D::TestBinding);
9514 let args = &*args;
9515 let argc = args.argc_;
9516 let result: GenericUnionTypes::HTMLElementOrUnsignedLongOrStringOrBoolean::<D> = this.ReceiveUnion9();
9517
9518 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9519 return true;
9520 })());
9521 result
9522}
9523
9524
9525static receiveUnion9_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9526
9527pub(crate) fn init_receiveUnion9_methodinfo<D: DomTypes>() {
9528 receiveUnion9_methodinfo.set(JSJitInfo {
9529 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9530 method: Some(receiveUnion9::<D>)
9531 },
9532 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9533 protoID: PrototypeList::ID::TestBinding as u16,
9534 },
9535 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9536 _bitfield_align_1: [],
9537 _bitfield_1: __BindgenBitfieldUnit::new(
9538 new_jsjitinfo_bitfield_1!(
9539 JSJitInfo_OpType::Method as u8,
9540 JSJitInfo_AliasSet::AliasEverything as u8,
9541 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9542 true,
9543 false,
9544 false,
9545 false,
9546 false,
9547 false,
9548 0,
9549 ).to_ne_bytes()
9550 ),
9551});
9552}
9553unsafe extern "C" fn receiveUnion10<D: DomTypes>
9554(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9555 let mut result = false;
9556 wrap_panic(&mut || result = (|| {
9557 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9558 let this = &*(this as *const D::TestBinding);
9559 let args = &*args;
9560 let argc = args.argc_;
9561 let result: GenericUnionTypes::ByteStringOrLong = this.ReceiveUnion10();
9562
9563 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9564 return true;
9565 })());
9566 result
9567}
9568
9569
9570static receiveUnion10_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9571
9572pub(crate) fn init_receiveUnion10_methodinfo<D: DomTypes>() {
9573 receiveUnion10_methodinfo.set(JSJitInfo {
9574 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9575 method: Some(receiveUnion10::<D>)
9576 },
9577 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9578 protoID: PrototypeList::ID::TestBinding as u16,
9579 },
9580 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9581 _bitfield_align_1: [],
9582 _bitfield_1: __BindgenBitfieldUnit::new(
9583 new_jsjitinfo_bitfield_1!(
9584 JSJitInfo_OpType::Method as u8,
9585 JSJitInfo_AliasSet::AliasEverything as u8,
9586 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9587 true,
9588 false,
9589 false,
9590 false,
9591 false,
9592 false,
9593 0,
9594 ).to_ne_bytes()
9595 ),
9596});
9597}
9598unsafe extern "C" fn receiveUnion11<D: DomTypes>
9599(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9600 let mut result = false;
9601 wrap_panic(&mut || result = (|| {
9602 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9603 let this = &*(this as *const D::TestBinding);
9604 let args = &*args;
9605 let argc = args.argc_;
9606 let result: GenericUnionTypes::ByteStringSequenceOrLongOrString = this.ReceiveUnion11();
9607
9608 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9609 return true;
9610 })());
9611 result
9612}
9613
9614
9615static receiveUnion11_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9616
9617pub(crate) fn init_receiveUnion11_methodinfo<D: DomTypes>() {
9618 receiveUnion11_methodinfo.set(JSJitInfo {
9619 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9620 method: Some(receiveUnion11::<D>)
9621 },
9622 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9623 protoID: PrototypeList::ID::TestBinding as u16,
9624 },
9625 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9626 _bitfield_align_1: [],
9627 _bitfield_1: __BindgenBitfieldUnit::new(
9628 new_jsjitinfo_bitfield_1!(
9629 JSJitInfo_OpType::Method as u8,
9630 JSJitInfo_AliasSet::AliasEverything as u8,
9631 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9632 true,
9633 false,
9634 false,
9635 false,
9636 false,
9637 false,
9638 0,
9639 ).to_ne_bytes()
9640 ),
9641});
9642}
9643unsafe extern "C" fn receiveSequence<D: DomTypes>
9644(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9645 let mut result = false;
9646 wrap_panic(&mut || result = (|| {
9647 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9648 let this = &*(this as *const D::TestBinding);
9649 let args = &*args;
9650 let argc = args.argc_;
9651 let result: Vec<i32> = this.ReceiveSequence();
9652
9653 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9654 return true;
9655 })());
9656 result
9657}
9658
9659
9660static receiveSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9661
9662pub(crate) fn init_receiveSequence_methodinfo<D: DomTypes>() {
9663 receiveSequence_methodinfo.set(JSJitInfo {
9664 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9665 method: Some(receiveSequence::<D>)
9666 },
9667 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9668 protoID: PrototypeList::ID::TestBinding as u16,
9669 },
9670 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9671 _bitfield_align_1: [],
9672 _bitfield_1: __BindgenBitfieldUnit::new(
9673 new_jsjitinfo_bitfield_1!(
9674 JSJitInfo_OpType::Method as u8,
9675 JSJitInfo_AliasSet::AliasEverything as u8,
9676 JSValueType::JSVAL_TYPE_OBJECT as u8,
9677 true,
9678 false,
9679 false,
9680 false,
9681 false,
9682 false,
9683 0,
9684 ).to_ne_bytes()
9685 ),
9686});
9687}
9688unsafe extern "C" fn receiveInterfaceSequence<D: DomTypes>
9689(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9690 let mut result = false;
9691 wrap_panic(&mut || result = (|| {
9692 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9693 let this = &*(this as *const D::TestBinding);
9694 let args = &*args;
9695 let argc = args.argc_;
9696 let result: Vec<DomRoot<D::Blob>> = this.ReceiveInterfaceSequence(CanGc::note());
9697
9698 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9699 return true;
9700 })());
9701 result
9702}
9703
9704
9705static receiveInterfaceSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9706
9707pub(crate) fn init_receiveInterfaceSequence_methodinfo<D: DomTypes>() {
9708 receiveInterfaceSequence_methodinfo.set(JSJitInfo {
9709 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9710 method: Some(receiveInterfaceSequence::<D>)
9711 },
9712 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9713 protoID: PrototypeList::ID::TestBinding as u16,
9714 },
9715 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9716 _bitfield_align_1: [],
9717 _bitfield_1: __BindgenBitfieldUnit::new(
9718 new_jsjitinfo_bitfield_1!(
9719 JSJitInfo_OpType::Method as u8,
9720 JSJitInfo_AliasSet::AliasEverything as u8,
9721 JSValueType::JSVAL_TYPE_OBJECT as u8,
9722 true,
9723 false,
9724 false,
9725 false,
9726 false,
9727 false,
9728 0,
9729 ).to_ne_bytes()
9730 ),
9731});
9732}
9733unsafe extern "C" fn receiveNullableByte<D: DomTypes>
9734(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9735 let mut result = false;
9736 wrap_panic(&mut || result = (|| {
9737 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9738 let this = &*(this as *const D::TestBinding);
9739 let args = &*args;
9740 let argc = args.argc_;
9741 let result: Option<i8> = this.ReceiveNullableByte();
9742
9743 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9744 return true;
9745 })());
9746 result
9747}
9748
9749
9750static receiveNullableByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9751
9752pub(crate) fn init_receiveNullableByte_methodinfo<D: DomTypes>() {
9753 receiveNullableByte_methodinfo.set(JSJitInfo {
9754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9755 method: Some(receiveNullableByte::<D>)
9756 },
9757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9758 protoID: PrototypeList::ID::TestBinding as u16,
9759 },
9760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9761 _bitfield_align_1: [],
9762 _bitfield_1: __BindgenBitfieldUnit::new(
9763 new_jsjitinfo_bitfield_1!(
9764 JSJitInfo_OpType::Method as u8,
9765 JSJitInfo_AliasSet::AliasEverything as u8,
9766 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9767 true,
9768 false,
9769 false,
9770 false,
9771 false,
9772 false,
9773 0,
9774 ).to_ne_bytes()
9775 ),
9776});
9777}
9778unsafe extern "C" fn receiveNullableBoolean<D: DomTypes>
9779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9780 let mut result = false;
9781 wrap_panic(&mut || result = (|| {
9782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9783 let this = &*(this as *const D::TestBinding);
9784 let args = &*args;
9785 let argc = args.argc_;
9786 let result: Option<bool> = this.ReceiveNullableBoolean();
9787
9788 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9789 return true;
9790 })());
9791 result
9792}
9793
9794
9795static receiveNullableBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9796
9797pub(crate) fn init_receiveNullableBoolean_methodinfo<D: DomTypes>() {
9798 receiveNullableBoolean_methodinfo.set(JSJitInfo {
9799 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9800 method: Some(receiveNullableBoolean::<D>)
9801 },
9802 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9803 protoID: PrototypeList::ID::TestBinding as u16,
9804 },
9805 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9806 _bitfield_align_1: [],
9807 _bitfield_1: __BindgenBitfieldUnit::new(
9808 new_jsjitinfo_bitfield_1!(
9809 JSJitInfo_OpType::Method as u8,
9810 JSJitInfo_AliasSet::AliasEverything as u8,
9811 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9812 true,
9813 false,
9814 false,
9815 false,
9816 false,
9817 false,
9818 0,
9819 ).to_ne_bytes()
9820 ),
9821});
9822}
9823unsafe extern "C" fn receiveNullableOctet<D: DomTypes>
9824(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9825 let mut result = false;
9826 wrap_panic(&mut || result = (|| {
9827 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9828 let this = &*(this as *const D::TestBinding);
9829 let args = &*args;
9830 let argc = args.argc_;
9831 let result: Option<u8> = this.ReceiveNullableOctet();
9832
9833 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9834 return true;
9835 })());
9836 result
9837}
9838
9839
9840static receiveNullableOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9841
9842pub(crate) fn init_receiveNullableOctet_methodinfo<D: DomTypes>() {
9843 receiveNullableOctet_methodinfo.set(JSJitInfo {
9844 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9845 method: Some(receiveNullableOctet::<D>)
9846 },
9847 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9848 protoID: PrototypeList::ID::TestBinding as u16,
9849 },
9850 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9851 _bitfield_align_1: [],
9852 _bitfield_1: __BindgenBitfieldUnit::new(
9853 new_jsjitinfo_bitfield_1!(
9854 JSJitInfo_OpType::Method as u8,
9855 JSJitInfo_AliasSet::AliasEverything as u8,
9856 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9857 true,
9858 false,
9859 false,
9860 false,
9861 false,
9862 false,
9863 0,
9864 ).to_ne_bytes()
9865 ),
9866});
9867}
9868unsafe extern "C" fn receiveNullableShort<D: DomTypes>
9869(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9870 let mut result = false;
9871 wrap_panic(&mut || result = (|| {
9872 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9873 let this = &*(this as *const D::TestBinding);
9874 let args = &*args;
9875 let argc = args.argc_;
9876 let result: Option<i16> = this.ReceiveNullableShort();
9877
9878 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9879 return true;
9880 })());
9881 result
9882}
9883
9884
9885static receiveNullableShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9886
9887pub(crate) fn init_receiveNullableShort_methodinfo<D: DomTypes>() {
9888 receiveNullableShort_methodinfo.set(JSJitInfo {
9889 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9890 method: Some(receiveNullableShort::<D>)
9891 },
9892 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9893 protoID: PrototypeList::ID::TestBinding as u16,
9894 },
9895 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9896 _bitfield_align_1: [],
9897 _bitfield_1: __BindgenBitfieldUnit::new(
9898 new_jsjitinfo_bitfield_1!(
9899 JSJitInfo_OpType::Method as u8,
9900 JSJitInfo_AliasSet::AliasEverything as u8,
9901 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9902 true,
9903 false,
9904 false,
9905 false,
9906 false,
9907 false,
9908 0,
9909 ).to_ne_bytes()
9910 ),
9911});
9912}
9913unsafe extern "C" fn receiveNullableUnsignedShort<D: DomTypes>
9914(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9915 let mut result = false;
9916 wrap_panic(&mut || result = (|| {
9917 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9918 let this = &*(this as *const D::TestBinding);
9919 let args = &*args;
9920 let argc = args.argc_;
9921 let result: Option<u16> = this.ReceiveNullableUnsignedShort();
9922
9923 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9924 return true;
9925 })());
9926 result
9927}
9928
9929
9930static receiveNullableUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9931
9932pub(crate) fn init_receiveNullableUnsignedShort_methodinfo<D: DomTypes>() {
9933 receiveNullableUnsignedShort_methodinfo.set(JSJitInfo {
9934 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9935 method: Some(receiveNullableUnsignedShort::<D>)
9936 },
9937 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9938 protoID: PrototypeList::ID::TestBinding as u16,
9939 },
9940 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9941 _bitfield_align_1: [],
9942 _bitfield_1: __BindgenBitfieldUnit::new(
9943 new_jsjitinfo_bitfield_1!(
9944 JSJitInfo_OpType::Method as u8,
9945 JSJitInfo_AliasSet::AliasEverything as u8,
9946 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9947 true,
9948 false,
9949 false,
9950 false,
9951 false,
9952 false,
9953 0,
9954 ).to_ne_bytes()
9955 ),
9956});
9957}
9958unsafe extern "C" fn receiveNullableLong<D: DomTypes>
9959(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
9960 let mut result = false;
9961 wrap_panic(&mut || result = (|| {
9962 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
9963 let this = &*(this as *const D::TestBinding);
9964 let args = &*args;
9965 let argc = args.argc_;
9966 let result: Option<i32> = this.ReceiveNullableLong();
9967
9968 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
9969 return true;
9970 })());
9971 result
9972}
9973
9974
9975static receiveNullableLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
9976
9977pub(crate) fn init_receiveNullableLong_methodinfo<D: DomTypes>() {
9978 receiveNullableLong_methodinfo.set(JSJitInfo {
9979 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
9980 method: Some(receiveNullableLong::<D>)
9981 },
9982 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
9983 protoID: PrototypeList::ID::TestBinding as u16,
9984 },
9985 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
9986 _bitfield_align_1: [],
9987 _bitfield_1: __BindgenBitfieldUnit::new(
9988 new_jsjitinfo_bitfield_1!(
9989 JSJitInfo_OpType::Method as u8,
9990 JSJitInfo_AliasSet::AliasEverything as u8,
9991 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
9992 true,
9993 false,
9994 false,
9995 false,
9996 false,
9997 false,
9998 0,
9999 ).to_ne_bytes()
10000 ),
10001});
10002}
10003unsafe extern "C" fn receiveNullableUnsignedLong<D: DomTypes>
10004(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10005 let mut result = false;
10006 wrap_panic(&mut || result = (|| {
10007 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10008 let this = &*(this as *const D::TestBinding);
10009 let args = &*args;
10010 let argc = args.argc_;
10011 let result: Option<u32> = this.ReceiveNullableUnsignedLong();
10012
10013 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10014 return true;
10015 })());
10016 result
10017}
10018
10019
10020static receiveNullableUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10021
10022pub(crate) fn init_receiveNullableUnsignedLong_methodinfo<D: DomTypes>() {
10023 receiveNullableUnsignedLong_methodinfo.set(JSJitInfo {
10024 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10025 method: Some(receiveNullableUnsignedLong::<D>)
10026 },
10027 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10028 protoID: PrototypeList::ID::TestBinding as u16,
10029 },
10030 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10031 _bitfield_align_1: [],
10032 _bitfield_1: __BindgenBitfieldUnit::new(
10033 new_jsjitinfo_bitfield_1!(
10034 JSJitInfo_OpType::Method as u8,
10035 JSJitInfo_AliasSet::AliasEverything as u8,
10036 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10037 true,
10038 false,
10039 false,
10040 false,
10041 false,
10042 false,
10043 0,
10044 ).to_ne_bytes()
10045 ),
10046});
10047}
10048unsafe extern "C" fn receiveNullableLongLong<D: DomTypes>
10049(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10050 let mut result = false;
10051 wrap_panic(&mut || result = (|| {
10052 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10053 let this = &*(this as *const D::TestBinding);
10054 let args = &*args;
10055 let argc = args.argc_;
10056 let result: Option<i64> = this.ReceiveNullableLongLong();
10057
10058 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10059 return true;
10060 })());
10061 result
10062}
10063
10064
10065static receiveNullableLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10066
10067pub(crate) fn init_receiveNullableLongLong_methodinfo<D: DomTypes>() {
10068 receiveNullableLongLong_methodinfo.set(JSJitInfo {
10069 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10070 method: Some(receiveNullableLongLong::<D>)
10071 },
10072 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10073 protoID: PrototypeList::ID::TestBinding as u16,
10074 },
10075 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10076 _bitfield_align_1: [],
10077 _bitfield_1: __BindgenBitfieldUnit::new(
10078 new_jsjitinfo_bitfield_1!(
10079 JSJitInfo_OpType::Method as u8,
10080 JSJitInfo_AliasSet::AliasEverything as u8,
10081 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10082 true,
10083 false,
10084 false,
10085 false,
10086 false,
10087 false,
10088 0,
10089 ).to_ne_bytes()
10090 ),
10091});
10092}
10093unsafe extern "C" fn receiveNullableUnsignedLongLong<D: DomTypes>
10094(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10095 let mut result = false;
10096 wrap_panic(&mut || result = (|| {
10097 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10098 let this = &*(this as *const D::TestBinding);
10099 let args = &*args;
10100 let argc = args.argc_;
10101 let result: Option<u64> = this.ReceiveNullableUnsignedLongLong();
10102
10103 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10104 return true;
10105 })());
10106 result
10107}
10108
10109
10110static receiveNullableUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10111
10112pub(crate) fn init_receiveNullableUnsignedLongLong_methodinfo<D: DomTypes>() {
10113 receiveNullableUnsignedLongLong_methodinfo.set(JSJitInfo {
10114 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10115 method: Some(receiveNullableUnsignedLongLong::<D>)
10116 },
10117 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10118 protoID: PrototypeList::ID::TestBinding as u16,
10119 },
10120 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10121 _bitfield_align_1: [],
10122 _bitfield_1: __BindgenBitfieldUnit::new(
10123 new_jsjitinfo_bitfield_1!(
10124 JSJitInfo_OpType::Method as u8,
10125 JSJitInfo_AliasSet::AliasEverything as u8,
10126 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10127 true,
10128 false,
10129 false,
10130 false,
10131 false,
10132 false,
10133 0,
10134 ).to_ne_bytes()
10135 ),
10136});
10137}
10138unsafe extern "C" fn receiveNullableUnrestrictedFloat<D: DomTypes>
10139(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10140 let mut result = false;
10141 wrap_panic(&mut || result = (|| {
10142 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10143 let this = &*(this as *const D::TestBinding);
10144 let args = &*args;
10145 let argc = args.argc_;
10146 let result: Option<f32> = this.ReceiveNullableUnrestrictedFloat();
10147
10148 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10149 return true;
10150 })());
10151 result
10152}
10153
10154
10155static receiveNullableUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10156
10157pub(crate) fn init_receiveNullableUnrestrictedFloat_methodinfo<D: DomTypes>() {
10158 receiveNullableUnrestrictedFloat_methodinfo.set(JSJitInfo {
10159 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10160 method: Some(receiveNullableUnrestrictedFloat::<D>)
10161 },
10162 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10163 protoID: PrototypeList::ID::TestBinding as u16,
10164 },
10165 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10166 _bitfield_align_1: [],
10167 _bitfield_1: __BindgenBitfieldUnit::new(
10168 new_jsjitinfo_bitfield_1!(
10169 JSJitInfo_OpType::Method as u8,
10170 JSJitInfo_AliasSet::AliasEverything as u8,
10171 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10172 true,
10173 false,
10174 false,
10175 false,
10176 false,
10177 false,
10178 0,
10179 ).to_ne_bytes()
10180 ),
10181});
10182}
10183unsafe extern "C" fn receiveNullableFloat<D: DomTypes>
10184(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10185 let mut result = false;
10186 wrap_panic(&mut || result = (|| {
10187 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10188 let this = &*(this as *const D::TestBinding);
10189 let args = &*args;
10190 let argc = args.argc_;
10191 let result: Option<Finite<f32>> = this.ReceiveNullableFloat();
10192
10193 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10194 return true;
10195 })());
10196 result
10197}
10198
10199
10200static receiveNullableFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10201
10202pub(crate) fn init_receiveNullableFloat_methodinfo<D: DomTypes>() {
10203 receiveNullableFloat_methodinfo.set(JSJitInfo {
10204 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10205 method: Some(receiveNullableFloat::<D>)
10206 },
10207 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10208 protoID: PrototypeList::ID::TestBinding as u16,
10209 },
10210 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10211 _bitfield_align_1: [],
10212 _bitfield_1: __BindgenBitfieldUnit::new(
10213 new_jsjitinfo_bitfield_1!(
10214 JSJitInfo_OpType::Method as u8,
10215 JSJitInfo_AliasSet::AliasEverything as u8,
10216 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10217 true,
10218 false,
10219 false,
10220 false,
10221 false,
10222 false,
10223 0,
10224 ).to_ne_bytes()
10225 ),
10226});
10227}
10228unsafe extern "C" fn receiveNullableUnrestrictedDouble<D: DomTypes>
10229(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10230 let mut result = false;
10231 wrap_panic(&mut || result = (|| {
10232 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10233 let this = &*(this as *const D::TestBinding);
10234 let args = &*args;
10235 let argc = args.argc_;
10236 let result: Option<f64> = this.ReceiveNullableUnrestrictedDouble();
10237
10238 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10239 return true;
10240 })());
10241 result
10242}
10243
10244
10245static receiveNullableUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10246
10247pub(crate) fn init_receiveNullableUnrestrictedDouble_methodinfo<D: DomTypes>() {
10248 receiveNullableUnrestrictedDouble_methodinfo.set(JSJitInfo {
10249 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10250 method: Some(receiveNullableUnrestrictedDouble::<D>)
10251 },
10252 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10253 protoID: PrototypeList::ID::TestBinding as u16,
10254 },
10255 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10256 _bitfield_align_1: [],
10257 _bitfield_1: __BindgenBitfieldUnit::new(
10258 new_jsjitinfo_bitfield_1!(
10259 JSJitInfo_OpType::Method as u8,
10260 JSJitInfo_AliasSet::AliasEverything as u8,
10261 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10262 true,
10263 false,
10264 false,
10265 false,
10266 false,
10267 false,
10268 0,
10269 ).to_ne_bytes()
10270 ),
10271});
10272}
10273unsafe extern "C" fn receiveNullableDouble<D: DomTypes>
10274(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10275 let mut result = false;
10276 wrap_panic(&mut || result = (|| {
10277 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10278 let this = &*(this as *const D::TestBinding);
10279 let args = &*args;
10280 let argc = args.argc_;
10281 let result: Option<Finite<f64>> = this.ReceiveNullableDouble();
10282
10283 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10284 return true;
10285 })());
10286 result
10287}
10288
10289
10290static receiveNullableDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10291
10292pub(crate) fn init_receiveNullableDouble_methodinfo<D: DomTypes>() {
10293 receiveNullableDouble_methodinfo.set(JSJitInfo {
10294 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10295 method: Some(receiveNullableDouble::<D>)
10296 },
10297 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10298 protoID: PrototypeList::ID::TestBinding as u16,
10299 },
10300 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10301 _bitfield_align_1: [],
10302 _bitfield_1: __BindgenBitfieldUnit::new(
10303 new_jsjitinfo_bitfield_1!(
10304 JSJitInfo_OpType::Method as u8,
10305 JSJitInfo_AliasSet::AliasEverything as u8,
10306 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10307 true,
10308 false,
10309 false,
10310 false,
10311 false,
10312 false,
10313 0,
10314 ).to_ne_bytes()
10315 ),
10316});
10317}
10318unsafe extern "C" fn receiveNullableString<D: DomTypes>
10319(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10320 let mut result = false;
10321 wrap_panic(&mut || result = (|| {
10322 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10323 let this = &*(this as *const D::TestBinding);
10324 let args = &*args;
10325 let argc = args.argc_;
10326 let result: Option<DOMString> = this.ReceiveNullableString();
10327
10328 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10329 return true;
10330 })());
10331 result
10332}
10333
10334
10335static receiveNullableString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10336
10337pub(crate) fn init_receiveNullableString_methodinfo<D: DomTypes>() {
10338 receiveNullableString_methodinfo.set(JSJitInfo {
10339 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10340 method: Some(receiveNullableString::<D>)
10341 },
10342 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10343 protoID: PrototypeList::ID::TestBinding as u16,
10344 },
10345 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10346 _bitfield_align_1: [],
10347 _bitfield_1: __BindgenBitfieldUnit::new(
10348 new_jsjitinfo_bitfield_1!(
10349 JSJitInfo_OpType::Method as u8,
10350 JSJitInfo_AliasSet::AliasEverything as u8,
10351 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10352 true,
10353 false,
10354 false,
10355 false,
10356 false,
10357 false,
10358 0,
10359 ).to_ne_bytes()
10360 ),
10361});
10362}
10363unsafe extern "C" fn receiveNullableUsvstring<D: DomTypes>
10364(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10365 let mut result = false;
10366 wrap_panic(&mut || result = (|| {
10367 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10368 let this = &*(this as *const D::TestBinding);
10369 let args = &*args;
10370 let argc = args.argc_;
10371 let result: Option<USVString> = this.ReceiveNullableUsvstring();
10372
10373 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10374 return true;
10375 })());
10376 result
10377}
10378
10379
10380static receiveNullableUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10381
10382pub(crate) fn init_receiveNullableUsvstring_methodinfo<D: DomTypes>() {
10383 receiveNullableUsvstring_methodinfo.set(JSJitInfo {
10384 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10385 method: Some(receiveNullableUsvstring::<D>)
10386 },
10387 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10388 protoID: PrototypeList::ID::TestBinding as u16,
10389 },
10390 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10391 _bitfield_align_1: [],
10392 _bitfield_1: __BindgenBitfieldUnit::new(
10393 new_jsjitinfo_bitfield_1!(
10394 JSJitInfo_OpType::Method as u8,
10395 JSJitInfo_AliasSet::AliasEverything as u8,
10396 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10397 true,
10398 false,
10399 false,
10400 false,
10401 false,
10402 false,
10403 0,
10404 ).to_ne_bytes()
10405 ),
10406});
10407}
10408unsafe extern "C" fn receiveNullableByteString<D: DomTypes>
10409(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10410 let mut result = false;
10411 wrap_panic(&mut || result = (|| {
10412 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10413 let this = &*(this as *const D::TestBinding);
10414 let args = &*args;
10415 let argc = args.argc_;
10416 let result: Option<ByteString> = this.ReceiveNullableByteString();
10417
10418 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10419 return true;
10420 })());
10421 result
10422}
10423
10424
10425static receiveNullableByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10426
10427pub(crate) fn init_receiveNullableByteString_methodinfo<D: DomTypes>() {
10428 receiveNullableByteString_methodinfo.set(JSJitInfo {
10429 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10430 method: Some(receiveNullableByteString::<D>)
10431 },
10432 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10433 protoID: PrototypeList::ID::TestBinding as u16,
10434 },
10435 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10436 _bitfield_align_1: [],
10437 _bitfield_1: __BindgenBitfieldUnit::new(
10438 new_jsjitinfo_bitfield_1!(
10439 JSJitInfo_OpType::Method as u8,
10440 JSJitInfo_AliasSet::AliasEverything as u8,
10441 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10442 true,
10443 false,
10444 false,
10445 false,
10446 false,
10447 false,
10448 0,
10449 ).to_ne_bytes()
10450 ),
10451});
10452}
10453unsafe extern "C" fn receiveNullableEnum<D: DomTypes>
10454(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10455 let mut result = false;
10456 wrap_panic(&mut || result = (|| {
10457 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10458 let this = &*(this as *const D::TestBinding);
10459 let args = &*args;
10460 let argc = args.argc_;
10461 let result: Option<TestEnum> = this.ReceiveNullableEnum();
10462
10463 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10464 return true;
10465 })());
10466 result
10467}
10468
10469
10470static receiveNullableEnum_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10471
10472pub(crate) fn init_receiveNullableEnum_methodinfo<D: DomTypes>() {
10473 receiveNullableEnum_methodinfo.set(JSJitInfo {
10474 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10475 method: Some(receiveNullableEnum::<D>)
10476 },
10477 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10478 protoID: PrototypeList::ID::TestBinding as u16,
10479 },
10480 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10481 _bitfield_align_1: [],
10482 _bitfield_1: __BindgenBitfieldUnit::new(
10483 new_jsjitinfo_bitfield_1!(
10484 JSJitInfo_OpType::Method as u8,
10485 JSJitInfo_AliasSet::AliasEverything as u8,
10486 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10487 true,
10488 false,
10489 false,
10490 false,
10491 false,
10492 false,
10493 0,
10494 ).to_ne_bytes()
10495 ),
10496});
10497}
10498unsafe extern "C" fn receiveNullableInterface<D: DomTypes>
10499(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10500 let mut result = false;
10501 wrap_panic(&mut || result = (|| {
10502 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10503 let this = &*(this as *const D::TestBinding);
10504 let args = &*args;
10505 let argc = args.argc_;
10506 let result: Option<DomRoot<D::Blob>> = this.ReceiveNullableInterface(CanGc::note());
10507
10508 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10509 return true;
10510 })());
10511 result
10512}
10513
10514
10515static receiveNullableInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10516
10517pub(crate) fn init_receiveNullableInterface_methodinfo<D: DomTypes>() {
10518 receiveNullableInterface_methodinfo.set(JSJitInfo {
10519 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10520 method: Some(receiveNullableInterface::<D>)
10521 },
10522 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10523 protoID: PrototypeList::ID::TestBinding as u16,
10524 },
10525 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10526 _bitfield_align_1: [],
10527 _bitfield_1: __BindgenBitfieldUnit::new(
10528 new_jsjitinfo_bitfield_1!(
10529 JSJitInfo_OpType::Method as u8,
10530 JSJitInfo_AliasSet::AliasEverything as u8,
10531 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10532 true,
10533 false,
10534 false,
10535 false,
10536 false,
10537 false,
10538 0,
10539 ).to_ne_bytes()
10540 ),
10541});
10542}
10543unsafe extern "C" fn receiveNullableObject<D: DomTypes>
10544(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10545 let mut result = false;
10546 wrap_panic(&mut || result = (|| {
10547 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10548 let this = &*(this as *const D::TestBinding);
10549 let args = &*args;
10550 let argc = args.argc_;
10551 let result: Option<NonNull<JSObject>> = this.ReceiveNullableObject(SafeJSContext::from_ptr(cx.raw_cx()));
10552
10553 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10554 return true;
10555 })());
10556 result
10557}
10558
10559
10560static receiveNullableObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10561
10562pub(crate) fn init_receiveNullableObject_methodinfo<D: DomTypes>() {
10563 receiveNullableObject_methodinfo.set(JSJitInfo {
10564 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10565 method: Some(receiveNullableObject::<D>)
10566 },
10567 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10568 protoID: PrototypeList::ID::TestBinding as u16,
10569 },
10570 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10571 _bitfield_align_1: [],
10572 _bitfield_1: __BindgenBitfieldUnit::new(
10573 new_jsjitinfo_bitfield_1!(
10574 JSJitInfo_OpType::Method as u8,
10575 JSJitInfo_AliasSet::AliasEverything as u8,
10576 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10577 true,
10578 false,
10579 false,
10580 false,
10581 false,
10582 false,
10583 0,
10584 ).to_ne_bytes()
10585 ),
10586});
10587}
10588unsafe extern "C" fn receiveNullableUnion<D: DomTypes>
10589(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10590 let mut result = false;
10591 wrap_panic(&mut || result = (|| {
10592 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10593 let this = &*(this as *const D::TestBinding);
10594 let args = &*args;
10595 let argc = args.argc_;
10596 let result: Option<GenericUnionTypes::HTMLElementOrLong::<D>> = this.ReceiveNullableUnion();
10597
10598 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10599 return true;
10600 })());
10601 result
10602}
10603
10604
10605static receiveNullableUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10606
10607pub(crate) fn init_receiveNullableUnion_methodinfo<D: DomTypes>() {
10608 receiveNullableUnion_methodinfo.set(JSJitInfo {
10609 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10610 method: Some(receiveNullableUnion::<D>)
10611 },
10612 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10613 protoID: PrototypeList::ID::TestBinding as u16,
10614 },
10615 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10616 _bitfield_align_1: [],
10617 _bitfield_1: __BindgenBitfieldUnit::new(
10618 new_jsjitinfo_bitfield_1!(
10619 JSJitInfo_OpType::Method as u8,
10620 JSJitInfo_AliasSet::AliasEverything as u8,
10621 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10622 true,
10623 false,
10624 false,
10625 false,
10626 false,
10627 false,
10628 0,
10629 ).to_ne_bytes()
10630 ),
10631});
10632}
10633unsafe extern "C" fn receiveNullableUnion2<D: DomTypes>
10634(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10635 let mut result = false;
10636 wrap_panic(&mut || result = (|| {
10637 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10638 let this = &*(this as *const D::TestBinding);
10639 let args = &*args;
10640 let argc = args.argc_;
10641 let result: Option<GenericUnionTypes::EventOrString::<D>> = this.ReceiveNullableUnion2();
10642
10643 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10644 return true;
10645 })());
10646 result
10647}
10648
10649
10650static receiveNullableUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10651
10652pub(crate) fn init_receiveNullableUnion2_methodinfo<D: DomTypes>() {
10653 receiveNullableUnion2_methodinfo.set(JSJitInfo {
10654 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10655 method: Some(receiveNullableUnion2::<D>)
10656 },
10657 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10658 protoID: PrototypeList::ID::TestBinding as u16,
10659 },
10660 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10661 _bitfield_align_1: [],
10662 _bitfield_1: __BindgenBitfieldUnit::new(
10663 new_jsjitinfo_bitfield_1!(
10664 JSJitInfo_OpType::Method as u8,
10665 JSJitInfo_AliasSet::AliasEverything as u8,
10666 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10667 true,
10668 false,
10669 false,
10670 false,
10671 false,
10672 false,
10673 0,
10674 ).to_ne_bytes()
10675 ),
10676});
10677}
10678unsafe extern "C" fn receiveNullableUnion3<D: DomTypes>
10679(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10680 let mut result = false;
10681 wrap_panic(&mut || result = (|| {
10682 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10683 let this = &*(this as *const D::TestBinding);
10684 let args = &*args;
10685 let argc = args.argc_;
10686 let result: Option<GenericUnionTypes::StringOrLongSequence> = this.ReceiveNullableUnion3();
10687
10688 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10689 return true;
10690 })());
10691 result
10692}
10693
10694
10695static receiveNullableUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10696
10697pub(crate) fn init_receiveNullableUnion3_methodinfo<D: DomTypes>() {
10698 receiveNullableUnion3_methodinfo.set(JSJitInfo {
10699 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10700 method: Some(receiveNullableUnion3::<D>)
10701 },
10702 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10703 protoID: PrototypeList::ID::TestBinding as u16,
10704 },
10705 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10706 _bitfield_align_1: [],
10707 _bitfield_1: __BindgenBitfieldUnit::new(
10708 new_jsjitinfo_bitfield_1!(
10709 JSJitInfo_OpType::Method as u8,
10710 JSJitInfo_AliasSet::AliasEverything as u8,
10711 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10712 true,
10713 false,
10714 false,
10715 false,
10716 false,
10717 false,
10718 0,
10719 ).to_ne_bytes()
10720 ),
10721});
10722}
10723unsafe extern "C" fn receiveNullableUnion4<D: DomTypes>
10724(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10725 let mut result = false;
10726 wrap_panic(&mut || result = (|| {
10727 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10728 let this = &*(this as *const D::TestBinding);
10729 let args = &*args;
10730 let argc = args.argc_;
10731 let result: Option<GenericUnionTypes::LongSequenceOrBoolean> = this.ReceiveNullableUnion4();
10732
10733 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10734 return true;
10735 })());
10736 result
10737}
10738
10739
10740static receiveNullableUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10741
10742pub(crate) fn init_receiveNullableUnion4_methodinfo<D: DomTypes>() {
10743 receiveNullableUnion4_methodinfo.set(JSJitInfo {
10744 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10745 method: Some(receiveNullableUnion4::<D>)
10746 },
10747 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10748 protoID: PrototypeList::ID::TestBinding as u16,
10749 },
10750 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10751 _bitfield_align_1: [],
10752 _bitfield_1: __BindgenBitfieldUnit::new(
10753 new_jsjitinfo_bitfield_1!(
10754 JSJitInfo_OpType::Method as u8,
10755 JSJitInfo_AliasSet::AliasEverything as u8,
10756 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10757 true,
10758 false,
10759 false,
10760 false,
10761 false,
10762 false,
10763 0,
10764 ).to_ne_bytes()
10765 ),
10766});
10767}
10768unsafe extern "C" fn receiveNullableUnion5<D: DomTypes>
10769(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10770 let mut result = false;
10771 wrap_panic(&mut || result = (|| {
10772 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10773 let this = &*(this as *const D::TestBinding);
10774 let args = &*args;
10775 let argc = args.argc_;
10776 let result: Option<GenericUnionTypes::UnsignedLongOrBoolean> = this.ReceiveNullableUnion5();
10777
10778 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10779 return true;
10780 })());
10781 result
10782}
10783
10784
10785static receiveNullableUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10786
10787pub(crate) fn init_receiveNullableUnion5_methodinfo<D: DomTypes>() {
10788 receiveNullableUnion5_methodinfo.set(JSJitInfo {
10789 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10790 method: Some(receiveNullableUnion5::<D>)
10791 },
10792 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10793 protoID: PrototypeList::ID::TestBinding as u16,
10794 },
10795 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10796 _bitfield_align_1: [],
10797 _bitfield_1: __BindgenBitfieldUnit::new(
10798 new_jsjitinfo_bitfield_1!(
10799 JSJitInfo_OpType::Method as u8,
10800 JSJitInfo_AliasSet::AliasEverything as u8,
10801 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10802 true,
10803 false,
10804 false,
10805 false,
10806 false,
10807 false,
10808 0,
10809 ).to_ne_bytes()
10810 ),
10811});
10812}
10813unsafe extern "C" fn receiveNullableUnion6<D: DomTypes>
10814(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10815 let mut result = false;
10816 wrap_panic(&mut || result = (|| {
10817 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10818 let this = &*(this as *const D::TestBinding);
10819 let args = &*args;
10820 let argc = args.argc_;
10821 let result: Option<GenericUnionTypes::ByteStringOrLong> = this.ReceiveNullableUnion6();
10822
10823 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10824 return true;
10825 })());
10826 result
10827}
10828
10829
10830static receiveNullableUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10831
10832pub(crate) fn init_receiveNullableUnion6_methodinfo<D: DomTypes>() {
10833 receiveNullableUnion6_methodinfo.set(JSJitInfo {
10834 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10835 method: Some(receiveNullableUnion6::<D>)
10836 },
10837 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10838 protoID: PrototypeList::ID::TestBinding as u16,
10839 },
10840 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10841 _bitfield_align_1: [],
10842 _bitfield_1: __BindgenBitfieldUnit::new(
10843 new_jsjitinfo_bitfield_1!(
10844 JSJitInfo_OpType::Method as u8,
10845 JSJitInfo_AliasSet::AliasEverything as u8,
10846 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10847 true,
10848 false,
10849 false,
10850 false,
10851 false,
10852 false,
10853 0,
10854 ).to_ne_bytes()
10855 ),
10856});
10857}
10858unsafe extern "C" fn receiveNullableSequence<D: DomTypes>
10859(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10860 let mut result = false;
10861 wrap_panic(&mut || result = (|| {
10862 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10863 let this = &*(this as *const D::TestBinding);
10864 let args = &*args;
10865 let argc = args.argc_;
10866 let result: Option<Vec<i32>> = this.ReceiveNullableSequence();
10867
10868 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10869 return true;
10870 })());
10871 result
10872}
10873
10874
10875static receiveNullableSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10876
10877pub(crate) fn init_receiveNullableSequence_methodinfo<D: DomTypes>() {
10878 receiveNullableSequence_methodinfo.set(JSJitInfo {
10879 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10880 method: Some(receiveNullableSequence::<D>)
10881 },
10882 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10883 protoID: PrototypeList::ID::TestBinding as u16,
10884 },
10885 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10886 _bitfield_align_1: [],
10887 _bitfield_1: __BindgenBitfieldUnit::new(
10888 new_jsjitinfo_bitfield_1!(
10889 JSJitInfo_OpType::Method as u8,
10890 JSJitInfo_AliasSet::AliasEverything as u8,
10891 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
10892 true,
10893 false,
10894 false,
10895 false,
10896 false,
10897 false,
10898 0,
10899 ).to_ne_bytes()
10900 ),
10901});
10902}
10903unsafe extern "C" fn receiveTestDictionaryWithSuccessOnKeyword<D: DomTypes>
10904(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10905 let mut result = false;
10906 wrap_panic(&mut || result = (|| {
10907 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10908 let this = &*(this as *const D::TestBinding);
10909 let args = &*args;
10910 let argc = args.argc_;
10911 let result: RootedTraceableBox<TestDictionary<D>> = this.ReceiveTestDictionaryWithSuccessOnKeyword();
10912
10913 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10914 return true;
10915 })());
10916 result
10917}
10918
10919
10920static receiveTestDictionaryWithSuccessOnKeyword_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10921
10922pub(crate) fn init_receiveTestDictionaryWithSuccessOnKeyword_methodinfo<D: DomTypes>() {
10923 receiveTestDictionaryWithSuccessOnKeyword_methodinfo.set(JSJitInfo {
10924 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10925 method: Some(receiveTestDictionaryWithSuccessOnKeyword::<D>)
10926 },
10927 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10928 protoID: PrototypeList::ID::TestBinding as u16,
10929 },
10930 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10931 _bitfield_align_1: [],
10932 _bitfield_1: __BindgenBitfieldUnit::new(
10933 new_jsjitinfo_bitfield_1!(
10934 JSJitInfo_OpType::Method as u8,
10935 JSJitInfo_AliasSet::AliasEverything as u8,
10936 JSValueType::JSVAL_TYPE_OBJECT as u8,
10937 true,
10938 false,
10939 false,
10940 false,
10941 false,
10942 false,
10943 0,
10944 ).to_ne_bytes()
10945 ),
10946});
10947}
10948unsafe extern "C" fn dictMatchesPassedValues<D: DomTypes>
10949(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
10950 let mut result = false;
10951 wrap_panic(&mut || result = (|| {
10952 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
10953 let this = &*(this as *const D::TestBinding);
10954 let args = &*args;
10955 let argc = args.argc_;
10956
10957 if argc < 1 {
10958 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.dictMatchesPassedValues\".");
10959 return false;
10960 }
10961 let arg0: RootedTraceableBox<crate::codegen::GenericBindings::TestBindingBinding::TestDictionary<D>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
10962 Ok(ConversionResult::Success(value)) => value,
10963 Ok(ConversionResult::Failure(error)) => {
10964 throw_type_error(cx.raw_cx(), &error);
10965 return false;
10966
10967 }
10968 _ => {
10969 return false;
10970
10971 },
10972 }
10973 ;
10974 let result: bool = this.DictMatchesPassedValues(arg0);
10975
10976 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
10977 return true;
10978 })());
10979 result
10980}
10981
10982
10983static dictMatchesPassedValues_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
10984
10985pub(crate) fn init_dictMatchesPassedValues_methodinfo<D: DomTypes>() {
10986 dictMatchesPassedValues_methodinfo.set(JSJitInfo {
10987 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
10988 method: Some(dictMatchesPassedValues::<D>)
10989 },
10990 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
10991 protoID: PrototypeList::ID::TestBinding as u16,
10992 },
10993 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
10994 _bitfield_align_1: [],
10995 _bitfield_1: __BindgenBitfieldUnit::new(
10996 new_jsjitinfo_bitfield_1!(
10997 JSJitInfo_OpType::Method as u8,
10998 JSJitInfo_AliasSet::AliasEverything as u8,
10999 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
11000 false,
11001 false,
11002 false,
11003 false,
11004 false,
11005 false,
11006 0,
11007 ).to_ne_bytes()
11008 ),
11009});
11010}
11011unsafe extern "C" fn receiveUnionIdentity<D: DomTypes>
11012(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11013 let mut result = false;
11014 wrap_panic(&mut || result = (|| {
11015 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11016 let this = &*(this as *const D::TestBinding);
11017 let args = &*args;
11018 let argc = args.argc_;
11019
11020 if argc < 1 {
11021 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.receiveUnionIdentity\".");
11022 return false;
11023 }
11024 let arg0: GenericUnionTypes::StringOrObject = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11025 Ok(ConversionResult::Success(value)) => value,
11026 Ok(ConversionResult::Failure(error)) => {
11027 throw_type_error(cx.raw_cx(), &error);
11028 return false;
11029
11030 }
11031 _ => {
11032 return false;
11033
11034 },
11035 }
11036 ;
11037 let result: GenericUnionTypes::StringOrObject = this.ReceiveUnionIdentity(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
11038
11039 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11040 return true;
11041 })());
11042 result
11043}
11044
11045
11046static receiveUnionIdentity_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11047
11048pub(crate) fn init_receiveUnionIdentity_methodinfo<D: DomTypes>() {
11049 receiveUnionIdentity_methodinfo.set(JSJitInfo {
11050 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11051 method: Some(receiveUnionIdentity::<D>)
11052 },
11053 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11054 protoID: PrototypeList::ID::TestBinding as u16,
11055 },
11056 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11057 _bitfield_align_1: [],
11058 _bitfield_1: __BindgenBitfieldUnit::new(
11059 new_jsjitinfo_bitfield_1!(
11060 JSJitInfo_OpType::Method as u8,
11061 JSJitInfo_AliasSet::AliasEverything as u8,
11062 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
11063 false,
11064 false,
11065 false,
11066 false,
11067 false,
11068 false,
11069 0,
11070 ).to_ne_bytes()
11071 ),
11072});
11073}
11074unsafe extern "C" fn passBoolean<D: DomTypes>
11075(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11076 let mut result = false;
11077 wrap_panic(&mut || result = (|| {
11078 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11079 let this = &*(this as *const D::TestBinding);
11080 let args = &*args;
11081 let argc = args.argc_;
11082
11083 if argc < 1 {
11084 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passBoolean\".");
11085 return false;
11086 }
11087 let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11088 Ok(ConversionResult::Success(value)) => value,
11089 Ok(ConversionResult::Failure(error)) => {
11090 throw_type_error(cx.raw_cx(), &error);
11091 return false;
11092
11093 }
11094 _ => {
11095 return false;
11096
11097 },
11098 }
11099 ;
11100 let result: () = this.PassBoolean(arg0);
11101
11102 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11103 return true;
11104 })());
11105 result
11106}
11107
11108
11109static passBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11110
11111pub(crate) fn init_passBoolean_methodinfo<D: DomTypes>() {
11112 passBoolean_methodinfo.set(JSJitInfo {
11113 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11114 method: Some(passBoolean::<D>)
11115 },
11116 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11117 protoID: PrototypeList::ID::TestBinding as u16,
11118 },
11119 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11120 _bitfield_align_1: [],
11121 _bitfield_1: __BindgenBitfieldUnit::new(
11122 new_jsjitinfo_bitfield_1!(
11123 JSJitInfo_OpType::Method as u8,
11124 JSJitInfo_AliasSet::AliasEverything as u8,
11125 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11126 false,
11127 false,
11128 false,
11129 false,
11130 false,
11131 false,
11132 0,
11133 ).to_ne_bytes()
11134 ),
11135});
11136}
11137unsafe extern "C" fn passByte<D: DomTypes>
11138(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11139 let mut result = false;
11140 wrap_panic(&mut || result = (|| {
11141 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11142 let this = &*(this as *const D::TestBinding);
11143 let args = &*args;
11144 let argc = args.argc_;
11145
11146 if argc < 1 {
11147 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passByte\".");
11148 return false;
11149 }
11150 let arg0: i8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11151 Ok(ConversionResult::Success(value)) => value,
11152 Ok(ConversionResult::Failure(error)) => {
11153 throw_type_error(cx.raw_cx(), &error);
11154 return false;
11155
11156 }
11157 _ => {
11158 return false;
11159
11160 },
11161 }
11162 ;
11163 let result: () = this.PassByte(arg0);
11164
11165 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11166 return true;
11167 })());
11168 result
11169}
11170
11171
11172static passByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11173
11174pub(crate) fn init_passByte_methodinfo<D: DomTypes>() {
11175 passByte_methodinfo.set(JSJitInfo {
11176 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11177 method: Some(passByte::<D>)
11178 },
11179 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11180 protoID: PrototypeList::ID::TestBinding as u16,
11181 },
11182 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11183 _bitfield_align_1: [],
11184 _bitfield_1: __BindgenBitfieldUnit::new(
11185 new_jsjitinfo_bitfield_1!(
11186 JSJitInfo_OpType::Method as u8,
11187 JSJitInfo_AliasSet::AliasEverything as u8,
11188 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11189 false,
11190 false,
11191 false,
11192 false,
11193 false,
11194 false,
11195 0,
11196 ).to_ne_bytes()
11197 ),
11198});
11199}
11200unsafe extern "C" fn passOctet<D: DomTypes>
11201(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11202 let mut result = false;
11203 wrap_panic(&mut || result = (|| {
11204 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11205 let this = &*(this as *const D::TestBinding);
11206 let args = &*args;
11207 let argc = args.argc_;
11208
11209 if argc < 1 {
11210 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passOctet\".");
11211 return false;
11212 }
11213 let arg0: u8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11214 Ok(ConversionResult::Success(value)) => value,
11215 Ok(ConversionResult::Failure(error)) => {
11216 throw_type_error(cx.raw_cx(), &error);
11217 return false;
11218
11219 }
11220 _ => {
11221 return false;
11222
11223 },
11224 }
11225 ;
11226 let result: () = this.PassOctet(arg0);
11227
11228 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11229 return true;
11230 })());
11231 result
11232}
11233
11234
11235static passOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11236
11237pub(crate) fn init_passOctet_methodinfo<D: DomTypes>() {
11238 passOctet_methodinfo.set(JSJitInfo {
11239 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11240 method: Some(passOctet::<D>)
11241 },
11242 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11243 protoID: PrototypeList::ID::TestBinding as u16,
11244 },
11245 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11246 _bitfield_align_1: [],
11247 _bitfield_1: __BindgenBitfieldUnit::new(
11248 new_jsjitinfo_bitfield_1!(
11249 JSJitInfo_OpType::Method as u8,
11250 JSJitInfo_AliasSet::AliasEverything as u8,
11251 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11252 false,
11253 false,
11254 false,
11255 false,
11256 false,
11257 false,
11258 0,
11259 ).to_ne_bytes()
11260 ),
11261});
11262}
11263unsafe extern "C" fn passShort<D: DomTypes>
11264(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11265 let mut result = false;
11266 wrap_panic(&mut || result = (|| {
11267 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11268 let this = &*(this as *const D::TestBinding);
11269 let args = &*args;
11270 let argc = args.argc_;
11271
11272 if argc < 1 {
11273 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passShort\".");
11274 return false;
11275 }
11276 let arg0: i16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11277 Ok(ConversionResult::Success(value)) => value,
11278 Ok(ConversionResult::Failure(error)) => {
11279 throw_type_error(cx.raw_cx(), &error);
11280 return false;
11281
11282 }
11283 _ => {
11284 return false;
11285
11286 },
11287 }
11288 ;
11289 let result: () = this.PassShort(arg0);
11290
11291 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11292 return true;
11293 })());
11294 result
11295}
11296
11297
11298static passShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11299
11300pub(crate) fn init_passShort_methodinfo<D: DomTypes>() {
11301 passShort_methodinfo.set(JSJitInfo {
11302 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11303 method: Some(passShort::<D>)
11304 },
11305 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11306 protoID: PrototypeList::ID::TestBinding as u16,
11307 },
11308 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11309 _bitfield_align_1: [],
11310 _bitfield_1: __BindgenBitfieldUnit::new(
11311 new_jsjitinfo_bitfield_1!(
11312 JSJitInfo_OpType::Method as u8,
11313 JSJitInfo_AliasSet::AliasEverything as u8,
11314 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11315 false,
11316 false,
11317 false,
11318 false,
11319 false,
11320 false,
11321 0,
11322 ).to_ne_bytes()
11323 ),
11324});
11325}
11326unsafe extern "C" fn passUnsignedShort<D: DomTypes>
11327(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11328 let mut result = false;
11329 wrap_panic(&mut || result = (|| {
11330 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11331 let this = &*(this as *const D::TestBinding);
11332 let args = &*args;
11333 let argc = args.argc_;
11334
11335 if argc < 1 {
11336 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnsignedShort\".");
11337 return false;
11338 }
11339 let arg0: u16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11340 Ok(ConversionResult::Success(value)) => value,
11341 Ok(ConversionResult::Failure(error)) => {
11342 throw_type_error(cx.raw_cx(), &error);
11343 return false;
11344
11345 }
11346 _ => {
11347 return false;
11348
11349 },
11350 }
11351 ;
11352 let result: () = this.PassUnsignedShort(arg0);
11353
11354 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11355 return true;
11356 })());
11357 result
11358}
11359
11360
11361static passUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11362
11363pub(crate) fn init_passUnsignedShort_methodinfo<D: DomTypes>() {
11364 passUnsignedShort_methodinfo.set(JSJitInfo {
11365 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11366 method: Some(passUnsignedShort::<D>)
11367 },
11368 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11369 protoID: PrototypeList::ID::TestBinding as u16,
11370 },
11371 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11372 _bitfield_align_1: [],
11373 _bitfield_1: __BindgenBitfieldUnit::new(
11374 new_jsjitinfo_bitfield_1!(
11375 JSJitInfo_OpType::Method as u8,
11376 JSJitInfo_AliasSet::AliasEverything as u8,
11377 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11378 false,
11379 false,
11380 false,
11381 false,
11382 false,
11383 false,
11384 0,
11385 ).to_ne_bytes()
11386 ),
11387});
11388}
11389unsafe extern "C" fn passLong<D: DomTypes>
11390(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11391 let mut result = false;
11392 wrap_panic(&mut || result = (|| {
11393 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11394 let this = &*(this as *const D::TestBinding);
11395 let args = &*args;
11396 let argc = args.argc_;
11397
11398 if argc < 1 {
11399 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passLong\".");
11400 return false;
11401 }
11402 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11403 Ok(ConversionResult::Success(value)) => value,
11404 Ok(ConversionResult::Failure(error)) => {
11405 throw_type_error(cx.raw_cx(), &error);
11406 return false;
11407
11408 }
11409 _ => {
11410 return false;
11411
11412 },
11413 }
11414 ;
11415 let result: () = this.PassLong(arg0);
11416
11417 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11418 return true;
11419 })());
11420 result
11421}
11422
11423
11424static passLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11425
11426pub(crate) fn init_passLong_methodinfo<D: DomTypes>() {
11427 passLong_methodinfo.set(JSJitInfo {
11428 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11429 method: Some(passLong::<D>)
11430 },
11431 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11432 protoID: PrototypeList::ID::TestBinding as u16,
11433 },
11434 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11435 _bitfield_align_1: [],
11436 _bitfield_1: __BindgenBitfieldUnit::new(
11437 new_jsjitinfo_bitfield_1!(
11438 JSJitInfo_OpType::Method as u8,
11439 JSJitInfo_AliasSet::AliasEverything as u8,
11440 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11441 false,
11442 false,
11443 false,
11444 false,
11445 false,
11446 false,
11447 0,
11448 ).to_ne_bytes()
11449 ),
11450});
11451}
11452unsafe extern "C" fn passUnsignedLong<D: DomTypes>
11453(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11454 let mut result = false;
11455 wrap_panic(&mut || result = (|| {
11456 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11457 let this = &*(this as *const D::TestBinding);
11458 let args = &*args;
11459 let argc = args.argc_;
11460
11461 if argc < 1 {
11462 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnsignedLong\".");
11463 return false;
11464 }
11465 let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11466 Ok(ConversionResult::Success(value)) => value,
11467 Ok(ConversionResult::Failure(error)) => {
11468 throw_type_error(cx.raw_cx(), &error);
11469 return false;
11470
11471 }
11472 _ => {
11473 return false;
11474
11475 },
11476 }
11477 ;
11478 let result: () = this.PassUnsignedLong(arg0);
11479
11480 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11481 return true;
11482 })());
11483 result
11484}
11485
11486
11487static passUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11488
11489pub(crate) fn init_passUnsignedLong_methodinfo<D: DomTypes>() {
11490 passUnsignedLong_methodinfo.set(JSJitInfo {
11491 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11492 method: Some(passUnsignedLong::<D>)
11493 },
11494 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11495 protoID: PrototypeList::ID::TestBinding as u16,
11496 },
11497 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11498 _bitfield_align_1: [],
11499 _bitfield_1: __BindgenBitfieldUnit::new(
11500 new_jsjitinfo_bitfield_1!(
11501 JSJitInfo_OpType::Method as u8,
11502 JSJitInfo_AliasSet::AliasEverything as u8,
11503 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11504 false,
11505 false,
11506 false,
11507 false,
11508 false,
11509 false,
11510 0,
11511 ).to_ne_bytes()
11512 ),
11513});
11514}
11515unsafe extern "C" fn passLongLong<D: DomTypes>
11516(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11517 let mut result = false;
11518 wrap_panic(&mut || result = (|| {
11519 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11520 let this = &*(this as *const D::TestBinding);
11521 let args = &*args;
11522 let argc = args.argc_;
11523
11524 if argc < 1 {
11525 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passLongLong\".");
11526 return false;
11527 }
11528 let arg0: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11529 Ok(ConversionResult::Success(value)) => value,
11530 Ok(ConversionResult::Failure(error)) => {
11531 throw_type_error(cx.raw_cx(), &error);
11532 return false;
11533
11534 }
11535 _ => {
11536 return false;
11537
11538 },
11539 }
11540 ;
11541 let result: () = this.PassLongLong(arg0);
11542
11543 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11544 return true;
11545 })());
11546 result
11547}
11548
11549
11550static passLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11551
11552pub(crate) fn init_passLongLong_methodinfo<D: DomTypes>() {
11553 passLongLong_methodinfo.set(JSJitInfo {
11554 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11555 method: Some(passLongLong::<D>)
11556 },
11557 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11558 protoID: PrototypeList::ID::TestBinding as u16,
11559 },
11560 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11561 _bitfield_align_1: [],
11562 _bitfield_1: __BindgenBitfieldUnit::new(
11563 new_jsjitinfo_bitfield_1!(
11564 JSJitInfo_OpType::Method as u8,
11565 JSJitInfo_AliasSet::AliasEverything as u8,
11566 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11567 false,
11568 false,
11569 false,
11570 false,
11571 false,
11572 false,
11573 0,
11574 ).to_ne_bytes()
11575 ),
11576});
11577}
11578unsafe extern "C" fn passUnsignedLongLong<D: DomTypes>
11579(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11580 let mut result = false;
11581 wrap_panic(&mut || result = (|| {
11582 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11583 let this = &*(this as *const D::TestBinding);
11584 let args = &*args;
11585 let argc = args.argc_;
11586
11587 if argc < 1 {
11588 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnsignedLongLong\".");
11589 return false;
11590 }
11591 let arg0: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
11592 Ok(ConversionResult::Success(value)) => value,
11593 Ok(ConversionResult::Failure(error)) => {
11594 throw_type_error(cx.raw_cx(), &error);
11595 return false;
11596
11597 }
11598 _ => {
11599 return false;
11600
11601 },
11602 }
11603 ;
11604 let result: () = this.PassUnsignedLongLong(arg0);
11605
11606 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11607 return true;
11608 })());
11609 result
11610}
11611
11612
11613static passUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11614
11615pub(crate) fn init_passUnsignedLongLong_methodinfo<D: DomTypes>() {
11616 passUnsignedLongLong_methodinfo.set(JSJitInfo {
11617 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11618 method: Some(passUnsignedLongLong::<D>)
11619 },
11620 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11621 protoID: PrototypeList::ID::TestBinding as u16,
11622 },
11623 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11624 _bitfield_align_1: [],
11625 _bitfield_1: __BindgenBitfieldUnit::new(
11626 new_jsjitinfo_bitfield_1!(
11627 JSJitInfo_OpType::Method as u8,
11628 JSJitInfo_AliasSet::AliasEverything as u8,
11629 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11630 false,
11631 false,
11632 false,
11633 false,
11634 false,
11635 false,
11636 0,
11637 ).to_ne_bytes()
11638 ),
11639});
11640}
11641unsafe extern "C" fn passUnrestrictedFloat<D: DomTypes>
11642(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11643 let mut result = false;
11644 wrap_panic(&mut || result = (|| {
11645 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11646 let this = &*(this as *const D::TestBinding);
11647 let args = &*args;
11648 let argc = args.argc_;
11649
11650 if argc < 1 {
11651 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnrestrictedFloat\".");
11652 return false;
11653 }
11654 let arg0: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11655 Ok(ConversionResult::Success(value)) => value,
11656 Ok(ConversionResult::Failure(error)) => {
11657 throw_type_error(cx.raw_cx(), &error);
11658 return false;
11659
11660 }
11661 _ => {
11662 return false;
11663
11664 },
11665 }
11666 ;
11667 let result: () = this.PassUnrestrictedFloat(arg0);
11668
11669 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11670 return true;
11671 })());
11672 result
11673}
11674
11675
11676static passUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11677
11678pub(crate) fn init_passUnrestrictedFloat_methodinfo<D: DomTypes>() {
11679 passUnrestrictedFloat_methodinfo.set(JSJitInfo {
11680 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11681 method: Some(passUnrestrictedFloat::<D>)
11682 },
11683 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11684 protoID: PrototypeList::ID::TestBinding as u16,
11685 },
11686 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11687 _bitfield_align_1: [],
11688 _bitfield_1: __BindgenBitfieldUnit::new(
11689 new_jsjitinfo_bitfield_1!(
11690 JSJitInfo_OpType::Method as u8,
11691 JSJitInfo_AliasSet::AliasEverything as u8,
11692 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11693 false,
11694 false,
11695 false,
11696 false,
11697 false,
11698 false,
11699 0,
11700 ).to_ne_bytes()
11701 ),
11702});
11703}
11704unsafe extern "C" fn passFloat<D: DomTypes>
11705(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11706 let mut result = false;
11707 wrap_panic(&mut || result = (|| {
11708 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11709 let this = &*(this as *const D::TestBinding);
11710 let args = &*args;
11711 let argc = args.argc_;
11712
11713 if argc < 1 {
11714 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passFloat\".");
11715 return false;
11716 }
11717 let arg0: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11718 Ok(ConversionResult::Success(value)) => value,
11719 Ok(ConversionResult::Failure(error)) => {
11720 throw_type_error(cx.raw_cx(), &error);
11721 return false;
11722
11723 }
11724 _ => {
11725 return false;
11726
11727 },
11728 }
11729 ;
11730 let result: () = this.PassFloat(arg0);
11731
11732 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11733 return true;
11734 })());
11735 result
11736}
11737
11738
11739static passFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11740
11741pub(crate) fn init_passFloat_methodinfo<D: DomTypes>() {
11742 passFloat_methodinfo.set(JSJitInfo {
11743 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11744 method: Some(passFloat::<D>)
11745 },
11746 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11747 protoID: PrototypeList::ID::TestBinding as u16,
11748 },
11749 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11750 _bitfield_align_1: [],
11751 _bitfield_1: __BindgenBitfieldUnit::new(
11752 new_jsjitinfo_bitfield_1!(
11753 JSJitInfo_OpType::Method as u8,
11754 JSJitInfo_AliasSet::AliasEverything as u8,
11755 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11756 false,
11757 false,
11758 false,
11759 false,
11760 false,
11761 false,
11762 0,
11763 ).to_ne_bytes()
11764 ),
11765});
11766}
11767unsafe extern "C" fn passUnrestrictedDouble<D: DomTypes>
11768(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11769 let mut result = false;
11770 wrap_panic(&mut || result = (|| {
11771 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11772 let this = &*(this as *const D::TestBinding);
11773 let args = &*args;
11774 let argc = args.argc_;
11775
11776 if argc < 1 {
11777 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnrestrictedDouble\".");
11778 return false;
11779 }
11780 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11781 Ok(ConversionResult::Success(value)) => value,
11782 Ok(ConversionResult::Failure(error)) => {
11783 throw_type_error(cx.raw_cx(), &error);
11784 return false;
11785
11786 }
11787 _ => {
11788 return false;
11789
11790 },
11791 }
11792 ;
11793 let result: () = this.PassUnrestrictedDouble(arg0);
11794
11795 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11796 return true;
11797 })());
11798 result
11799}
11800
11801
11802static passUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11803
11804pub(crate) fn init_passUnrestrictedDouble_methodinfo<D: DomTypes>() {
11805 passUnrestrictedDouble_methodinfo.set(JSJitInfo {
11806 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11807 method: Some(passUnrestrictedDouble::<D>)
11808 },
11809 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11810 protoID: PrototypeList::ID::TestBinding as u16,
11811 },
11812 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11813 _bitfield_align_1: [],
11814 _bitfield_1: __BindgenBitfieldUnit::new(
11815 new_jsjitinfo_bitfield_1!(
11816 JSJitInfo_OpType::Method as u8,
11817 JSJitInfo_AliasSet::AliasEverything as u8,
11818 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11819 false,
11820 false,
11821 false,
11822 false,
11823 false,
11824 false,
11825 0,
11826 ).to_ne_bytes()
11827 ),
11828});
11829}
11830unsafe extern "C" fn passDouble<D: DomTypes>
11831(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11832 let mut result = false;
11833 wrap_panic(&mut || result = (|| {
11834 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11835 let this = &*(this as *const D::TestBinding);
11836 let args = &*args;
11837 let argc = args.argc_;
11838
11839 if argc < 1 {
11840 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passDouble\".");
11841 return false;
11842 }
11843 let arg0: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11844 Ok(ConversionResult::Success(value)) => value,
11845 Ok(ConversionResult::Failure(error)) => {
11846 throw_type_error(cx.raw_cx(), &error);
11847 return false;
11848
11849 }
11850 _ => {
11851 return false;
11852
11853 },
11854 }
11855 ;
11856 let result: () = this.PassDouble(arg0);
11857
11858 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11859 return true;
11860 })());
11861 result
11862}
11863
11864
11865static passDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11866
11867pub(crate) fn init_passDouble_methodinfo<D: DomTypes>() {
11868 passDouble_methodinfo.set(JSJitInfo {
11869 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11870 method: Some(passDouble::<D>)
11871 },
11872 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11873 protoID: PrototypeList::ID::TestBinding as u16,
11874 },
11875 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11876 _bitfield_align_1: [],
11877 _bitfield_1: __BindgenBitfieldUnit::new(
11878 new_jsjitinfo_bitfield_1!(
11879 JSJitInfo_OpType::Method as u8,
11880 JSJitInfo_AliasSet::AliasEverything as u8,
11881 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11882 false,
11883 false,
11884 false,
11885 false,
11886 false,
11887 false,
11888 0,
11889 ).to_ne_bytes()
11890 ),
11891});
11892}
11893unsafe extern "C" fn passString<D: DomTypes>
11894(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11895 let mut result = false;
11896 wrap_panic(&mut || result = (|| {
11897 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11898 let this = &*(this as *const D::TestBinding);
11899 let args = &*args;
11900 let argc = args.argc_;
11901
11902 if argc < 1 {
11903 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passString\".");
11904 return false;
11905 }
11906 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
11907 Ok(ConversionResult::Success(value)) => value,
11908 Ok(ConversionResult::Failure(error)) => {
11909 throw_type_error(cx.raw_cx(), &error);
11910 return false;
11911
11912 }
11913 _ => {
11914 return false;
11915
11916 },
11917 }
11918 ;
11919 let result: () = this.PassString(arg0);
11920
11921 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11922 return true;
11923 })());
11924 result
11925}
11926
11927
11928static passString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11929
11930pub(crate) fn init_passString_methodinfo<D: DomTypes>() {
11931 passString_methodinfo.set(JSJitInfo {
11932 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11933 method: Some(passString::<D>)
11934 },
11935 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11936 protoID: PrototypeList::ID::TestBinding as u16,
11937 },
11938 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
11939 _bitfield_align_1: [],
11940 _bitfield_1: __BindgenBitfieldUnit::new(
11941 new_jsjitinfo_bitfield_1!(
11942 JSJitInfo_OpType::Method as u8,
11943 JSJitInfo_AliasSet::AliasEverything as u8,
11944 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
11945 false,
11946 false,
11947 false,
11948 false,
11949 false,
11950 false,
11951 0,
11952 ).to_ne_bytes()
11953 ),
11954});
11955}
11956unsafe extern "C" fn passUsvstring<D: DomTypes>
11957(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
11958 let mut result = false;
11959 wrap_panic(&mut || result = (|| {
11960 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
11961 let this = &*(this as *const D::TestBinding);
11962 let args = &*args;
11963 let argc = args.argc_;
11964
11965 if argc < 1 {
11966 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUsvstring\".");
11967 return false;
11968 }
11969 let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
11970 Ok(ConversionResult::Success(value)) => value,
11971 Ok(ConversionResult::Failure(error)) => {
11972 throw_type_error(cx.raw_cx(), &error);
11973 return false;
11974
11975 }
11976 _ => {
11977 return false;
11978
11979 },
11980 }
11981 ;
11982 let result: () = this.PassUsvstring(arg0);
11983
11984 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
11985 return true;
11986 })());
11987 result
11988}
11989
11990
11991static passUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
11992
11993pub(crate) fn init_passUsvstring_methodinfo<D: DomTypes>() {
11994 passUsvstring_methodinfo.set(JSJitInfo {
11995 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
11996 method: Some(passUsvstring::<D>)
11997 },
11998 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
11999 protoID: PrototypeList::ID::TestBinding as u16,
12000 },
12001 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12002 _bitfield_align_1: [],
12003 _bitfield_1: __BindgenBitfieldUnit::new(
12004 new_jsjitinfo_bitfield_1!(
12005 JSJitInfo_OpType::Method as u8,
12006 JSJitInfo_AliasSet::AliasEverything as u8,
12007 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12008 false,
12009 false,
12010 false,
12011 false,
12012 false,
12013 false,
12014 0,
12015 ).to_ne_bytes()
12016 ),
12017});
12018}
12019unsafe extern "C" fn passByteString<D: DomTypes>
12020(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12021 let mut result = false;
12022 wrap_panic(&mut || result = (|| {
12023 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12024 let this = &*(this as *const D::TestBinding);
12025 let args = &*args;
12026 let argc = args.argc_;
12027
12028 if argc < 1 {
12029 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passByteString\".");
12030 return false;
12031 }
12032 let arg0: ByteString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12033 Ok(ConversionResult::Success(value)) => value,
12034 Ok(ConversionResult::Failure(error)) => {
12035 throw_type_error(cx.raw_cx(), &error);
12036 return false;
12037
12038 }
12039 _ => {
12040 return false;
12041
12042 },
12043 }
12044 ;
12045 let result: () = this.PassByteString(arg0);
12046
12047 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12048 return true;
12049 })());
12050 result
12051}
12052
12053
12054static passByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12055
12056pub(crate) fn init_passByteString_methodinfo<D: DomTypes>() {
12057 passByteString_methodinfo.set(JSJitInfo {
12058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12059 method: Some(passByteString::<D>)
12060 },
12061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12062 protoID: PrototypeList::ID::TestBinding as u16,
12063 },
12064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12065 _bitfield_align_1: [],
12066 _bitfield_1: __BindgenBitfieldUnit::new(
12067 new_jsjitinfo_bitfield_1!(
12068 JSJitInfo_OpType::Method as u8,
12069 JSJitInfo_AliasSet::AliasEverything as u8,
12070 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12071 false,
12072 false,
12073 false,
12074 false,
12075 false,
12076 false,
12077 0,
12078 ).to_ne_bytes()
12079 ),
12080});
12081}
12082unsafe extern "C" fn passEnum<D: DomTypes>
12083(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12084 let mut result = false;
12085 wrap_panic(&mut || result = (|| {
12086 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12087 let this = &*(this as *const D::TestBinding);
12088 let args = &*args;
12089 let argc = args.argc_;
12090
12091 if argc < 1 {
12092 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passEnum\".");
12093 return false;
12094 }
12095 let arg0: TestEnum = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12096 Ok(ConversionResult::Success(value)) => value,
12097 Ok(ConversionResult::Failure(error)) => {
12098 throw_type_error(cx.raw_cx(), &error); return false;
12099
12100 }
12101 _ => {
12102 return false;
12103
12104 },
12105 }
12106 ;
12107 let result: () = this.PassEnum(arg0);
12108
12109 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12110 return true;
12111 })());
12112 result
12113}
12114
12115
12116static passEnum_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12117
12118pub(crate) fn init_passEnum_methodinfo<D: DomTypes>() {
12119 passEnum_methodinfo.set(JSJitInfo {
12120 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12121 method: Some(passEnum::<D>)
12122 },
12123 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12124 protoID: PrototypeList::ID::TestBinding as u16,
12125 },
12126 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12127 _bitfield_align_1: [],
12128 _bitfield_1: __BindgenBitfieldUnit::new(
12129 new_jsjitinfo_bitfield_1!(
12130 JSJitInfo_OpType::Method as u8,
12131 JSJitInfo_AliasSet::AliasEverything as u8,
12132 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12133 false,
12134 false,
12135 false,
12136 false,
12137 false,
12138 false,
12139 0,
12140 ).to_ne_bytes()
12141 ),
12142});
12143}
12144unsafe extern "C" fn passInterface<D: DomTypes>
12145(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12146 let mut result = false;
12147 wrap_panic(&mut || result = (|| {
12148 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12149 let this = &*(this as *const D::TestBinding);
12150 let args = &*args;
12151 let argc = args.argc_;
12152
12153 if argc < 1 {
12154 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passInterface\".");
12155 return false;
12156 }
12157 let arg0: DomRoot<D::Blob> = if HandleValue::from_raw(args.get(0)).get().is_object() {
12158 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
12159 Ok(val) => val,
12160 Err(()) => {
12161 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
12162 return false;
12163
12164 }
12165 }
12166
12167 } else {
12168 throw_type_error(cx.raw_cx(), "Value is not an object.");
12169 return false;
12170
12171 };
12172 let result: () = this.PassInterface(&arg0);
12173
12174 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12175 return true;
12176 })());
12177 result
12178}
12179
12180
12181static passInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12182
12183pub(crate) fn init_passInterface_methodinfo<D: DomTypes>() {
12184 passInterface_methodinfo.set(JSJitInfo {
12185 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12186 method: Some(passInterface::<D>)
12187 },
12188 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12189 protoID: PrototypeList::ID::TestBinding as u16,
12190 },
12191 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12192 _bitfield_align_1: [],
12193 _bitfield_1: __BindgenBitfieldUnit::new(
12194 new_jsjitinfo_bitfield_1!(
12195 JSJitInfo_OpType::Method as u8,
12196 JSJitInfo_AliasSet::AliasEverything as u8,
12197 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12198 false,
12199 false,
12200 false,
12201 false,
12202 false,
12203 false,
12204 0,
12205 ).to_ne_bytes()
12206 ),
12207});
12208}
12209unsafe extern "C" fn passTypedArray<D: DomTypes>
12210(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12211 let mut result = false;
12212 wrap_panic(&mut || result = (|| {
12213 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12214 let this = &*(this as *const D::TestBinding);
12215 let args = &*args;
12216 let argc = args.argc_;
12217
12218 if argc < 1 {
12219 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passTypedArray\".");
12220 return false;
12221 }
12222 let arg0: typedarray::Int8Array = if HandleValue::from_raw(args.get(0)).get().is_object() {
12223 match typedarray::Int8Array::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
12224 Ok(val) => val,
12225 Err(()) => {
12226 throw_type_error(cx.raw_cx(), "value is not a typed array.");
12227 return false;
12228
12229 }
12230 }
12231
12232 } else {
12233 throw_type_error(cx.raw_cx(), "Value is not an object.");
12234 return false;
12235
12236 };
12237 auto_root!(&in(cx) let arg0 = arg0);
12238 let result: () = this.PassTypedArray(arg0);
12239
12240 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12241 return true;
12242 })());
12243 result
12244}
12245
12246
12247static passTypedArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12248
12249pub(crate) fn init_passTypedArray_methodinfo<D: DomTypes>() {
12250 passTypedArray_methodinfo.set(JSJitInfo {
12251 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12252 method: Some(passTypedArray::<D>)
12253 },
12254 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12255 protoID: PrototypeList::ID::TestBinding as u16,
12256 },
12257 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12258 _bitfield_align_1: [],
12259 _bitfield_1: __BindgenBitfieldUnit::new(
12260 new_jsjitinfo_bitfield_1!(
12261 JSJitInfo_OpType::Method as u8,
12262 JSJitInfo_AliasSet::AliasEverything as u8,
12263 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12264 false,
12265 false,
12266 false,
12267 false,
12268 false,
12269 false,
12270 0,
12271 ).to_ne_bytes()
12272 ),
12273});
12274}
12275unsafe extern "C" fn passTypedArray2<D: DomTypes>
12276(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12277 let mut result = false;
12278 wrap_panic(&mut || result = (|| {
12279 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12280 let this = &*(this as *const D::TestBinding);
12281 let args = &*args;
12282 let argc = args.argc_;
12283
12284 if argc < 1 {
12285 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passTypedArray2\".");
12286 return false;
12287 }
12288 let arg0: typedarray::ArrayBuffer = if HandleValue::from_raw(args.get(0)).get().is_object() {
12289 match typedarray::ArrayBuffer::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
12290 Ok(val) => val,
12291 Err(()) => {
12292 throw_type_error(cx.raw_cx(), "value is not a typed array.");
12293 return false;
12294
12295 }
12296 }
12297
12298 } else {
12299 throw_type_error(cx.raw_cx(), "Value is not an object.");
12300 return false;
12301
12302 };
12303 auto_root!(&in(cx) let arg0 = arg0);
12304 let result: () = this.PassTypedArray2(arg0);
12305
12306 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12307 return true;
12308 })());
12309 result
12310}
12311
12312
12313static passTypedArray2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12314
12315pub(crate) fn init_passTypedArray2_methodinfo<D: DomTypes>() {
12316 passTypedArray2_methodinfo.set(JSJitInfo {
12317 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12318 method: Some(passTypedArray2::<D>)
12319 },
12320 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12321 protoID: PrototypeList::ID::TestBinding as u16,
12322 },
12323 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12324 _bitfield_align_1: [],
12325 _bitfield_1: __BindgenBitfieldUnit::new(
12326 new_jsjitinfo_bitfield_1!(
12327 JSJitInfo_OpType::Method as u8,
12328 JSJitInfo_AliasSet::AliasEverything as u8,
12329 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12330 false,
12331 false,
12332 false,
12333 false,
12334 false,
12335 false,
12336 0,
12337 ).to_ne_bytes()
12338 ),
12339});
12340}
12341unsafe extern "C" fn passTypedArray3<D: DomTypes>
12342(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12343 let mut result = false;
12344 wrap_panic(&mut || result = (|| {
12345 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12346 let this = &*(this as *const D::TestBinding);
12347 let args = &*args;
12348 let argc = args.argc_;
12349
12350 if argc < 1 {
12351 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passTypedArray3\".");
12352 return false;
12353 }
12354 let arg0: typedarray::ArrayBufferView = if HandleValue::from_raw(args.get(0)).get().is_object() {
12355 match typedarray::ArrayBufferView::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
12356 Ok(val) => val,
12357 Err(()) => {
12358 throw_type_error(cx.raw_cx(), "value is not a typed array.");
12359 return false;
12360
12361 }
12362 }
12363
12364 } else {
12365 throw_type_error(cx.raw_cx(), "Value is not an object.");
12366 return false;
12367
12368 };
12369 auto_root!(&in(cx) let arg0 = arg0);
12370 let result: () = this.PassTypedArray3(arg0);
12371
12372 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12373 return true;
12374 })());
12375 result
12376}
12377
12378
12379static passTypedArray3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12380
12381pub(crate) fn init_passTypedArray3_methodinfo<D: DomTypes>() {
12382 passTypedArray3_methodinfo.set(JSJitInfo {
12383 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12384 method: Some(passTypedArray3::<D>)
12385 },
12386 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12387 protoID: PrototypeList::ID::TestBinding as u16,
12388 },
12389 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12390 _bitfield_align_1: [],
12391 _bitfield_1: __BindgenBitfieldUnit::new(
12392 new_jsjitinfo_bitfield_1!(
12393 JSJitInfo_OpType::Method as u8,
12394 JSJitInfo_AliasSet::AliasEverything as u8,
12395 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12396 false,
12397 false,
12398 false,
12399 false,
12400 false,
12401 false,
12402 0,
12403 ).to_ne_bytes()
12404 ),
12405});
12406}
12407unsafe extern "C" fn passUnion<D: DomTypes>
12408(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12409 let mut result = false;
12410 wrap_panic(&mut || result = (|| {
12411 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12412 let this = &*(this as *const D::TestBinding);
12413 let args = &*args;
12414 let argc = args.argc_;
12415
12416 if argc < 1 {
12417 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion\".");
12418 return false;
12419 }
12420 let arg0: GenericUnionTypes::HTMLElementOrLong::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12421 Ok(ConversionResult::Success(value)) => value,
12422 Ok(ConversionResult::Failure(error)) => {
12423 throw_type_error(cx.raw_cx(), &error);
12424 return false;
12425
12426 }
12427 _ => {
12428 return false;
12429
12430 },
12431 }
12432 ;
12433 let result: () = this.PassUnion(arg0);
12434
12435 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12436 return true;
12437 })());
12438 result
12439}
12440
12441
12442static passUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12443
12444pub(crate) fn init_passUnion_methodinfo<D: DomTypes>() {
12445 passUnion_methodinfo.set(JSJitInfo {
12446 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12447 method: Some(passUnion::<D>)
12448 },
12449 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12450 protoID: PrototypeList::ID::TestBinding as u16,
12451 },
12452 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12453 _bitfield_align_1: [],
12454 _bitfield_1: __BindgenBitfieldUnit::new(
12455 new_jsjitinfo_bitfield_1!(
12456 JSJitInfo_OpType::Method as u8,
12457 JSJitInfo_AliasSet::AliasEverything as u8,
12458 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12459 false,
12460 false,
12461 false,
12462 false,
12463 false,
12464 false,
12465 0,
12466 ).to_ne_bytes()
12467 ),
12468});
12469}
12470unsafe extern "C" fn passUnion2<D: DomTypes>
12471(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12472 let mut result = false;
12473 wrap_panic(&mut || result = (|| {
12474 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12475 let this = &*(this as *const D::TestBinding);
12476 let args = &*args;
12477 let argc = args.argc_;
12478
12479 if argc < 1 {
12480 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion2\".");
12481 return false;
12482 }
12483 let arg0: GenericUnionTypes::EventOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12484 Ok(ConversionResult::Success(value)) => value,
12485 Ok(ConversionResult::Failure(error)) => {
12486 throw_type_error(cx.raw_cx(), &error);
12487 return false;
12488
12489 }
12490 _ => {
12491 return false;
12492
12493 },
12494 }
12495 ;
12496 let result: () = this.PassUnion2(arg0);
12497
12498 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12499 return true;
12500 })());
12501 result
12502}
12503
12504
12505static passUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12506
12507pub(crate) fn init_passUnion2_methodinfo<D: DomTypes>() {
12508 passUnion2_methodinfo.set(JSJitInfo {
12509 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12510 method: Some(passUnion2::<D>)
12511 },
12512 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12513 protoID: PrototypeList::ID::TestBinding as u16,
12514 },
12515 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12516 _bitfield_align_1: [],
12517 _bitfield_1: __BindgenBitfieldUnit::new(
12518 new_jsjitinfo_bitfield_1!(
12519 JSJitInfo_OpType::Method as u8,
12520 JSJitInfo_AliasSet::AliasEverything as u8,
12521 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12522 false,
12523 false,
12524 false,
12525 false,
12526 false,
12527 false,
12528 0,
12529 ).to_ne_bytes()
12530 ),
12531});
12532}
12533unsafe extern "C" fn passUnion3<D: DomTypes>
12534(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12535 let mut result = false;
12536 wrap_panic(&mut || result = (|| {
12537 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12538 let this = &*(this as *const D::TestBinding);
12539 let args = &*args;
12540 let argc = args.argc_;
12541
12542 if argc < 1 {
12543 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion3\".");
12544 return false;
12545 }
12546 let arg0: GenericUnionTypes::BlobOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12547 Ok(ConversionResult::Success(value)) => value,
12548 Ok(ConversionResult::Failure(error)) => {
12549 throw_type_error(cx.raw_cx(), &error);
12550 return false;
12551
12552 }
12553 _ => {
12554 return false;
12555
12556 },
12557 }
12558 ;
12559 let result: () = this.PassUnion3(arg0);
12560
12561 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12562 return true;
12563 })());
12564 result
12565}
12566
12567
12568static passUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12569
12570pub(crate) fn init_passUnion3_methodinfo<D: DomTypes>() {
12571 passUnion3_methodinfo.set(JSJitInfo {
12572 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12573 method: Some(passUnion3::<D>)
12574 },
12575 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12576 protoID: PrototypeList::ID::TestBinding as u16,
12577 },
12578 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12579 _bitfield_align_1: [],
12580 _bitfield_1: __BindgenBitfieldUnit::new(
12581 new_jsjitinfo_bitfield_1!(
12582 JSJitInfo_OpType::Method as u8,
12583 JSJitInfo_AliasSet::AliasEverything as u8,
12584 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12585 false,
12586 false,
12587 false,
12588 false,
12589 false,
12590 false,
12591 0,
12592 ).to_ne_bytes()
12593 ),
12594});
12595}
12596unsafe extern "C" fn passUnion4<D: DomTypes>
12597(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12598 let mut result = false;
12599 wrap_panic(&mut || result = (|| {
12600 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12601 let this = &*(this as *const D::TestBinding);
12602 let args = &*args;
12603 let argc = args.argc_;
12604
12605 if argc < 1 {
12606 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion4\".");
12607 return false;
12608 }
12609 let arg0: GenericUnionTypes::StringOrStringSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12610 Ok(ConversionResult::Success(value)) => value,
12611 Ok(ConversionResult::Failure(error)) => {
12612 throw_type_error(cx.raw_cx(), &error);
12613 return false;
12614
12615 }
12616 _ => {
12617 return false;
12618
12619 },
12620 }
12621 ;
12622 let result: () = this.PassUnion4(arg0);
12623
12624 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12625 return true;
12626 })());
12627 result
12628}
12629
12630
12631static passUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12632
12633pub(crate) fn init_passUnion4_methodinfo<D: DomTypes>() {
12634 passUnion4_methodinfo.set(JSJitInfo {
12635 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12636 method: Some(passUnion4::<D>)
12637 },
12638 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12639 protoID: PrototypeList::ID::TestBinding as u16,
12640 },
12641 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12642 _bitfield_align_1: [],
12643 _bitfield_1: __BindgenBitfieldUnit::new(
12644 new_jsjitinfo_bitfield_1!(
12645 JSJitInfo_OpType::Method as u8,
12646 JSJitInfo_AliasSet::AliasEverything as u8,
12647 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12648 false,
12649 false,
12650 false,
12651 false,
12652 false,
12653 false,
12654 0,
12655 ).to_ne_bytes()
12656 ),
12657});
12658}
12659unsafe extern "C" fn passUnion5<D: DomTypes>
12660(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12661 let mut result = false;
12662 wrap_panic(&mut || result = (|| {
12663 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12664 let this = &*(this as *const D::TestBinding);
12665 let args = &*args;
12666 let argc = args.argc_;
12667
12668 if argc < 1 {
12669 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion5\".");
12670 return false;
12671 }
12672 let arg0: GenericUnionTypes::StringOrBoolean = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12673 Ok(ConversionResult::Success(value)) => value,
12674 Ok(ConversionResult::Failure(error)) => {
12675 throw_type_error(cx.raw_cx(), &error);
12676 return false;
12677
12678 }
12679 _ => {
12680 return false;
12681
12682 },
12683 }
12684 ;
12685 let result: () = this.PassUnion5(arg0);
12686
12687 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12688 return true;
12689 })());
12690 result
12691}
12692
12693
12694static passUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12695
12696pub(crate) fn init_passUnion5_methodinfo<D: DomTypes>() {
12697 passUnion5_methodinfo.set(JSJitInfo {
12698 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12699 method: Some(passUnion5::<D>)
12700 },
12701 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12702 protoID: PrototypeList::ID::TestBinding as u16,
12703 },
12704 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12705 _bitfield_align_1: [],
12706 _bitfield_1: __BindgenBitfieldUnit::new(
12707 new_jsjitinfo_bitfield_1!(
12708 JSJitInfo_OpType::Method as u8,
12709 JSJitInfo_AliasSet::AliasEverything as u8,
12710 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12711 false,
12712 false,
12713 false,
12714 false,
12715 false,
12716 false,
12717 0,
12718 ).to_ne_bytes()
12719 ),
12720});
12721}
12722unsafe extern "C" fn passUnion6<D: DomTypes>
12723(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12724 let mut result = false;
12725 wrap_panic(&mut || result = (|| {
12726 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12727 let this = &*(this as *const D::TestBinding);
12728 let args = &*args;
12729 let argc = args.argc_;
12730
12731 if argc < 1 {
12732 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion6\".");
12733 return false;
12734 }
12735 let arg0: GenericUnionTypes::UnsignedLongOrBoolean = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12736 Ok(ConversionResult::Success(value)) => value,
12737 Ok(ConversionResult::Failure(error)) => {
12738 throw_type_error(cx.raw_cx(), &error);
12739 return false;
12740
12741 }
12742 _ => {
12743 return false;
12744
12745 },
12746 }
12747 ;
12748 let result: () = this.PassUnion6(arg0);
12749
12750 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12751 return true;
12752 })());
12753 result
12754}
12755
12756
12757static passUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12758
12759pub(crate) fn init_passUnion6_methodinfo<D: DomTypes>() {
12760 passUnion6_methodinfo.set(JSJitInfo {
12761 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12762 method: Some(passUnion6::<D>)
12763 },
12764 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12765 protoID: PrototypeList::ID::TestBinding as u16,
12766 },
12767 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12768 _bitfield_align_1: [],
12769 _bitfield_1: __BindgenBitfieldUnit::new(
12770 new_jsjitinfo_bitfield_1!(
12771 JSJitInfo_OpType::Method as u8,
12772 JSJitInfo_AliasSet::AliasEverything as u8,
12773 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12774 false,
12775 false,
12776 false,
12777 false,
12778 false,
12779 false,
12780 0,
12781 ).to_ne_bytes()
12782 ),
12783});
12784}
12785unsafe extern "C" fn passUnion7<D: DomTypes>
12786(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12787 let mut result = false;
12788 wrap_panic(&mut || result = (|| {
12789 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12790 let this = &*(this as *const D::TestBinding);
12791 let args = &*args;
12792 let argc = args.argc_;
12793
12794 if argc < 1 {
12795 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion7\".");
12796 return false;
12797 }
12798 let arg0: GenericUnionTypes::StringSequenceOrUnsignedLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12799 Ok(ConversionResult::Success(value)) => value,
12800 Ok(ConversionResult::Failure(error)) => {
12801 throw_type_error(cx.raw_cx(), &error);
12802 return false;
12803
12804 }
12805 _ => {
12806 return false;
12807
12808 },
12809 }
12810 ;
12811 let result: () = this.PassUnion7(arg0);
12812
12813 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12814 return true;
12815 })());
12816 result
12817}
12818
12819
12820static passUnion7_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12821
12822pub(crate) fn init_passUnion7_methodinfo<D: DomTypes>() {
12823 passUnion7_methodinfo.set(JSJitInfo {
12824 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12825 method: Some(passUnion7::<D>)
12826 },
12827 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12828 protoID: PrototypeList::ID::TestBinding as u16,
12829 },
12830 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12831 _bitfield_align_1: [],
12832 _bitfield_1: __BindgenBitfieldUnit::new(
12833 new_jsjitinfo_bitfield_1!(
12834 JSJitInfo_OpType::Method as u8,
12835 JSJitInfo_AliasSet::AliasEverything as u8,
12836 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12837 false,
12838 false,
12839 false,
12840 false,
12841 false,
12842 false,
12843 0,
12844 ).to_ne_bytes()
12845 ),
12846});
12847}
12848unsafe extern "C" fn passUnion8<D: DomTypes>
12849(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12850 let mut result = false;
12851 wrap_panic(&mut || result = (|| {
12852 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12853 let this = &*(this as *const D::TestBinding);
12854 let args = &*args;
12855 let argc = args.argc_;
12856
12857 if argc < 1 {
12858 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion8\".");
12859 return false;
12860 }
12861 let arg0: GenericUnionTypes::ByteStringSequenceOrLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12862 Ok(ConversionResult::Success(value)) => value,
12863 Ok(ConversionResult::Failure(error)) => {
12864 throw_type_error(cx.raw_cx(), &error);
12865 return false;
12866
12867 }
12868 _ => {
12869 return false;
12870
12871 },
12872 }
12873 ;
12874 let result: () = this.PassUnion8(arg0);
12875
12876 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12877 return true;
12878 })());
12879 result
12880}
12881
12882
12883static passUnion8_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12884
12885pub(crate) fn init_passUnion8_methodinfo<D: DomTypes>() {
12886 passUnion8_methodinfo.set(JSJitInfo {
12887 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12888 method: Some(passUnion8::<D>)
12889 },
12890 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12891 protoID: PrototypeList::ID::TestBinding as u16,
12892 },
12893 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12894 _bitfield_align_1: [],
12895 _bitfield_1: __BindgenBitfieldUnit::new(
12896 new_jsjitinfo_bitfield_1!(
12897 JSJitInfo_OpType::Method as u8,
12898 JSJitInfo_AliasSet::AliasEverything as u8,
12899 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12900 false,
12901 false,
12902 false,
12903 false,
12904 false,
12905 false,
12906 0,
12907 ).to_ne_bytes()
12908 ),
12909});
12910}
12911unsafe extern "C" fn passUnion9<D: DomTypes>
12912(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12913 let mut result = false;
12914 wrap_panic(&mut || result = (|| {
12915 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12916 let this = &*(this as *const D::TestBinding);
12917 let args = &*args;
12918 let argc = args.argc_;
12919
12920 if argc < 1 {
12921 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion9\".");
12922 return false;
12923 }
12924 let arg0: GenericUnionTypes::TestDictionaryOrLong::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12925 Ok(ConversionResult::Success(value)) => value,
12926 Ok(ConversionResult::Failure(error)) => {
12927 throw_type_error(cx.raw_cx(), &error);
12928 return false;
12929
12930 }
12931 _ => {
12932 return false;
12933
12934 },
12935 }
12936 ;
12937 let result: () = this.PassUnion9(arg0);
12938
12939 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
12940 return true;
12941 })());
12942 result
12943}
12944
12945
12946static passUnion9_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
12947
12948pub(crate) fn init_passUnion9_methodinfo<D: DomTypes>() {
12949 passUnion9_methodinfo.set(JSJitInfo {
12950 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
12951 method: Some(passUnion9::<D>)
12952 },
12953 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
12954 protoID: PrototypeList::ID::TestBinding as u16,
12955 },
12956 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
12957 _bitfield_align_1: [],
12958 _bitfield_1: __BindgenBitfieldUnit::new(
12959 new_jsjitinfo_bitfield_1!(
12960 JSJitInfo_OpType::Method as u8,
12961 JSJitInfo_AliasSet::AliasEverything as u8,
12962 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
12963 false,
12964 false,
12965 false,
12966 false,
12967 false,
12968 false,
12969 0,
12970 ).to_ne_bytes()
12971 ),
12972});
12973}
12974unsafe extern "C" fn passUnion10<D: DomTypes>
12975(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
12976 let mut result = false;
12977 wrap_panic(&mut || result = (|| {
12978 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
12979 let this = &*(this as *const D::TestBinding);
12980 let args = &*args;
12981 let argc = args.argc_;
12982
12983 if argc < 1 {
12984 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion10\".");
12985 return false;
12986 }
12987 let arg0: GenericUnionTypes::StringOrObject = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
12988 Ok(ConversionResult::Success(value)) => value,
12989 Ok(ConversionResult::Failure(error)) => {
12990 throw_type_error(cx.raw_cx(), &error);
12991 return false;
12992
12993 }
12994 _ => {
12995 return false;
12996
12997 },
12998 }
12999 ;
13000 let result: () = this.PassUnion10(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13001
13002 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13003 return true;
13004 })());
13005 result
13006}
13007
13008
13009static passUnion10_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13010
13011pub(crate) fn init_passUnion10_methodinfo<D: DomTypes>() {
13012 passUnion10_methodinfo.set(JSJitInfo {
13013 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13014 method: Some(passUnion10::<D>)
13015 },
13016 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13017 protoID: PrototypeList::ID::TestBinding as u16,
13018 },
13019 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13020 _bitfield_align_1: [],
13021 _bitfield_1: __BindgenBitfieldUnit::new(
13022 new_jsjitinfo_bitfield_1!(
13023 JSJitInfo_OpType::Method as u8,
13024 JSJitInfo_AliasSet::AliasEverything as u8,
13025 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13026 false,
13027 false,
13028 false,
13029 false,
13030 false,
13031 false,
13032 0,
13033 ).to_ne_bytes()
13034 ),
13035});
13036}
13037unsafe extern "C" fn passUnion11<D: DomTypes>
13038(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13039 let mut result = false;
13040 wrap_panic(&mut || result = (|| {
13041 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13042 let this = &*(this as *const D::TestBinding);
13043 let args = &*args;
13044 let argc = args.argc_;
13045
13046 if argc < 1 {
13047 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnion11\".");
13048 return false;
13049 }
13050 let arg0: GenericUnionTypes::ArrayBufferOrArrayBufferView = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13051 Ok(ConversionResult::Success(value)) => value,
13052 Ok(ConversionResult::Failure(error)) => {
13053 throw_type_error(cx.raw_cx(), &error);
13054 return false;
13055
13056 }
13057 _ => {
13058 return false;
13059
13060 },
13061 }
13062 ;
13063 let result: () = this.PassUnion11(arg0);
13064
13065 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13066 return true;
13067 })());
13068 result
13069}
13070
13071
13072static passUnion11_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13073
13074pub(crate) fn init_passUnion11_methodinfo<D: DomTypes>() {
13075 passUnion11_methodinfo.set(JSJitInfo {
13076 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13077 method: Some(passUnion11::<D>)
13078 },
13079 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13080 protoID: PrototypeList::ID::TestBinding as u16,
13081 },
13082 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13083 _bitfield_align_1: [],
13084 _bitfield_1: __BindgenBitfieldUnit::new(
13085 new_jsjitinfo_bitfield_1!(
13086 JSJitInfo_OpType::Method as u8,
13087 JSJitInfo_AliasSet::AliasEverything as u8,
13088 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13089 false,
13090 false,
13091 false,
13092 false,
13093 false,
13094 false,
13095 0,
13096 ).to_ne_bytes()
13097 ),
13098});
13099}
13100unsafe extern "C" fn passUnionWithTypedef<D: DomTypes>
13101(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13102 let mut result = false;
13103 wrap_panic(&mut || result = (|| {
13104 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13105 let this = &*(this as *const D::TestBinding);
13106 let args = &*args;
13107 let argc = args.argc_;
13108
13109 if argc < 1 {
13110 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnionWithTypedef\".");
13111 return false;
13112 }
13113 let arg0: GenericUnionTypes::DocumentOrStringOrURLOrBlob::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13114 Ok(ConversionResult::Success(value)) => value,
13115 Ok(ConversionResult::Failure(error)) => {
13116 throw_type_error(cx.raw_cx(), &error);
13117 return false;
13118
13119 }
13120 _ => {
13121 return false;
13122
13123 },
13124 }
13125 ;
13126 let result: () = this.PassUnionWithTypedef(arg0);
13127
13128 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13129 return true;
13130 })());
13131 result
13132}
13133
13134
13135static passUnionWithTypedef_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13136
13137pub(crate) fn init_passUnionWithTypedef_methodinfo<D: DomTypes>() {
13138 passUnionWithTypedef_methodinfo.set(JSJitInfo {
13139 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13140 method: Some(passUnionWithTypedef::<D>)
13141 },
13142 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13143 protoID: PrototypeList::ID::TestBinding as u16,
13144 },
13145 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13146 _bitfield_align_1: [],
13147 _bitfield_1: __BindgenBitfieldUnit::new(
13148 new_jsjitinfo_bitfield_1!(
13149 JSJitInfo_OpType::Method as u8,
13150 JSJitInfo_AliasSet::AliasEverything as u8,
13151 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13152 false,
13153 false,
13154 false,
13155 false,
13156 false,
13157 false,
13158 0,
13159 ).to_ne_bytes()
13160 ),
13161});
13162}
13163unsafe extern "C" fn passUnionWithTypedef2<D: DomTypes>
13164(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13165 let mut result = false;
13166 wrap_panic(&mut || result = (|| {
13167 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13168 let this = &*(this as *const D::TestBinding);
13169 let args = &*args;
13170 let argc = args.argc_;
13171
13172 if argc < 1 {
13173 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnionWithTypedef2\".");
13174 return false;
13175 }
13176 let arg0: GenericUnionTypes::LongSequenceOrStringOrURLOrBlob::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13177 Ok(ConversionResult::Success(value)) => value,
13178 Ok(ConversionResult::Failure(error)) => {
13179 throw_type_error(cx.raw_cx(), &error);
13180 return false;
13181
13182 }
13183 _ => {
13184 return false;
13185
13186 },
13187 }
13188 ;
13189 let result: () = this.PassUnionWithTypedef2(arg0);
13190
13191 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13192 return true;
13193 })());
13194 result
13195}
13196
13197
13198static passUnionWithTypedef2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13199
13200pub(crate) fn init_passUnionWithTypedef2_methodinfo<D: DomTypes>() {
13201 passUnionWithTypedef2_methodinfo.set(JSJitInfo {
13202 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13203 method: Some(passUnionWithTypedef2::<D>)
13204 },
13205 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13206 protoID: PrototypeList::ID::TestBinding as u16,
13207 },
13208 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13209 _bitfield_align_1: [],
13210 _bitfield_1: __BindgenBitfieldUnit::new(
13211 new_jsjitinfo_bitfield_1!(
13212 JSJitInfo_OpType::Method as u8,
13213 JSJitInfo_AliasSet::AliasEverything as u8,
13214 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13215 false,
13216 false,
13217 false,
13218 false,
13219 false,
13220 false,
13221 0,
13222 ).to_ne_bytes()
13223 ),
13224});
13225}
13226unsafe extern "C" fn passAny<D: DomTypes>
13227(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13228 let mut result = false;
13229 wrap_panic(&mut || result = (|| {
13230 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13231 let this = &*(this as *const D::TestBinding);
13232 let args = &*args;
13233 let argc = args.argc_;
13234
13235 if argc < 1 {
13236 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passAny\".");
13237 return false;
13238 }
13239 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
13240 let result: () = this.PassAny(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13241
13242 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13243 return true;
13244 })());
13245 result
13246}
13247
13248
13249static passAny_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13250
13251pub(crate) fn init_passAny_methodinfo<D: DomTypes>() {
13252 passAny_methodinfo.set(JSJitInfo {
13253 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13254 method: Some(passAny::<D>)
13255 },
13256 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13257 protoID: PrototypeList::ID::TestBinding as u16,
13258 },
13259 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13260 _bitfield_align_1: [],
13261 _bitfield_1: __BindgenBitfieldUnit::new(
13262 new_jsjitinfo_bitfield_1!(
13263 JSJitInfo_OpType::Method as u8,
13264 JSJitInfo_AliasSet::AliasEverything as u8,
13265 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13266 false,
13267 false,
13268 false,
13269 false,
13270 false,
13271 false,
13272 0,
13273 ).to_ne_bytes()
13274 ),
13275});
13276}
13277unsafe extern "C" fn passObject<D: DomTypes>
13278(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13279 let mut result = false;
13280 wrap_panic(&mut || result = (|| {
13281 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13282 let this = &*(this as *const D::TestBinding);
13283 let args = &*args;
13284 let argc = args.argc_;
13285
13286 if argc < 1 {
13287 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passObject\".");
13288 return false;
13289 }
13290 let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
13291 HandleValue::from_raw(args.get(0)).get().to_object()
13292 } else {
13293 throw_type_error(cx.raw_cx(), "Value is not an object.");
13294 return false;
13295
13296 };
13297 let result: () = this.PassObject(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13298
13299 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13300 return true;
13301 })());
13302 result
13303}
13304
13305
13306static passObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13307
13308pub(crate) fn init_passObject_methodinfo<D: DomTypes>() {
13309 passObject_methodinfo.set(JSJitInfo {
13310 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13311 method: Some(passObject::<D>)
13312 },
13313 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13314 protoID: PrototypeList::ID::TestBinding as u16,
13315 },
13316 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13317 _bitfield_align_1: [],
13318 _bitfield_1: __BindgenBitfieldUnit::new(
13319 new_jsjitinfo_bitfield_1!(
13320 JSJitInfo_OpType::Method as u8,
13321 JSJitInfo_AliasSet::AliasEverything as u8,
13322 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13323 false,
13324 false,
13325 false,
13326 false,
13327 false,
13328 false,
13329 0,
13330 ).to_ne_bytes()
13331 ),
13332});
13333}
13334unsafe extern "C" fn passCallbackFunction<D: DomTypes>
13335(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13336 let mut result = false;
13337 wrap_panic(&mut || result = (|| {
13338 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13339 let this = &*(this as *const D::TestBinding);
13340 let args = &*args;
13341 let argc = args.argc_;
13342
13343 if argc < 1 {
13344 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passCallbackFunction\".");
13345 return false;
13346 }
13347 let arg0: Rc<Function<D>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
13348 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
13349 Function::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object())
13350 } else {
13351 throw_type_error(cx.raw_cx(), "Value is not callable.");
13352 return false;
13353
13354 }
13355 } else {
13356 throw_type_error(cx.raw_cx(), "Value is not an object.");
13357 return false;
13358
13359 };
13360 let result: () = this.PassCallbackFunction(arg0);
13361
13362 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13363 return true;
13364 })());
13365 result
13366}
13367
13368
13369static passCallbackFunction_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13370
13371pub(crate) fn init_passCallbackFunction_methodinfo<D: DomTypes>() {
13372 passCallbackFunction_methodinfo.set(JSJitInfo {
13373 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13374 method: Some(passCallbackFunction::<D>)
13375 },
13376 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13377 protoID: PrototypeList::ID::TestBinding as u16,
13378 },
13379 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13380 _bitfield_align_1: [],
13381 _bitfield_1: __BindgenBitfieldUnit::new(
13382 new_jsjitinfo_bitfield_1!(
13383 JSJitInfo_OpType::Method as u8,
13384 JSJitInfo_AliasSet::AliasEverything as u8,
13385 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13386 false,
13387 false,
13388 false,
13389 false,
13390 false,
13391 false,
13392 0,
13393 ).to_ne_bytes()
13394 ),
13395});
13396}
13397unsafe extern "C" fn passCallbackInterface<D: DomTypes>
13398(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13399 let mut result = false;
13400 wrap_panic(&mut || result = (|| {
13401 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13402 let this = &*(this as *const D::TestBinding);
13403 let args = &*args;
13404 let argc = args.argc_;
13405
13406 if argc < 1 {
13407 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passCallbackInterface\".");
13408 return false;
13409 }
13410 let arg0: Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>> = crate::codegen::GenericBindings::EventListenerBinding::EventListener::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object());
13411 let result: () = this.PassCallbackInterface(arg0);
13412
13413 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13414 return true;
13415 })());
13416 result
13417}
13418
13419
13420static passCallbackInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13421
13422pub(crate) fn init_passCallbackInterface_methodinfo<D: DomTypes>() {
13423 passCallbackInterface_methodinfo.set(JSJitInfo {
13424 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13425 method: Some(passCallbackInterface::<D>)
13426 },
13427 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13428 protoID: PrototypeList::ID::TestBinding as u16,
13429 },
13430 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13431 _bitfield_align_1: [],
13432 _bitfield_1: __BindgenBitfieldUnit::new(
13433 new_jsjitinfo_bitfield_1!(
13434 JSJitInfo_OpType::Method as u8,
13435 JSJitInfo_AliasSet::AliasEverything as u8,
13436 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13437 false,
13438 false,
13439 false,
13440 false,
13441 false,
13442 false,
13443 0,
13444 ).to_ne_bytes()
13445 ),
13446});
13447}
13448unsafe extern "C" fn passSequence<D: DomTypes>
13449(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13450 let mut result = false;
13451 wrap_panic(&mut || result = (|| {
13452 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13453 let this = &*(this as *const D::TestBinding);
13454 let args = &*args;
13455 let argc = args.argc_;
13456
13457 if argc < 1 {
13458 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passSequence\".");
13459 return false;
13460 }
13461 let arg0: Vec<i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
13462 Ok(ConversionResult::Success(value)) => value,
13463 Ok(ConversionResult::Failure(error)) => {
13464 throw_type_error(cx.raw_cx(), &error);
13465 return false;
13466
13467 }
13468 _ => {
13469 return false;
13470
13471 },
13472 }
13473 ;
13474 let result: () = this.PassSequence(arg0);
13475
13476 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13477 return true;
13478 })());
13479 result
13480}
13481
13482
13483static passSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13484
13485pub(crate) fn init_passSequence_methodinfo<D: DomTypes>() {
13486 passSequence_methodinfo.set(JSJitInfo {
13487 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13488 method: Some(passSequence::<D>)
13489 },
13490 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13491 protoID: PrototypeList::ID::TestBinding as u16,
13492 },
13493 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13494 _bitfield_align_1: [],
13495 _bitfield_1: __BindgenBitfieldUnit::new(
13496 new_jsjitinfo_bitfield_1!(
13497 JSJitInfo_OpType::Method as u8,
13498 JSJitInfo_AliasSet::AliasEverything as u8,
13499 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13500 false,
13501 false,
13502 false,
13503 false,
13504 false,
13505 false,
13506 0,
13507 ).to_ne_bytes()
13508 ),
13509});
13510}
13511unsafe extern "C" fn passAnySequence<D: DomTypes>
13512(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13513 let mut result = false;
13514 wrap_panic(&mut || result = (|| {
13515 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13516 let this = &*(this as *const D::TestBinding);
13517 let args = &*args;
13518 let argc = args.argc_;
13519
13520 if argc < 1 {
13521 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passAnySequence\".");
13522 return false;
13523 }
13524 let arg0: Vec<JSVal> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13525 Ok(ConversionResult::Success(value)) => value,
13526 Ok(ConversionResult::Failure(error)) => {
13527 throw_type_error(cx.raw_cx(), &error);
13528 return false;
13529
13530 }
13531 _ => {
13532 return false;
13533
13534 },
13535 }
13536 ;
13537 auto_root!(&in(cx) let arg0 = arg0);
13538 let result: () = this.PassAnySequence(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13539
13540 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13541 return true;
13542 })());
13543 result
13544}
13545
13546
13547static passAnySequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13548
13549pub(crate) fn init_passAnySequence_methodinfo<D: DomTypes>() {
13550 passAnySequence_methodinfo.set(JSJitInfo {
13551 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13552 method: Some(passAnySequence::<D>)
13553 },
13554 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13555 protoID: PrototypeList::ID::TestBinding as u16,
13556 },
13557 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13558 _bitfield_align_1: [],
13559 _bitfield_1: __BindgenBitfieldUnit::new(
13560 new_jsjitinfo_bitfield_1!(
13561 JSJitInfo_OpType::Method as u8,
13562 JSJitInfo_AliasSet::AliasEverything as u8,
13563 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13564 false,
13565 false,
13566 false,
13567 false,
13568 false,
13569 false,
13570 0,
13571 ).to_ne_bytes()
13572 ),
13573});
13574}
13575unsafe extern "C" fn anySequencePassthrough<D: DomTypes>
13576(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13577 let mut result = false;
13578 wrap_panic(&mut || result = (|| {
13579 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13580 let this = &*(this as *const D::TestBinding);
13581 let args = &*args;
13582 let argc = args.argc_;
13583
13584 if argc < 1 {
13585 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.anySequencePassthrough\".");
13586 return false;
13587 }
13588 let arg0: Vec<JSVal> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13589 Ok(ConversionResult::Success(value)) => value,
13590 Ok(ConversionResult::Failure(error)) => {
13591 throw_type_error(cx.raw_cx(), &error);
13592 return false;
13593
13594 }
13595 _ => {
13596 return false;
13597
13598 },
13599 }
13600 ;
13601 auto_root!(&in(cx) let arg0 = arg0);
13602 let result: Vec<JSVal> = this.AnySequencePassthrough(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13603
13604 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13605 return true;
13606 })());
13607 result
13608}
13609
13610
13611static anySequencePassthrough_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13612
13613pub(crate) fn init_anySequencePassthrough_methodinfo<D: DomTypes>() {
13614 anySequencePassthrough_methodinfo.set(JSJitInfo {
13615 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13616 method: Some(anySequencePassthrough::<D>)
13617 },
13618 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13619 protoID: PrototypeList::ID::TestBinding as u16,
13620 },
13621 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13622 _bitfield_align_1: [],
13623 _bitfield_1: __BindgenBitfieldUnit::new(
13624 new_jsjitinfo_bitfield_1!(
13625 JSJitInfo_OpType::Method as u8,
13626 JSJitInfo_AliasSet::AliasEverything as u8,
13627 JSValueType::JSVAL_TYPE_OBJECT as u8,
13628 false,
13629 false,
13630 false,
13631 false,
13632 false,
13633 false,
13634 0,
13635 ).to_ne_bytes()
13636 ),
13637});
13638}
13639unsafe extern "C" fn passObjectSequence<D: DomTypes>
13640(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13641 let mut result = false;
13642 wrap_panic(&mut || result = (|| {
13643 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13644 let this = &*(this as *const D::TestBinding);
13645 let args = &*args;
13646 let argc = args.argc_;
13647
13648 if argc < 1 {
13649 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passObjectSequence\".");
13650 return false;
13651 }
13652 let arg0: Vec<*mut JSObject> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13653 Ok(ConversionResult::Success(value)) => value,
13654 Ok(ConversionResult::Failure(error)) => {
13655 throw_type_error(cx.raw_cx(), &error);
13656 return false;
13657
13658 }
13659 _ => {
13660 return false;
13661
13662 },
13663 }
13664 ;
13665 auto_root!(&in(cx) let arg0 = arg0);
13666 let result: () = this.PassObjectSequence(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
13667
13668 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13669 return true;
13670 })());
13671 result
13672}
13673
13674
13675static passObjectSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13676
13677pub(crate) fn init_passObjectSequence_methodinfo<D: DomTypes>() {
13678 passObjectSequence_methodinfo.set(JSJitInfo {
13679 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13680 method: Some(passObjectSequence::<D>)
13681 },
13682 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13683 protoID: PrototypeList::ID::TestBinding as u16,
13684 },
13685 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13686 _bitfield_align_1: [],
13687 _bitfield_1: __BindgenBitfieldUnit::new(
13688 new_jsjitinfo_bitfield_1!(
13689 JSJitInfo_OpType::Method as u8,
13690 JSJitInfo_AliasSet::AliasEverything as u8,
13691 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13692 false,
13693 false,
13694 false,
13695 false,
13696 false,
13697 false,
13698 0,
13699 ).to_ne_bytes()
13700 ),
13701});
13702}
13703unsafe extern "C" fn passStringSequence<D: DomTypes>
13704(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13705 let mut result = false;
13706 wrap_panic(&mut || result = (|| {
13707 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13708 let this = &*(this as *const D::TestBinding);
13709 let args = &*args;
13710 let argc = args.argc_;
13711
13712 if argc < 1 {
13713 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passStringSequence\".");
13714 return false;
13715 }
13716 let arg0: Vec<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13717 Ok(ConversionResult::Success(value)) => value,
13718 Ok(ConversionResult::Failure(error)) => {
13719 throw_type_error(cx.raw_cx(), &error);
13720 return false;
13721
13722 }
13723 _ => {
13724 return false;
13725
13726 },
13727 }
13728 ;
13729 let result: () = this.PassStringSequence(arg0);
13730
13731 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13732 return true;
13733 })());
13734 result
13735}
13736
13737
13738static passStringSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13739
13740pub(crate) fn init_passStringSequence_methodinfo<D: DomTypes>() {
13741 passStringSequence_methodinfo.set(JSJitInfo {
13742 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13743 method: Some(passStringSequence::<D>)
13744 },
13745 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13746 protoID: PrototypeList::ID::TestBinding as u16,
13747 },
13748 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13749 _bitfield_align_1: [],
13750 _bitfield_1: __BindgenBitfieldUnit::new(
13751 new_jsjitinfo_bitfield_1!(
13752 JSJitInfo_OpType::Method as u8,
13753 JSJitInfo_AliasSet::AliasEverything as u8,
13754 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13755 false,
13756 false,
13757 false,
13758 false,
13759 false,
13760 false,
13761 0,
13762 ).to_ne_bytes()
13763 ),
13764});
13765}
13766unsafe extern "C" fn passInterfaceSequence<D: DomTypes>
13767(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13768 let mut result = false;
13769 wrap_panic(&mut || result = (|| {
13770 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13771 let this = &*(this as *const D::TestBinding);
13772 let args = &*args;
13773 let argc = args.argc_;
13774
13775 if argc < 1 {
13776 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passInterfaceSequence\".");
13777 return false;
13778 }
13779 let arg0: Vec<DomRoot<D::Blob>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13780 Ok(ConversionResult::Success(value)) => value,
13781 Ok(ConversionResult::Failure(error)) => {
13782 throw_type_error(cx.raw_cx(), &error);
13783 return false;
13784
13785 }
13786 _ => {
13787 return false;
13788
13789 },
13790 }
13791 ;
13792 let result: () = this.PassInterfaceSequence(arg0);
13793
13794 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13795 return true;
13796 })());
13797 result
13798}
13799
13800
13801static passInterfaceSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13802
13803pub(crate) fn init_passInterfaceSequence_methodinfo<D: DomTypes>() {
13804 passInterfaceSequence_methodinfo.set(JSJitInfo {
13805 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13806 method: Some(passInterfaceSequence::<D>)
13807 },
13808 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13809 protoID: PrototypeList::ID::TestBinding as u16,
13810 },
13811 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13812 _bitfield_align_1: [],
13813 _bitfield_1: __BindgenBitfieldUnit::new(
13814 new_jsjitinfo_bitfield_1!(
13815 JSJitInfo_OpType::Method as u8,
13816 JSJitInfo_AliasSet::AliasEverything as u8,
13817 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13818 false,
13819 false,
13820 false,
13821 false,
13822 false,
13823 false,
13824 0,
13825 ).to_ne_bytes()
13826 ),
13827});
13828}
13829unsafe extern "C" fn passOverloaded<D: DomTypes>
13830(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13831 let mut result = false;
13832 wrap_panic(&mut || result = (|| {
13833 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13834 let this = &*(this as *const D::TestBinding);
13835 let args = &*args;
13836 let argc = args.argc_;
13837
13838 let argcount = cmp::min(argc, 1);
13839 match argcount {
13840 1 => {
13841 if HandleValue::from_raw(args.get(0)).get().is_object() {
13842 '_block: {
13843 let arg0: typedarray::ArrayBuffer = match typedarray::ArrayBuffer::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
13844 Ok(val) => val,
13845 Err(()) => {
13846 break '_block;
13847 }
13848 }
13849 ;
13850 auto_root!(&in(cx) let arg0 = arg0);
13851 let result: () = this.PassOverloaded(arg0);
13852
13853 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13854 return true;
13855 }
13856 }
13857 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
13858 Ok(ConversionResult::Success(value)) => value,
13859 Ok(ConversionResult::Failure(error)) => {
13860 throw_type_error(cx.raw_cx(), &error);
13861 return false;
13862
13863 }
13864 _ => {
13865 return false;
13866
13867 },
13868 }
13869 ;
13870 let result: () = this.PassOverloaded_(arg0);
13871
13872 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13873 return true;
13874 }
13875 _ => {
13876 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passOverloaded\".");
13877 return false;
13878 }
13879 }
13880 })());
13881 result
13882}
13883
13884
13885static passOverloaded_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13886
13887pub(crate) fn init_passOverloaded_methodinfo<D: DomTypes>() {
13888 passOverloaded_methodinfo.set(JSJitInfo {
13889 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13890 method: Some(passOverloaded::<D>)
13891 },
13892 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13893 protoID: PrototypeList::ID::TestBinding as u16,
13894 },
13895 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
13896 _bitfield_align_1: [],
13897 _bitfield_1: __BindgenBitfieldUnit::new(
13898 new_jsjitinfo_bitfield_1!(
13899 JSJitInfo_OpType::Method as u8,
13900 JSJitInfo_AliasSet::AliasEverything as u8,
13901 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
13902 false,
13903 false,
13904 false,
13905 false,
13906 false,
13907 false,
13908 0,
13909 ).to_ne_bytes()
13910 ),
13911});
13912}
13913unsafe extern "C" fn passOverloadedDict<D: DomTypes>
13914(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
13915 let mut result = false;
13916 wrap_panic(&mut || result = (|| {
13917 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
13918 let this = &*(this as *const D::TestBinding);
13919 let args = &*args;
13920 let argc = args.argc_;
13921
13922 let argcount = cmp::min(argc, 1);
13923 match argcount {
13924 1 => {
13925 if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
13926 let arg0: crate::codegen::GenericBindings::TestBindingBinding::TestURLLike = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13927 Ok(ConversionResult::Success(value)) => value,
13928 Ok(ConversionResult::Failure(error)) => {
13929 throw_type_error(cx.raw_cx(), &error);
13930 return false;
13931
13932 }
13933 _ => {
13934 return false;
13935
13936 },
13937 }
13938 ;
13939 let result: DOMString = this.PassOverloadedDict_(&arg0);
13940
13941 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13942 return true;
13943 }
13944 if HandleValue::from_raw(args.get(0)).get().is_object() {
13945 '_block: {
13946 let arg0: DomRoot<D::Node> = match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
13947 Ok(val) => val,
13948 Err(()) => {
13949 break '_block;
13950 }
13951 }
13952 ;
13953 let result: DOMString = this.PassOverloadedDict(&arg0);
13954
13955 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13956 return true;
13957 }
13958 }
13959 if HandleValue::from_raw(args.get(0)).get().is_object() {
13960 let arg0: crate::codegen::GenericBindings::TestBindingBinding::TestURLLike = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
13961 Ok(ConversionResult::Success(value)) => value,
13962 Ok(ConversionResult::Failure(error)) => {
13963 throw_type_error(cx.raw_cx(), &error);
13964 return false;
13965
13966 }
13967 _ => {
13968 return false;
13969
13970 },
13971 }
13972 ;
13973 let result: DOMString = this.PassOverloadedDict_(&arg0);
13974
13975 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
13976 return true;
13977 }
13978 throw_type_error(cx.raw_cx(), "Could not convert JavaScript argument");
13979 return false;
13980 }
13981 _ => {
13982 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passOverloadedDict\".");
13983 return false;
13984 }
13985 }
13986 })());
13987 result
13988}
13989
13990
13991static passOverloadedDict_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
13992
13993pub(crate) fn init_passOverloadedDict_methodinfo<D: DomTypes>() {
13994 passOverloadedDict_methodinfo.set(JSJitInfo {
13995 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
13996 method: Some(passOverloadedDict::<D>)
13997 },
13998 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
13999 protoID: PrototypeList::ID::TestBinding as u16,
14000 },
14001 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14002 _bitfield_align_1: [],
14003 _bitfield_1: __BindgenBitfieldUnit::new(
14004 new_jsjitinfo_bitfield_1!(
14005 JSJitInfo_OpType::Method as u8,
14006 JSJitInfo_AliasSet::AliasEverything as u8,
14007 JSValueType::JSVAL_TYPE_STRING as u8,
14008 false,
14009 false,
14010 false,
14011 false,
14012 false,
14013 false,
14014 0,
14015 ).to_ne_bytes()
14016 ),
14017});
14018}
14019unsafe extern "C" fn passNullableBoolean<D: DomTypes>
14020(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14021 let mut result = false;
14022 wrap_panic(&mut || result = (|| {
14023 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14024 let this = &*(this as *const D::TestBinding);
14025 let args = &*args;
14026 let argc = args.argc_;
14027
14028 if argc < 1 {
14029 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableBoolean\".");
14030 return false;
14031 }
14032 let arg0: Option<bool> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14033 Ok(ConversionResult::Success(value)) => value,
14034 Ok(ConversionResult::Failure(error)) => {
14035 throw_type_error(cx.raw_cx(), &error);
14036 return false;
14037
14038 }
14039 _ => {
14040 return false;
14041
14042 },
14043 }
14044 ;
14045 let result: () = this.PassNullableBoolean(arg0);
14046
14047 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14048 return true;
14049 })());
14050 result
14051}
14052
14053
14054static passNullableBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14055
14056pub(crate) fn init_passNullableBoolean_methodinfo<D: DomTypes>() {
14057 passNullableBoolean_methodinfo.set(JSJitInfo {
14058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14059 method: Some(passNullableBoolean::<D>)
14060 },
14061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14062 protoID: PrototypeList::ID::TestBinding as u16,
14063 },
14064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14065 _bitfield_align_1: [],
14066 _bitfield_1: __BindgenBitfieldUnit::new(
14067 new_jsjitinfo_bitfield_1!(
14068 JSJitInfo_OpType::Method as u8,
14069 JSJitInfo_AliasSet::AliasEverything as u8,
14070 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14071 false,
14072 false,
14073 false,
14074 false,
14075 false,
14076 false,
14077 0,
14078 ).to_ne_bytes()
14079 ),
14080});
14081}
14082unsafe extern "C" fn passNullableByte<D: DomTypes>
14083(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14084 let mut result = false;
14085 wrap_panic(&mut || result = (|| {
14086 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14087 let this = &*(this as *const D::TestBinding);
14088 let args = &*args;
14089 let argc = args.argc_;
14090
14091 if argc < 1 {
14092 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableByte\".");
14093 return false;
14094 }
14095 let arg0: Option<i8> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14096 Ok(ConversionResult::Success(value)) => value,
14097 Ok(ConversionResult::Failure(error)) => {
14098 throw_type_error(cx.raw_cx(), &error);
14099 return false;
14100
14101 }
14102 _ => {
14103 return false;
14104
14105 },
14106 }
14107 ;
14108 let result: () = this.PassNullableByte(arg0);
14109
14110 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14111 return true;
14112 })());
14113 result
14114}
14115
14116
14117static passNullableByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14118
14119pub(crate) fn init_passNullableByte_methodinfo<D: DomTypes>() {
14120 passNullableByte_methodinfo.set(JSJitInfo {
14121 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14122 method: Some(passNullableByte::<D>)
14123 },
14124 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14125 protoID: PrototypeList::ID::TestBinding as u16,
14126 },
14127 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14128 _bitfield_align_1: [],
14129 _bitfield_1: __BindgenBitfieldUnit::new(
14130 new_jsjitinfo_bitfield_1!(
14131 JSJitInfo_OpType::Method as u8,
14132 JSJitInfo_AliasSet::AliasEverything as u8,
14133 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14134 false,
14135 false,
14136 false,
14137 false,
14138 false,
14139 false,
14140 0,
14141 ).to_ne_bytes()
14142 ),
14143});
14144}
14145unsafe extern "C" fn passNullableOctet<D: DomTypes>
14146(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14147 let mut result = false;
14148 wrap_panic(&mut || result = (|| {
14149 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14150 let this = &*(this as *const D::TestBinding);
14151 let args = &*args;
14152 let argc = args.argc_;
14153
14154 if argc < 1 {
14155 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableOctet\".");
14156 return false;
14157 }
14158 let arg0: Option<u8> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14159 Ok(ConversionResult::Success(value)) => value,
14160 Ok(ConversionResult::Failure(error)) => {
14161 throw_type_error(cx.raw_cx(), &error);
14162 return false;
14163
14164 }
14165 _ => {
14166 return false;
14167
14168 },
14169 }
14170 ;
14171 let result: () = this.PassNullableOctet(arg0);
14172
14173 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14174 return true;
14175 })());
14176 result
14177}
14178
14179
14180static passNullableOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14181
14182pub(crate) fn init_passNullableOctet_methodinfo<D: DomTypes>() {
14183 passNullableOctet_methodinfo.set(JSJitInfo {
14184 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14185 method: Some(passNullableOctet::<D>)
14186 },
14187 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14188 protoID: PrototypeList::ID::TestBinding as u16,
14189 },
14190 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14191 _bitfield_align_1: [],
14192 _bitfield_1: __BindgenBitfieldUnit::new(
14193 new_jsjitinfo_bitfield_1!(
14194 JSJitInfo_OpType::Method as u8,
14195 JSJitInfo_AliasSet::AliasEverything as u8,
14196 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14197 false,
14198 false,
14199 false,
14200 false,
14201 false,
14202 false,
14203 0,
14204 ).to_ne_bytes()
14205 ),
14206});
14207}
14208unsafe extern "C" fn passNullableShort<D: DomTypes>
14209(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14210 let mut result = false;
14211 wrap_panic(&mut || result = (|| {
14212 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14213 let this = &*(this as *const D::TestBinding);
14214 let args = &*args;
14215 let argc = args.argc_;
14216
14217 if argc < 1 {
14218 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableShort\".");
14219 return false;
14220 }
14221 let arg0: Option<i16> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14222 Ok(ConversionResult::Success(value)) => value,
14223 Ok(ConversionResult::Failure(error)) => {
14224 throw_type_error(cx.raw_cx(), &error);
14225 return false;
14226
14227 }
14228 _ => {
14229 return false;
14230
14231 },
14232 }
14233 ;
14234 let result: () = this.PassNullableShort(arg0);
14235
14236 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14237 return true;
14238 })());
14239 result
14240}
14241
14242
14243static passNullableShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14244
14245pub(crate) fn init_passNullableShort_methodinfo<D: DomTypes>() {
14246 passNullableShort_methodinfo.set(JSJitInfo {
14247 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14248 method: Some(passNullableShort::<D>)
14249 },
14250 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14251 protoID: PrototypeList::ID::TestBinding as u16,
14252 },
14253 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14254 _bitfield_align_1: [],
14255 _bitfield_1: __BindgenBitfieldUnit::new(
14256 new_jsjitinfo_bitfield_1!(
14257 JSJitInfo_OpType::Method as u8,
14258 JSJitInfo_AliasSet::AliasEverything as u8,
14259 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14260 false,
14261 false,
14262 false,
14263 false,
14264 false,
14265 false,
14266 0,
14267 ).to_ne_bytes()
14268 ),
14269});
14270}
14271unsafe extern "C" fn passNullableUnsignedShort<D: DomTypes>
14272(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14273 let mut result = false;
14274 wrap_panic(&mut || result = (|| {
14275 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14276 let this = &*(this as *const D::TestBinding);
14277 let args = &*args;
14278 let argc = args.argc_;
14279
14280 if argc < 1 {
14281 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnsignedShort\".");
14282 return false;
14283 }
14284 let arg0: Option<u16> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14285 Ok(ConversionResult::Success(value)) => value,
14286 Ok(ConversionResult::Failure(error)) => {
14287 throw_type_error(cx.raw_cx(), &error);
14288 return false;
14289
14290 }
14291 _ => {
14292 return false;
14293
14294 },
14295 }
14296 ;
14297 let result: () = this.PassNullableUnsignedShort(arg0);
14298
14299 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14300 return true;
14301 })());
14302 result
14303}
14304
14305
14306static passNullableUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14307
14308pub(crate) fn init_passNullableUnsignedShort_methodinfo<D: DomTypes>() {
14309 passNullableUnsignedShort_methodinfo.set(JSJitInfo {
14310 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14311 method: Some(passNullableUnsignedShort::<D>)
14312 },
14313 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14314 protoID: PrototypeList::ID::TestBinding as u16,
14315 },
14316 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14317 _bitfield_align_1: [],
14318 _bitfield_1: __BindgenBitfieldUnit::new(
14319 new_jsjitinfo_bitfield_1!(
14320 JSJitInfo_OpType::Method as u8,
14321 JSJitInfo_AliasSet::AliasEverything as u8,
14322 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14323 false,
14324 false,
14325 false,
14326 false,
14327 false,
14328 false,
14329 0,
14330 ).to_ne_bytes()
14331 ),
14332});
14333}
14334unsafe extern "C" fn passNullableLong<D: DomTypes>
14335(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14336 let mut result = false;
14337 wrap_panic(&mut || result = (|| {
14338 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14339 let this = &*(this as *const D::TestBinding);
14340 let args = &*args;
14341 let argc = args.argc_;
14342
14343 if argc < 1 {
14344 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableLong\".");
14345 return false;
14346 }
14347 let arg0: Option<i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14348 Ok(ConversionResult::Success(value)) => value,
14349 Ok(ConversionResult::Failure(error)) => {
14350 throw_type_error(cx.raw_cx(), &error);
14351 return false;
14352
14353 }
14354 _ => {
14355 return false;
14356
14357 },
14358 }
14359 ;
14360 let result: () = this.PassNullableLong(arg0);
14361
14362 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14363 return true;
14364 })());
14365 result
14366}
14367
14368
14369static passNullableLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14370
14371pub(crate) fn init_passNullableLong_methodinfo<D: DomTypes>() {
14372 passNullableLong_methodinfo.set(JSJitInfo {
14373 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14374 method: Some(passNullableLong::<D>)
14375 },
14376 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14377 protoID: PrototypeList::ID::TestBinding as u16,
14378 },
14379 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14380 _bitfield_align_1: [],
14381 _bitfield_1: __BindgenBitfieldUnit::new(
14382 new_jsjitinfo_bitfield_1!(
14383 JSJitInfo_OpType::Method as u8,
14384 JSJitInfo_AliasSet::AliasEverything as u8,
14385 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14386 false,
14387 false,
14388 false,
14389 false,
14390 false,
14391 false,
14392 0,
14393 ).to_ne_bytes()
14394 ),
14395});
14396}
14397unsafe extern "C" fn passNullableUnsignedLong<D: DomTypes>
14398(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14399 let mut result = false;
14400 wrap_panic(&mut || result = (|| {
14401 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14402 let this = &*(this as *const D::TestBinding);
14403 let args = &*args;
14404 let argc = args.argc_;
14405
14406 if argc < 1 {
14407 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnsignedLong\".");
14408 return false;
14409 }
14410 let arg0: Option<u32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14411 Ok(ConversionResult::Success(value)) => value,
14412 Ok(ConversionResult::Failure(error)) => {
14413 throw_type_error(cx.raw_cx(), &error);
14414 return false;
14415
14416 }
14417 _ => {
14418 return false;
14419
14420 },
14421 }
14422 ;
14423 let result: () = this.PassNullableUnsignedLong(arg0);
14424
14425 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14426 return true;
14427 })());
14428 result
14429}
14430
14431
14432static passNullableUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14433
14434pub(crate) fn init_passNullableUnsignedLong_methodinfo<D: DomTypes>() {
14435 passNullableUnsignedLong_methodinfo.set(JSJitInfo {
14436 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14437 method: Some(passNullableUnsignedLong::<D>)
14438 },
14439 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14440 protoID: PrototypeList::ID::TestBinding as u16,
14441 },
14442 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14443 _bitfield_align_1: [],
14444 _bitfield_1: __BindgenBitfieldUnit::new(
14445 new_jsjitinfo_bitfield_1!(
14446 JSJitInfo_OpType::Method as u8,
14447 JSJitInfo_AliasSet::AliasEverything as u8,
14448 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14449 false,
14450 false,
14451 false,
14452 false,
14453 false,
14454 false,
14455 0,
14456 ).to_ne_bytes()
14457 ),
14458});
14459}
14460unsafe extern "C" fn passNullableLongLong<D: DomTypes>
14461(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14462 let mut result = false;
14463 wrap_panic(&mut || result = (|| {
14464 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14465 let this = &*(this as *const D::TestBinding);
14466 let args = &*args;
14467 let argc = args.argc_;
14468
14469 if argc < 1 {
14470 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableLongLong\".");
14471 return false;
14472 }
14473 let arg0: Option<i64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14474 Ok(ConversionResult::Success(value)) => value,
14475 Ok(ConversionResult::Failure(error)) => {
14476 throw_type_error(cx.raw_cx(), &error);
14477 return false;
14478
14479 }
14480 _ => {
14481 return false;
14482
14483 },
14484 }
14485 ;
14486 let result: () = this.PassNullableLongLong(arg0);
14487
14488 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14489 return true;
14490 })());
14491 result
14492}
14493
14494
14495static passNullableLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14496
14497pub(crate) fn init_passNullableLongLong_methodinfo<D: DomTypes>() {
14498 passNullableLongLong_methodinfo.set(JSJitInfo {
14499 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14500 method: Some(passNullableLongLong::<D>)
14501 },
14502 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14503 protoID: PrototypeList::ID::TestBinding as u16,
14504 },
14505 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14506 _bitfield_align_1: [],
14507 _bitfield_1: __BindgenBitfieldUnit::new(
14508 new_jsjitinfo_bitfield_1!(
14509 JSJitInfo_OpType::Method as u8,
14510 JSJitInfo_AliasSet::AliasEverything as u8,
14511 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14512 false,
14513 false,
14514 false,
14515 false,
14516 false,
14517 false,
14518 0,
14519 ).to_ne_bytes()
14520 ),
14521});
14522}
14523unsafe extern "C" fn passNullableUnsignedLongLong<D: DomTypes>
14524(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14525 let mut result = false;
14526 wrap_panic(&mut || result = (|| {
14527 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14528 let this = &*(this as *const D::TestBinding);
14529 let args = &*args;
14530 let argc = args.argc_;
14531
14532 if argc < 1 {
14533 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnsignedLongLong\".");
14534 return false;
14535 }
14536 let arg0: Option<u64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
14537 Ok(ConversionResult::Success(value)) => value,
14538 Ok(ConversionResult::Failure(error)) => {
14539 throw_type_error(cx.raw_cx(), &error);
14540 return false;
14541
14542 }
14543 _ => {
14544 return false;
14545
14546 },
14547 }
14548 ;
14549 let result: () = this.PassNullableUnsignedLongLong(arg0);
14550
14551 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14552 return true;
14553 })());
14554 result
14555}
14556
14557
14558static passNullableUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14559
14560pub(crate) fn init_passNullableUnsignedLongLong_methodinfo<D: DomTypes>() {
14561 passNullableUnsignedLongLong_methodinfo.set(JSJitInfo {
14562 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14563 method: Some(passNullableUnsignedLongLong::<D>)
14564 },
14565 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14566 protoID: PrototypeList::ID::TestBinding as u16,
14567 },
14568 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14569 _bitfield_align_1: [],
14570 _bitfield_1: __BindgenBitfieldUnit::new(
14571 new_jsjitinfo_bitfield_1!(
14572 JSJitInfo_OpType::Method as u8,
14573 JSJitInfo_AliasSet::AliasEverything as u8,
14574 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14575 false,
14576 false,
14577 false,
14578 false,
14579 false,
14580 false,
14581 0,
14582 ).to_ne_bytes()
14583 ),
14584});
14585}
14586unsafe extern "C" fn passNullableUnrestrictedFloat<D: DomTypes>
14587(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14588 let mut result = false;
14589 wrap_panic(&mut || result = (|| {
14590 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14591 let this = &*(this as *const D::TestBinding);
14592 let args = &*args;
14593 let argc = args.argc_;
14594
14595 if argc < 1 {
14596 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnrestrictedFloat\".");
14597 return false;
14598 }
14599 let arg0: Option<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14600 Ok(ConversionResult::Success(value)) => value,
14601 Ok(ConversionResult::Failure(error)) => {
14602 throw_type_error(cx.raw_cx(), &error);
14603 return false;
14604
14605 }
14606 _ => {
14607 return false;
14608
14609 },
14610 }
14611 ;
14612 let result: () = this.PassNullableUnrestrictedFloat(arg0);
14613
14614 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14615 return true;
14616 })());
14617 result
14618}
14619
14620
14621static passNullableUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14622
14623pub(crate) fn init_passNullableUnrestrictedFloat_methodinfo<D: DomTypes>() {
14624 passNullableUnrestrictedFloat_methodinfo.set(JSJitInfo {
14625 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14626 method: Some(passNullableUnrestrictedFloat::<D>)
14627 },
14628 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14629 protoID: PrototypeList::ID::TestBinding as u16,
14630 },
14631 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14632 _bitfield_align_1: [],
14633 _bitfield_1: __BindgenBitfieldUnit::new(
14634 new_jsjitinfo_bitfield_1!(
14635 JSJitInfo_OpType::Method as u8,
14636 JSJitInfo_AliasSet::AliasEverything as u8,
14637 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14638 false,
14639 false,
14640 false,
14641 false,
14642 false,
14643 false,
14644 0,
14645 ).to_ne_bytes()
14646 ),
14647});
14648}
14649unsafe extern "C" fn passNullableFloat<D: DomTypes>
14650(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14651 let mut result = false;
14652 wrap_panic(&mut || result = (|| {
14653 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14654 let this = &*(this as *const D::TestBinding);
14655 let args = &*args;
14656 let argc = args.argc_;
14657
14658 if argc < 1 {
14659 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableFloat\".");
14660 return false;
14661 }
14662 let arg0: Option<Finite<f32>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14663 Ok(ConversionResult::Success(value)) => value,
14664 Ok(ConversionResult::Failure(error)) => {
14665 throw_type_error(cx.raw_cx(), &error);
14666 return false;
14667
14668 }
14669 _ => {
14670 return false;
14671
14672 },
14673 }
14674 ;
14675 let result: () = this.PassNullableFloat(arg0);
14676
14677 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14678 return true;
14679 })());
14680 result
14681}
14682
14683
14684static passNullableFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14685
14686pub(crate) fn init_passNullableFloat_methodinfo<D: DomTypes>() {
14687 passNullableFloat_methodinfo.set(JSJitInfo {
14688 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14689 method: Some(passNullableFloat::<D>)
14690 },
14691 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14692 protoID: PrototypeList::ID::TestBinding as u16,
14693 },
14694 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14695 _bitfield_align_1: [],
14696 _bitfield_1: __BindgenBitfieldUnit::new(
14697 new_jsjitinfo_bitfield_1!(
14698 JSJitInfo_OpType::Method as u8,
14699 JSJitInfo_AliasSet::AliasEverything as u8,
14700 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14701 false,
14702 false,
14703 false,
14704 false,
14705 false,
14706 false,
14707 0,
14708 ).to_ne_bytes()
14709 ),
14710});
14711}
14712unsafe extern "C" fn passNullableUnrestrictedDouble<D: DomTypes>
14713(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14714 let mut result = false;
14715 wrap_panic(&mut || result = (|| {
14716 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14717 let this = &*(this as *const D::TestBinding);
14718 let args = &*args;
14719 let argc = args.argc_;
14720
14721 if argc < 1 {
14722 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnrestrictedDouble\".");
14723 return false;
14724 }
14725 let arg0: Option<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14726 Ok(ConversionResult::Success(value)) => value,
14727 Ok(ConversionResult::Failure(error)) => {
14728 throw_type_error(cx.raw_cx(), &error);
14729 return false;
14730
14731 }
14732 _ => {
14733 return false;
14734
14735 },
14736 }
14737 ;
14738 let result: () = this.PassNullableUnrestrictedDouble(arg0);
14739
14740 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14741 return true;
14742 })());
14743 result
14744}
14745
14746
14747static passNullableUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14748
14749pub(crate) fn init_passNullableUnrestrictedDouble_methodinfo<D: DomTypes>() {
14750 passNullableUnrestrictedDouble_methodinfo.set(JSJitInfo {
14751 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14752 method: Some(passNullableUnrestrictedDouble::<D>)
14753 },
14754 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14755 protoID: PrototypeList::ID::TestBinding as u16,
14756 },
14757 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14758 _bitfield_align_1: [],
14759 _bitfield_1: __BindgenBitfieldUnit::new(
14760 new_jsjitinfo_bitfield_1!(
14761 JSJitInfo_OpType::Method as u8,
14762 JSJitInfo_AliasSet::AliasEverything as u8,
14763 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14764 false,
14765 false,
14766 false,
14767 false,
14768 false,
14769 false,
14770 0,
14771 ).to_ne_bytes()
14772 ),
14773});
14774}
14775unsafe extern "C" fn passNullableDouble<D: DomTypes>
14776(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14777 let mut result = false;
14778 wrap_panic(&mut || result = (|| {
14779 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14780 let this = &*(this as *const D::TestBinding);
14781 let args = &*args;
14782 let argc = args.argc_;
14783
14784 if argc < 1 {
14785 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableDouble\".");
14786 return false;
14787 }
14788 let arg0: Option<Finite<f64>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14789 Ok(ConversionResult::Success(value)) => value,
14790 Ok(ConversionResult::Failure(error)) => {
14791 throw_type_error(cx.raw_cx(), &error);
14792 return false;
14793
14794 }
14795 _ => {
14796 return false;
14797
14798 },
14799 }
14800 ;
14801 let result: () = this.PassNullableDouble(arg0);
14802
14803 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14804 return true;
14805 })());
14806 result
14807}
14808
14809
14810static passNullableDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14811
14812pub(crate) fn init_passNullableDouble_methodinfo<D: DomTypes>() {
14813 passNullableDouble_methodinfo.set(JSJitInfo {
14814 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14815 method: Some(passNullableDouble::<D>)
14816 },
14817 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14818 protoID: PrototypeList::ID::TestBinding as u16,
14819 },
14820 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14821 _bitfield_align_1: [],
14822 _bitfield_1: __BindgenBitfieldUnit::new(
14823 new_jsjitinfo_bitfield_1!(
14824 JSJitInfo_OpType::Method as u8,
14825 JSJitInfo_AliasSet::AliasEverything as u8,
14826 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14827 false,
14828 false,
14829 false,
14830 false,
14831 false,
14832 false,
14833 0,
14834 ).to_ne_bytes()
14835 ),
14836});
14837}
14838unsafe extern "C" fn passNullableString<D: DomTypes>
14839(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14840 let mut result = false;
14841 wrap_panic(&mut || result = (|| {
14842 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14843 let this = &*(this as *const D::TestBinding);
14844 let args = &*args;
14845 let argc = args.argc_;
14846
14847 if argc < 1 {
14848 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableString\".");
14849 return false;
14850 }
14851 let arg0: Option<DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
14852 Ok(ConversionResult::Success(value)) => value,
14853 Ok(ConversionResult::Failure(error)) => {
14854 throw_type_error(cx.raw_cx(), &error);
14855 return false;
14856
14857 }
14858 _ => {
14859 return false;
14860
14861 },
14862 }
14863 ;
14864 let result: () = this.PassNullableString(arg0);
14865
14866 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14867 return true;
14868 })());
14869 result
14870}
14871
14872
14873static passNullableString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14874
14875pub(crate) fn init_passNullableString_methodinfo<D: DomTypes>() {
14876 passNullableString_methodinfo.set(JSJitInfo {
14877 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14878 method: Some(passNullableString::<D>)
14879 },
14880 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14881 protoID: PrototypeList::ID::TestBinding as u16,
14882 },
14883 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14884 _bitfield_align_1: [],
14885 _bitfield_1: __BindgenBitfieldUnit::new(
14886 new_jsjitinfo_bitfield_1!(
14887 JSJitInfo_OpType::Method as u8,
14888 JSJitInfo_AliasSet::AliasEverything as u8,
14889 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14890 false,
14891 false,
14892 false,
14893 false,
14894 false,
14895 false,
14896 0,
14897 ).to_ne_bytes()
14898 ),
14899});
14900}
14901unsafe extern "C" fn passNullableUsvstring<D: DomTypes>
14902(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14903 let mut result = false;
14904 wrap_panic(&mut || result = (|| {
14905 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14906 let this = &*(this as *const D::TestBinding);
14907 let args = &*args;
14908 let argc = args.argc_;
14909
14910 if argc < 1 {
14911 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUsvstring\".");
14912 return false;
14913 }
14914 let arg0: Option<USVString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14915 Ok(ConversionResult::Success(value)) => value,
14916 Ok(ConversionResult::Failure(error)) => {
14917 throw_type_error(cx.raw_cx(), &error);
14918 return false;
14919
14920 }
14921 _ => {
14922 return false;
14923
14924 },
14925 }
14926 ;
14927 let result: () = this.PassNullableUsvstring(arg0);
14928
14929 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14930 return true;
14931 })());
14932 result
14933}
14934
14935
14936static passNullableUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
14937
14938pub(crate) fn init_passNullableUsvstring_methodinfo<D: DomTypes>() {
14939 passNullableUsvstring_methodinfo.set(JSJitInfo {
14940 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
14941 method: Some(passNullableUsvstring::<D>)
14942 },
14943 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
14944 protoID: PrototypeList::ID::TestBinding as u16,
14945 },
14946 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
14947 _bitfield_align_1: [],
14948 _bitfield_1: __BindgenBitfieldUnit::new(
14949 new_jsjitinfo_bitfield_1!(
14950 JSJitInfo_OpType::Method as u8,
14951 JSJitInfo_AliasSet::AliasEverything as u8,
14952 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
14953 false,
14954 false,
14955 false,
14956 false,
14957 false,
14958 false,
14959 0,
14960 ).to_ne_bytes()
14961 ),
14962});
14963}
14964unsafe extern "C" fn passNullableByteString<D: DomTypes>
14965(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
14966 let mut result = false;
14967 wrap_panic(&mut || result = (|| {
14968 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
14969 let this = &*(this as *const D::TestBinding);
14970 let args = &*args;
14971 let argc = args.argc_;
14972
14973 if argc < 1 {
14974 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableByteString\".");
14975 return false;
14976 }
14977 let arg0: Option<ByteString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
14978 Ok(ConversionResult::Success(value)) => value,
14979 Ok(ConversionResult::Failure(error)) => {
14980 throw_type_error(cx.raw_cx(), &error);
14981 return false;
14982
14983 }
14984 _ => {
14985 return false;
14986
14987 },
14988 }
14989 ;
14990 let result: () = this.PassNullableByteString(arg0);
14991
14992 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
14993 return true;
14994 })());
14995 result
14996}
14997
14998
14999static passNullableByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15000
15001pub(crate) fn init_passNullableByteString_methodinfo<D: DomTypes>() {
15002 passNullableByteString_methodinfo.set(JSJitInfo {
15003 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15004 method: Some(passNullableByteString::<D>)
15005 },
15006 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15007 protoID: PrototypeList::ID::TestBinding as u16,
15008 },
15009 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15010 _bitfield_align_1: [],
15011 _bitfield_1: __BindgenBitfieldUnit::new(
15012 new_jsjitinfo_bitfield_1!(
15013 JSJitInfo_OpType::Method as u8,
15014 JSJitInfo_AliasSet::AliasEverything as u8,
15015 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15016 false,
15017 false,
15018 false,
15019 false,
15020 false,
15021 false,
15022 0,
15023 ).to_ne_bytes()
15024 ),
15025});
15026}
15027unsafe extern "C" fn passNullableInterface<D: DomTypes>
15028(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15029 let mut result = false;
15030 wrap_panic(&mut || result = (|| {
15031 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15032 let this = &*(this as *const D::TestBinding);
15033 let args = &*args;
15034 let argc = args.argc_;
15035
15036 if argc < 1 {
15037 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableInterface\".");
15038 return false;
15039 }
15040 let arg0: Option<DomRoot<D::Blob>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15041 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
15042 Ok(val) => val,
15043 Err(()) => {
15044 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
15045 return false;
15046
15047 }
15048 }
15049 )
15050 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
15051 None
15052 } else {
15053 throw_type_error(cx.raw_cx(), "Value is not an object.");
15054 return false;
15055
15056 };
15057 let result: () = this.PassNullableInterface(arg0.as_deref());
15058
15059 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15060 return true;
15061 })());
15062 result
15063}
15064
15065
15066static passNullableInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15067
15068pub(crate) fn init_passNullableInterface_methodinfo<D: DomTypes>() {
15069 passNullableInterface_methodinfo.set(JSJitInfo {
15070 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15071 method: Some(passNullableInterface::<D>)
15072 },
15073 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15074 protoID: PrototypeList::ID::TestBinding as u16,
15075 },
15076 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15077 _bitfield_align_1: [],
15078 _bitfield_1: __BindgenBitfieldUnit::new(
15079 new_jsjitinfo_bitfield_1!(
15080 JSJitInfo_OpType::Method as u8,
15081 JSJitInfo_AliasSet::AliasEverything as u8,
15082 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15083 false,
15084 false,
15085 false,
15086 false,
15087 false,
15088 false,
15089 0,
15090 ).to_ne_bytes()
15091 ),
15092});
15093}
15094unsafe extern "C" fn passNullableObject<D: DomTypes>
15095(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15096 let mut result = false;
15097 wrap_panic(&mut || result = (|| {
15098 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15099 let this = &*(this as *const D::TestBinding);
15100 let args = &*args;
15101 let argc = args.argc_;
15102
15103 if argc < 1 {
15104 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableObject\".");
15105 return false;
15106 }
15107 let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
15108 HandleValue::from_raw(args.get(0)).get().to_object()
15109 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
15110 ptr::null_mut()
15111 } else {
15112 throw_type_error(cx.raw_cx(), "Value is not an object.");
15113 return false;
15114
15115 };
15116 let result: () = this.PassNullableObject(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
15117
15118 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15119 return true;
15120 })());
15121 result
15122}
15123
15124
15125static passNullableObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15126
15127pub(crate) fn init_passNullableObject_methodinfo<D: DomTypes>() {
15128 passNullableObject_methodinfo.set(JSJitInfo {
15129 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15130 method: Some(passNullableObject::<D>)
15131 },
15132 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15133 protoID: PrototypeList::ID::TestBinding as u16,
15134 },
15135 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15136 _bitfield_align_1: [],
15137 _bitfield_1: __BindgenBitfieldUnit::new(
15138 new_jsjitinfo_bitfield_1!(
15139 JSJitInfo_OpType::Method as u8,
15140 JSJitInfo_AliasSet::AliasEverything as u8,
15141 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15142 false,
15143 false,
15144 false,
15145 false,
15146 false,
15147 false,
15148 0,
15149 ).to_ne_bytes()
15150 ),
15151});
15152}
15153unsafe extern "C" fn passNullableTypedArray<D: DomTypes>
15154(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15155 let mut result = false;
15156 wrap_panic(&mut || result = (|| {
15157 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15158 let this = &*(this as *const D::TestBinding);
15159 let args = &*args;
15160 let argc = args.argc_;
15161
15162 if argc < 1 {
15163 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableTypedArray\".");
15164 return false;
15165 }
15166 let arg0: Option<typedarray::Int8Array> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15167 Some(match typedarray::Int8Array::from(HandleValue::from_raw(args.get(0)).get().to_object()) {
15168 Ok(val) => val,
15169 Err(()) => {
15170 throw_type_error(cx.raw_cx(), "value is not a typed array.");
15171 return false;
15172
15173 }
15174 }
15175 )
15176 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
15177 None
15178 } else {
15179 throw_type_error(cx.raw_cx(), "Value is not an object.");
15180 return false;
15181
15182 };
15183 auto_root!(&in(cx) let arg0 = arg0);
15184 let result: () = this.PassNullableTypedArray(arg0);
15185
15186 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15187 return true;
15188 })());
15189 result
15190}
15191
15192
15193static passNullableTypedArray_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15194
15195pub(crate) fn init_passNullableTypedArray_methodinfo<D: DomTypes>() {
15196 passNullableTypedArray_methodinfo.set(JSJitInfo {
15197 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15198 method: Some(passNullableTypedArray::<D>)
15199 },
15200 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15201 protoID: PrototypeList::ID::TestBinding as u16,
15202 },
15203 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15204 _bitfield_align_1: [],
15205 _bitfield_1: __BindgenBitfieldUnit::new(
15206 new_jsjitinfo_bitfield_1!(
15207 JSJitInfo_OpType::Method as u8,
15208 JSJitInfo_AliasSet::AliasEverything as u8,
15209 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15210 false,
15211 false,
15212 false,
15213 false,
15214 false,
15215 false,
15216 0,
15217 ).to_ne_bytes()
15218 ),
15219});
15220}
15221unsafe extern "C" fn passNullableUnion<D: DomTypes>
15222(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15223 let mut result = false;
15224 wrap_panic(&mut || result = (|| {
15225 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15226 let this = &*(this as *const D::TestBinding);
15227 let args = &*args;
15228 let argc = args.argc_;
15229
15230 if argc < 1 {
15231 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion\".");
15232 return false;
15233 }
15234 let arg0: Option<GenericUnionTypes::HTMLElementOrLong::<D> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15235 Ok(ConversionResult::Success(value)) => value,
15236 Ok(ConversionResult::Failure(error)) => {
15237 throw_type_error(cx.raw_cx(), &error);
15238 return false;
15239
15240 }
15241 _ => {
15242 return false;
15243
15244 },
15245 }
15246 ;
15247 let result: () = this.PassNullableUnion(arg0);
15248
15249 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15250 return true;
15251 })());
15252 result
15253}
15254
15255
15256static passNullableUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15257
15258pub(crate) fn init_passNullableUnion_methodinfo<D: DomTypes>() {
15259 passNullableUnion_methodinfo.set(JSJitInfo {
15260 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15261 method: Some(passNullableUnion::<D>)
15262 },
15263 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15264 protoID: PrototypeList::ID::TestBinding as u16,
15265 },
15266 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15267 _bitfield_align_1: [],
15268 _bitfield_1: __BindgenBitfieldUnit::new(
15269 new_jsjitinfo_bitfield_1!(
15270 JSJitInfo_OpType::Method as u8,
15271 JSJitInfo_AliasSet::AliasEverything as u8,
15272 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15273 false,
15274 false,
15275 false,
15276 false,
15277 false,
15278 false,
15279 0,
15280 ).to_ne_bytes()
15281 ),
15282});
15283}
15284unsafe extern "C" fn passNullableUnion2<D: DomTypes>
15285(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15286 let mut result = false;
15287 wrap_panic(&mut || result = (|| {
15288 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15289 let this = &*(this as *const D::TestBinding);
15290 let args = &*args;
15291 let argc = args.argc_;
15292
15293 if argc < 1 {
15294 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion2\".");
15295 return false;
15296 }
15297 let arg0: Option<GenericUnionTypes::EventOrString::<D> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15298 Ok(ConversionResult::Success(value)) => value,
15299 Ok(ConversionResult::Failure(error)) => {
15300 throw_type_error(cx.raw_cx(), &error);
15301 return false;
15302
15303 }
15304 _ => {
15305 return false;
15306
15307 },
15308 }
15309 ;
15310 let result: () = this.PassNullableUnion2(arg0);
15311
15312 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15313 return true;
15314 })());
15315 result
15316}
15317
15318
15319static passNullableUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15320
15321pub(crate) fn init_passNullableUnion2_methodinfo<D: DomTypes>() {
15322 passNullableUnion2_methodinfo.set(JSJitInfo {
15323 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15324 method: Some(passNullableUnion2::<D>)
15325 },
15326 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15327 protoID: PrototypeList::ID::TestBinding as u16,
15328 },
15329 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15330 _bitfield_align_1: [],
15331 _bitfield_1: __BindgenBitfieldUnit::new(
15332 new_jsjitinfo_bitfield_1!(
15333 JSJitInfo_OpType::Method as u8,
15334 JSJitInfo_AliasSet::AliasEverything as u8,
15335 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15336 false,
15337 false,
15338 false,
15339 false,
15340 false,
15341 false,
15342 0,
15343 ).to_ne_bytes()
15344 ),
15345});
15346}
15347unsafe extern "C" fn passNullableUnion3<D: DomTypes>
15348(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15349 let mut result = false;
15350 wrap_panic(&mut || result = (|| {
15351 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15352 let this = &*(this as *const D::TestBinding);
15353 let args = &*args;
15354 let argc = args.argc_;
15355
15356 if argc < 1 {
15357 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion3\".");
15358 return false;
15359 }
15360 let arg0: Option<GenericUnionTypes::StringOrLongSequence > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15361 Ok(ConversionResult::Success(value)) => value,
15362 Ok(ConversionResult::Failure(error)) => {
15363 throw_type_error(cx.raw_cx(), &error);
15364 return false;
15365
15366 }
15367 _ => {
15368 return false;
15369
15370 },
15371 }
15372 ;
15373 let result: () = this.PassNullableUnion3(arg0);
15374
15375 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15376 return true;
15377 })());
15378 result
15379}
15380
15381
15382static passNullableUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15383
15384pub(crate) fn init_passNullableUnion3_methodinfo<D: DomTypes>() {
15385 passNullableUnion3_methodinfo.set(JSJitInfo {
15386 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15387 method: Some(passNullableUnion3::<D>)
15388 },
15389 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15390 protoID: PrototypeList::ID::TestBinding as u16,
15391 },
15392 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15393 _bitfield_align_1: [],
15394 _bitfield_1: __BindgenBitfieldUnit::new(
15395 new_jsjitinfo_bitfield_1!(
15396 JSJitInfo_OpType::Method as u8,
15397 JSJitInfo_AliasSet::AliasEverything as u8,
15398 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15399 false,
15400 false,
15401 false,
15402 false,
15403 false,
15404 false,
15405 0,
15406 ).to_ne_bytes()
15407 ),
15408});
15409}
15410unsafe extern "C" fn passNullableUnion4<D: DomTypes>
15411(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15412 let mut result = false;
15413 wrap_panic(&mut || result = (|| {
15414 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15415 let this = &*(this as *const D::TestBinding);
15416 let args = &*args;
15417 let argc = args.argc_;
15418
15419 if argc < 1 {
15420 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion4\".");
15421 return false;
15422 }
15423 let arg0: Option<GenericUnionTypes::LongSequenceOrBoolean > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15424 Ok(ConversionResult::Success(value)) => value,
15425 Ok(ConversionResult::Failure(error)) => {
15426 throw_type_error(cx.raw_cx(), &error);
15427 return false;
15428
15429 }
15430 _ => {
15431 return false;
15432
15433 },
15434 }
15435 ;
15436 let result: () = this.PassNullableUnion4(arg0);
15437
15438 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15439 return true;
15440 })());
15441 result
15442}
15443
15444
15445static passNullableUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15446
15447pub(crate) fn init_passNullableUnion4_methodinfo<D: DomTypes>() {
15448 passNullableUnion4_methodinfo.set(JSJitInfo {
15449 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15450 method: Some(passNullableUnion4::<D>)
15451 },
15452 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15453 protoID: PrototypeList::ID::TestBinding as u16,
15454 },
15455 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15456 _bitfield_align_1: [],
15457 _bitfield_1: __BindgenBitfieldUnit::new(
15458 new_jsjitinfo_bitfield_1!(
15459 JSJitInfo_OpType::Method as u8,
15460 JSJitInfo_AliasSet::AliasEverything as u8,
15461 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15462 false,
15463 false,
15464 false,
15465 false,
15466 false,
15467 false,
15468 0,
15469 ).to_ne_bytes()
15470 ),
15471});
15472}
15473unsafe extern "C" fn passNullableUnion5<D: DomTypes>
15474(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15475 let mut result = false;
15476 wrap_panic(&mut || result = (|| {
15477 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15478 let this = &*(this as *const D::TestBinding);
15479 let args = &*args;
15480 let argc = args.argc_;
15481
15482 if argc < 1 {
15483 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion5\".");
15484 return false;
15485 }
15486 let arg0: Option<GenericUnionTypes::UnsignedLongOrBoolean > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15487 Ok(ConversionResult::Success(value)) => value,
15488 Ok(ConversionResult::Failure(error)) => {
15489 throw_type_error(cx.raw_cx(), &error);
15490 return false;
15491
15492 }
15493 _ => {
15494 return false;
15495
15496 },
15497 }
15498 ;
15499 let result: () = this.PassNullableUnion5(arg0);
15500
15501 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15502 return true;
15503 })());
15504 result
15505}
15506
15507
15508static passNullableUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15509
15510pub(crate) fn init_passNullableUnion5_methodinfo<D: DomTypes>() {
15511 passNullableUnion5_methodinfo.set(JSJitInfo {
15512 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15513 method: Some(passNullableUnion5::<D>)
15514 },
15515 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15516 protoID: PrototypeList::ID::TestBinding as u16,
15517 },
15518 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15519 _bitfield_align_1: [],
15520 _bitfield_1: __BindgenBitfieldUnit::new(
15521 new_jsjitinfo_bitfield_1!(
15522 JSJitInfo_OpType::Method as u8,
15523 JSJitInfo_AliasSet::AliasEverything as u8,
15524 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15525 false,
15526 false,
15527 false,
15528 false,
15529 false,
15530 false,
15531 0,
15532 ).to_ne_bytes()
15533 ),
15534});
15535}
15536unsafe extern "C" fn passNullableUnion6<D: DomTypes>
15537(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15538 let mut result = false;
15539 wrap_panic(&mut || result = (|| {
15540 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15541 let this = &*(this as *const D::TestBinding);
15542 let args = &*args;
15543 let argc = args.argc_;
15544
15545 if argc < 1 {
15546 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableUnion6\".");
15547 return false;
15548 }
15549 let arg0: Option<GenericUnionTypes::ByteStringOrLong > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15550 Ok(ConversionResult::Success(value)) => value,
15551 Ok(ConversionResult::Failure(error)) => {
15552 throw_type_error(cx.raw_cx(), &error);
15553 return false;
15554
15555 }
15556 _ => {
15557 return false;
15558
15559 },
15560 }
15561 ;
15562 let result: () = this.PassNullableUnion6(arg0);
15563
15564 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15565 return true;
15566 })());
15567 result
15568}
15569
15570
15571static passNullableUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15572
15573pub(crate) fn init_passNullableUnion6_methodinfo<D: DomTypes>() {
15574 passNullableUnion6_methodinfo.set(JSJitInfo {
15575 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15576 method: Some(passNullableUnion6::<D>)
15577 },
15578 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15579 protoID: PrototypeList::ID::TestBinding as u16,
15580 },
15581 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15582 _bitfield_align_1: [],
15583 _bitfield_1: __BindgenBitfieldUnit::new(
15584 new_jsjitinfo_bitfield_1!(
15585 JSJitInfo_OpType::Method as u8,
15586 JSJitInfo_AliasSet::AliasEverything as u8,
15587 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15588 false,
15589 false,
15590 false,
15591 false,
15592 false,
15593 false,
15594 0,
15595 ).to_ne_bytes()
15596 ),
15597});
15598}
15599unsafe extern "C" fn passNullableCallbackFunction<D: DomTypes>
15600(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15601 let mut result = false;
15602 wrap_panic(&mut || result = (|| {
15603 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15604 let this = &*(this as *const D::TestBinding);
15605 let args = &*args;
15606 let argc = args.argc_;
15607
15608 if argc < 1 {
15609 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableCallbackFunction\".");
15610 return false;
15611 }
15612 let arg0: Option<Rc<Function<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15613 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
15614 Some(Function::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
15615 } else {
15616 throw_type_error(cx.raw_cx(), "Value is not callable.");
15617 return false;
15618
15619 }
15620 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
15621 None
15622 } else {
15623 throw_type_error(cx.raw_cx(), "Value is not an object.");
15624 return false;
15625
15626 };
15627 let result: () = this.PassNullableCallbackFunction(arg0);
15628
15629 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15630 return true;
15631 })());
15632 result
15633}
15634
15635
15636static passNullableCallbackFunction_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15637
15638pub(crate) fn init_passNullableCallbackFunction_methodinfo<D: DomTypes>() {
15639 passNullableCallbackFunction_methodinfo.set(JSJitInfo {
15640 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15641 method: Some(passNullableCallbackFunction::<D>)
15642 },
15643 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15644 protoID: PrototypeList::ID::TestBinding as u16,
15645 },
15646 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15647 _bitfield_align_1: [],
15648 _bitfield_1: __BindgenBitfieldUnit::new(
15649 new_jsjitinfo_bitfield_1!(
15650 JSJitInfo_OpType::Method as u8,
15651 JSJitInfo_AliasSet::AliasEverything as u8,
15652 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15653 false,
15654 false,
15655 false,
15656 false,
15657 false,
15658 false,
15659 0,
15660 ).to_ne_bytes()
15661 ),
15662});
15663}
15664unsafe extern "C" fn passNullableCallbackInterface<D: DomTypes>
15665(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15666 let mut result = false;
15667 wrap_panic(&mut || result = (|| {
15668 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15669 let this = &*(this as *const D::TestBinding);
15670 let args = &*args;
15671 let argc = args.argc_;
15672
15673 if argc < 1 {
15674 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableCallbackInterface\".");
15675 return false;
15676 }
15677 let arg0: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
15678 Some(crate::codegen::GenericBindings::EventListenerBinding::EventListener::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
15679 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
15680 None
15681 } else {
15682 throw_type_error(cx.raw_cx(), "Value is not an object.");
15683 return false;
15684
15685 };
15686 let result: () = this.PassNullableCallbackInterface(arg0);
15687
15688 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15689 return true;
15690 })());
15691 result
15692}
15693
15694
15695static passNullableCallbackInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15696
15697pub(crate) fn init_passNullableCallbackInterface_methodinfo<D: DomTypes>() {
15698 passNullableCallbackInterface_methodinfo.set(JSJitInfo {
15699 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15700 method: Some(passNullableCallbackInterface::<D>)
15701 },
15702 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15703 protoID: PrototypeList::ID::TestBinding as u16,
15704 },
15705 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15706 _bitfield_align_1: [],
15707 _bitfield_1: __BindgenBitfieldUnit::new(
15708 new_jsjitinfo_bitfield_1!(
15709 JSJitInfo_OpType::Method as u8,
15710 JSJitInfo_AliasSet::AliasEverything as u8,
15711 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15712 false,
15713 false,
15714 false,
15715 false,
15716 false,
15717 false,
15718 0,
15719 ).to_ne_bytes()
15720 ),
15721});
15722}
15723unsafe extern "C" fn passNullableSequence<D: DomTypes>
15724(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15725 let mut result = false;
15726 wrap_panic(&mut || result = (|| {
15727 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15728 let this = &*(this as *const D::TestBinding);
15729 let args = &*args;
15730 let argc = args.argc_;
15731
15732 if argc < 1 {
15733 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableSequence\".");
15734 return false;
15735 }
15736 let arg0: Option<Vec<i32> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15737 Ok(ConversionResult::Success(value)) => value,
15738 Ok(ConversionResult::Failure(error)) => {
15739 throw_type_error(cx.raw_cx(), &error);
15740 return false;
15741
15742 }
15743 _ => {
15744 return false;
15745
15746 },
15747 }
15748 ;
15749 let result: () = this.PassNullableSequence(arg0);
15750
15751 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15752 return true;
15753 })());
15754 result
15755}
15756
15757
15758static passNullableSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15759
15760pub(crate) fn init_passNullableSequence_methodinfo<D: DomTypes>() {
15761 passNullableSequence_methodinfo.set(JSJitInfo {
15762 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15763 method: Some(passNullableSequence::<D>)
15764 },
15765 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15766 protoID: PrototypeList::ID::TestBinding as u16,
15767 },
15768 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15769 _bitfield_align_1: [],
15770 _bitfield_1: __BindgenBitfieldUnit::new(
15771 new_jsjitinfo_bitfield_1!(
15772 JSJitInfo_OpType::Method as u8,
15773 JSJitInfo_AliasSet::AliasEverything as u8,
15774 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15775 false,
15776 false,
15777 false,
15778 false,
15779 false,
15780 false,
15781 0,
15782 ).to_ne_bytes()
15783 ),
15784});
15785}
15786unsafe extern "C" fn passOptionalBoolean<D: DomTypes>
15787(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15788 let mut result = false;
15789 wrap_panic(&mut || result = (|| {
15790 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15791 let this = &*(this as *const D::TestBinding);
15792 let args = &*args;
15793 let argc = args.argc_;
15794 let arg0: Option<bool> = if args.get(0).is_undefined() {
15795 None
15796 } else {
15797 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
15798 Ok(ConversionResult::Success(value)) => value,
15799 Ok(ConversionResult::Failure(error)) => {
15800 throw_type_error(cx.raw_cx(), &error);
15801 return false;
15802
15803 }
15804 _ => {
15805 return false;
15806
15807 },
15808 }
15809 )
15810 };
15811 let result: () = this.PassOptionalBoolean(arg0);
15812
15813 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15814 return true;
15815 })());
15816 result
15817}
15818
15819
15820static passOptionalBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15821
15822pub(crate) fn init_passOptionalBoolean_methodinfo<D: DomTypes>() {
15823 passOptionalBoolean_methodinfo.set(JSJitInfo {
15824 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15825 method: Some(passOptionalBoolean::<D>)
15826 },
15827 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15828 protoID: PrototypeList::ID::TestBinding as u16,
15829 },
15830 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15831 _bitfield_align_1: [],
15832 _bitfield_1: __BindgenBitfieldUnit::new(
15833 new_jsjitinfo_bitfield_1!(
15834 JSJitInfo_OpType::Method as u8,
15835 JSJitInfo_AliasSet::AliasEverything as u8,
15836 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15837 false,
15838 false,
15839 false,
15840 false,
15841 false,
15842 false,
15843 0,
15844 ).to_ne_bytes()
15845 ),
15846});
15847}
15848unsafe extern "C" fn passOptionalByte<D: DomTypes>
15849(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15850 let mut result = false;
15851 wrap_panic(&mut || result = (|| {
15852 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15853 let this = &*(this as *const D::TestBinding);
15854 let args = &*args;
15855 let argc = args.argc_;
15856 let arg0: Option<i8> = if args.get(0).is_undefined() {
15857 None
15858 } else {
15859 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15860 Ok(ConversionResult::Success(value)) => value,
15861 Ok(ConversionResult::Failure(error)) => {
15862 throw_type_error(cx.raw_cx(), &error);
15863 return false;
15864
15865 }
15866 _ => {
15867 return false;
15868
15869 },
15870 }
15871 )
15872 };
15873 let result: () = this.PassOptionalByte(arg0);
15874
15875 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15876 return true;
15877 })());
15878 result
15879}
15880
15881
15882static passOptionalByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15883
15884pub(crate) fn init_passOptionalByte_methodinfo<D: DomTypes>() {
15885 passOptionalByte_methodinfo.set(JSJitInfo {
15886 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15887 method: Some(passOptionalByte::<D>)
15888 },
15889 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15890 protoID: PrototypeList::ID::TestBinding as u16,
15891 },
15892 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15893 _bitfield_align_1: [],
15894 _bitfield_1: __BindgenBitfieldUnit::new(
15895 new_jsjitinfo_bitfield_1!(
15896 JSJitInfo_OpType::Method as u8,
15897 JSJitInfo_AliasSet::AliasEverything as u8,
15898 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15899 false,
15900 false,
15901 false,
15902 false,
15903 false,
15904 false,
15905 0,
15906 ).to_ne_bytes()
15907 ),
15908});
15909}
15910unsafe extern "C" fn passOptionalOctet<D: DomTypes>
15911(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15912 let mut result = false;
15913 wrap_panic(&mut || result = (|| {
15914 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15915 let this = &*(this as *const D::TestBinding);
15916 let args = &*args;
15917 let argc = args.argc_;
15918 let arg0: Option<u8> = if args.get(0).is_undefined() {
15919 None
15920 } else {
15921 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15922 Ok(ConversionResult::Success(value)) => value,
15923 Ok(ConversionResult::Failure(error)) => {
15924 throw_type_error(cx.raw_cx(), &error);
15925 return false;
15926
15927 }
15928 _ => {
15929 return false;
15930
15931 },
15932 }
15933 )
15934 };
15935 let result: () = this.PassOptionalOctet(arg0);
15936
15937 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
15938 return true;
15939 })());
15940 result
15941}
15942
15943
15944static passOptionalOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
15945
15946pub(crate) fn init_passOptionalOctet_methodinfo<D: DomTypes>() {
15947 passOptionalOctet_methodinfo.set(JSJitInfo {
15948 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
15949 method: Some(passOptionalOctet::<D>)
15950 },
15951 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
15952 protoID: PrototypeList::ID::TestBinding as u16,
15953 },
15954 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
15955 _bitfield_align_1: [],
15956 _bitfield_1: __BindgenBitfieldUnit::new(
15957 new_jsjitinfo_bitfield_1!(
15958 JSJitInfo_OpType::Method as u8,
15959 JSJitInfo_AliasSet::AliasEverything as u8,
15960 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
15961 false,
15962 false,
15963 false,
15964 false,
15965 false,
15966 false,
15967 0,
15968 ).to_ne_bytes()
15969 ),
15970});
15971}
15972unsafe extern "C" fn passOptionalShort<D: DomTypes>
15973(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
15974 let mut result = false;
15975 wrap_panic(&mut || result = (|| {
15976 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
15977 let this = &*(this as *const D::TestBinding);
15978 let args = &*args;
15979 let argc = args.argc_;
15980 let arg0: Option<i16> = if args.get(0).is_undefined() {
15981 None
15982 } else {
15983 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
15984 Ok(ConversionResult::Success(value)) => value,
15985 Ok(ConversionResult::Failure(error)) => {
15986 throw_type_error(cx.raw_cx(), &error);
15987 return false;
15988
15989 }
15990 _ => {
15991 return false;
15992
15993 },
15994 }
15995 )
15996 };
15997 let result: () = this.PassOptionalShort(arg0);
15998
15999 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16000 return true;
16001 })());
16002 result
16003}
16004
16005
16006static passOptionalShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16007
16008pub(crate) fn init_passOptionalShort_methodinfo<D: DomTypes>() {
16009 passOptionalShort_methodinfo.set(JSJitInfo {
16010 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16011 method: Some(passOptionalShort::<D>)
16012 },
16013 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16014 protoID: PrototypeList::ID::TestBinding as u16,
16015 },
16016 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16017 _bitfield_align_1: [],
16018 _bitfield_1: __BindgenBitfieldUnit::new(
16019 new_jsjitinfo_bitfield_1!(
16020 JSJitInfo_OpType::Method as u8,
16021 JSJitInfo_AliasSet::AliasEverything as u8,
16022 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16023 false,
16024 false,
16025 false,
16026 false,
16027 false,
16028 false,
16029 0,
16030 ).to_ne_bytes()
16031 ),
16032});
16033}
16034unsafe extern "C" fn passOptionalUnsignedShort<D: DomTypes>
16035(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16036 let mut result = false;
16037 wrap_panic(&mut || result = (|| {
16038 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16039 let this = &*(this as *const D::TestBinding);
16040 let args = &*args;
16041 let argc = args.argc_;
16042 let arg0: Option<u16> = if args.get(0).is_undefined() {
16043 None
16044 } else {
16045 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16046 Ok(ConversionResult::Success(value)) => value,
16047 Ok(ConversionResult::Failure(error)) => {
16048 throw_type_error(cx.raw_cx(), &error);
16049 return false;
16050
16051 }
16052 _ => {
16053 return false;
16054
16055 },
16056 }
16057 )
16058 };
16059 let result: () = this.PassOptionalUnsignedShort(arg0);
16060
16061 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16062 return true;
16063 })());
16064 result
16065}
16066
16067
16068static passOptionalUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16069
16070pub(crate) fn init_passOptionalUnsignedShort_methodinfo<D: DomTypes>() {
16071 passOptionalUnsignedShort_methodinfo.set(JSJitInfo {
16072 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16073 method: Some(passOptionalUnsignedShort::<D>)
16074 },
16075 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16076 protoID: PrototypeList::ID::TestBinding as u16,
16077 },
16078 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16079 _bitfield_align_1: [],
16080 _bitfield_1: __BindgenBitfieldUnit::new(
16081 new_jsjitinfo_bitfield_1!(
16082 JSJitInfo_OpType::Method as u8,
16083 JSJitInfo_AliasSet::AliasEverything as u8,
16084 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16085 false,
16086 false,
16087 false,
16088 false,
16089 false,
16090 false,
16091 0,
16092 ).to_ne_bytes()
16093 ),
16094});
16095}
16096unsafe extern "C" fn passOptionalLong<D: DomTypes>
16097(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16098 let mut result = false;
16099 wrap_panic(&mut || result = (|| {
16100 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16101 let this = &*(this as *const D::TestBinding);
16102 let args = &*args;
16103 let argc = args.argc_;
16104 let arg0: Option<i32> = if args.get(0).is_undefined() {
16105 None
16106 } else {
16107 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16108 Ok(ConversionResult::Success(value)) => value,
16109 Ok(ConversionResult::Failure(error)) => {
16110 throw_type_error(cx.raw_cx(), &error);
16111 return false;
16112
16113 }
16114 _ => {
16115 return false;
16116
16117 },
16118 }
16119 )
16120 };
16121 let result: () = this.PassOptionalLong(arg0);
16122
16123 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16124 return true;
16125 })());
16126 result
16127}
16128
16129
16130static passOptionalLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16131
16132pub(crate) fn init_passOptionalLong_methodinfo<D: DomTypes>() {
16133 passOptionalLong_methodinfo.set(JSJitInfo {
16134 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16135 method: Some(passOptionalLong::<D>)
16136 },
16137 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16138 protoID: PrototypeList::ID::TestBinding as u16,
16139 },
16140 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16141 _bitfield_align_1: [],
16142 _bitfield_1: __BindgenBitfieldUnit::new(
16143 new_jsjitinfo_bitfield_1!(
16144 JSJitInfo_OpType::Method as u8,
16145 JSJitInfo_AliasSet::AliasEverything as u8,
16146 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16147 false,
16148 false,
16149 false,
16150 false,
16151 false,
16152 false,
16153 0,
16154 ).to_ne_bytes()
16155 ),
16156});
16157}
16158unsafe extern "C" fn passOptionalUnsignedLong<D: DomTypes>
16159(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16160 let mut result = false;
16161 wrap_panic(&mut || result = (|| {
16162 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16163 let this = &*(this as *const D::TestBinding);
16164 let args = &*args;
16165 let argc = args.argc_;
16166 let arg0: Option<u32> = if args.get(0).is_undefined() {
16167 None
16168 } else {
16169 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16170 Ok(ConversionResult::Success(value)) => value,
16171 Ok(ConversionResult::Failure(error)) => {
16172 throw_type_error(cx.raw_cx(), &error);
16173 return false;
16174
16175 }
16176 _ => {
16177 return false;
16178
16179 },
16180 }
16181 )
16182 };
16183 let result: () = this.PassOptionalUnsignedLong(arg0);
16184
16185 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16186 return true;
16187 })());
16188 result
16189}
16190
16191
16192static passOptionalUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16193
16194pub(crate) fn init_passOptionalUnsignedLong_methodinfo<D: DomTypes>() {
16195 passOptionalUnsignedLong_methodinfo.set(JSJitInfo {
16196 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16197 method: Some(passOptionalUnsignedLong::<D>)
16198 },
16199 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16200 protoID: PrototypeList::ID::TestBinding as u16,
16201 },
16202 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16203 _bitfield_align_1: [],
16204 _bitfield_1: __BindgenBitfieldUnit::new(
16205 new_jsjitinfo_bitfield_1!(
16206 JSJitInfo_OpType::Method as u8,
16207 JSJitInfo_AliasSet::AliasEverything as u8,
16208 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16209 false,
16210 false,
16211 false,
16212 false,
16213 false,
16214 false,
16215 0,
16216 ).to_ne_bytes()
16217 ),
16218});
16219}
16220unsafe extern "C" fn passOptionalLongLong<D: DomTypes>
16221(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16222 let mut result = false;
16223 wrap_panic(&mut || result = (|| {
16224 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16225 let this = &*(this as *const D::TestBinding);
16226 let args = &*args;
16227 let argc = args.argc_;
16228 let arg0: Option<i64> = if args.get(0).is_undefined() {
16229 None
16230 } else {
16231 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16232 Ok(ConversionResult::Success(value)) => value,
16233 Ok(ConversionResult::Failure(error)) => {
16234 throw_type_error(cx.raw_cx(), &error);
16235 return false;
16236
16237 }
16238 _ => {
16239 return false;
16240
16241 },
16242 }
16243 )
16244 };
16245 let result: () = this.PassOptionalLongLong(arg0);
16246
16247 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16248 return true;
16249 })());
16250 result
16251}
16252
16253
16254static passOptionalLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16255
16256pub(crate) fn init_passOptionalLongLong_methodinfo<D: DomTypes>() {
16257 passOptionalLongLong_methodinfo.set(JSJitInfo {
16258 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16259 method: Some(passOptionalLongLong::<D>)
16260 },
16261 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16262 protoID: PrototypeList::ID::TestBinding as u16,
16263 },
16264 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16265 _bitfield_align_1: [],
16266 _bitfield_1: __BindgenBitfieldUnit::new(
16267 new_jsjitinfo_bitfield_1!(
16268 JSJitInfo_OpType::Method as u8,
16269 JSJitInfo_AliasSet::AliasEverything as u8,
16270 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16271 false,
16272 false,
16273 false,
16274 false,
16275 false,
16276 false,
16277 0,
16278 ).to_ne_bytes()
16279 ),
16280});
16281}
16282unsafe extern "C" fn passOptionalUnsignedLongLong<D: DomTypes>
16283(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16284 let mut result = false;
16285 wrap_panic(&mut || result = (|| {
16286 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16287 let this = &*(this as *const D::TestBinding);
16288 let args = &*args;
16289 let argc = args.argc_;
16290 let arg0: Option<u64> = if args.get(0).is_undefined() {
16291 None
16292 } else {
16293 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
16294 Ok(ConversionResult::Success(value)) => value,
16295 Ok(ConversionResult::Failure(error)) => {
16296 throw_type_error(cx.raw_cx(), &error);
16297 return false;
16298
16299 }
16300 _ => {
16301 return false;
16302
16303 },
16304 }
16305 )
16306 };
16307 let result: () = this.PassOptionalUnsignedLongLong(arg0);
16308
16309 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16310 return true;
16311 })());
16312 result
16313}
16314
16315
16316static passOptionalUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16317
16318pub(crate) fn init_passOptionalUnsignedLongLong_methodinfo<D: DomTypes>() {
16319 passOptionalUnsignedLongLong_methodinfo.set(JSJitInfo {
16320 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16321 method: Some(passOptionalUnsignedLongLong::<D>)
16322 },
16323 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16324 protoID: PrototypeList::ID::TestBinding as u16,
16325 },
16326 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16327 _bitfield_align_1: [],
16328 _bitfield_1: __BindgenBitfieldUnit::new(
16329 new_jsjitinfo_bitfield_1!(
16330 JSJitInfo_OpType::Method as u8,
16331 JSJitInfo_AliasSet::AliasEverything as u8,
16332 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16333 false,
16334 false,
16335 false,
16336 false,
16337 false,
16338 false,
16339 0,
16340 ).to_ne_bytes()
16341 ),
16342});
16343}
16344unsafe extern "C" fn passOptionalUnrestrictedFloat<D: DomTypes>
16345(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16346 let mut result = false;
16347 wrap_panic(&mut || result = (|| {
16348 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16349 let this = &*(this as *const D::TestBinding);
16350 let args = &*args;
16351 let argc = args.argc_;
16352 let arg0: Option<f32> = if args.get(0).is_undefined() {
16353 None
16354 } else {
16355 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16356 Ok(ConversionResult::Success(value)) => value,
16357 Ok(ConversionResult::Failure(error)) => {
16358 throw_type_error(cx.raw_cx(), &error);
16359 return false;
16360
16361 }
16362 _ => {
16363 return false;
16364
16365 },
16366 }
16367 )
16368 };
16369 let result: () = this.PassOptionalUnrestrictedFloat(arg0);
16370
16371 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16372 return true;
16373 })());
16374 result
16375}
16376
16377
16378static passOptionalUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16379
16380pub(crate) fn init_passOptionalUnrestrictedFloat_methodinfo<D: DomTypes>() {
16381 passOptionalUnrestrictedFloat_methodinfo.set(JSJitInfo {
16382 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16383 method: Some(passOptionalUnrestrictedFloat::<D>)
16384 },
16385 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16386 protoID: PrototypeList::ID::TestBinding as u16,
16387 },
16388 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16389 _bitfield_align_1: [],
16390 _bitfield_1: __BindgenBitfieldUnit::new(
16391 new_jsjitinfo_bitfield_1!(
16392 JSJitInfo_OpType::Method as u8,
16393 JSJitInfo_AliasSet::AliasEverything as u8,
16394 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16395 false,
16396 false,
16397 false,
16398 false,
16399 false,
16400 false,
16401 0,
16402 ).to_ne_bytes()
16403 ),
16404});
16405}
16406unsafe extern "C" fn passOptionalFloat<D: DomTypes>
16407(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16408 let mut result = false;
16409 wrap_panic(&mut || result = (|| {
16410 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16411 let this = &*(this as *const D::TestBinding);
16412 let args = &*args;
16413 let argc = args.argc_;
16414 let arg0: Option<Finite<f32>> = if args.get(0).is_undefined() {
16415 None
16416 } else {
16417 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16418 Ok(ConversionResult::Success(value)) => value,
16419 Ok(ConversionResult::Failure(error)) => {
16420 throw_type_error(cx.raw_cx(), &error);
16421 return false;
16422
16423 }
16424 _ => {
16425 return false;
16426
16427 },
16428 }
16429 )
16430 };
16431 let result: () = this.PassOptionalFloat(arg0);
16432
16433 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16434 return true;
16435 })());
16436 result
16437}
16438
16439
16440static passOptionalFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16441
16442pub(crate) fn init_passOptionalFloat_methodinfo<D: DomTypes>() {
16443 passOptionalFloat_methodinfo.set(JSJitInfo {
16444 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16445 method: Some(passOptionalFloat::<D>)
16446 },
16447 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16448 protoID: PrototypeList::ID::TestBinding as u16,
16449 },
16450 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16451 _bitfield_align_1: [],
16452 _bitfield_1: __BindgenBitfieldUnit::new(
16453 new_jsjitinfo_bitfield_1!(
16454 JSJitInfo_OpType::Method as u8,
16455 JSJitInfo_AliasSet::AliasEverything as u8,
16456 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16457 false,
16458 false,
16459 false,
16460 false,
16461 false,
16462 false,
16463 0,
16464 ).to_ne_bytes()
16465 ),
16466});
16467}
16468unsafe extern "C" fn passOptionalUnrestrictedDouble<D: DomTypes>
16469(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16470 let mut result = false;
16471 wrap_panic(&mut || result = (|| {
16472 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16473 let this = &*(this as *const D::TestBinding);
16474 let args = &*args;
16475 let argc = args.argc_;
16476 let arg0: Option<f64> = if args.get(0).is_undefined() {
16477 None
16478 } else {
16479 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16480 Ok(ConversionResult::Success(value)) => value,
16481 Ok(ConversionResult::Failure(error)) => {
16482 throw_type_error(cx.raw_cx(), &error);
16483 return false;
16484
16485 }
16486 _ => {
16487 return false;
16488
16489 },
16490 }
16491 )
16492 };
16493 let result: () = this.PassOptionalUnrestrictedDouble(arg0);
16494
16495 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16496 return true;
16497 })());
16498 result
16499}
16500
16501
16502static passOptionalUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16503
16504pub(crate) fn init_passOptionalUnrestrictedDouble_methodinfo<D: DomTypes>() {
16505 passOptionalUnrestrictedDouble_methodinfo.set(JSJitInfo {
16506 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16507 method: Some(passOptionalUnrestrictedDouble::<D>)
16508 },
16509 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16510 protoID: PrototypeList::ID::TestBinding as u16,
16511 },
16512 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16513 _bitfield_align_1: [],
16514 _bitfield_1: __BindgenBitfieldUnit::new(
16515 new_jsjitinfo_bitfield_1!(
16516 JSJitInfo_OpType::Method as u8,
16517 JSJitInfo_AliasSet::AliasEverything as u8,
16518 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16519 false,
16520 false,
16521 false,
16522 false,
16523 false,
16524 false,
16525 0,
16526 ).to_ne_bytes()
16527 ),
16528});
16529}
16530unsafe extern "C" fn passOptionalDouble<D: DomTypes>
16531(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16532 let mut result = false;
16533 wrap_panic(&mut || result = (|| {
16534 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16535 let this = &*(this as *const D::TestBinding);
16536 let args = &*args;
16537 let argc = args.argc_;
16538 let arg0: Option<Finite<f64>> = if args.get(0).is_undefined() {
16539 None
16540 } else {
16541 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16542 Ok(ConversionResult::Success(value)) => value,
16543 Ok(ConversionResult::Failure(error)) => {
16544 throw_type_error(cx.raw_cx(), &error);
16545 return false;
16546
16547 }
16548 _ => {
16549 return false;
16550
16551 },
16552 }
16553 )
16554 };
16555 let result: () = this.PassOptionalDouble(arg0);
16556
16557 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16558 return true;
16559 })());
16560 result
16561}
16562
16563
16564static passOptionalDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16565
16566pub(crate) fn init_passOptionalDouble_methodinfo<D: DomTypes>() {
16567 passOptionalDouble_methodinfo.set(JSJitInfo {
16568 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16569 method: Some(passOptionalDouble::<D>)
16570 },
16571 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16572 protoID: PrototypeList::ID::TestBinding as u16,
16573 },
16574 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16575 _bitfield_align_1: [],
16576 _bitfield_1: __BindgenBitfieldUnit::new(
16577 new_jsjitinfo_bitfield_1!(
16578 JSJitInfo_OpType::Method as u8,
16579 JSJitInfo_AliasSet::AliasEverything as u8,
16580 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16581 false,
16582 false,
16583 false,
16584 false,
16585 false,
16586 false,
16587 0,
16588 ).to_ne_bytes()
16589 ),
16590});
16591}
16592unsafe extern "C" fn passOptionalString<D: DomTypes>
16593(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16594 let mut result = false;
16595 wrap_panic(&mut || result = (|| {
16596 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16597 let this = &*(this as *const D::TestBinding);
16598 let args = &*args;
16599 let argc = args.argc_;
16600 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
16601 None
16602 } else {
16603 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
16604 Ok(ConversionResult::Success(value)) => value,
16605 Ok(ConversionResult::Failure(error)) => {
16606 throw_type_error(cx.raw_cx(), &error);
16607 return false;
16608
16609 }
16610 _ => {
16611 return false;
16612
16613 },
16614 }
16615 )
16616 };
16617 let result: () = this.PassOptionalString(arg0);
16618
16619 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16620 return true;
16621 })());
16622 result
16623}
16624
16625
16626static passOptionalString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16627
16628pub(crate) fn init_passOptionalString_methodinfo<D: DomTypes>() {
16629 passOptionalString_methodinfo.set(JSJitInfo {
16630 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16631 method: Some(passOptionalString::<D>)
16632 },
16633 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16634 protoID: PrototypeList::ID::TestBinding as u16,
16635 },
16636 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16637 _bitfield_align_1: [],
16638 _bitfield_1: __BindgenBitfieldUnit::new(
16639 new_jsjitinfo_bitfield_1!(
16640 JSJitInfo_OpType::Method as u8,
16641 JSJitInfo_AliasSet::AliasEverything as u8,
16642 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16643 false,
16644 false,
16645 false,
16646 false,
16647 false,
16648 false,
16649 0,
16650 ).to_ne_bytes()
16651 ),
16652});
16653}
16654unsafe extern "C" fn passOptionalUsvstring<D: DomTypes>
16655(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16656 let mut result = false;
16657 wrap_panic(&mut || result = (|| {
16658 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16659 let this = &*(this as *const D::TestBinding);
16660 let args = &*args;
16661 let argc = args.argc_;
16662 let arg0: Option<USVString> = if args.get(0).is_undefined() {
16663 None
16664 } else {
16665 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16666 Ok(ConversionResult::Success(value)) => value,
16667 Ok(ConversionResult::Failure(error)) => {
16668 throw_type_error(cx.raw_cx(), &error);
16669 return false;
16670
16671 }
16672 _ => {
16673 return false;
16674
16675 },
16676 }
16677 )
16678 };
16679 let result: () = this.PassOptionalUsvstring(arg0);
16680
16681 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16682 return true;
16683 })());
16684 result
16685}
16686
16687
16688static passOptionalUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16689
16690pub(crate) fn init_passOptionalUsvstring_methodinfo<D: DomTypes>() {
16691 passOptionalUsvstring_methodinfo.set(JSJitInfo {
16692 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16693 method: Some(passOptionalUsvstring::<D>)
16694 },
16695 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16696 protoID: PrototypeList::ID::TestBinding as u16,
16697 },
16698 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16699 _bitfield_align_1: [],
16700 _bitfield_1: __BindgenBitfieldUnit::new(
16701 new_jsjitinfo_bitfield_1!(
16702 JSJitInfo_OpType::Method as u8,
16703 JSJitInfo_AliasSet::AliasEverything as u8,
16704 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16705 false,
16706 false,
16707 false,
16708 false,
16709 false,
16710 false,
16711 0,
16712 ).to_ne_bytes()
16713 ),
16714});
16715}
16716unsafe extern "C" fn passOptionalByteString<D: DomTypes>
16717(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16718 let mut result = false;
16719 wrap_panic(&mut || result = (|| {
16720 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16721 let this = &*(this as *const D::TestBinding);
16722 let args = &*args;
16723 let argc = args.argc_;
16724 let arg0: Option<ByteString> = if args.get(0).is_undefined() {
16725 None
16726 } else {
16727 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16728 Ok(ConversionResult::Success(value)) => value,
16729 Ok(ConversionResult::Failure(error)) => {
16730 throw_type_error(cx.raw_cx(), &error);
16731 return false;
16732
16733 }
16734 _ => {
16735 return false;
16736
16737 },
16738 }
16739 )
16740 };
16741 let result: () = this.PassOptionalByteString(arg0);
16742
16743 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16744 return true;
16745 })());
16746 result
16747}
16748
16749
16750static passOptionalByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16751
16752pub(crate) fn init_passOptionalByteString_methodinfo<D: DomTypes>() {
16753 passOptionalByteString_methodinfo.set(JSJitInfo {
16754 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16755 method: Some(passOptionalByteString::<D>)
16756 },
16757 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16758 protoID: PrototypeList::ID::TestBinding as u16,
16759 },
16760 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16761 _bitfield_align_1: [],
16762 _bitfield_1: __BindgenBitfieldUnit::new(
16763 new_jsjitinfo_bitfield_1!(
16764 JSJitInfo_OpType::Method as u8,
16765 JSJitInfo_AliasSet::AliasEverything as u8,
16766 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16767 false,
16768 false,
16769 false,
16770 false,
16771 false,
16772 false,
16773 0,
16774 ).to_ne_bytes()
16775 ),
16776});
16777}
16778unsafe extern "C" fn passOptionalEnum<D: DomTypes>
16779(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16780 let mut result = false;
16781 wrap_panic(&mut || result = (|| {
16782 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16783 let this = &*(this as *const D::TestBinding);
16784 let args = &*args;
16785 let argc = args.argc_;
16786 let arg0: Option<TestEnum> = if args.get(0).is_undefined() {
16787 None
16788 } else {
16789 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16790 Ok(ConversionResult::Success(value)) => value,
16791 Ok(ConversionResult::Failure(error)) => {
16792 throw_type_error(cx.raw_cx(), &error); return false;
16793
16794 }
16795 _ => {
16796 return false;
16797
16798 },
16799 }
16800 )
16801 };
16802 let result: () = this.PassOptionalEnum(arg0);
16803
16804 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16805 return true;
16806 })());
16807 result
16808}
16809
16810
16811static passOptionalEnum_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16812
16813pub(crate) fn init_passOptionalEnum_methodinfo<D: DomTypes>() {
16814 passOptionalEnum_methodinfo.set(JSJitInfo {
16815 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16816 method: Some(passOptionalEnum::<D>)
16817 },
16818 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16819 protoID: PrototypeList::ID::TestBinding as u16,
16820 },
16821 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16822 _bitfield_align_1: [],
16823 _bitfield_1: __BindgenBitfieldUnit::new(
16824 new_jsjitinfo_bitfield_1!(
16825 JSJitInfo_OpType::Method as u8,
16826 JSJitInfo_AliasSet::AliasEverything as u8,
16827 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16828 false,
16829 false,
16830 false,
16831 false,
16832 false,
16833 false,
16834 0,
16835 ).to_ne_bytes()
16836 ),
16837});
16838}
16839unsafe extern "C" fn passOptionalInterface<D: DomTypes>
16840(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16841 let mut result = false;
16842 wrap_panic(&mut || result = (|| {
16843 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16844 let this = &*(this as *const D::TestBinding);
16845 let args = &*args;
16846 let argc = args.argc_;
16847 let arg0: Option<DomRoot<D::Blob>> = if args.get(0).is_undefined() {
16848 None
16849 } else {
16850 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
16851 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
16852 Ok(val) => val,
16853 Err(()) => {
16854 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
16855 return false;
16856
16857 }
16858 }
16859
16860 } else {
16861 throw_type_error(cx.raw_cx(), "Value is not an object.");
16862 return false;
16863
16864 })
16865 };
16866 let result: () = this.PassOptionalInterface(arg0.as_deref());
16867
16868 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16869 return true;
16870 })());
16871 result
16872}
16873
16874
16875static passOptionalInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16876
16877pub(crate) fn init_passOptionalInterface_methodinfo<D: DomTypes>() {
16878 passOptionalInterface_methodinfo.set(JSJitInfo {
16879 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16880 method: Some(passOptionalInterface::<D>)
16881 },
16882 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16883 protoID: PrototypeList::ID::TestBinding as u16,
16884 },
16885 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16886 _bitfield_align_1: [],
16887 _bitfield_1: __BindgenBitfieldUnit::new(
16888 new_jsjitinfo_bitfield_1!(
16889 JSJitInfo_OpType::Method as u8,
16890 JSJitInfo_AliasSet::AliasEverything as u8,
16891 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16892 false,
16893 false,
16894 false,
16895 false,
16896 false,
16897 false,
16898 0,
16899 ).to_ne_bytes()
16900 ),
16901});
16902}
16903unsafe extern "C" fn passOptionalUnion<D: DomTypes>
16904(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16905 let mut result = false;
16906 wrap_panic(&mut || result = (|| {
16907 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16908 let this = &*(this as *const D::TestBinding);
16909 let args = &*args;
16910 let argc = args.argc_;
16911 let arg0: Option<GenericUnionTypes::HTMLElementOrLong::<D>> = if args.get(0).is_undefined() {
16912 None
16913 } else {
16914 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16915 Ok(ConversionResult::Success(value)) => value,
16916 Ok(ConversionResult::Failure(error)) => {
16917 throw_type_error(cx.raw_cx(), &error);
16918 return false;
16919
16920 }
16921 _ => {
16922 return false;
16923
16924 },
16925 }
16926 )
16927 };
16928 let result: () = this.PassOptionalUnion(arg0);
16929
16930 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16931 return true;
16932 })());
16933 result
16934}
16935
16936
16937static passOptionalUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
16938
16939pub(crate) fn init_passOptionalUnion_methodinfo<D: DomTypes>() {
16940 passOptionalUnion_methodinfo.set(JSJitInfo {
16941 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
16942 method: Some(passOptionalUnion::<D>)
16943 },
16944 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
16945 protoID: PrototypeList::ID::TestBinding as u16,
16946 },
16947 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
16948 _bitfield_align_1: [],
16949 _bitfield_1: __BindgenBitfieldUnit::new(
16950 new_jsjitinfo_bitfield_1!(
16951 JSJitInfo_OpType::Method as u8,
16952 JSJitInfo_AliasSet::AliasEverything as u8,
16953 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
16954 false,
16955 false,
16956 false,
16957 false,
16958 false,
16959 false,
16960 0,
16961 ).to_ne_bytes()
16962 ),
16963});
16964}
16965unsafe extern "C" fn passOptionalUnion2<D: DomTypes>
16966(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
16967 let mut result = false;
16968 wrap_panic(&mut || result = (|| {
16969 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
16970 let this = &*(this as *const D::TestBinding);
16971 let args = &*args;
16972 let argc = args.argc_;
16973 let arg0: Option<GenericUnionTypes::EventOrString::<D>> = if args.get(0).is_undefined() {
16974 None
16975 } else {
16976 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
16977 Ok(ConversionResult::Success(value)) => value,
16978 Ok(ConversionResult::Failure(error)) => {
16979 throw_type_error(cx.raw_cx(), &error);
16980 return false;
16981
16982 }
16983 _ => {
16984 return false;
16985
16986 },
16987 }
16988 )
16989 };
16990 let result: () = this.PassOptionalUnion2(arg0);
16991
16992 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
16993 return true;
16994 })());
16995 result
16996}
16997
16998
16999static passOptionalUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17000
17001pub(crate) fn init_passOptionalUnion2_methodinfo<D: DomTypes>() {
17002 passOptionalUnion2_methodinfo.set(JSJitInfo {
17003 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17004 method: Some(passOptionalUnion2::<D>)
17005 },
17006 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17007 protoID: PrototypeList::ID::TestBinding as u16,
17008 },
17009 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17010 _bitfield_align_1: [],
17011 _bitfield_1: __BindgenBitfieldUnit::new(
17012 new_jsjitinfo_bitfield_1!(
17013 JSJitInfo_OpType::Method as u8,
17014 JSJitInfo_AliasSet::AliasEverything as u8,
17015 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17016 false,
17017 false,
17018 false,
17019 false,
17020 false,
17021 false,
17022 0,
17023 ).to_ne_bytes()
17024 ),
17025});
17026}
17027unsafe extern "C" fn passOptionalUnion3<D: DomTypes>
17028(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17029 let mut result = false;
17030 wrap_panic(&mut || result = (|| {
17031 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17032 let this = &*(this as *const D::TestBinding);
17033 let args = &*args;
17034 let argc = args.argc_;
17035 let arg0: Option<GenericUnionTypes::StringOrLongSequence> = if args.get(0).is_undefined() {
17036 None
17037 } else {
17038 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17039 Ok(ConversionResult::Success(value)) => value,
17040 Ok(ConversionResult::Failure(error)) => {
17041 throw_type_error(cx.raw_cx(), &error);
17042 return false;
17043
17044 }
17045 _ => {
17046 return false;
17047
17048 },
17049 }
17050 )
17051 };
17052 let result: () = this.PassOptionalUnion3(arg0);
17053
17054 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17055 return true;
17056 })());
17057 result
17058}
17059
17060
17061static passOptionalUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17062
17063pub(crate) fn init_passOptionalUnion3_methodinfo<D: DomTypes>() {
17064 passOptionalUnion3_methodinfo.set(JSJitInfo {
17065 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17066 method: Some(passOptionalUnion3::<D>)
17067 },
17068 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17069 protoID: PrototypeList::ID::TestBinding as u16,
17070 },
17071 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17072 _bitfield_align_1: [],
17073 _bitfield_1: __BindgenBitfieldUnit::new(
17074 new_jsjitinfo_bitfield_1!(
17075 JSJitInfo_OpType::Method as u8,
17076 JSJitInfo_AliasSet::AliasEverything as u8,
17077 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17078 false,
17079 false,
17080 false,
17081 false,
17082 false,
17083 false,
17084 0,
17085 ).to_ne_bytes()
17086 ),
17087});
17088}
17089unsafe extern "C" fn passOptionalUnion4<D: DomTypes>
17090(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17091 let mut result = false;
17092 wrap_panic(&mut || result = (|| {
17093 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17094 let this = &*(this as *const D::TestBinding);
17095 let args = &*args;
17096 let argc = args.argc_;
17097 let arg0: Option<GenericUnionTypes::LongSequenceOrBoolean> = if args.get(0).is_undefined() {
17098 None
17099 } else {
17100 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17101 Ok(ConversionResult::Success(value)) => value,
17102 Ok(ConversionResult::Failure(error)) => {
17103 throw_type_error(cx.raw_cx(), &error);
17104 return false;
17105
17106 }
17107 _ => {
17108 return false;
17109
17110 },
17111 }
17112 )
17113 };
17114 let result: () = this.PassOptionalUnion4(arg0);
17115
17116 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17117 return true;
17118 })());
17119 result
17120}
17121
17122
17123static passOptionalUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17124
17125pub(crate) fn init_passOptionalUnion4_methodinfo<D: DomTypes>() {
17126 passOptionalUnion4_methodinfo.set(JSJitInfo {
17127 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17128 method: Some(passOptionalUnion4::<D>)
17129 },
17130 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17131 protoID: PrototypeList::ID::TestBinding as u16,
17132 },
17133 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17134 _bitfield_align_1: [],
17135 _bitfield_1: __BindgenBitfieldUnit::new(
17136 new_jsjitinfo_bitfield_1!(
17137 JSJitInfo_OpType::Method as u8,
17138 JSJitInfo_AliasSet::AliasEverything as u8,
17139 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17140 false,
17141 false,
17142 false,
17143 false,
17144 false,
17145 false,
17146 0,
17147 ).to_ne_bytes()
17148 ),
17149});
17150}
17151unsafe extern "C" fn passOptionalUnion5<D: DomTypes>
17152(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17153 let mut result = false;
17154 wrap_panic(&mut || result = (|| {
17155 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17156 let this = &*(this as *const D::TestBinding);
17157 let args = &*args;
17158 let argc = args.argc_;
17159 let arg0: Option<GenericUnionTypes::UnsignedLongOrBoolean> = if args.get(0).is_undefined() {
17160 None
17161 } else {
17162 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17163 Ok(ConversionResult::Success(value)) => value,
17164 Ok(ConversionResult::Failure(error)) => {
17165 throw_type_error(cx.raw_cx(), &error);
17166 return false;
17167
17168 }
17169 _ => {
17170 return false;
17171
17172 },
17173 }
17174 )
17175 };
17176 let result: () = this.PassOptionalUnion5(arg0);
17177
17178 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17179 return true;
17180 })());
17181 result
17182}
17183
17184
17185static passOptionalUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17186
17187pub(crate) fn init_passOptionalUnion5_methodinfo<D: DomTypes>() {
17188 passOptionalUnion5_methodinfo.set(JSJitInfo {
17189 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17190 method: Some(passOptionalUnion5::<D>)
17191 },
17192 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17193 protoID: PrototypeList::ID::TestBinding as u16,
17194 },
17195 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17196 _bitfield_align_1: [],
17197 _bitfield_1: __BindgenBitfieldUnit::new(
17198 new_jsjitinfo_bitfield_1!(
17199 JSJitInfo_OpType::Method as u8,
17200 JSJitInfo_AliasSet::AliasEverything as u8,
17201 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17202 false,
17203 false,
17204 false,
17205 false,
17206 false,
17207 false,
17208 0,
17209 ).to_ne_bytes()
17210 ),
17211});
17212}
17213unsafe extern "C" fn passOptionalUnion6<D: DomTypes>
17214(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17215 let mut result = false;
17216 wrap_panic(&mut || result = (|| {
17217 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17218 let this = &*(this as *const D::TestBinding);
17219 let args = &*args;
17220 let argc = args.argc_;
17221 let arg0: Option<GenericUnionTypes::ByteStringOrLong> = if args.get(0).is_undefined() {
17222 None
17223 } else {
17224 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17225 Ok(ConversionResult::Success(value)) => value,
17226 Ok(ConversionResult::Failure(error)) => {
17227 throw_type_error(cx.raw_cx(), &error);
17228 return false;
17229
17230 }
17231 _ => {
17232 return false;
17233
17234 },
17235 }
17236 )
17237 };
17238 let result: () = this.PassOptionalUnion6(arg0);
17239
17240 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17241 return true;
17242 })());
17243 result
17244}
17245
17246
17247static passOptionalUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17248
17249pub(crate) fn init_passOptionalUnion6_methodinfo<D: DomTypes>() {
17250 passOptionalUnion6_methodinfo.set(JSJitInfo {
17251 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17252 method: Some(passOptionalUnion6::<D>)
17253 },
17254 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17255 protoID: PrototypeList::ID::TestBinding as u16,
17256 },
17257 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17258 _bitfield_align_1: [],
17259 _bitfield_1: __BindgenBitfieldUnit::new(
17260 new_jsjitinfo_bitfield_1!(
17261 JSJitInfo_OpType::Method as u8,
17262 JSJitInfo_AliasSet::AliasEverything as u8,
17263 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17264 false,
17265 false,
17266 false,
17267 false,
17268 false,
17269 false,
17270 0,
17271 ).to_ne_bytes()
17272 ),
17273});
17274}
17275unsafe extern "C" fn passOptionalAny<D: DomTypes>
17276(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17277 let mut result = false;
17278 wrap_panic(&mut || result = (|| {
17279 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17280 let this = &*(this as *const D::TestBinding);
17281 let args = &*args;
17282 let argc = args.argc_;
17283 let arg0: HandleValue = if args.get(0).is_undefined() {
17284 HandleValue::undefined()
17285 } else {
17286 HandleValue::from_raw(args.get(0))
17287 };
17288 let result: () = this.PassOptionalAny(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
17289
17290 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17291 return true;
17292 })());
17293 result
17294}
17295
17296
17297static passOptionalAny_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17298
17299pub(crate) fn init_passOptionalAny_methodinfo<D: DomTypes>() {
17300 passOptionalAny_methodinfo.set(JSJitInfo {
17301 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17302 method: Some(passOptionalAny::<D>)
17303 },
17304 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17305 protoID: PrototypeList::ID::TestBinding as u16,
17306 },
17307 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17308 _bitfield_align_1: [],
17309 _bitfield_1: __BindgenBitfieldUnit::new(
17310 new_jsjitinfo_bitfield_1!(
17311 JSJitInfo_OpType::Method as u8,
17312 JSJitInfo_AliasSet::AliasEverything as u8,
17313 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17314 false,
17315 false,
17316 false,
17317 false,
17318 false,
17319 false,
17320 0,
17321 ).to_ne_bytes()
17322 ),
17323});
17324}
17325unsafe extern "C" fn passOptionalObject<D: DomTypes>
17326(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17327 let mut result = false;
17328 wrap_panic(&mut || result = (|| {
17329 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17330 let this = &*(this as *const D::TestBinding);
17331 let args = &*args;
17332 let argc = args.argc_;
17333 let arg0: Option<*mut JSObject> = if args.get(0).is_undefined() {
17334 None
17335 } else {
17336 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
17337 HandleValue::from_raw(args.get(0)).get().to_object()
17338 } else {
17339 throw_type_error(cx.raw_cx(), "Value is not an object.");
17340 return false;
17341
17342 })
17343 };
17344 let result: () = this.PassOptionalObject(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
17345
17346 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17347 return true;
17348 })());
17349 result
17350}
17351
17352
17353static passOptionalObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17354
17355pub(crate) fn init_passOptionalObject_methodinfo<D: DomTypes>() {
17356 passOptionalObject_methodinfo.set(JSJitInfo {
17357 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17358 method: Some(passOptionalObject::<D>)
17359 },
17360 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17361 protoID: PrototypeList::ID::TestBinding as u16,
17362 },
17363 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17364 _bitfield_align_1: [],
17365 _bitfield_1: __BindgenBitfieldUnit::new(
17366 new_jsjitinfo_bitfield_1!(
17367 JSJitInfo_OpType::Method as u8,
17368 JSJitInfo_AliasSet::AliasEverything as u8,
17369 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17370 false,
17371 false,
17372 false,
17373 false,
17374 false,
17375 false,
17376 0,
17377 ).to_ne_bytes()
17378 ),
17379});
17380}
17381unsafe extern "C" fn passOptionalCallbackFunction<D: DomTypes>
17382(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17383 let mut result = false;
17384 wrap_panic(&mut || result = (|| {
17385 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17386 let this = &*(this as *const D::TestBinding);
17387 let args = &*args;
17388 let argc = args.argc_;
17389 let arg0: Option<Rc<Function<D>>> = if args.get(0).is_undefined() {
17390 None
17391 } else {
17392 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
17393 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
17394 Function::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object())
17395 } else {
17396 throw_type_error(cx.raw_cx(), "Value is not callable.");
17397 return false;
17398
17399 }
17400 } else {
17401 throw_type_error(cx.raw_cx(), "Value is not an object.");
17402 return false;
17403
17404 })
17405 };
17406 let result: () = this.PassOptionalCallbackFunction(arg0);
17407
17408 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17409 return true;
17410 })());
17411 result
17412}
17413
17414
17415static passOptionalCallbackFunction_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17416
17417pub(crate) fn init_passOptionalCallbackFunction_methodinfo<D: DomTypes>() {
17418 passOptionalCallbackFunction_methodinfo.set(JSJitInfo {
17419 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17420 method: Some(passOptionalCallbackFunction::<D>)
17421 },
17422 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17423 protoID: PrototypeList::ID::TestBinding as u16,
17424 },
17425 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17426 _bitfield_align_1: [],
17427 _bitfield_1: __BindgenBitfieldUnit::new(
17428 new_jsjitinfo_bitfield_1!(
17429 JSJitInfo_OpType::Method as u8,
17430 JSJitInfo_AliasSet::AliasEverything as u8,
17431 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17432 false,
17433 false,
17434 false,
17435 false,
17436 false,
17437 false,
17438 0,
17439 ).to_ne_bytes()
17440 ),
17441});
17442}
17443unsafe extern "C" fn passOptionalCallbackInterface<D: DomTypes>
17444(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17445 let mut result = false;
17446 wrap_panic(&mut || result = (|| {
17447 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17448 let this = &*(this as *const D::TestBinding);
17449 let args = &*args;
17450 let argc = args.argc_;
17451 let arg0: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>> = if args.get(0).is_undefined() {
17452 None
17453 } else {
17454 Some(crate::codegen::GenericBindings::EventListenerBinding::EventListener::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
17455 };
17456 let result: () = this.PassOptionalCallbackInterface(arg0);
17457
17458 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17459 return true;
17460 })());
17461 result
17462}
17463
17464
17465static passOptionalCallbackInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17466
17467pub(crate) fn init_passOptionalCallbackInterface_methodinfo<D: DomTypes>() {
17468 passOptionalCallbackInterface_methodinfo.set(JSJitInfo {
17469 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17470 method: Some(passOptionalCallbackInterface::<D>)
17471 },
17472 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17473 protoID: PrototypeList::ID::TestBinding as u16,
17474 },
17475 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17476 _bitfield_align_1: [],
17477 _bitfield_1: __BindgenBitfieldUnit::new(
17478 new_jsjitinfo_bitfield_1!(
17479 JSJitInfo_OpType::Method as u8,
17480 JSJitInfo_AliasSet::AliasEverything as u8,
17481 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17482 false,
17483 false,
17484 false,
17485 false,
17486 false,
17487 false,
17488 0,
17489 ).to_ne_bytes()
17490 ),
17491});
17492}
17493unsafe extern "C" fn passOptionalSequence<D: DomTypes>
17494(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17495 let mut result = false;
17496 wrap_panic(&mut || result = (|| {
17497 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17498 let this = &*(this as *const D::TestBinding);
17499 let args = &*args;
17500 let argc = args.argc_;
17501 let arg0: Option<Vec<i32>> = if args.get(0).is_undefined() {
17502 None
17503 } else {
17504 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17505 Ok(ConversionResult::Success(value)) => value,
17506 Ok(ConversionResult::Failure(error)) => {
17507 throw_type_error(cx.raw_cx(), &error);
17508 return false;
17509
17510 }
17511 _ => {
17512 return false;
17513
17514 },
17515 }
17516 )
17517 };
17518 let result: () = this.PassOptionalSequence(arg0);
17519
17520 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17521 return true;
17522 })());
17523 result
17524}
17525
17526
17527static passOptionalSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17528
17529pub(crate) fn init_passOptionalSequence_methodinfo<D: DomTypes>() {
17530 passOptionalSequence_methodinfo.set(JSJitInfo {
17531 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17532 method: Some(passOptionalSequence::<D>)
17533 },
17534 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17535 protoID: PrototypeList::ID::TestBinding as u16,
17536 },
17537 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17538 _bitfield_align_1: [],
17539 _bitfield_1: __BindgenBitfieldUnit::new(
17540 new_jsjitinfo_bitfield_1!(
17541 JSJitInfo_OpType::Method as u8,
17542 JSJitInfo_AliasSet::AliasEverything as u8,
17543 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17544 false,
17545 false,
17546 false,
17547 false,
17548 false,
17549 false,
17550 0,
17551 ).to_ne_bytes()
17552 ),
17553});
17554}
17555unsafe extern "C" fn passOptionalNullableBoolean<D: DomTypes>
17556(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17557 let mut result = false;
17558 wrap_panic(&mut || result = (|| {
17559 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17560 let this = &*(this as *const D::TestBinding);
17561 let args = &*args;
17562 let argc = args.argc_;
17563 let arg0: Option<Option<bool>> = if args.get(0).is_undefined() {
17564 None
17565 } else {
17566 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
17567 Ok(ConversionResult::Success(value)) => value,
17568 Ok(ConversionResult::Failure(error)) => {
17569 throw_type_error(cx.raw_cx(), &error);
17570 return false;
17571
17572 }
17573 _ => {
17574 return false;
17575
17576 },
17577 }
17578 )
17579 };
17580 let result: () = this.PassOptionalNullableBoolean(arg0);
17581
17582 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17583 return true;
17584 })());
17585 result
17586}
17587
17588
17589static passOptionalNullableBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17590
17591pub(crate) fn init_passOptionalNullableBoolean_methodinfo<D: DomTypes>() {
17592 passOptionalNullableBoolean_methodinfo.set(JSJitInfo {
17593 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17594 method: Some(passOptionalNullableBoolean::<D>)
17595 },
17596 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17597 protoID: PrototypeList::ID::TestBinding as u16,
17598 },
17599 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17600 _bitfield_align_1: [],
17601 _bitfield_1: __BindgenBitfieldUnit::new(
17602 new_jsjitinfo_bitfield_1!(
17603 JSJitInfo_OpType::Method as u8,
17604 JSJitInfo_AliasSet::AliasEverything as u8,
17605 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17606 false,
17607 false,
17608 false,
17609 false,
17610 false,
17611 false,
17612 0,
17613 ).to_ne_bytes()
17614 ),
17615});
17616}
17617unsafe extern "C" fn passOptionalNullableByte<D: DomTypes>
17618(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17619 let mut result = false;
17620 wrap_panic(&mut || result = (|| {
17621 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17622 let this = &*(this as *const D::TestBinding);
17623 let args = &*args;
17624 let argc = args.argc_;
17625 let arg0: Option<Option<i8>> = if args.get(0).is_undefined() {
17626 None
17627 } else {
17628 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17629 Ok(ConversionResult::Success(value)) => value,
17630 Ok(ConversionResult::Failure(error)) => {
17631 throw_type_error(cx.raw_cx(), &error);
17632 return false;
17633
17634 }
17635 _ => {
17636 return false;
17637
17638 },
17639 }
17640 )
17641 };
17642 let result: () = this.PassOptionalNullableByte(arg0);
17643
17644 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17645 return true;
17646 })());
17647 result
17648}
17649
17650
17651static passOptionalNullableByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17652
17653pub(crate) fn init_passOptionalNullableByte_methodinfo<D: DomTypes>() {
17654 passOptionalNullableByte_methodinfo.set(JSJitInfo {
17655 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17656 method: Some(passOptionalNullableByte::<D>)
17657 },
17658 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17659 protoID: PrototypeList::ID::TestBinding as u16,
17660 },
17661 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17662 _bitfield_align_1: [],
17663 _bitfield_1: __BindgenBitfieldUnit::new(
17664 new_jsjitinfo_bitfield_1!(
17665 JSJitInfo_OpType::Method as u8,
17666 JSJitInfo_AliasSet::AliasEverything as u8,
17667 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17668 false,
17669 false,
17670 false,
17671 false,
17672 false,
17673 false,
17674 0,
17675 ).to_ne_bytes()
17676 ),
17677});
17678}
17679unsafe extern "C" fn passOptionalNullableOctet<D: DomTypes>
17680(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17681 let mut result = false;
17682 wrap_panic(&mut || result = (|| {
17683 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17684 let this = &*(this as *const D::TestBinding);
17685 let args = &*args;
17686 let argc = args.argc_;
17687 let arg0: Option<Option<u8>> = if args.get(0).is_undefined() {
17688 None
17689 } else {
17690 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17691 Ok(ConversionResult::Success(value)) => value,
17692 Ok(ConversionResult::Failure(error)) => {
17693 throw_type_error(cx.raw_cx(), &error);
17694 return false;
17695
17696 }
17697 _ => {
17698 return false;
17699
17700 },
17701 }
17702 )
17703 };
17704 let result: () = this.PassOptionalNullableOctet(arg0);
17705
17706 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17707 return true;
17708 })());
17709 result
17710}
17711
17712
17713static passOptionalNullableOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17714
17715pub(crate) fn init_passOptionalNullableOctet_methodinfo<D: DomTypes>() {
17716 passOptionalNullableOctet_methodinfo.set(JSJitInfo {
17717 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17718 method: Some(passOptionalNullableOctet::<D>)
17719 },
17720 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17721 protoID: PrototypeList::ID::TestBinding as u16,
17722 },
17723 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17724 _bitfield_align_1: [],
17725 _bitfield_1: __BindgenBitfieldUnit::new(
17726 new_jsjitinfo_bitfield_1!(
17727 JSJitInfo_OpType::Method as u8,
17728 JSJitInfo_AliasSet::AliasEverything as u8,
17729 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17730 false,
17731 false,
17732 false,
17733 false,
17734 false,
17735 false,
17736 0,
17737 ).to_ne_bytes()
17738 ),
17739});
17740}
17741unsafe extern "C" fn passOptionalNullableShort<D: DomTypes>
17742(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17743 let mut result = false;
17744 wrap_panic(&mut || result = (|| {
17745 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17746 let this = &*(this as *const D::TestBinding);
17747 let args = &*args;
17748 let argc = args.argc_;
17749 let arg0: Option<Option<i16>> = if args.get(0).is_undefined() {
17750 None
17751 } else {
17752 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17753 Ok(ConversionResult::Success(value)) => value,
17754 Ok(ConversionResult::Failure(error)) => {
17755 throw_type_error(cx.raw_cx(), &error);
17756 return false;
17757
17758 }
17759 _ => {
17760 return false;
17761
17762 },
17763 }
17764 )
17765 };
17766 let result: () = this.PassOptionalNullableShort(arg0);
17767
17768 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17769 return true;
17770 })());
17771 result
17772}
17773
17774
17775static passOptionalNullableShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17776
17777pub(crate) fn init_passOptionalNullableShort_methodinfo<D: DomTypes>() {
17778 passOptionalNullableShort_methodinfo.set(JSJitInfo {
17779 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17780 method: Some(passOptionalNullableShort::<D>)
17781 },
17782 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17783 protoID: PrototypeList::ID::TestBinding as u16,
17784 },
17785 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17786 _bitfield_align_1: [],
17787 _bitfield_1: __BindgenBitfieldUnit::new(
17788 new_jsjitinfo_bitfield_1!(
17789 JSJitInfo_OpType::Method as u8,
17790 JSJitInfo_AliasSet::AliasEverything as u8,
17791 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17792 false,
17793 false,
17794 false,
17795 false,
17796 false,
17797 false,
17798 0,
17799 ).to_ne_bytes()
17800 ),
17801});
17802}
17803unsafe extern "C" fn passOptionalNullableUnsignedShort<D: DomTypes>
17804(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17805 let mut result = false;
17806 wrap_panic(&mut || result = (|| {
17807 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17808 let this = &*(this as *const D::TestBinding);
17809 let args = &*args;
17810 let argc = args.argc_;
17811 let arg0: Option<Option<u16>> = if args.get(0).is_undefined() {
17812 None
17813 } else {
17814 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17815 Ok(ConversionResult::Success(value)) => value,
17816 Ok(ConversionResult::Failure(error)) => {
17817 throw_type_error(cx.raw_cx(), &error);
17818 return false;
17819
17820 }
17821 _ => {
17822 return false;
17823
17824 },
17825 }
17826 )
17827 };
17828 let result: () = this.PassOptionalNullableUnsignedShort(arg0);
17829
17830 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17831 return true;
17832 })());
17833 result
17834}
17835
17836
17837static passOptionalNullableUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17838
17839pub(crate) fn init_passOptionalNullableUnsignedShort_methodinfo<D: DomTypes>() {
17840 passOptionalNullableUnsignedShort_methodinfo.set(JSJitInfo {
17841 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17842 method: Some(passOptionalNullableUnsignedShort::<D>)
17843 },
17844 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17845 protoID: PrototypeList::ID::TestBinding as u16,
17846 },
17847 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17848 _bitfield_align_1: [],
17849 _bitfield_1: __BindgenBitfieldUnit::new(
17850 new_jsjitinfo_bitfield_1!(
17851 JSJitInfo_OpType::Method as u8,
17852 JSJitInfo_AliasSet::AliasEverything as u8,
17853 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17854 false,
17855 false,
17856 false,
17857 false,
17858 false,
17859 false,
17860 0,
17861 ).to_ne_bytes()
17862 ),
17863});
17864}
17865unsafe extern "C" fn passOptionalNullableLong<D: DomTypes>
17866(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17867 let mut result = false;
17868 wrap_panic(&mut || result = (|| {
17869 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17870 let this = &*(this as *const D::TestBinding);
17871 let args = &*args;
17872 let argc = args.argc_;
17873 let arg0: Option<Option<i32>> = if args.get(0).is_undefined() {
17874 None
17875 } else {
17876 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17877 Ok(ConversionResult::Success(value)) => value,
17878 Ok(ConversionResult::Failure(error)) => {
17879 throw_type_error(cx.raw_cx(), &error);
17880 return false;
17881
17882 }
17883 _ => {
17884 return false;
17885
17886 },
17887 }
17888 )
17889 };
17890 let result: () = this.PassOptionalNullableLong(arg0);
17891
17892 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17893 return true;
17894 })());
17895 result
17896}
17897
17898
17899static passOptionalNullableLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17900
17901pub(crate) fn init_passOptionalNullableLong_methodinfo<D: DomTypes>() {
17902 passOptionalNullableLong_methodinfo.set(JSJitInfo {
17903 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17904 method: Some(passOptionalNullableLong::<D>)
17905 },
17906 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17907 protoID: PrototypeList::ID::TestBinding as u16,
17908 },
17909 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17910 _bitfield_align_1: [],
17911 _bitfield_1: __BindgenBitfieldUnit::new(
17912 new_jsjitinfo_bitfield_1!(
17913 JSJitInfo_OpType::Method as u8,
17914 JSJitInfo_AliasSet::AliasEverything as u8,
17915 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17916 false,
17917 false,
17918 false,
17919 false,
17920 false,
17921 false,
17922 0,
17923 ).to_ne_bytes()
17924 ),
17925});
17926}
17927unsafe extern "C" fn passOptionalNullableUnsignedLong<D: DomTypes>
17928(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17929 let mut result = false;
17930 wrap_panic(&mut || result = (|| {
17931 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17932 let this = &*(this as *const D::TestBinding);
17933 let args = &*args;
17934 let argc = args.argc_;
17935 let arg0: Option<Option<u32>> = if args.get(0).is_undefined() {
17936 None
17937 } else {
17938 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
17939 Ok(ConversionResult::Success(value)) => value,
17940 Ok(ConversionResult::Failure(error)) => {
17941 throw_type_error(cx.raw_cx(), &error);
17942 return false;
17943
17944 }
17945 _ => {
17946 return false;
17947
17948 },
17949 }
17950 )
17951 };
17952 let result: () = this.PassOptionalNullableUnsignedLong(arg0);
17953
17954 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
17955 return true;
17956 })());
17957 result
17958}
17959
17960
17961static passOptionalNullableUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
17962
17963pub(crate) fn init_passOptionalNullableUnsignedLong_methodinfo<D: DomTypes>() {
17964 passOptionalNullableUnsignedLong_methodinfo.set(JSJitInfo {
17965 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
17966 method: Some(passOptionalNullableUnsignedLong::<D>)
17967 },
17968 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
17969 protoID: PrototypeList::ID::TestBinding as u16,
17970 },
17971 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
17972 _bitfield_align_1: [],
17973 _bitfield_1: __BindgenBitfieldUnit::new(
17974 new_jsjitinfo_bitfield_1!(
17975 JSJitInfo_OpType::Method as u8,
17976 JSJitInfo_AliasSet::AliasEverything as u8,
17977 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
17978 false,
17979 false,
17980 false,
17981 false,
17982 false,
17983 false,
17984 0,
17985 ).to_ne_bytes()
17986 ),
17987});
17988}
17989unsafe extern "C" fn passOptionalNullableLongLong<D: DomTypes>
17990(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
17991 let mut result = false;
17992 wrap_panic(&mut || result = (|| {
17993 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
17994 let this = &*(this as *const D::TestBinding);
17995 let args = &*args;
17996 let argc = args.argc_;
17997 let arg0: Option<Option<i64>> = if args.get(0).is_undefined() {
17998 None
17999 } else {
18000 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18001 Ok(ConversionResult::Success(value)) => value,
18002 Ok(ConversionResult::Failure(error)) => {
18003 throw_type_error(cx.raw_cx(), &error);
18004 return false;
18005
18006 }
18007 _ => {
18008 return false;
18009
18010 },
18011 }
18012 )
18013 };
18014 let result: () = this.PassOptionalNullableLongLong(arg0);
18015
18016 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18017 return true;
18018 })());
18019 result
18020}
18021
18022
18023static passOptionalNullableLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18024
18025pub(crate) fn init_passOptionalNullableLongLong_methodinfo<D: DomTypes>() {
18026 passOptionalNullableLongLong_methodinfo.set(JSJitInfo {
18027 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18028 method: Some(passOptionalNullableLongLong::<D>)
18029 },
18030 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18031 protoID: PrototypeList::ID::TestBinding as u16,
18032 },
18033 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18034 _bitfield_align_1: [],
18035 _bitfield_1: __BindgenBitfieldUnit::new(
18036 new_jsjitinfo_bitfield_1!(
18037 JSJitInfo_OpType::Method as u8,
18038 JSJitInfo_AliasSet::AliasEverything as u8,
18039 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18040 false,
18041 false,
18042 false,
18043 false,
18044 false,
18045 false,
18046 0,
18047 ).to_ne_bytes()
18048 ),
18049});
18050}
18051unsafe extern "C" fn passOptionalNullableUnsignedLongLong<D: DomTypes>
18052(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18053 let mut result = false;
18054 wrap_panic(&mut || result = (|| {
18055 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18056 let this = &*(this as *const D::TestBinding);
18057 let args = &*args;
18058 let argc = args.argc_;
18059 let arg0: Option<Option<u64>> = if args.get(0).is_undefined() {
18060 None
18061 } else {
18062 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
18063 Ok(ConversionResult::Success(value)) => value,
18064 Ok(ConversionResult::Failure(error)) => {
18065 throw_type_error(cx.raw_cx(), &error);
18066 return false;
18067
18068 }
18069 _ => {
18070 return false;
18071
18072 },
18073 }
18074 )
18075 };
18076 let result: () = this.PassOptionalNullableUnsignedLongLong(arg0);
18077
18078 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18079 return true;
18080 })());
18081 result
18082}
18083
18084
18085static passOptionalNullableUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18086
18087pub(crate) fn init_passOptionalNullableUnsignedLongLong_methodinfo<D: DomTypes>() {
18088 passOptionalNullableUnsignedLongLong_methodinfo.set(JSJitInfo {
18089 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18090 method: Some(passOptionalNullableUnsignedLongLong::<D>)
18091 },
18092 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18093 protoID: PrototypeList::ID::TestBinding as u16,
18094 },
18095 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18096 _bitfield_align_1: [],
18097 _bitfield_1: __BindgenBitfieldUnit::new(
18098 new_jsjitinfo_bitfield_1!(
18099 JSJitInfo_OpType::Method as u8,
18100 JSJitInfo_AliasSet::AliasEverything as u8,
18101 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18102 false,
18103 false,
18104 false,
18105 false,
18106 false,
18107 false,
18108 0,
18109 ).to_ne_bytes()
18110 ),
18111});
18112}
18113unsafe extern "C" fn passOptionalNullableUnrestrictedFloat<D: DomTypes>
18114(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18115 let mut result = false;
18116 wrap_panic(&mut || result = (|| {
18117 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18118 let this = &*(this as *const D::TestBinding);
18119 let args = &*args;
18120 let argc = args.argc_;
18121 let arg0: Option<Option<f32>> = if args.get(0).is_undefined() {
18122 None
18123 } else {
18124 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18125 Ok(ConversionResult::Success(value)) => value,
18126 Ok(ConversionResult::Failure(error)) => {
18127 throw_type_error(cx.raw_cx(), &error);
18128 return false;
18129
18130 }
18131 _ => {
18132 return false;
18133
18134 },
18135 }
18136 )
18137 };
18138 let result: () = this.PassOptionalNullableUnrestrictedFloat(arg0);
18139
18140 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18141 return true;
18142 })());
18143 result
18144}
18145
18146
18147static passOptionalNullableUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18148
18149pub(crate) fn init_passOptionalNullableUnrestrictedFloat_methodinfo<D: DomTypes>() {
18150 passOptionalNullableUnrestrictedFloat_methodinfo.set(JSJitInfo {
18151 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18152 method: Some(passOptionalNullableUnrestrictedFloat::<D>)
18153 },
18154 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18155 protoID: PrototypeList::ID::TestBinding as u16,
18156 },
18157 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18158 _bitfield_align_1: [],
18159 _bitfield_1: __BindgenBitfieldUnit::new(
18160 new_jsjitinfo_bitfield_1!(
18161 JSJitInfo_OpType::Method as u8,
18162 JSJitInfo_AliasSet::AliasEverything as u8,
18163 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18164 false,
18165 false,
18166 false,
18167 false,
18168 false,
18169 false,
18170 0,
18171 ).to_ne_bytes()
18172 ),
18173});
18174}
18175unsafe extern "C" fn passOptionalNullableFloat<D: DomTypes>
18176(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18177 let mut result = false;
18178 wrap_panic(&mut || result = (|| {
18179 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18180 let this = &*(this as *const D::TestBinding);
18181 let args = &*args;
18182 let argc = args.argc_;
18183 let arg0: Option<Option<Finite<f32>>> = if args.get(0).is_undefined() {
18184 None
18185 } else {
18186 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18187 Ok(ConversionResult::Success(value)) => value,
18188 Ok(ConversionResult::Failure(error)) => {
18189 throw_type_error(cx.raw_cx(), &error);
18190 return false;
18191
18192 }
18193 _ => {
18194 return false;
18195
18196 },
18197 }
18198 )
18199 };
18200 let result: () = this.PassOptionalNullableFloat(arg0);
18201
18202 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18203 return true;
18204 })());
18205 result
18206}
18207
18208
18209static passOptionalNullableFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18210
18211pub(crate) fn init_passOptionalNullableFloat_methodinfo<D: DomTypes>() {
18212 passOptionalNullableFloat_methodinfo.set(JSJitInfo {
18213 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18214 method: Some(passOptionalNullableFloat::<D>)
18215 },
18216 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18217 protoID: PrototypeList::ID::TestBinding as u16,
18218 },
18219 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18220 _bitfield_align_1: [],
18221 _bitfield_1: __BindgenBitfieldUnit::new(
18222 new_jsjitinfo_bitfield_1!(
18223 JSJitInfo_OpType::Method as u8,
18224 JSJitInfo_AliasSet::AliasEverything as u8,
18225 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18226 false,
18227 false,
18228 false,
18229 false,
18230 false,
18231 false,
18232 0,
18233 ).to_ne_bytes()
18234 ),
18235});
18236}
18237unsafe extern "C" fn passOptionalNullableUnrestrictedDouble<D: DomTypes>
18238(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18239 let mut result = false;
18240 wrap_panic(&mut || result = (|| {
18241 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18242 let this = &*(this as *const D::TestBinding);
18243 let args = &*args;
18244 let argc = args.argc_;
18245 let arg0: Option<Option<f64>> = if args.get(0).is_undefined() {
18246 None
18247 } else {
18248 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18249 Ok(ConversionResult::Success(value)) => value,
18250 Ok(ConversionResult::Failure(error)) => {
18251 throw_type_error(cx.raw_cx(), &error);
18252 return false;
18253
18254 }
18255 _ => {
18256 return false;
18257
18258 },
18259 }
18260 )
18261 };
18262 let result: () = this.PassOptionalNullableUnrestrictedDouble(arg0);
18263
18264 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18265 return true;
18266 })());
18267 result
18268}
18269
18270
18271static passOptionalNullableUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18272
18273pub(crate) fn init_passOptionalNullableUnrestrictedDouble_methodinfo<D: DomTypes>() {
18274 passOptionalNullableUnrestrictedDouble_methodinfo.set(JSJitInfo {
18275 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18276 method: Some(passOptionalNullableUnrestrictedDouble::<D>)
18277 },
18278 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18279 protoID: PrototypeList::ID::TestBinding as u16,
18280 },
18281 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18282 _bitfield_align_1: [],
18283 _bitfield_1: __BindgenBitfieldUnit::new(
18284 new_jsjitinfo_bitfield_1!(
18285 JSJitInfo_OpType::Method as u8,
18286 JSJitInfo_AliasSet::AliasEverything as u8,
18287 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18288 false,
18289 false,
18290 false,
18291 false,
18292 false,
18293 false,
18294 0,
18295 ).to_ne_bytes()
18296 ),
18297});
18298}
18299unsafe extern "C" fn passOptionalNullableDouble<D: DomTypes>
18300(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18301 let mut result = false;
18302 wrap_panic(&mut || result = (|| {
18303 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18304 let this = &*(this as *const D::TestBinding);
18305 let args = &*args;
18306 let argc = args.argc_;
18307 let arg0: Option<Option<Finite<f64>>> = if args.get(0).is_undefined() {
18308 None
18309 } else {
18310 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18311 Ok(ConversionResult::Success(value)) => value,
18312 Ok(ConversionResult::Failure(error)) => {
18313 throw_type_error(cx.raw_cx(), &error);
18314 return false;
18315
18316 }
18317 _ => {
18318 return false;
18319
18320 },
18321 }
18322 )
18323 };
18324 let result: () = this.PassOptionalNullableDouble(arg0);
18325
18326 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18327 return true;
18328 })());
18329 result
18330}
18331
18332
18333static passOptionalNullableDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18334
18335pub(crate) fn init_passOptionalNullableDouble_methodinfo<D: DomTypes>() {
18336 passOptionalNullableDouble_methodinfo.set(JSJitInfo {
18337 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18338 method: Some(passOptionalNullableDouble::<D>)
18339 },
18340 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18341 protoID: PrototypeList::ID::TestBinding as u16,
18342 },
18343 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18344 _bitfield_align_1: [],
18345 _bitfield_1: __BindgenBitfieldUnit::new(
18346 new_jsjitinfo_bitfield_1!(
18347 JSJitInfo_OpType::Method as u8,
18348 JSJitInfo_AliasSet::AliasEverything as u8,
18349 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18350 false,
18351 false,
18352 false,
18353 false,
18354 false,
18355 false,
18356 0,
18357 ).to_ne_bytes()
18358 ),
18359});
18360}
18361unsafe extern "C" fn passOptionalNullableString<D: DomTypes>
18362(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18363 let mut result = false;
18364 wrap_panic(&mut || result = (|| {
18365 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18366 let this = &*(this as *const D::TestBinding);
18367 let args = &*args;
18368 let argc = args.argc_;
18369 let arg0: Option<Option<DOMString>> = if args.get(0).is_undefined() {
18370 None
18371 } else {
18372 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
18373 Ok(ConversionResult::Success(value)) => value,
18374 Ok(ConversionResult::Failure(error)) => {
18375 throw_type_error(cx.raw_cx(), &error);
18376 return false;
18377
18378 }
18379 _ => {
18380 return false;
18381
18382 },
18383 }
18384 )
18385 };
18386 let result: () = this.PassOptionalNullableString(arg0);
18387
18388 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18389 return true;
18390 })());
18391 result
18392}
18393
18394
18395static passOptionalNullableString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18396
18397pub(crate) fn init_passOptionalNullableString_methodinfo<D: DomTypes>() {
18398 passOptionalNullableString_methodinfo.set(JSJitInfo {
18399 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18400 method: Some(passOptionalNullableString::<D>)
18401 },
18402 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18403 protoID: PrototypeList::ID::TestBinding as u16,
18404 },
18405 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18406 _bitfield_align_1: [],
18407 _bitfield_1: __BindgenBitfieldUnit::new(
18408 new_jsjitinfo_bitfield_1!(
18409 JSJitInfo_OpType::Method as u8,
18410 JSJitInfo_AliasSet::AliasEverything as u8,
18411 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18412 false,
18413 false,
18414 false,
18415 false,
18416 false,
18417 false,
18418 0,
18419 ).to_ne_bytes()
18420 ),
18421});
18422}
18423unsafe extern "C" fn passOptionalNullableUsvstring<D: DomTypes>
18424(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18425 let mut result = false;
18426 wrap_panic(&mut || result = (|| {
18427 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18428 let this = &*(this as *const D::TestBinding);
18429 let args = &*args;
18430 let argc = args.argc_;
18431 let arg0: Option<Option<USVString>> = if args.get(0).is_undefined() {
18432 None
18433 } else {
18434 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18435 Ok(ConversionResult::Success(value)) => value,
18436 Ok(ConversionResult::Failure(error)) => {
18437 throw_type_error(cx.raw_cx(), &error);
18438 return false;
18439
18440 }
18441 _ => {
18442 return false;
18443
18444 },
18445 }
18446 )
18447 };
18448 let result: () = this.PassOptionalNullableUsvstring(arg0);
18449
18450 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18451 return true;
18452 })());
18453 result
18454}
18455
18456
18457static passOptionalNullableUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18458
18459pub(crate) fn init_passOptionalNullableUsvstring_methodinfo<D: DomTypes>() {
18460 passOptionalNullableUsvstring_methodinfo.set(JSJitInfo {
18461 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18462 method: Some(passOptionalNullableUsvstring::<D>)
18463 },
18464 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18465 protoID: PrototypeList::ID::TestBinding as u16,
18466 },
18467 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18468 _bitfield_align_1: [],
18469 _bitfield_1: __BindgenBitfieldUnit::new(
18470 new_jsjitinfo_bitfield_1!(
18471 JSJitInfo_OpType::Method as u8,
18472 JSJitInfo_AliasSet::AliasEverything as u8,
18473 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18474 false,
18475 false,
18476 false,
18477 false,
18478 false,
18479 false,
18480 0,
18481 ).to_ne_bytes()
18482 ),
18483});
18484}
18485unsafe extern "C" fn passOptionalNullableByteString<D: DomTypes>
18486(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18487 let mut result = false;
18488 wrap_panic(&mut || result = (|| {
18489 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18490 let this = &*(this as *const D::TestBinding);
18491 let args = &*args;
18492 let argc = args.argc_;
18493 let arg0: Option<Option<ByteString>> = if args.get(0).is_undefined() {
18494 None
18495 } else {
18496 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18497 Ok(ConversionResult::Success(value)) => value,
18498 Ok(ConversionResult::Failure(error)) => {
18499 throw_type_error(cx.raw_cx(), &error);
18500 return false;
18501
18502 }
18503 _ => {
18504 return false;
18505
18506 },
18507 }
18508 )
18509 };
18510 let result: () = this.PassOptionalNullableByteString(arg0);
18511
18512 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18513 return true;
18514 })());
18515 result
18516}
18517
18518
18519static passOptionalNullableByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18520
18521pub(crate) fn init_passOptionalNullableByteString_methodinfo<D: DomTypes>() {
18522 passOptionalNullableByteString_methodinfo.set(JSJitInfo {
18523 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18524 method: Some(passOptionalNullableByteString::<D>)
18525 },
18526 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18527 protoID: PrototypeList::ID::TestBinding as u16,
18528 },
18529 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18530 _bitfield_align_1: [],
18531 _bitfield_1: __BindgenBitfieldUnit::new(
18532 new_jsjitinfo_bitfield_1!(
18533 JSJitInfo_OpType::Method as u8,
18534 JSJitInfo_AliasSet::AliasEverything as u8,
18535 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18536 false,
18537 false,
18538 false,
18539 false,
18540 false,
18541 false,
18542 0,
18543 ).to_ne_bytes()
18544 ),
18545});
18546}
18547unsafe extern "C" fn passOptionalNullableInterface<D: DomTypes>
18548(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18549 let mut result = false;
18550 wrap_panic(&mut || result = (|| {
18551 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18552 let this = &*(this as *const D::TestBinding);
18553 let args = &*args;
18554 let argc = args.argc_;
18555 let arg0: Option<Option<DomRoot<D::Blob>>> = if args.get(0).is_undefined() {
18556 None
18557 } else {
18558 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
18559 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
18560 Ok(val) => val,
18561 Err(()) => {
18562 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
18563 return false;
18564
18565 }
18566 }
18567 )
18568 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18569 None
18570 } else {
18571 throw_type_error(cx.raw_cx(), "Value is not an object.");
18572 return false;
18573
18574 })
18575 };
18576 let result: () = this.PassOptionalNullableInterface(arg0.as_ref().map(Option::as_deref));
18577
18578 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18579 return true;
18580 })());
18581 result
18582}
18583
18584
18585static passOptionalNullableInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18586
18587pub(crate) fn init_passOptionalNullableInterface_methodinfo<D: DomTypes>() {
18588 passOptionalNullableInterface_methodinfo.set(JSJitInfo {
18589 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18590 method: Some(passOptionalNullableInterface::<D>)
18591 },
18592 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18593 protoID: PrototypeList::ID::TestBinding as u16,
18594 },
18595 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18596 _bitfield_align_1: [],
18597 _bitfield_1: __BindgenBitfieldUnit::new(
18598 new_jsjitinfo_bitfield_1!(
18599 JSJitInfo_OpType::Method as u8,
18600 JSJitInfo_AliasSet::AliasEverything as u8,
18601 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18602 false,
18603 false,
18604 false,
18605 false,
18606 false,
18607 false,
18608 0,
18609 ).to_ne_bytes()
18610 ),
18611});
18612}
18613unsafe extern "C" fn passOptionalNullableObject<D: DomTypes>
18614(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18615 let mut result = false;
18616 wrap_panic(&mut || result = (|| {
18617 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18618 let this = &*(this as *const D::TestBinding);
18619 let args = &*args;
18620 let argc = args.argc_;
18621 let arg0: Option<*mut JSObject> = if args.get(0).is_undefined() {
18622 None
18623 } else {
18624 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
18625 HandleValue::from_raw(args.get(0)).get().to_object()
18626 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
18627 ptr::null_mut()
18628 } else {
18629 throw_type_error(cx.raw_cx(), "Value is not an object.");
18630 return false;
18631
18632 })
18633 };
18634 let result: () = this.PassOptionalNullableObject(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
18635
18636 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18637 return true;
18638 })());
18639 result
18640}
18641
18642
18643static passOptionalNullableObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18644
18645pub(crate) fn init_passOptionalNullableObject_methodinfo<D: DomTypes>() {
18646 passOptionalNullableObject_methodinfo.set(JSJitInfo {
18647 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18648 method: Some(passOptionalNullableObject::<D>)
18649 },
18650 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18651 protoID: PrototypeList::ID::TestBinding as u16,
18652 },
18653 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18654 _bitfield_align_1: [],
18655 _bitfield_1: __BindgenBitfieldUnit::new(
18656 new_jsjitinfo_bitfield_1!(
18657 JSJitInfo_OpType::Method as u8,
18658 JSJitInfo_AliasSet::AliasEverything as u8,
18659 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18660 false,
18661 false,
18662 false,
18663 false,
18664 false,
18665 false,
18666 0,
18667 ).to_ne_bytes()
18668 ),
18669});
18670}
18671unsafe extern "C" fn passOptionalNullableUnion<D: DomTypes>
18672(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18673 let mut result = false;
18674 wrap_panic(&mut || result = (|| {
18675 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18676 let this = &*(this as *const D::TestBinding);
18677 let args = &*args;
18678 let argc = args.argc_;
18679 let arg0: Option<Option<GenericUnionTypes::HTMLElementOrLong::<D> >> = if args.get(0).is_undefined() {
18680 None
18681 } else {
18682 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18683 Ok(ConversionResult::Success(value)) => value,
18684 Ok(ConversionResult::Failure(error)) => {
18685 throw_type_error(cx.raw_cx(), &error);
18686 return false;
18687
18688 }
18689 _ => {
18690 return false;
18691
18692 },
18693 }
18694 )
18695 };
18696 let result: () = this.PassOptionalNullableUnion(arg0);
18697
18698 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18699 return true;
18700 })());
18701 result
18702}
18703
18704
18705static passOptionalNullableUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18706
18707pub(crate) fn init_passOptionalNullableUnion_methodinfo<D: DomTypes>() {
18708 passOptionalNullableUnion_methodinfo.set(JSJitInfo {
18709 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18710 method: Some(passOptionalNullableUnion::<D>)
18711 },
18712 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18713 protoID: PrototypeList::ID::TestBinding as u16,
18714 },
18715 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18716 _bitfield_align_1: [],
18717 _bitfield_1: __BindgenBitfieldUnit::new(
18718 new_jsjitinfo_bitfield_1!(
18719 JSJitInfo_OpType::Method as u8,
18720 JSJitInfo_AliasSet::AliasEverything as u8,
18721 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18722 false,
18723 false,
18724 false,
18725 false,
18726 false,
18727 false,
18728 0,
18729 ).to_ne_bytes()
18730 ),
18731});
18732}
18733unsafe extern "C" fn passOptionalNullableUnion2<D: DomTypes>
18734(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18735 let mut result = false;
18736 wrap_panic(&mut || result = (|| {
18737 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18738 let this = &*(this as *const D::TestBinding);
18739 let args = &*args;
18740 let argc = args.argc_;
18741 let arg0: Option<Option<GenericUnionTypes::EventOrString::<D> >> = if args.get(0).is_undefined() {
18742 None
18743 } else {
18744 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18745 Ok(ConversionResult::Success(value)) => value,
18746 Ok(ConversionResult::Failure(error)) => {
18747 throw_type_error(cx.raw_cx(), &error);
18748 return false;
18749
18750 }
18751 _ => {
18752 return false;
18753
18754 },
18755 }
18756 )
18757 };
18758 let result: () = this.PassOptionalNullableUnion2(arg0);
18759
18760 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18761 return true;
18762 })());
18763 result
18764}
18765
18766
18767static passOptionalNullableUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18768
18769pub(crate) fn init_passOptionalNullableUnion2_methodinfo<D: DomTypes>() {
18770 passOptionalNullableUnion2_methodinfo.set(JSJitInfo {
18771 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18772 method: Some(passOptionalNullableUnion2::<D>)
18773 },
18774 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18775 protoID: PrototypeList::ID::TestBinding as u16,
18776 },
18777 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18778 _bitfield_align_1: [],
18779 _bitfield_1: __BindgenBitfieldUnit::new(
18780 new_jsjitinfo_bitfield_1!(
18781 JSJitInfo_OpType::Method as u8,
18782 JSJitInfo_AliasSet::AliasEverything as u8,
18783 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18784 false,
18785 false,
18786 false,
18787 false,
18788 false,
18789 false,
18790 0,
18791 ).to_ne_bytes()
18792 ),
18793});
18794}
18795unsafe extern "C" fn passOptionalNullableUnion3<D: DomTypes>
18796(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18797 let mut result = false;
18798 wrap_panic(&mut || result = (|| {
18799 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18800 let this = &*(this as *const D::TestBinding);
18801 let args = &*args;
18802 let argc = args.argc_;
18803 let arg0: Option<Option<GenericUnionTypes::StringOrLongSequence >> = if args.get(0).is_undefined() {
18804 None
18805 } else {
18806 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18807 Ok(ConversionResult::Success(value)) => value,
18808 Ok(ConversionResult::Failure(error)) => {
18809 throw_type_error(cx.raw_cx(), &error);
18810 return false;
18811
18812 }
18813 _ => {
18814 return false;
18815
18816 },
18817 }
18818 )
18819 };
18820 let result: () = this.PassOptionalNullableUnion3(arg0);
18821
18822 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18823 return true;
18824 })());
18825 result
18826}
18827
18828
18829static passOptionalNullableUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18830
18831pub(crate) fn init_passOptionalNullableUnion3_methodinfo<D: DomTypes>() {
18832 passOptionalNullableUnion3_methodinfo.set(JSJitInfo {
18833 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18834 method: Some(passOptionalNullableUnion3::<D>)
18835 },
18836 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18837 protoID: PrototypeList::ID::TestBinding as u16,
18838 },
18839 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18840 _bitfield_align_1: [],
18841 _bitfield_1: __BindgenBitfieldUnit::new(
18842 new_jsjitinfo_bitfield_1!(
18843 JSJitInfo_OpType::Method as u8,
18844 JSJitInfo_AliasSet::AliasEverything as u8,
18845 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18846 false,
18847 false,
18848 false,
18849 false,
18850 false,
18851 false,
18852 0,
18853 ).to_ne_bytes()
18854 ),
18855});
18856}
18857unsafe extern "C" fn passOptionalNullableUnion4<D: DomTypes>
18858(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18859 let mut result = false;
18860 wrap_panic(&mut || result = (|| {
18861 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18862 let this = &*(this as *const D::TestBinding);
18863 let args = &*args;
18864 let argc = args.argc_;
18865 let arg0: Option<Option<GenericUnionTypes::LongSequenceOrBoolean >> = if args.get(0).is_undefined() {
18866 None
18867 } else {
18868 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18869 Ok(ConversionResult::Success(value)) => value,
18870 Ok(ConversionResult::Failure(error)) => {
18871 throw_type_error(cx.raw_cx(), &error);
18872 return false;
18873
18874 }
18875 _ => {
18876 return false;
18877
18878 },
18879 }
18880 )
18881 };
18882 let result: () = this.PassOptionalNullableUnion4(arg0);
18883
18884 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18885 return true;
18886 })());
18887 result
18888}
18889
18890
18891static passOptionalNullableUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18892
18893pub(crate) fn init_passOptionalNullableUnion4_methodinfo<D: DomTypes>() {
18894 passOptionalNullableUnion4_methodinfo.set(JSJitInfo {
18895 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18896 method: Some(passOptionalNullableUnion4::<D>)
18897 },
18898 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18899 protoID: PrototypeList::ID::TestBinding as u16,
18900 },
18901 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18902 _bitfield_align_1: [],
18903 _bitfield_1: __BindgenBitfieldUnit::new(
18904 new_jsjitinfo_bitfield_1!(
18905 JSJitInfo_OpType::Method as u8,
18906 JSJitInfo_AliasSet::AliasEverything as u8,
18907 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18908 false,
18909 false,
18910 false,
18911 false,
18912 false,
18913 false,
18914 0,
18915 ).to_ne_bytes()
18916 ),
18917});
18918}
18919unsafe extern "C" fn passOptionalNullableUnion5<D: DomTypes>
18920(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18921 let mut result = false;
18922 wrap_panic(&mut || result = (|| {
18923 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18924 let this = &*(this as *const D::TestBinding);
18925 let args = &*args;
18926 let argc = args.argc_;
18927 let arg0: Option<Option<GenericUnionTypes::UnsignedLongOrBoolean >> = if args.get(0).is_undefined() {
18928 None
18929 } else {
18930 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18931 Ok(ConversionResult::Success(value)) => value,
18932 Ok(ConversionResult::Failure(error)) => {
18933 throw_type_error(cx.raw_cx(), &error);
18934 return false;
18935
18936 }
18937 _ => {
18938 return false;
18939
18940 },
18941 }
18942 )
18943 };
18944 let result: () = this.PassOptionalNullableUnion5(arg0);
18945
18946 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
18947 return true;
18948 })());
18949 result
18950}
18951
18952
18953static passOptionalNullableUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
18954
18955pub(crate) fn init_passOptionalNullableUnion5_methodinfo<D: DomTypes>() {
18956 passOptionalNullableUnion5_methodinfo.set(JSJitInfo {
18957 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
18958 method: Some(passOptionalNullableUnion5::<D>)
18959 },
18960 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
18961 protoID: PrototypeList::ID::TestBinding as u16,
18962 },
18963 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
18964 _bitfield_align_1: [],
18965 _bitfield_1: __BindgenBitfieldUnit::new(
18966 new_jsjitinfo_bitfield_1!(
18967 JSJitInfo_OpType::Method as u8,
18968 JSJitInfo_AliasSet::AliasEverything as u8,
18969 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
18970 false,
18971 false,
18972 false,
18973 false,
18974 false,
18975 false,
18976 0,
18977 ).to_ne_bytes()
18978 ),
18979});
18980}
18981unsafe extern "C" fn passOptionalNullableUnion6<D: DomTypes>
18982(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
18983 let mut result = false;
18984 wrap_panic(&mut || result = (|| {
18985 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
18986 let this = &*(this as *const D::TestBinding);
18987 let args = &*args;
18988 let argc = args.argc_;
18989 let arg0: Option<Option<GenericUnionTypes::ByteStringOrLong >> = if args.get(0).is_undefined() {
18990 None
18991 } else {
18992 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
18993 Ok(ConversionResult::Success(value)) => value,
18994 Ok(ConversionResult::Failure(error)) => {
18995 throw_type_error(cx.raw_cx(), &error);
18996 return false;
18997
18998 }
18999 _ => {
19000 return false;
19001
19002 },
19003 }
19004 )
19005 };
19006 let result: () = this.PassOptionalNullableUnion6(arg0);
19007
19008 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19009 return true;
19010 })());
19011 result
19012}
19013
19014
19015static passOptionalNullableUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19016
19017pub(crate) fn init_passOptionalNullableUnion6_methodinfo<D: DomTypes>() {
19018 passOptionalNullableUnion6_methodinfo.set(JSJitInfo {
19019 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19020 method: Some(passOptionalNullableUnion6::<D>)
19021 },
19022 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19023 protoID: PrototypeList::ID::TestBinding as u16,
19024 },
19025 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19026 _bitfield_align_1: [],
19027 _bitfield_1: __BindgenBitfieldUnit::new(
19028 new_jsjitinfo_bitfield_1!(
19029 JSJitInfo_OpType::Method as u8,
19030 JSJitInfo_AliasSet::AliasEverything as u8,
19031 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19032 false,
19033 false,
19034 false,
19035 false,
19036 false,
19037 false,
19038 0,
19039 ).to_ne_bytes()
19040 ),
19041});
19042}
19043unsafe extern "C" fn passOptionalNullableCallbackFunction<D: DomTypes>
19044(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19045 let mut result = false;
19046 wrap_panic(&mut || result = (|| {
19047 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19048 let this = &*(this as *const D::TestBinding);
19049 let args = &*args;
19050 let argc = args.argc_;
19051 let arg0: Option<Option<Rc<Function<D>>>> = if args.get(0).is_undefined() {
19052 None
19053 } else {
19054 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
19055 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
19056 Some(Function::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
19057 } else {
19058 throw_type_error(cx.raw_cx(), "Value is not callable.");
19059 return false;
19060
19061 }
19062 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
19063 None
19064 } else {
19065 throw_type_error(cx.raw_cx(), "Value is not an object.");
19066 return false;
19067
19068 })
19069 };
19070 let result: () = this.PassOptionalNullableCallbackFunction(arg0);
19071
19072 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19073 return true;
19074 })());
19075 result
19076}
19077
19078
19079static passOptionalNullableCallbackFunction_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19080
19081pub(crate) fn init_passOptionalNullableCallbackFunction_methodinfo<D: DomTypes>() {
19082 passOptionalNullableCallbackFunction_methodinfo.set(JSJitInfo {
19083 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19084 method: Some(passOptionalNullableCallbackFunction::<D>)
19085 },
19086 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19087 protoID: PrototypeList::ID::TestBinding as u16,
19088 },
19089 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19090 _bitfield_align_1: [],
19091 _bitfield_1: __BindgenBitfieldUnit::new(
19092 new_jsjitinfo_bitfield_1!(
19093 JSJitInfo_OpType::Method as u8,
19094 JSJitInfo_AliasSet::AliasEverything as u8,
19095 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19096 false,
19097 false,
19098 false,
19099 false,
19100 false,
19101 false,
19102 0,
19103 ).to_ne_bytes()
19104 ),
19105});
19106}
19107unsafe extern "C" fn passOptionalNullableCallbackInterface<D: DomTypes>
19108(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19109 let mut result = false;
19110 wrap_panic(&mut || result = (|| {
19111 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19112 let this = &*(this as *const D::TestBinding);
19113 let args = &*args;
19114 let argc = args.argc_;
19115 let arg0: Option<Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>>> = if args.get(0).is_undefined() {
19116 None
19117 } else {
19118 Some(if HandleValue::from_raw(args.get(0)).get().is_object() {
19119 Some(crate::codegen::GenericBindings::EventListenerBinding::EventListener::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
19120 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
19121 None
19122 } else {
19123 throw_type_error(cx.raw_cx(), "Value is not an object.");
19124 return false;
19125
19126 })
19127 };
19128 let result: () = this.PassOptionalNullableCallbackInterface(arg0);
19129
19130 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19131 return true;
19132 })());
19133 result
19134}
19135
19136
19137static passOptionalNullableCallbackInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19138
19139pub(crate) fn init_passOptionalNullableCallbackInterface_methodinfo<D: DomTypes>() {
19140 passOptionalNullableCallbackInterface_methodinfo.set(JSJitInfo {
19141 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19142 method: Some(passOptionalNullableCallbackInterface::<D>)
19143 },
19144 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19145 protoID: PrototypeList::ID::TestBinding as u16,
19146 },
19147 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19148 _bitfield_align_1: [],
19149 _bitfield_1: __BindgenBitfieldUnit::new(
19150 new_jsjitinfo_bitfield_1!(
19151 JSJitInfo_OpType::Method as u8,
19152 JSJitInfo_AliasSet::AliasEverything as u8,
19153 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19154 false,
19155 false,
19156 false,
19157 false,
19158 false,
19159 false,
19160 0,
19161 ).to_ne_bytes()
19162 ),
19163});
19164}
19165unsafe extern "C" fn passOptionalNullableSequence<D: DomTypes>
19166(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19167 let mut result = false;
19168 wrap_panic(&mut || result = (|| {
19169 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19170 let this = &*(this as *const D::TestBinding);
19171 let args = &*args;
19172 let argc = args.argc_;
19173 let arg0: Option<Option<Vec<i32> >> = if args.get(0).is_undefined() {
19174 None
19175 } else {
19176 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19177 Ok(ConversionResult::Success(value)) => value,
19178 Ok(ConversionResult::Failure(error)) => {
19179 throw_type_error(cx.raw_cx(), &error);
19180 return false;
19181
19182 }
19183 _ => {
19184 return false;
19185
19186 },
19187 }
19188 )
19189 };
19190 let result: () = this.PassOptionalNullableSequence(arg0);
19191
19192 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19193 return true;
19194 })());
19195 result
19196}
19197
19198
19199static passOptionalNullableSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19200
19201pub(crate) fn init_passOptionalNullableSequence_methodinfo<D: DomTypes>() {
19202 passOptionalNullableSequence_methodinfo.set(JSJitInfo {
19203 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19204 method: Some(passOptionalNullableSequence::<D>)
19205 },
19206 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19207 protoID: PrototypeList::ID::TestBinding as u16,
19208 },
19209 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19210 _bitfield_align_1: [],
19211 _bitfield_1: __BindgenBitfieldUnit::new(
19212 new_jsjitinfo_bitfield_1!(
19213 JSJitInfo_OpType::Method as u8,
19214 JSJitInfo_AliasSet::AliasEverything as u8,
19215 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19216 false,
19217 false,
19218 false,
19219 false,
19220 false,
19221 false,
19222 0,
19223 ).to_ne_bytes()
19224 ),
19225});
19226}
19227unsafe extern "C" fn passOptionalBooleanWithDefault<D: DomTypes>
19228(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19229 let mut result = false;
19230 wrap_panic(&mut || result = (|| {
19231 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19232 let this = &*(this as *const D::TestBinding);
19233 let args = &*args;
19234 let argc = args.argc_;
19235 let arg0: bool = if args.get(0).is_undefined() {
19236 false
19237 } else {
19238 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
19239 Ok(ConversionResult::Success(value)) => value,
19240 Ok(ConversionResult::Failure(error)) => {
19241 throw_type_error(cx.raw_cx(), &error);
19242 return false;
19243
19244 }
19245 _ => {
19246 return false;
19247
19248 },
19249 }
19250
19251 };
19252 let result: () = this.PassOptionalBooleanWithDefault(arg0);
19253
19254 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19255 return true;
19256 })());
19257 result
19258}
19259
19260
19261static passOptionalBooleanWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19262
19263pub(crate) fn init_passOptionalBooleanWithDefault_methodinfo<D: DomTypes>() {
19264 passOptionalBooleanWithDefault_methodinfo.set(JSJitInfo {
19265 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19266 method: Some(passOptionalBooleanWithDefault::<D>)
19267 },
19268 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19269 protoID: PrototypeList::ID::TestBinding as u16,
19270 },
19271 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19272 _bitfield_align_1: [],
19273 _bitfield_1: __BindgenBitfieldUnit::new(
19274 new_jsjitinfo_bitfield_1!(
19275 JSJitInfo_OpType::Method as u8,
19276 JSJitInfo_AliasSet::AliasEverything as u8,
19277 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19278 false,
19279 false,
19280 false,
19281 false,
19282 false,
19283 false,
19284 0,
19285 ).to_ne_bytes()
19286 ),
19287});
19288}
19289unsafe extern "C" fn passOptionalByteWithDefault<D: DomTypes>
19290(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19291 let mut result = false;
19292 wrap_panic(&mut || result = (|| {
19293 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19294 let this = &*(this as *const D::TestBinding);
19295 let args = &*args;
19296 let argc = args.argc_;
19297 let arg0: i8 = if args.get(0).is_undefined() {
19298 0
19299 } else {
19300 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19301 Ok(ConversionResult::Success(value)) => value,
19302 Ok(ConversionResult::Failure(error)) => {
19303 throw_type_error(cx.raw_cx(), &error);
19304 return false;
19305
19306 }
19307 _ => {
19308 return false;
19309
19310 },
19311 }
19312
19313 };
19314 let result: () = this.PassOptionalByteWithDefault(arg0);
19315
19316 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19317 return true;
19318 })());
19319 result
19320}
19321
19322
19323static passOptionalByteWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19324
19325pub(crate) fn init_passOptionalByteWithDefault_methodinfo<D: DomTypes>() {
19326 passOptionalByteWithDefault_methodinfo.set(JSJitInfo {
19327 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19328 method: Some(passOptionalByteWithDefault::<D>)
19329 },
19330 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19331 protoID: PrototypeList::ID::TestBinding as u16,
19332 },
19333 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19334 _bitfield_align_1: [],
19335 _bitfield_1: __BindgenBitfieldUnit::new(
19336 new_jsjitinfo_bitfield_1!(
19337 JSJitInfo_OpType::Method as u8,
19338 JSJitInfo_AliasSet::AliasEverything as u8,
19339 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19340 false,
19341 false,
19342 false,
19343 false,
19344 false,
19345 false,
19346 0,
19347 ).to_ne_bytes()
19348 ),
19349});
19350}
19351unsafe extern "C" fn passOptionalOctetWithDefault<D: DomTypes>
19352(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19353 let mut result = false;
19354 wrap_panic(&mut || result = (|| {
19355 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19356 let this = &*(this as *const D::TestBinding);
19357 let args = &*args;
19358 let argc = args.argc_;
19359 let arg0: u8 = if args.get(0).is_undefined() {
19360 19
19361 } else {
19362 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19363 Ok(ConversionResult::Success(value)) => value,
19364 Ok(ConversionResult::Failure(error)) => {
19365 throw_type_error(cx.raw_cx(), &error);
19366 return false;
19367
19368 }
19369 _ => {
19370 return false;
19371
19372 },
19373 }
19374
19375 };
19376 let result: () = this.PassOptionalOctetWithDefault(arg0);
19377
19378 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19379 return true;
19380 })());
19381 result
19382}
19383
19384
19385static passOptionalOctetWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19386
19387pub(crate) fn init_passOptionalOctetWithDefault_methodinfo<D: DomTypes>() {
19388 passOptionalOctetWithDefault_methodinfo.set(JSJitInfo {
19389 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19390 method: Some(passOptionalOctetWithDefault::<D>)
19391 },
19392 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19393 protoID: PrototypeList::ID::TestBinding as u16,
19394 },
19395 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19396 _bitfield_align_1: [],
19397 _bitfield_1: __BindgenBitfieldUnit::new(
19398 new_jsjitinfo_bitfield_1!(
19399 JSJitInfo_OpType::Method as u8,
19400 JSJitInfo_AliasSet::AliasEverything as u8,
19401 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19402 false,
19403 false,
19404 false,
19405 false,
19406 false,
19407 false,
19408 0,
19409 ).to_ne_bytes()
19410 ),
19411});
19412}
19413unsafe extern "C" fn passOptionalShortWithDefault<D: DomTypes>
19414(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19415 let mut result = false;
19416 wrap_panic(&mut || result = (|| {
19417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19418 let this = &*(this as *const D::TestBinding);
19419 let args = &*args;
19420 let argc = args.argc_;
19421 let arg0: i16 = if args.get(0).is_undefined() {
19422 5
19423 } else {
19424 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19425 Ok(ConversionResult::Success(value)) => value,
19426 Ok(ConversionResult::Failure(error)) => {
19427 throw_type_error(cx.raw_cx(), &error);
19428 return false;
19429
19430 }
19431 _ => {
19432 return false;
19433
19434 },
19435 }
19436
19437 };
19438 let result: () = this.PassOptionalShortWithDefault(arg0);
19439
19440 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19441 return true;
19442 })());
19443 result
19444}
19445
19446
19447static passOptionalShortWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19448
19449pub(crate) fn init_passOptionalShortWithDefault_methodinfo<D: DomTypes>() {
19450 passOptionalShortWithDefault_methodinfo.set(JSJitInfo {
19451 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19452 method: Some(passOptionalShortWithDefault::<D>)
19453 },
19454 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19455 protoID: PrototypeList::ID::TestBinding as u16,
19456 },
19457 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19458 _bitfield_align_1: [],
19459 _bitfield_1: __BindgenBitfieldUnit::new(
19460 new_jsjitinfo_bitfield_1!(
19461 JSJitInfo_OpType::Method as u8,
19462 JSJitInfo_AliasSet::AliasEverything as u8,
19463 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19464 false,
19465 false,
19466 false,
19467 false,
19468 false,
19469 false,
19470 0,
19471 ).to_ne_bytes()
19472 ),
19473});
19474}
19475unsafe extern "C" fn passOptionalUnsignedShortWithDefault<D: DomTypes>
19476(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19477 let mut result = false;
19478 wrap_panic(&mut || result = (|| {
19479 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19480 let this = &*(this as *const D::TestBinding);
19481 let args = &*args;
19482 let argc = args.argc_;
19483 let arg0: u16 = if args.get(0).is_undefined() {
19484 2
19485 } else {
19486 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19487 Ok(ConversionResult::Success(value)) => value,
19488 Ok(ConversionResult::Failure(error)) => {
19489 throw_type_error(cx.raw_cx(), &error);
19490 return false;
19491
19492 }
19493 _ => {
19494 return false;
19495
19496 },
19497 }
19498
19499 };
19500 let result: () = this.PassOptionalUnsignedShortWithDefault(arg0);
19501
19502 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19503 return true;
19504 })());
19505 result
19506}
19507
19508
19509static passOptionalUnsignedShortWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19510
19511pub(crate) fn init_passOptionalUnsignedShortWithDefault_methodinfo<D: DomTypes>() {
19512 passOptionalUnsignedShortWithDefault_methodinfo.set(JSJitInfo {
19513 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19514 method: Some(passOptionalUnsignedShortWithDefault::<D>)
19515 },
19516 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19517 protoID: PrototypeList::ID::TestBinding as u16,
19518 },
19519 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19520 _bitfield_align_1: [],
19521 _bitfield_1: __BindgenBitfieldUnit::new(
19522 new_jsjitinfo_bitfield_1!(
19523 JSJitInfo_OpType::Method as u8,
19524 JSJitInfo_AliasSet::AliasEverything as u8,
19525 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19526 false,
19527 false,
19528 false,
19529 false,
19530 false,
19531 false,
19532 0,
19533 ).to_ne_bytes()
19534 ),
19535});
19536}
19537unsafe extern "C" fn passOptionalLongWithDefault<D: DomTypes>
19538(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19539 let mut result = false;
19540 wrap_panic(&mut || result = (|| {
19541 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19542 let this = &*(this as *const D::TestBinding);
19543 let args = &*args;
19544 let argc = args.argc_;
19545 let arg0: i32 = if args.get(0).is_undefined() {
19546 7
19547 } else {
19548 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19549 Ok(ConversionResult::Success(value)) => value,
19550 Ok(ConversionResult::Failure(error)) => {
19551 throw_type_error(cx.raw_cx(), &error);
19552 return false;
19553
19554 }
19555 _ => {
19556 return false;
19557
19558 },
19559 }
19560
19561 };
19562 let result: () = this.PassOptionalLongWithDefault(arg0);
19563
19564 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19565 return true;
19566 })());
19567 result
19568}
19569
19570
19571static passOptionalLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19572
19573pub(crate) fn init_passOptionalLongWithDefault_methodinfo<D: DomTypes>() {
19574 passOptionalLongWithDefault_methodinfo.set(JSJitInfo {
19575 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19576 method: Some(passOptionalLongWithDefault::<D>)
19577 },
19578 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19579 protoID: PrototypeList::ID::TestBinding as u16,
19580 },
19581 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19582 _bitfield_align_1: [],
19583 _bitfield_1: __BindgenBitfieldUnit::new(
19584 new_jsjitinfo_bitfield_1!(
19585 JSJitInfo_OpType::Method as u8,
19586 JSJitInfo_AliasSet::AliasEverything as u8,
19587 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19588 false,
19589 false,
19590 false,
19591 false,
19592 false,
19593 false,
19594 0,
19595 ).to_ne_bytes()
19596 ),
19597});
19598}
19599unsafe extern "C" fn passOptionalUnsignedLongWithDefault<D: DomTypes>
19600(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19601 let mut result = false;
19602 wrap_panic(&mut || result = (|| {
19603 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19604 let this = &*(this as *const D::TestBinding);
19605 let args = &*args;
19606 let argc = args.argc_;
19607 let arg0: u32 = if args.get(0).is_undefined() {
19608 6
19609 } else {
19610 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19611 Ok(ConversionResult::Success(value)) => value,
19612 Ok(ConversionResult::Failure(error)) => {
19613 throw_type_error(cx.raw_cx(), &error);
19614 return false;
19615
19616 }
19617 _ => {
19618 return false;
19619
19620 },
19621 }
19622
19623 };
19624 let result: () = this.PassOptionalUnsignedLongWithDefault(arg0);
19625
19626 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19627 return true;
19628 })());
19629 result
19630}
19631
19632
19633static passOptionalUnsignedLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19634
19635pub(crate) fn init_passOptionalUnsignedLongWithDefault_methodinfo<D: DomTypes>() {
19636 passOptionalUnsignedLongWithDefault_methodinfo.set(JSJitInfo {
19637 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19638 method: Some(passOptionalUnsignedLongWithDefault::<D>)
19639 },
19640 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19641 protoID: PrototypeList::ID::TestBinding as u16,
19642 },
19643 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19644 _bitfield_align_1: [],
19645 _bitfield_1: __BindgenBitfieldUnit::new(
19646 new_jsjitinfo_bitfield_1!(
19647 JSJitInfo_OpType::Method as u8,
19648 JSJitInfo_AliasSet::AliasEverything as u8,
19649 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19650 false,
19651 false,
19652 false,
19653 false,
19654 false,
19655 false,
19656 0,
19657 ).to_ne_bytes()
19658 ),
19659});
19660}
19661unsafe extern "C" fn passOptionalLongLongWithDefault<D: DomTypes>
19662(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19663 let mut result = false;
19664 wrap_panic(&mut || result = (|| {
19665 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19666 let this = &*(this as *const D::TestBinding);
19667 let args = &*args;
19668 let argc = args.argc_;
19669 let arg0: i64 = if args.get(0).is_undefined() {
19670 -12
19671 } else {
19672 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19673 Ok(ConversionResult::Success(value)) => value,
19674 Ok(ConversionResult::Failure(error)) => {
19675 throw_type_error(cx.raw_cx(), &error);
19676 return false;
19677
19678 }
19679 _ => {
19680 return false;
19681
19682 },
19683 }
19684
19685 };
19686 let result: () = this.PassOptionalLongLongWithDefault(arg0);
19687
19688 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19689 return true;
19690 })());
19691 result
19692}
19693
19694
19695static passOptionalLongLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19696
19697pub(crate) fn init_passOptionalLongLongWithDefault_methodinfo<D: DomTypes>() {
19698 passOptionalLongLongWithDefault_methodinfo.set(JSJitInfo {
19699 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19700 method: Some(passOptionalLongLongWithDefault::<D>)
19701 },
19702 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19703 protoID: PrototypeList::ID::TestBinding as u16,
19704 },
19705 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19706 _bitfield_align_1: [],
19707 _bitfield_1: __BindgenBitfieldUnit::new(
19708 new_jsjitinfo_bitfield_1!(
19709 JSJitInfo_OpType::Method as u8,
19710 JSJitInfo_AliasSet::AliasEverything as u8,
19711 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19712 false,
19713 false,
19714 false,
19715 false,
19716 false,
19717 false,
19718 0,
19719 ).to_ne_bytes()
19720 ),
19721});
19722}
19723unsafe extern "C" fn passOptionalUnsignedLongLongWithDefault<D: DomTypes>
19724(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19725 let mut result = false;
19726 wrap_panic(&mut || result = (|| {
19727 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19728 let this = &*(this as *const D::TestBinding);
19729 let args = &*args;
19730 let argc = args.argc_;
19731 let arg0: u64 = if args.get(0).is_undefined() {
19732 17
19733 } else {
19734 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
19735 Ok(ConversionResult::Success(value)) => value,
19736 Ok(ConversionResult::Failure(error)) => {
19737 throw_type_error(cx.raw_cx(), &error);
19738 return false;
19739
19740 }
19741 _ => {
19742 return false;
19743
19744 },
19745 }
19746
19747 };
19748 let result: () = this.PassOptionalUnsignedLongLongWithDefault(arg0);
19749
19750 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19751 return true;
19752 })());
19753 result
19754}
19755
19756
19757static passOptionalUnsignedLongLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19758
19759pub(crate) fn init_passOptionalUnsignedLongLongWithDefault_methodinfo<D: DomTypes>() {
19760 passOptionalUnsignedLongLongWithDefault_methodinfo.set(JSJitInfo {
19761 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19762 method: Some(passOptionalUnsignedLongLongWithDefault::<D>)
19763 },
19764 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19765 protoID: PrototypeList::ID::TestBinding as u16,
19766 },
19767 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19768 _bitfield_align_1: [],
19769 _bitfield_1: __BindgenBitfieldUnit::new(
19770 new_jsjitinfo_bitfield_1!(
19771 JSJitInfo_OpType::Method as u8,
19772 JSJitInfo_AliasSet::AliasEverything as u8,
19773 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19774 false,
19775 false,
19776 false,
19777 false,
19778 false,
19779 false,
19780 0,
19781 ).to_ne_bytes()
19782 ),
19783});
19784}
19785unsafe extern "C" fn passOptionalBytestringWithDefault<D: DomTypes>
19786(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19787 let mut result = false;
19788 wrap_panic(&mut || result = (|| {
19789 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19790 let this = &*(this as *const D::TestBinding);
19791 let args = &*args;
19792 let argc = args.argc_;
19793 let arg0: ByteString = if args.get(0).is_undefined() {
19794 ByteString::new(b"x".to_vec())
19795 } else {
19796 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
19797 Ok(ConversionResult::Success(value)) => value,
19798 Ok(ConversionResult::Failure(error)) => {
19799 throw_type_error(cx.raw_cx(), &error);
19800 return false;
19801
19802 }
19803 _ => {
19804 return false;
19805
19806 },
19807 }
19808
19809 };
19810 let result: () = this.PassOptionalBytestringWithDefault(arg0);
19811
19812 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19813 return true;
19814 })());
19815 result
19816}
19817
19818
19819static passOptionalBytestringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19820
19821pub(crate) fn init_passOptionalBytestringWithDefault_methodinfo<D: DomTypes>() {
19822 passOptionalBytestringWithDefault_methodinfo.set(JSJitInfo {
19823 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19824 method: Some(passOptionalBytestringWithDefault::<D>)
19825 },
19826 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19827 protoID: PrototypeList::ID::TestBinding as u16,
19828 },
19829 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19830 _bitfield_align_1: [],
19831 _bitfield_1: __BindgenBitfieldUnit::new(
19832 new_jsjitinfo_bitfield_1!(
19833 JSJitInfo_OpType::Method as u8,
19834 JSJitInfo_AliasSet::AliasEverything as u8,
19835 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19836 false,
19837 false,
19838 false,
19839 false,
19840 false,
19841 false,
19842 0,
19843 ).to_ne_bytes()
19844 ),
19845});
19846}
19847unsafe extern "C" fn passOptionalStringWithDefault<D: DomTypes>
19848(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19849 let mut result = false;
19850 wrap_panic(&mut || result = (|| {
19851 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19852 let this = &*(this as *const D::TestBinding);
19853 let args = &*args;
19854 let argc = args.argc_;
19855 let arg0: DOMString = if args.get(0).is_undefined() {
19856 DOMString::from("x")
19857 } else {
19858 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
19859 Ok(ConversionResult::Success(value)) => value,
19860 Ok(ConversionResult::Failure(error)) => {
19861 throw_type_error(cx.raw_cx(), &error);
19862 return false;
19863
19864 }
19865 _ => {
19866 return false;
19867
19868 },
19869 }
19870
19871 };
19872 let result: () = this.PassOptionalStringWithDefault(arg0);
19873
19874 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19875 return true;
19876 })());
19877 result
19878}
19879
19880
19881static passOptionalStringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19882
19883pub(crate) fn init_passOptionalStringWithDefault_methodinfo<D: DomTypes>() {
19884 passOptionalStringWithDefault_methodinfo.set(JSJitInfo {
19885 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19886 method: Some(passOptionalStringWithDefault::<D>)
19887 },
19888 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19889 protoID: PrototypeList::ID::TestBinding as u16,
19890 },
19891 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19892 _bitfield_align_1: [],
19893 _bitfield_1: __BindgenBitfieldUnit::new(
19894 new_jsjitinfo_bitfield_1!(
19895 JSJitInfo_OpType::Method as u8,
19896 JSJitInfo_AliasSet::AliasEverything as u8,
19897 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19898 false,
19899 false,
19900 false,
19901 false,
19902 false,
19903 false,
19904 0,
19905 ).to_ne_bytes()
19906 ),
19907});
19908}
19909unsafe extern "C" fn passOptionalUsvstringWithDefault<D: DomTypes>
19910(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19911 let mut result = false;
19912 wrap_panic(&mut || result = (|| {
19913 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19914 let this = &*(this as *const D::TestBinding);
19915 let args = &*args;
19916 let argc = args.argc_;
19917 let arg0: USVString = if args.get(0).is_undefined() {
19918 USVString("x".to_owned())
19919 } else {
19920 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
19921 Ok(ConversionResult::Success(value)) => value,
19922 Ok(ConversionResult::Failure(error)) => {
19923 throw_type_error(cx.raw_cx(), &error);
19924 return false;
19925
19926 }
19927 _ => {
19928 return false;
19929
19930 },
19931 }
19932
19933 };
19934 let result: () = this.PassOptionalUsvstringWithDefault(arg0);
19935
19936 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19937 return true;
19938 })());
19939 result
19940}
19941
19942
19943static passOptionalUsvstringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
19944
19945pub(crate) fn init_passOptionalUsvstringWithDefault_methodinfo<D: DomTypes>() {
19946 passOptionalUsvstringWithDefault_methodinfo.set(JSJitInfo {
19947 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
19948 method: Some(passOptionalUsvstringWithDefault::<D>)
19949 },
19950 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
19951 protoID: PrototypeList::ID::TestBinding as u16,
19952 },
19953 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
19954 _bitfield_align_1: [],
19955 _bitfield_1: __BindgenBitfieldUnit::new(
19956 new_jsjitinfo_bitfield_1!(
19957 JSJitInfo_OpType::Method as u8,
19958 JSJitInfo_AliasSet::AliasEverything as u8,
19959 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
19960 false,
19961 false,
19962 false,
19963 false,
19964 false,
19965 false,
19966 0,
19967 ).to_ne_bytes()
19968 ),
19969});
19970}
19971unsafe extern "C" fn passOptionalEnumWithDefault<D: DomTypes>
19972(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
19973 let mut result = false;
19974 wrap_panic(&mut || result = (|| {
19975 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
19976 let this = &*(this as *const D::TestBinding);
19977 let args = &*args;
19978 let argc = args.argc_;
19979 let arg0: TestEnum = if args.get(0).is_undefined() {
19980 TestEnum::Foo
19981 } else {
19982 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
19983 Ok(ConversionResult::Success(value)) => value,
19984 Ok(ConversionResult::Failure(error)) => {
19985 throw_type_error(cx.raw_cx(), &error); return false;
19986
19987 }
19988 _ => {
19989 return false;
19990
19991 },
19992 }
19993
19994 };
19995 let result: () = this.PassOptionalEnumWithDefault(arg0);
19996
19997 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
19998 return true;
19999 })());
20000 result
20001}
20002
20003
20004static passOptionalEnumWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20005
20006pub(crate) fn init_passOptionalEnumWithDefault_methodinfo<D: DomTypes>() {
20007 passOptionalEnumWithDefault_methodinfo.set(JSJitInfo {
20008 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20009 method: Some(passOptionalEnumWithDefault::<D>)
20010 },
20011 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20012 protoID: PrototypeList::ID::TestBinding as u16,
20013 },
20014 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20015 _bitfield_align_1: [],
20016 _bitfield_1: __BindgenBitfieldUnit::new(
20017 new_jsjitinfo_bitfield_1!(
20018 JSJitInfo_OpType::Method as u8,
20019 JSJitInfo_AliasSet::AliasEverything as u8,
20020 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20021 false,
20022 false,
20023 false,
20024 false,
20025 false,
20026 false,
20027 0,
20028 ).to_ne_bytes()
20029 ),
20030});
20031}
20032unsafe extern "C" fn passOptionalSequenceWithDefault<D: DomTypes>
20033(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20034 let mut result = false;
20035 wrap_panic(&mut || result = (|| {
20036 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20037 let this = &*(this as *const D::TestBinding);
20038 let args = &*args;
20039 let argc = args.argc_;
20040 let arg0: Vec<i32> = if args.get(0).is_undefined() {
20041 Vec::new()
20042 } else {
20043 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20044 Ok(ConversionResult::Success(value)) => value,
20045 Ok(ConversionResult::Failure(error)) => {
20046 throw_type_error(cx.raw_cx(), &error);
20047 return false;
20048
20049 }
20050 _ => {
20051 return false;
20052
20053 },
20054 }
20055
20056 };
20057 let result: () = this.PassOptionalSequenceWithDefault(arg0);
20058
20059 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20060 return true;
20061 })());
20062 result
20063}
20064
20065
20066static passOptionalSequenceWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20067
20068pub(crate) fn init_passOptionalSequenceWithDefault_methodinfo<D: DomTypes>() {
20069 passOptionalSequenceWithDefault_methodinfo.set(JSJitInfo {
20070 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20071 method: Some(passOptionalSequenceWithDefault::<D>)
20072 },
20073 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20074 protoID: PrototypeList::ID::TestBinding as u16,
20075 },
20076 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20077 _bitfield_align_1: [],
20078 _bitfield_1: __BindgenBitfieldUnit::new(
20079 new_jsjitinfo_bitfield_1!(
20080 JSJitInfo_OpType::Method as u8,
20081 JSJitInfo_AliasSet::AliasEverything as u8,
20082 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20083 false,
20084 false,
20085 false,
20086 false,
20087 false,
20088 false,
20089 0,
20090 ).to_ne_bytes()
20091 ),
20092});
20093}
20094unsafe extern "C" fn passOptionalNullableBooleanWithDefault<D: DomTypes>
20095(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20096 let mut result = false;
20097 wrap_panic(&mut || result = (|| {
20098 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20099 let this = &*(this as *const D::TestBinding);
20100 let args = &*args;
20101 let argc = args.argc_;
20102 let arg0: Option<bool> = if args.get(0).is_undefined() {
20103 None
20104 } else {
20105 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
20106 Ok(ConversionResult::Success(value)) => value,
20107 Ok(ConversionResult::Failure(error)) => {
20108 throw_type_error(cx.raw_cx(), &error);
20109 return false;
20110
20111 }
20112 _ => {
20113 return false;
20114
20115 },
20116 }
20117
20118 };
20119 let result: () = this.PassOptionalNullableBooleanWithDefault(arg0);
20120
20121 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20122 return true;
20123 })());
20124 result
20125}
20126
20127
20128static passOptionalNullableBooleanWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20129
20130pub(crate) fn init_passOptionalNullableBooleanWithDefault_methodinfo<D: DomTypes>() {
20131 passOptionalNullableBooleanWithDefault_methodinfo.set(JSJitInfo {
20132 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20133 method: Some(passOptionalNullableBooleanWithDefault::<D>)
20134 },
20135 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20136 protoID: PrototypeList::ID::TestBinding as u16,
20137 },
20138 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20139 _bitfield_align_1: [],
20140 _bitfield_1: __BindgenBitfieldUnit::new(
20141 new_jsjitinfo_bitfield_1!(
20142 JSJitInfo_OpType::Method as u8,
20143 JSJitInfo_AliasSet::AliasEverything as u8,
20144 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20145 false,
20146 false,
20147 false,
20148 false,
20149 false,
20150 false,
20151 0,
20152 ).to_ne_bytes()
20153 ),
20154});
20155}
20156unsafe extern "C" fn passOptionalNullableByteWithDefault<D: DomTypes>
20157(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20158 let mut result = false;
20159 wrap_panic(&mut || result = (|| {
20160 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20161 let this = &*(this as *const D::TestBinding);
20162 let args = &*args;
20163 let argc = args.argc_;
20164 let arg0: Option<i8> = if args.get(0).is_undefined() {
20165 None
20166 } else {
20167 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20168 Ok(ConversionResult::Success(value)) => value,
20169 Ok(ConversionResult::Failure(error)) => {
20170 throw_type_error(cx.raw_cx(), &error);
20171 return false;
20172
20173 }
20174 _ => {
20175 return false;
20176
20177 },
20178 }
20179
20180 };
20181 let result: () = this.PassOptionalNullableByteWithDefault(arg0);
20182
20183 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20184 return true;
20185 })());
20186 result
20187}
20188
20189
20190static passOptionalNullableByteWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20191
20192pub(crate) fn init_passOptionalNullableByteWithDefault_methodinfo<D: DomTypes>() {
20193 passOptionalNullableByteWithDefault_methodinfo.set(JSJitInfo {
20194 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20195 method: Some(passOptionalNullableByteWithDefault::<D>)
20196 },
20197 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20198 protoID: PrototypeList::ID::TestBinding as u16,
20199 },
20200 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20201 _bitfield_align_1: [],
20202 _bitfield_1: __BindgenBitfieldUnit::new(
20203 new_jsjitinfo_bitfield_1!(
20204 JSJitInfo_OpType::Method as u8,
20205 JSJitInfo_AliasSet::AliasEverything as u8,
20206 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20207 false,
20208 false,
20209 false,
20210 false,
20211 false,
20212 false,
20213 0,
20214 ).to_ne_bytes()
20215 ),
20216});
20217}
20218unsafe extern "C" fn passOptionalNullableOctetWithDefault<D: DomTypes>
20219(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20220 let mut result = false;
20221 wrap_panic(&mut || result = (|| {
20222 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20223 let this = &*(this as *const D::TestBinding);
20224 let args = &*args;
20225 let argc = args.argc_;
20226 let arg0: Option<u8> = if args.get(0).is_undefined() {
20227 None
20228 } else {
20229 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20230 Ok(ConversionResult::Success(value)) => value,
20231 Ok(ConversionResult::Failure(error)) => {
20232 throw_type_error(cx.raw_cx(), &error);
20233 return false;
20234
20235 }
20236 _ => {
20237 return false;
20238
20239 },
20240 }
20241
20242 };
20243 let result: () = this.PassOptionalNullableOctetWithDefault(arg0);
20244
20245 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20246 return true;
20247 })());
20248 result
20249}
20250
20251
20252static passOptionalNullableOctetWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20253
20254pub(crate) fn init_passOptionalNullableOctetWithDefault_methodinfo<D: DomTypes>() {
20255 passOptionalNullableOctetWithDefault_methodinfo.set(JSJitInfo {
20256 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20257 method: Some(passOptionalNullableOctetWithDefault::<D>)
20258 },
20259 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20260 protoID: PrototypeList::ID::TestBinding as u16,
20261 },
20262 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20263 _bitfield_align_1: [],
20264 _bitfield_1: __BindgenBitfieldUnit::new(
20265 new_jsjitinfo_bitfield_1!(
20266 JSJitInfo_OpType::Method as u8,
20267 JSJitInfo_AliasSet::AliasEverything as u8,
20268 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20269 false,
20270 false,
20271 false,
20272 false,
20273 false,
20274 false,
20275 0,
20276 ).to_ne_bytes()
20277 ),
20278});
20279}
20280unsafe extern "C" fn passOptionalNullableShortWithDefault<D: DomTypes>
20281(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20282 let mut result = false;
20283 wrap_panic(&mut || result = (|| {
20284 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20285 let this = &*(this as *const D::TestBinding);
20286 let args = &*args;
20287 let argc = args.argc_;
20288 let arg0: Option<i16> = if args.get(0).is_undefined() {
20289 None
20290 } else {
20291 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20292 Ok(ConversionResult::Success(value)) => value,
20293 Ok(ConversionResult::Failure(error)) => {
20294 throw_type_error(cx.raw_cx(), &error);
20295 return false;
20296
20297 }
20298 _ => {
20299 return false;
20300
20301 },
20302 }
20303
20304 };
20305 let result: () = this.PassOptionalNullableShortWithDefault(arg0);
20306
20307 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20308 return true;
20309 })());
20310 result
20311}
20312
20313
20314static passOptionalNullableShortWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20315
20316pub(crate) fn init_passOptionalNullableShortWithDefault_methodinfo<D: DomTypes>() {
20317 passOptionalNullableShortWithDefault_methodinfo.set(JSJitInfo {
20318 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20319 method: Some(passOptionalNullableShortWithDefault::<D>)
20320 },
20321 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20322 protoID: PrototypeList::ID::TestBinding as u16,
20323 },
20324 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20325 _bitfield_align_1: [],
20326 _bitfield_1: __BindgenBitfieldUnit::new(
20327 new_jsjitinfo_bitfield_1!(
20328 JSJitInfo_OpType::Method as u8,
20329 JSJitInfo_AliasSet::AliasEverything as u8,
20330 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20331 false,
20332 false,
20333 false,
20334 false,
20335 false,
20336 false,
20337 0,
20338 ).to_ne_bytes()
20339 ),
20340});
20341}
20342unsafe extern "C" fn passOptionalNullableUnsignedShortWithDefault<D: DomTypes>
20343(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20344 let mut result = false;
20345 wrap_panic(&mut || result = (|| {
20346 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20347 let this = &*(this as *const D::TestBinding);
20348 let args = &*args;
20349 let argc = args.argc_;
20350 let arg0: Option<u16> = if args.get(0).is_undefined() {
20351 None
20352 } else {
20353 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20354 Ok(ConversionResult::Success(value)) => value,
20355 Ok(ConversionResult::Failure(error)) => {
20356 throw_type_error(cx.raw_cx(), &error);
20357 return false;
20358
20359 }
20360 _ => {
20361 return false;
20362
20363 },
20364 }
20365
20366 };
20367 let result: () = this.PassOptionalNullableUnsignedShortWithDefault(arg0);
20368
20369 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20370 return true;
20371 })());
20372 result
20373}
20374
20375
20376static passOptionalNullableUnsignedShortWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20377
20378pub(crate) fn init_passOptionalNullableUnsignedShortWithDefault_methodinfo<D: DomTypes>() {
20379 passOptionalNullableUnsignedShortWithDefault_methodinfo.set(JSJitInfo {
20380 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20381 method: Some(passOptionalNullableUnsignedShortWithDefault::<D>)
20382 },
20383 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20384 protoID: PrototypeList::ID::TestBinding as u16,
20385 },
20386 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20387 _bitfield_align_1: [],
20388 _bitfield_1: __BindgenBitfieldUnit::new(
20389 new_jsjitinfo_bitfield_1!(
20390 JSJitInfo_OpType::Method as u8,
20391 JSJitInfo_AliasSet::AliasEverything as u8,
20392 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20393 false,
20394 false,
20395 false,
20396 false,
20397 false,
20398 false,
20399 0,
20400 ).to_ne_bytes()
20401 ),
20402});
20403}
20404unsafe extern "C" fn passOptionalNullableLongWithDefault<D: DomTypes>
20405(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20406 let mut result = false;
20407 wrap_panic(&mut || result = (|| {
20408 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20409 let this = &*(this as *const D::TestBinding);
20410 let args = &*args;
20411 let argc = args.argc_;
20412 let arg0: Option<i32> = if args.get(0).is_undefined() {
20413 None
20414 } else {
20415 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20416 Ok(ConversionResult::Success(value)) => value,
20417 Ok(ConversionResult::Failure(error)) => {
20418 throw_type_error(cx.raw_cx(), &error);
20419 return false;
20420
20421 }
20422 _ => {
20423 return false;
20424
20425 },
20426 }
20427
20428 };
20429 let result: () = this.PassOptionalNullableLongWithDefault(arg0);
20430
20431 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20432 return true;
20433 })());
20434 result
20435}
20436
20437
20438static passOptionalNullableLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20439
20440pub(crate) fn init_passOptionalNullableLongWithDefault_methodinfo<D: DomTypes>() {
20441 passOptionalNullableLongWithDefault_methodinfo.set(JSJitInfo {
20442 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20443 method: Some(passOptionalNullableLongWithDefault::<D>)
20444 },
20445 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20446 protoID: PrototypeList::ID::TestBinding as u16,
20447 },
20448 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20449 _bitfield_align_1: [],
20450 _bitfield_1: __BindgenBitfieldUnit::new(
20451 new_jsjitinfo_bitfield_1!(
20452 JSJitInfo_OpType::Method as u8,
20453 JSJitInfo_AliasSet::AliasEverything as u8,
20454 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20455 false,
20456 false,
20457 false,
20458 false,
20459 false,
20460 false,
20461 0,
20462 ).to_ne_bytes()
20463 ),
20464});
20465}
20466unsafe extern "C" fn passOptionalNullableUnsignedLongWithDefault<D: DomTypes>
20467(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20468 let mut result = false;
20469 wrap_panic(&mut || result = (|| {
20470 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20471 let this = &*(this as *const D::TestBinding);
20472 let args = &*args;
20473 let argc = args.argc_;
20474 let arg0: Option<u32> = if args.get(0).is_undefined() {
20475 None
20476 } else {
20477 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20478 Ok(ConversionResult::Success(value)) => value,
20479 Ok(ConversionResult::Failure(error)) => {
20480 throw_type_error(cx.raw_cx(), &error);
20481 return false;
20482
20483 }
20484 _ => {
20485 return false;
20486
20487 },
20488 }
20489
20490 };
20491 let result: () = this.PassOptionalNullableUnsignedLongWithDefault(arg0);
20492
20493 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20494 return true;
20495 })());
20496 result
20497}
20498
20499
20500static passOptionalNullableUnsignedLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20501
20502pub(crate) fn init_passOptionalNullableUnsignedLongWithDefault_methodinfo<D: DomTypes>() {
20503 passOptionalNullableUnsignedLongWithDefault_methodinfo.set(JSJitInfo {
20504 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20505 method: Some(passOptionalNullableUnsignedLongWithDefault::<D>)
20506 },
20507 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20508 protoID: PrototypeList::ID::TestBinding as u16,
20509 },
20510 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20511 _bitfield_align_1: [],
20512 _bitfield_1: __BindgenBitfieldUnit::new(
20513 new_jsjitinfo_bitfield_1!(
20514 JSJitInfo_OpType::Method as u8,
20515 JSJitInfo_AliasSet::AliasEverything as u8,
20516 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20517 false,
20518 false,
20519 false,
20520 false,
20521 false,
20522 false,
20523 0,
20524 ).to_ne_bytes()
20525 ),
20526});
20527}
20528unsafe extern "C" fn passOptionalNullableLongLongWithDefault<D: DomTypes>
20529(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20530 let mut result = false;
20531 wrap_panic(&mut || result = (|| {
20532 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20533 let this = &*(this as *const D::TestBinding);
20534 let args = &*args;
20535 let argc = args.argc_;
20536 let arg0: Option<i64> = if args.get(0).is_undefined() {
20537 None
20538 } else {
20539 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20540 Ok(ConversionResult::Success(value)) => value,
20541 Ok(ConversionResult::Failure(error)) => {
20542 throw_type_error(cx.raw_cx(), &error);
20543 return false;
20544
20545 }
20546 _ => {
20547 return false;
20548
20549 },
20550 }
20551
20552 };
20553 let result: () = this.PassOptionalNullableLongLongWithDefault(arg0);
20554
20555 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20556 return true;
20557 })());
20558 result
20559}
20560
20561
20562static passOptionalNullableLongLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20563
20564pub(crate) fn init_passOptionalNullableLongLongWithDefault_methodinfo<D: DomTypes>() {
20565 passOptionalNullableLongLongWithDefault_methodinfo.set(JSJitInfo {
20566 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20567 method: Some(passOptionalNullableLongLongWithDefault::<D>)
20568 },
20569 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20570 protoID: PrototypeList::ID::TestBinding as u16,
20571 },
20572 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20573 _bitfield_align_1: [],
20574 _bitfield_1: __BindgenBitfieldUnit::new(
20575 new_jsjitinfo_bitfield_1!(
20576 JSJitInfo_OpType::Method as u8,
20577 JSJitInfo_AliasSet::AliasEverything as u8,
20578 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20579 false,
20580 false,
20581 false,
20582 false,
20583 false,
20584 false,
20585 0,
20586 ).to_ne_bytes()
20587 ),
20588});
20589}
20590unsafe extern "C" fn passOptionalNullableUnsignedLongLongWithDefault<D: DomTypes>
20591(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20592 let mut result = false;
20593 wrap_panic(&mut || result = (|| {
20594 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20595 let this = &*(this as *const D::TestBinding);
20596 let args = &*args;
20597 let argc = args.argc_;
20598 let arg0: Option<u64> = if args.get(0).is_undefined() {
20599 None
20600 } else {
20601 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
20602 Ok(ConversionResult::Success(value)) => value,
20603 Ok(ConversionResult::Failure(error)) => {
20604 throw_type_error(cx.raw_cx(), &error);
20605 return false;
20606
20607 }
20608 _ => {
20609 return false;
20610
20611 },
20612 }
20613
20614 };
20615 let result: () = this.PassOptionalNullableUnsignedLongLongWithDefault(arg0);
20616
20617 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20618 return true;
20619 })());
20620 result
20621}
20622
20623
20624static passOptionalNullableUnsignedLongLongWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20625
20626pub(crate) fn init_passOptionalNullableUnsignedLongLongWithDefault_methodinfo<D: DomTypes>() {
20627 passOptionalNullableUnsignedLongLongWithDefault_methodinfo.set(JSJitInfo {
20628 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20629 method: Some(passOptionalNullableUnsignedLongLongWithDefault::<D>)
20630 },
20631 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20632 protoID: PrototypeList::ID::TestBinding as u16,
20633 },
20634 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20635 _bitfield_align_1: [],
20636 _bitfield_1: __BindgenBitfieldUnit::new(
20637 new_jsjitinfo_bitfield_1!(
20638 JSJitInfo_OpType::Method as u8,
20639 JSJitInfo_AliasSet::AliasEverything as u8,
20640 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20641 false,
20642 false,
20643 false,
20644 false,
20645 false,
20646 false,
20647 0,
20648 ).to_ne_bytes()
20649 ),
20650});
20651}
20652unsafe extern "C" fn passOptionalNullableStringWithDefault<D: DomTypes>
20653(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20654 let mut result = false;
20655 wrap_panic(&mut || result = (|| {
20656 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20657 let this = &*(this as *const D::TestBinding);
20658 let args = &*args;
20659 let argc = args.argc_;
20660 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
20661 None
20662 } else {
20663 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
20664 Ok(ConversionResult::Success(value)) => value,
20665 Ok(ConversionResult::Failure(error)) => {
20666 throw_type_error(cx.raw_cx(), &error);
20667 return false;
20668
20669 }
20670 _ => {
20671 return false;
20672
20673 },
20674 }
20675
20676 };
20677 let result: () = this.PassOptionalNullableStringWithDefault(arg0);
20678
20679 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20680 return true;
20681 })());
20682 result
20683}
20684
20685
20686static passOptionalNullableStringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20687
20688pub(crate) fn init_passOptionalNullableStringWithDefault_methodinfo<D: DomTypes>() {
20689 passOptionalNullableStringWithDefault_methodinfo.set(JSJitInfo {
20690 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20691 method: Some(passOptionalNullableStringWithDefault::<D>)
20692 },
20693 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20694 protoID: PrototypeList::ID::TestBinding as u16,
20695 },
20696 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20697 _bitfield_align_1: [],
20698 _bitfield_1: __BindgenBitfieldUnit::new(
20699 new_jsjitinfo_bitfield_1!(
20700 JSJitInfo_OpType::Method as u8,
20701 JSJitInfo_AliasSet::AliasEverything as u8,
20702 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20703 false,
20704 false,
20705 false,
20706 false,
20707 false,
20708 false,
20709 0,
20710 ).to_ne_bytes()
20711 ),
20712});
20713}
20714unsafe extern "C" fn passOptionalNullableUsvstringWithDefault<D: DomTypes>
20715(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20716 let mut result = false;
20717 wrap_panic(&mut || result = (|| {
20718 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20719 let this = &*(this as *const D::TestBinding);
20720 let args = &*args;
20721 let argc = args.argc_;
20722 let arg0: Option<USVString> = if args.get(0).is_undefined() {
20723 None
20724 } else {
20725 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
20726 Ok(ConversionResult::Success(value)) => value,
20727 Ok(ConversionResult::Failure(error)) => {
20728 throw_type_error(cx.raw_cx(), &error);
20729 return false;
20730
20731 }
20732 _ => {
20733 return false;
20734
20735 },
20736 }
20737
20738 };
20739 let result: () = this.PassOptionalNullableUsvstringWithDefault(arg0);
20740
20741 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20742 return true;
20743 })());
20744 result
20745}
20746
20747
20748static passOptionalNullableUsvstringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20749
20750pub(crate) fn init_passOptionalNullableUsvstringWithDefault_methodinfo<D: DomTypes>() {
20751 passOptionalNullableUsvstringWithDefault_methodinfo.set(JSJitInfo {
20752 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20753 method: Some(passOptionalNullableUsvstringWithDefault::<D>)
20754 },
20755 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20756 protoID: PrototypeList::ID::TestBinding as u16,
20757 },
20758 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20759 _bitfield_align_1: [],
20760 _bitfield_1: __BindgenBitfieldUnit::new(
20761 new_jsjitinfo_bitfield_1!(
20762 JSJitInfo_OpType::Method as u8,
20763 JSJitInfo_AliasSet::AliasEverything as u8,
20764 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20765 false,
20766 false,
20767 false,
20768 false,
20769 false,
20770 false,
20771 0,
20772 ).to_ne_bytes()
20773 ),
20774});
20775}
20776unsafe extern "C" fn passOptionalNullableByteStringWithDefault<D: DomTypes>
20777(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20778 let mut result = false;
20779 wrap_panic(&mut || result = (|| {
20780 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20781 let this = &*(this as *const D::TestBinding);
20782 let args = &*args;
20783 let argc = args.argc_;
20784 let arg0: Option<ByteString> = if args.get(0).is_undefined() {
20785 None
20786 } else {
20787 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
20788 Ok(ConversionResult::Success(value)) => value,
20789 Ok(ConversionResult::Failure(error)) => {
20790 throw_type_error(cx.raw_cx(), &error);
20791 return false;
20792
20793 }
20794 _ => {
20795 return false;
20796
20797 },
20798 }
20799
20800 };
20801 let result: () = this.PassOptionalNullableByteStringWithDefault(arg0);
20802
20803 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20804 return true;
20805 })());
20806 result
20807}
20808
20809
20810static passOptionalNullableByteStringWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20811
20812pub(crate) fn init_passOptionalNullableByteStringWithDefault_methodinfo<D: DomTypes>() {
20813 passOptionalNullableByteStringWithDefault_methodinfo.set(JSJitInfo {
20814 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20815 method: Some(passOptionalNullableByteStringWithDefault::<D>)
20816 },
20817 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20818 protoID: PrototypeList::ID::TestBinding as u16,
20819 },
20820 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20821 _bitfield_align_1: [],
20822 _bitfield_1: __BindgenBitfieldUnit::new(
20823 new_jsjitinfo_bitfield_1!(
20824 JSJitInfo_OpType::Method as u8,
20825 JSJitInfo_AliasSet::AliasEverything as u8,
20826 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20827 false,
20828 false,
20829 false,
20830 false,
20831 false,
20832 false,
20833 0,
20834 ).to_ne_bytes()
20835 ),
20836});
20837}
20838unsafe extern "C" fn passOptionalNullableInterfaceWithDefault<D: DomTypes>
20839(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20840 let mut result = false;
20841 wrap_panic(&mut || result = (|| {
20842 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20843 let this = &*(this as *const D::TestBinding);
20844 let args = &*args;
20845 let argc = args.argc_;
20846 let arg0: Option<DomRoot<D::Blob>> = if args.get(0).is_undefined() {
20847 None
20848 } else if HandleValue::from_raw(args.get(0)).get().is_object() {
20849 Some(match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
20850 Ok(val) => val,
20851 Err(()) => {
20852 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
20853 return false;
20854
20855 }
20856 }
20857 )
20858 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
20859 None
20860 } else {
20861 throw_type_error(cx.raw_cx(), "Value is not an object.");
20862 return false;
20863
20864 };
20865 let result: () = this.PassOptionalNullableInterfaceWithDefault(arg0.as_deref());
20866
20867 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20868 return true;
20869 })());
20870 result
20871}
20872
20873
20874static passOptionalNullableInterfaceWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20875
20876pub(crate) fn init_passOptionalNullableInterfaceWithDefault_methodinfo<D: DomTypes>() {
20877 passOptionalNullableInterfaceWithDefault_methodinfo.set(JSJitInfo {
20878 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20879 method: Some(passOptionalNullableInterfaceWithDefault::<D>)
20880 },
20881 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20882 protoID: PrototypeList::ID::TestBinding as u16,
20883 },
20884 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20885 _bitfield_align_1: [],
20886 _bitfield_1: __BindgenBitfieldUnit::new(
20887 new_jsjitinfo_bitfield_1!(
20888 JSJitInfo_OpType::Method as u8,
20889 JSJitInfo_AliasSet::AliasEverything as u8,
20890 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20891 false,
20892 false,
20893 false,
20894 false,
20895 false,
20896 false,
20897 0,
20898 ).to_ne_bytes()
20899 ),
20900});
20901}
20902unsafe extern "C" fn passOptionalNullableObjectWithDefault<D: DomTypes>
20903(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20904 let mut result = false;
20905 wrap_panic(&mut || result = (|| {
20906 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20907 let this = &*(this as *const D::TestBinding);
20908 let args = &*args;
20909 let argc = args.argc_;
20910 let arg0: *mut JSObject = if args.get(0).is_undefined() {
20911 ptr::null_mut()
20912 } else if HandleValue::from_raw(args.get(0)).get().is_object() {
20913 HandleValue::from_raw(args.get(0)).get().to_object()
20914 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
20915 ptr::null_mut()
20916 } else {
20917 throw_type_error(cx.raw_cx(), "Value is not an object.");
20918 return false;
20919
20920 };
20921 let result: () = this.PassOptionalNullableObjectWithDefault(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
20922
20923 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20924 return true;
20925 })());
20926 result
20927}
20928
20929
20930static passOptionalNullableObjectWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20931
20932pub(crate) fn init_passOptionalNullableObjectWithDefault_methodinfo<D: DomTypes>() {
20933 passOptionalNullableObjectWithDefault_methodinfo.set(JSJitInfo {
20934 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20935 method: Some(passOptionalNullableObjectWithDefault::<D>)
20936 },
20937 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
20938 protoID: PrototypeList::ID::TestBinding as u16,
20939 },
20940 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
20941 _bitfield_align_1: [],
20942 _bitfield_1: __BindgenBitfieldUnit::new(
20943 new_jsjitinfo_bitfield_1!(
20944 JSJitInfo_OpType::Method as u8,
20945 JSJitInfo_AliasSet::AliasEverything as u8,
20946 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
20947 false,
20948 false,
20949 false,
20950 false,
20951 false,
20952 false,
20953 0,
20954 ).to_ne_bytes()
20955 ),
20956});
20957}
20958unsafe extern "C" fn passOptionalNullableUnionWithDefault<D: DomTypes>
20959(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
20960 let mut result = false;
20961 wrap_panic(&mut || result = (|| {
20962 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
20963 let this = &*(this as *const D::TestBinding);
20964 let args = &*args;
20965 let argc = args.argc_;
20966 let arg0: Option<GenericUnionTypes::HTMLElementOrLong::<D> > = if args.get(0).is_undefined() {
20967 None
20968 } else {
20969 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
20970 Ok(ConversionResult::Success(value)) => value,
20971 Ok(ConversionResult::Failure(error)) => {
20972 throw_type_error(cx.raw_cx(), &error);
20973 return false;
20974
20975 }
20976 _ => {
20977 return false;
20978
20979 },
20980 }
20981
20982 };
20983 let result: () = this.PassOptionalNullableUnionWithDefault(arg0);
20984
20985 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
20986 return true;
20987 })());
20988 result
20989}
20990
20991
20992static passOptionalNullableUnionWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
20993
20994pub(crate) fn init_passOptionalNullableUnionWithDefault_methodinfo<D: DomTypes>() {
20995 passOptionalNullableUnionWithDefault_methodinfo.set(JSJitInfo {
20996 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
20997 method: Some(passOptionalNullableUnionWithDefault::<D>)
20998 },
20999 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21000 protoID: PrototypeList::ID::TestBinding as u16,
21001 },
21002 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21003 _bitfield_align_1: [],
21004 _bitfield_1: __BindgenBitfieldUnit::new(
21005 new_jsjitinfo_bitfield_1!(
21006 JSJitInfo_OpType::Method as u8,
21007 JSJitInfo_AliasSet::AliasEverything as u8,
21008 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21009 false,
21010 false,
21011 false,
21012 false,
21013 false,
21014 false,
21015 0,
21016 ).to_ne_bytes()
21017 ),
21018});
21019}
21020unsafe extern "C" fn passOptionalNullableUnion2WithDefault<D: DomTypes>
21021(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21022 let mut result = false;
21023 wrap_panic(&mut || result = (|| {
21024 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21025 let this = &*(this as *const D::TestBinding);
21026 let args = &*args;
21027 let argc = args.argc_;
21028 let arg0: Option<GenericUnionTypes::EventOrString::<D> > = if args.get(0).is_undefined() {
21029 None
21030 } else {
21031 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
21032 Ok(ConversionResult::Success(value)) => value,
21033 Ok(ConversionResult::Failure(error)) => {
21034 throw_type_error(cx.raw_cx(), &error);
21035 return false;
21036
21037 }
21038 _ => {
21039 return false;
21040
21041 },
21042 }
21043
21044 };
21045 let result: () = this.PassOptionalNullableUnion2WithDefault(arg0);
21046
21047 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21048 return true;
21049 })());
21050 result
21051}
21052
21053
21054static passOptionalNullableUnion2WithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21055
21056pub(crate) fn init_passOptionalNullableUnion2WithDefault_methodinfo<D: DomTypes>() {
21057 passOptionalNullableUnion2WithDefault_methodinfo.set(JSJitInfo {
21058 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21059 method: Some(passOptionalNullableUnion2WithDefault::<D>)
21060 },
21061 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21062 protoID: PrototypeList::ID::TestBinding as u16,
21063 },
21064 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21065 _bitfield_align_1: [],
21066 _bitfield_1: __BindgenBitfieldUnit::new(
21067 new_jsjitinfo_bitfield_1!(
21068 JSJitInfo_OpType::Method as u8,
21069 JSJitInfo_AliasSet::AliasEverything as u8,
21070 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21071 false,
21072 false,
21073 false,
21074 false,
21075 false,
21076 false,
21077 0,
21078 ).to_ne_bytes()
21079 ),
21080});
21081}
21082unsafe extern "C" fn passOptionalNullableCallbackInterfaceWithDefault<D: DomTypes>
21083(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21084 let mut result = false;
21085 wrap_panic(&mut || result = (|| {
21086 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21087 let this = &*(this as *const D::TestBinding);
21088 let args = &*args;
21089 let argc = args.argc_;
21090 let arg0: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>> = if args.get(0).is_undefined() {
21091 None
21092 } else if HandleValue::from_raw(args.get(0)).get().is_object() {
21093 Some(crate::codegen::GenericBindings::EventListenerBinding::EventListener::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
21094 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
21095 None
21096 } else {
21097 throw_type_error(cx.raw_cx(), "Value is not an object.");
21098 return false;
21099
21100 };
21101 let result: () = this.PassOptionalNullableCallbackInterfaceWithDefault(arg0);
21102
21103 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21104 return true;
21105 })());
21106 result
21107}
21108
21109
21110static passOptionalNullableCallbackInterfaceWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21111
21112pub(crate) fn init_passOptionalNullableCallbackInterfaceWithDefault_methodinfo<D: DomTypes>() {
21113 passOptionalNullableCallbackInterfaceWithDefault_methodinfo.set(JSJitInfo {
21114 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21115 method: Some(passOptionalNullableCallbackInterfaceWithDefault::<D>)
21116 },
21117 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21118 protoID: PrototypeList::ID::TestBinding as u16,
21119 },
21120 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21121 _bitfield_align_1: [],
21122 _bitfield_1: __BindgenBitfieldUnit::new(
21123 new_jsjitinfo_bitfield_1!(
21124 JSJitInfo_OpType::Method as u8,
21125 JSJitInfo_AliasSet::AliasEverything as u8,
21126 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21127 false,
21128 false,
21129 false,
21130 false,
21131 false,
21132 false,
21133 0,
21134 ).to_ne_bytes()
21135 ),
21136});
21137}
21138unsafe extern "C" fn passOptionalAnyWithDefault<D: DomTypes>
21139(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21140 let mut result = false;
21141 wrap_panic(&mut || result = (|| {
21142 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21143 let this = &*(this as *const D::TestBinding);
21144 let args = &*args;
21145 let argc = args.argc_;
21146 let arg0: HandleValue = if args.get(0).is_undefined() {
21147 HandleValue::null()
21148 } else {
21149 HandleValue::from_raw(args.get(0))
21150 };
21151 let result: () = this.PassOptionalAnyWithDefault(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
21152
21153 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21154 return true;
21155 })());
21156 result
21157}
21158
21159
21160static passOptionalAnyWithDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21161
21162pub(crate) fn init_passOptionalAnyWithDefault_methodinfo<D: DomTypes>() {
21163 passOptionalAnyWithDefault_methodinfo.set(JSJitInfo {
21164 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21165 method: Some(passOptionalAnyWithDefault::<D>)
21166 },
21167 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21168 protoID: PrototypeList::ID::TestBinding as u16,
21169 },
21170 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21171 _bitfield_align_1: [],
21172 _bitfield_1: __BindgenBitfieldUnit::new(
21173 new_jsjitinfo_bitfield_1!(
21174 JSJitInfo_OpType::Method as u8,
21175 JSJitInfo_AliasSet::AliasEverything as u8,
21176 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21177 false,
21178 false,
21179 false,
21180 false,
21181 false,
21182 false,
21183 0,
21184 ).to_ne_bytes()
21185 ),
21186});
21187}
21188unsafe extern "C" fn passOptionalNullableBooleanWithNonNullDefault<D: DomTypes>
21189(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21190 let mut result = false;
21191 wrap_panic(&mut || result = (|| {
21192 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21193 let this = &*(this as *const D::TestBinding);
21194 let args = &*args;
21195 let argc = args.argc_;
21196 let arg0: Option<bool> = if args.get(0).is_undefined() {
21197 Some(false)
21198 } else {
21199 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
21200 Ok(ConversionResult::Success(value)) => value,
21201 Ok(ConversionResult::Failure(error)) => {
21202 throw_type_error(cx.raw_cx(), &error);
21203 return false;
21204
21205 }
21206 _ => {
21207 return false;
21208
21209 },
21210 }
21211
21212 };
21213 let result: () = this.PassOptionalNullableBooleanWithNonNullDefault(arg0);
21214
21215 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21216 return true;
21217 })());
21218 result
21219}
21220
21221
21222static passOptionalNullableBooleanWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21223
21224pub(crate) fn init_passOptionalNullableBooleanWithNonNullDefault_methodinfo<D: DomTypes>() {
21225 passOptionalNullableBooleanWithNonNullDefault_methodinfo.set(JSJitInfo {
21226 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21227 method: Some(passOptionalNullableBooleanWithNonNullDefault::<D>)
21228 },
21229 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21230 protoID: PrototypeList::ID::TestBinding as u16,
21231 },
21232 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21233 _bitfield_align_1: [],
21234 _bitfield_1: __BindgenBitfieldUnit::new(
21235 new_jsjitinfo_bitfield_1!(
21236 JSJitInfo_OpType::Method as u8,
21237 JSJitInfo_AliasSet::AliasEverything as u8,
21238 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21239 false,
21240 false,
21241 false,
21242 false,
21243 false,
21244 false,
21245 0,
21246 ).to_ne_bytes()
21247 ),
21248});
21249}
21250unsafe extern "C" fn passOptionalNullableByteWithNonNullDefault<D: DomTypes>
21251(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21252 let mut result = false;
21253 wrap_panic(&mut || result = (|| {
21254 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21255 let this = &*(this as *const D::TestBinding);
21256 let args = &*args;
21257 let argc = args.argc_;
21258 let arg0: Option<i8> = if args.get(0).is_undefined() {
21259 Some(7)
21260 } else {
21261 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21262 Ok(ConversionResult::Success(value)) => value,
21263 Ok(ConversionResult::Failure(error)) => {
21264 throw_type_error(cx.raw_cx(), &error);
21265 return false;
21266
21267 }
21268 _ => {
21269 return false;
21270
21271 },
21272 }
21273
21274 };
21275 let result: () = this.PassOptionalNullableByteWithNonNullDefault(arg0);
21276
21277 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21278 return true;
21279 })());
21280 result
21281}
21282
21283
21284static passOptionalNullableByteWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21285
21286pub(crate) fn init_passOptionalNullableByteWithNonNullDefault_methodinfo<D: DomTypes>() {
21287 passOptionalNullableByteWithNonNullDefault_methodinfo.set(JSJitInfo {
21288 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21289 method: Some(passOptionalNullableByteWithNonNullDefault::<D>)
21290 },
21291 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21292 protoID: PrototypeList::ID::TestBinding as u16,
21293 },
21294 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21295 _bitfield_align_1: [],
21296 _bitfield_1: __BindgenBitfieldUnit::new(
21297 new_jsjitinfo_bitfield_1!(
21298 JSJitInfo_OpType::Method as u8,
21299 JSJitInfo_AliasSet::AliasEverything as u8,
21300 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21301 false,
21302 false,
21303 false,
21304 false,
21305 false,
21306 false,
21307 0,
21308 ).to_ne_bytes()
21309 ),
21310});
21311}
21312unsafe extern "C" fn passOptionalNullableOctetWithNonNullDefault<D: DomTypes>
21313(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21314 let mut result = false;
21315 wrap_panic(&mut || result = (|| {
21316 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21317 let this = &*(this as *const D::TestBinding);
21318 let args = &*args;
21319 let argc = args.argc_;
21320 let arg0: Option<u8> = if args.get(0).is_undefined() {
21321 Some(7)
21322 } else {
21323 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21324 Ok(ConversionResult::Success(value)) => value,
21325 Ok(ConversionResult::Failure(error)) => {
21326 throw_type_error(cx.raw_cx(), &error);
21327 return false;
21328
21329 }
21330 _ => {
21331 return false;
21332
21333 },
21334 }
21335
21336 };
21337 let result: () = this.PassOptionalNullableOctetWithNonNullDefault(arg0);
21338
21339 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21340 return true;
21341 })());
21342 result
21343}
21344
21345
21346static passOptionalNullableOctetWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21347
21348pub(crate) fn init_passOptionalNullableOctetWithNonNullDefault_methodinfo<D: DomTypes>() {
21349 passOptionalNullableOctetWithNonNullDefault_methodinfo.set(JSJitInfo {
21350 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21351 method: Some(passOptionalNullableOctetWithNonNullDefault::<D>)
21352 },
21353 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21354 protoID: PrototypeList::ID::TestBinding as u16,
21355 },
21356 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21357 _bitfield_align_1: [],
21358 _bitfield_1: __BindgenBitfieldUnit::new(
21359 new_jsjitinfo_bitfield_1!(
21360 JSJitInfo_OpType::Method as u8,
21361 JSJitInfo_AliasSet::AliasEverything as u8,
21362 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21363 false,
21364 false,
21365 false,
21366 false,
21367 false,
21368 false,
21369 0,
21370 ).to_ne_bytes()
21371 ),
21372});
21373}
21374unsafe extern "C" fn passOptionalNullableShortWithNonNullDefault<D: DomTypes>
21375(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21376 let mut result = false;
21377 wrap_panic(&mut || result = (|| {
21378 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21379 let this = &*(this as *const D::TestBinding);
21380 let args = &*args;
21381 let argc = args.argc_;
21382 let arg0: Option<i16> = if args.get(0).is_undefined() {
21383 Some(7)
21384 } else {
21385 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21386 Ok(ConversionResult::Success(value)) => value,
21387 Ok(ConversionResult::Failure(error)) => {
21388 throw_type_error(cx.raw_cx(), &error);
21389 return false;
21390
21391 }
21392 _ => {
21393 return false;
21394
21395 },
21396 }
21397
21398 };
21399 let result: () = this.PassOptionalNullableShortWithNonNullDefault(arg0);
21400
21401 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21402 return true;
21403 })());
21404 result
21405}
21406
21407
21408static passOptionalNullableShortWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21409
21410pub(crate) fn init_passOptionalNullableShortWithNonNullDefault_methodinfo<D: DomTypes>() {
21411 passOptionalNullableShortWithNonNullDefault_methodinfo.set(JSJitInfo {
21412 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21413 method: Some(passOptionalNullableShortWithNonNullDefault::<D>)
21414 },
21415 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21416 protoID: PrototypeList::ID::TestBinding as u16,
21417 },
21418 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21419 _bitfield_align_1: [],
21420 _bitfield_1: __BindgenBitfieldUnit::new(
21421 new_jsjitinfo_bitfield_1!(
21422 JSJitInfo_OpType::Method as u8,
21423 JSJitInfo_AliasSet::AliasEverything as u8,
21424 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21425 false,
21426 false,
21427 false,
21428 false,
21429 false,
21430 false,
21431 0,
21432 ).to_ne_bytes()
21433 ),
21434});
21435}
21436unsafe extern "C" fn passOptionalNullableUnsignedShortWithNonNullDefault<D: DomTypes>
21437(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21438 let mut result = false;
21439 wrap_panic(&mut || result = (|| {
21440 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21441 let this = &*(this as *const D::TestBinding);
21442 let args = &*args;
21443 let argc = args.argc_;
21444 let arg0: Option<u16> = if args.get(0).is_undefined() {
21445 Some(7)
21446 } else {
21447 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21448 Ok(ConversionResult::Success(value)) => value,
21449 Ok(ConversionResult::Failure(error)) => {
21450 throw_type_error(cx.raw_cx(), &error);
21451 return false;
21452
21453 }
21454 _ => {
21455 return false;
21456
21457 },
21458 }
21459
21460 };
21461 let result: () = this.PassOptionalNullableUnsignedShortWithNonNullDefault(arg0);
21462
21463 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21464 return true;
21465 })());
21466 result
21467}
21468
21469
21470static passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21471
21472pub(crate) fn init_passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo<D: DomTypes>() {
21473 passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo.set(JSJitInfo {
21474 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21475 method: Some(passOptionalNullableUnsignedShortWithNonNullDefault::<D>)
21476 },
21477 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21478 protoID: PrototypeList::ID::TestBinding as u16,
21479 },
21480 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21481 _bitfield_align_1: [],
21482 _bitfield_1: __BindgenBitfieldUnit::new(
21483 new_jsjitinfo_bitfield_1!(
21484 JSJitInfo_OpType::Method as u8,
21485 JSJitInfo_AliasSet::AliasEverything as u8,
21486 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21487 false,
21488 false,
21489 false,
21490 false,
21491 false,
21492 false,
21493 0,
21494 ).to_ne_bytes()
21495 ),
21496});
21497}
21498unsafe extern "C" fn passOptionalNullableLongWithNonNullDefault<D: DomTypes>
21499(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21500 let mut result = false;
21501 wrap_panic(&mut || result = (|| {
21502 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21503 let this = &*(this as *const D::TestBinding);
21504 let args = &*args;
21505 let argc = args.argc_;
21506 let arg0: Option<i32> = if args.get(0).is_undefined() {
21507 Some(7)
21508 } else {
21509 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21510 Ok(ConversionResult::Success(value)) => value,
21511 Ok(ConversionResult::Failure(error)) => {
21512 throw_type_error(cx.raw_cx(), &error);
21513 return false;
21514
21515 }
21516 _ => {
21517 return false;
21518
21519 },
21520 }
21521
21522 };
21523 let result: () = this.PassOptionalNullableLongWithNonNullDefault(arg0);
21524
21525 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21526 return true;
21527 })());
21528 result
21529}
21530
21531
21532static passOptionalNullableLongWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21533
21534pub(crate) fn init_passOptionalNullableLongWithNonNullDefault_methodinfo<D: DomTypes>() {
21535 passOptionalNullableLongWithNonNullDefault_methodinfo.set(JSJitInfo {
21536 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21537 method: Some(passOptionalNullableLongWithNonNullDefault::<D>)
21538 },
21539 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21540 protoID: PrototypeList::ID::TestBinding as u16,
21541 },
21542 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21543 _bitfield_align_1: [],
21544 _bitfield_1: __BindgenBitfieldUnit::new(
21545 new_jsjitinfo_bitfield_1!(
21546 JSJitInfo_OpType::Method as u8,
21547 JSJitInfo_AliasSet::AliasEverything as u8,
21548 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21549 false,
21550 false,
21551 false,
21552 false,
21553 false,
21554 false,
21555 0,
21556 ).to_ne_bytes()
21557 ),
21558});
21559}
21560unsafe extern "C" fn passOptionalNullableUnsignedLongWithNonNullDefault<D: DomTypes>
21561(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21562 let mut result = false;
21563 wrap_panic(&mut || result = (|| {
21564 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21565 let this = &*(this as *const D::TestBinding);
21566 let args = &*args;
21567 let argc = args.argc_;
21568 let arg0: Option<u32> = if args.get(0).is_undefined() {
21569 Some(7)
21570 } else {
21571 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21572 Ok(ConversionResult::Success(value)) => value,
21573 Ok(ConversionResult::Failure(error)) => {
21574 throw_type_error(cx.raw_cx(), &error);
21575 return false;
21576
21577 }
21578 _ => {
21579 return false;
21580
21581 },
21582 }
21583
21584 };
21585 let result: () = this.PassOptionalNullableUnsignedLongWithNonNullDefault(arg0);
21586
21587 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21588 return true;
21589 })());
21590 result
21591}
21592
21593
21594static passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21595
21596pub(crate) fn init_passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo<D: DomTypes>() {
21597 passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo.set(JSJitInfo {
21598 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21599 method: Some(passOptionalNullableUnsignedLongWithNonNullDefault::<D>)
21600 },
21601 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21602 protoID: PrototypeList::ID::TestBinding as u16,
21603 },
21604 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21605 _bitfield_align_1: [],
21606 _bitfield_1: __BindgenBitfieldUnit::new(
21607 new_jsjitinfo_bitfield_1!(
21608 JSJitInfo_OpType::Method as u8,
21609 JSJitInfo_AliasSet::AliasEverything as u8,
21610 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21611 false,
21612 false,
21613 false,
21614 false,
21615 false,
21616 false,
21617 0,
21618 ).to_ne_bytes()
21619 ),
21620});
21621}
21622unsafe extern "C" fn passOptionalNullableLongLongWithNonNullDefault<D: DomTypes>
21623(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21624 let mut result = false;
21625 wrap_panic(&mut || result = (|| {
21626 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21627 let this = &*(this as *const D::TestBinding);
21628 let args = &*args;
21629 let argc = args.argc_;
21630 let arg0: Option<i64> = if args.get(0).is_undefined() {
21631 Some(7)
21632 } else {
21633 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21634 Ok(ConversionResult::Success(value)) => value,
21635 Ok(ConversionResult::Failure(error)) => {
21636 throw_type_error(cx.raw_cx(), &error);
21637 return false;
21638
21639 }
21640 _ => {
21641 return false;
21642
21643 },
21644 }
21645
21646 };
21647 let result: () = this.PassOptionalNullableLongLongWithNonNullDefault(arg0);
21648
21649 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21650 return true;
21651 })());
21652 result
21653}
21654
21655
21656static passOptionalNullableLongLongWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21657
21658pub(crate) fn init_passOptionalNullableLongLongWithNonNullDefault_methodinfo<D: DomTypes>() {
21659 passOptionalNullableLongLongWithNonNullDefault_methodinfo.set(JSJitInfo {
21660 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21661 method: Some(passOptionalNullableLongLongWithNonNullDefault::<D>)
21662 },
21663 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21664 protoID: PrototypeList::ID::TestBinding as u16,
21665 },
21666 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21667 _bitfield_align_1: [],
21668 _bitfield_1: __BindgenBitfieldUnit::new(
21669 new_jsjitinfo_bitfield_1!(
21670 JSJitInfo_OpType::Method as u8,
21671 JSJitInfo_AliasSet::AliasEverything as u8,
21672 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21673 false,
21674 false,
21675 false,
21676 false,
21677 false,
21678 false,
21679 0,
21680 ).to_ne_bytes()
21681 ),
21682});
21683}
21684unsafe extern "C" fn passOptionalNullableUnsignedLongLongWithNonNullDefault<D: DomTypes>
21685(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21686 let mut result = false;
21687 wrap_panic(&mut || result = (|| {
21688 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21689 let this = &*(this as *const D::TestBinding);
21690 let args = &*args;
21691 let argc = args.argc_;
21692 let arg0: Option<u64> = if args.get(0).is_undefined() {
21693 Some(7)
21694 } else {
21695 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
21696 Ok(ConversionResult::Success(value)) => value,
21697 Ok(ConversionResult::Failure(error)) => {
21698 throw_type_error(cx.raw_cx(), &error);
21699 return false;
21700
21701 }
21702 _ => {
21703 return false;
21704
21705 },
21706 }
21707
21708 };
21709 let result: () = this.PassOptionalNullableUnsignedLongLongWithNonNullDefault(arg0);
21710
21711 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21712 return true;
21713 })());
21714 result
21715}
21716
21717
21718static passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21719
21720pub(crate) fn init_passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo<D: DomTypes>() {
21721 passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo.set(JSJitInfo {
21722 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21723 method: Some(passOptionalNullableUnsignedLongLongWithNonNullDefault::<D>)
21724 },
21725 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21726 protoID: PrototypeList::ID::TestBinding as u16,
21727 },
21728 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21729 _bitfield_align_1: [],
21730 _bitfield_1: __BindgenBitfieldUnit::new(
21731 new_jsjitinfo_bitfield_1!(
21732 JSJitInfo_OpType::Method as u8,
21733 JSJitInfo_AliasSet::AliasEverything as u8,
21734 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21735 false,
21736 false,
21737 false,
21738 false,
21739 false,
21740 false,
21741 0,
21742 ).to_ne_bytes()
21743 ),
21744});
21745}
21746unsafe extern "C" fn passOptionalNullableStringWithNonNullDefault<D: DomTypes>
21747(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21748 let mut result = false;
21749 wrap_panic(&mut || result = (|| {
21750 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21751 let this = &*(this as *const D::TestBinding);
21752 let args = &*args;
21753 let argc = args.argc_;
21754 let arg0: Option<DOMString> = if args.get(0).is_undefined() {
21755 Some(DOMString::from("x"))
21756 } else {
21757 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
21758 Ok(ConversionResult::Success(value)) => value,
21759 Ok(ConversionResult::Failure(error)) => {
21760 throw_type_error(cx.raw_cx(), &error);
21761 return false;
21762
21763 }
21764 _ => {
21765 return false;
21766
21767 },
21768 }
21769
21770 };
21771 let result: () = this.PassOptionalNullableStringWithNonNullDefault(arg0);
21772
21773 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21774 return true;
21775 })());
21776 result
21777}
21778
21779
21780static passOptionalNullableStringWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21781
21782pub(crate) fn init_passOptionalNullableStringWithNonNullDefault_methodinfo<D: DomTypes>() {
21783 passOptionalNullableStringWithNonNullDefault_methodinfo.set(JSJitInfo {
21784 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21785 method: Some(passOptionalNullableStringWithNonNullDefault::<D>)
21786 },
21787 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21788 protoID: PrototypeList::ID::TestBinding as u16,
21789 },
21790 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21791 _bitfield_align_1: [],
21792 _bitfield_1: __BindgenBitfieldUnit::new(
21793 new_jsjitinfo_bitfield_1!(
21794 JSJitInfo_OpType::Method as u8,
21795 JSJitInfo_AliasSet::AliasEverything as u8,
21796 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21797 false,
21798 false,
21799 false,
21800 false,
21801 false,
21802 false,
21803 0,
21804 ).to_ne_bytes()
21805 ),
21806});
21807}
21808unsafe extern "C" fn passOptionalNullableUsvstringWithNonNullDefault<D: DomTypes>
21809(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21810 let mut result = false;
21811 wrap_panic(&mut || result = (|| {
21812 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21813 let this = &*(this as *const D::TestBinding);
21814 let args = &*args;
21815 let argc = args.argc_;
21816 let arg0: Option<USVString> = if args.get(0).is_undefined() {
21817 Some(USVString("x".to_owned()))
21818 } else {
21819 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
21820 Ok(ConversionResult::Success(value)) => value,
21821 Ok(ConversionResult::Failure(error)) => {
21822 throw_type_error(cx.raw_cx(), &error);
21823 return false;
21824
21825 }
21826 _ => {
21827 return false;
21828
21829 },
21830 }
21831
21832 };
21833 let result: () = this.PassOptionalNullableUsvstringWithNonNullDefault(arg0);
21834
21835 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21836 return true;
21837 })());
21838 result
21839}
21840
21841
21842static passOptionalNullableUsvstringWithNonNullDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
21843
21844pub(crate) fn init_passOptionalNullableUsvstringWithNonNullDefault_methodinfo<D: DomTypes>() {
21845 passOptionalNullableUsvstringWithNonNullDefault_methodinfo.set(JSJitInfo {
21846 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
21847 method: Some(passOptionalNullableUsvstringWithNonNullDefault::<D>)
21848 },
21849 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
21850 protoID: PrototypeList::ID::TestBinding as u16,
21851 },
21852 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
21853 _bitfield_align_1: [],
21854 _bitfield_1: __BindgenBitfieldUnit::new(
21855 new_jsjitinfo_bitfield_1!(
21856 JSJitInfo_OpType::Method as u8,
21857 JSJitInfo_AliasSet::AliasEverything as u8,
21858 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
21859 false,
21860 false,
21861 false,
21862 false,
21863 false,
21864 false,
21865 0,
21866 ).to_ne_bytes()
21867 ),
21868});
21869}
21870unsafe extern "C" fn passOptionalOverloaded<D: DomTypes>
21871(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
21872 let mut result = false;
21873 wrap_panic(&mut || result = (|| {
21874 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
21875 let this = &*(this as *const D::TestBinding);
21876 let args = &*args;
21877 let argc = args.argc_;
21878
21879 let argcount = cmp::min(argc, 3);
21880 match argcount {
21881 1 => {
21882 if HandleValue::from_raw(args.get(0)).get().is_object() {
21883 '_block: {
21884 let arg0: DomRoot<D::TestBinding> = match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
21885 Ok(val) => val,
21886 Err(()) => {
21887 break '_block;
21888 }
21889 }
21890 ;
21891 let arg1: u32 = if args.get(1).is_undefined() {
21892 0
21893 } else {
21894 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
21895 Ok(ConversionResult::Success(value)) => value,
21896 Ok(ConversionResult::Failure(error)) => {
21897 throw_type_error(cx.raw_cx(), &error);
21898 return false;
21899
21900 }
21901 _ => {
21902 return false;
21903
21904 },
21905 }
21906
21907 };
21908 let arg2: u32 = if args.get(2).is_undefined() {
21909 0
21910 } else {
21911 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
21912 Ok(ConversionResult::Success(value)) => value,
21913 Ok(ConversionResult::Failure(error)) => {
21914 throw_type_error(cx.raw_cx(), &error);
21915 return false;
21916
21917 }
21918 _ => {
21919 return false;
21920
21921 },
21922 }
21923
21924 };
21925 let result: DomRoot<D::TestBinding> = this.PassOptionalOverloaded(&arg0, arg1, arg2);
21926
21927 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21928 return true;
21929 }
21930 '_block: {
21931 let arg0: DomRoot<D::Blob> = match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
21932 Ok(val) => val,
21933 Err(()) => {
21934 break '_block;
21935 }
21936 }
21937 ;
21938 let arg1: u32 = if args.get(1).is_undefined() {
21939 0
21940 } else {
21941 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
21942 Ok(ConversionResult::Success(value)) => value,
21943 Ok(ConversionResult::Failure(error)) => {
21944 throw_type_error(cx.raw_cx(), &error);
21945 return false;
21946
21947 }
21948 _ => {
21949 return false;
21950
21951 },
21952 }
21953
21954 };
21955 let result: () = this.PassOptionalOverloaded_(&arg0, arg1);
21956
21957 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
21958 return true;
21959 }
21960 }
21961 throw_type_error(cx.raw_cx(), "Could not convert JavaScript argument");
21962 return false;
21963 }
21964 2 => {
21965 if HandleValue::from_raw(args.get(0)).get().is_object() {
21966 '_block: {
21967 let arg0: DomRoot<D::TestBinding> = match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
21968 Ok(val) => val,
21969 Err(()) => {
21970 break '_block;
21971 }
21972 }
21973 ;
21974 let arg1: u32 = if args.get(1).is_undefined() {
21975 0
21976 } else {
21977 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
21978 Ok(ConversionResult::Success(value)) => value,
21979 Ok(ConversionResult::Failure(error)) => {
21980 throw_type_error(cx.raw_cx(), &error);
21981 return false;
21982
21983 }
21984 _ => {
21985 return false;
21986
21987 },
21988 }
21989
21990 };
21991 let arg2: u32 = if args.get(2).is_undefined() {
21992 0
21993 } else {
21994 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
21995 Ok(ConversionResult::Success(value)) => value,
21996 Ok(ConversionResult::Failure(error)) => {
21997 throw_type_error(cx.raw_cx(), &error);
21998 return false;
21999
22000 }
22001 _ => {
22002 return false;
22003
22004 },
22005 }
22006
22007 };
22008 let result: DomRoot<D::TestBinding> = this.PassOptionalOverloaded(&arg0, arg1, arg2);
22009
22010 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22011 return true;
22012 }
22013 '_block: {
22014 let arg0: DomRoot<D::Blob> = match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
22015 Ok(val) => val,
22016 Err(()) => {
22017 break '_block;
22018 }
22019 }
22020 ;
22021 let arg1: u32 = if args.get(1).is_undefined() {
22022 0
22023 } else {
22024 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
22025 Ok(ConversionResult::Success(value)) => value,
22026 Ok(ConversionResult::Failure(error)) => {
22027 throw_type_error(cx.raw_cx(), &error);
22028 return false;
22029
22030 }
22031 _ => {
22032 return false;
22033
22034 },
22035 }
22036
22037 };
22038 let result: () = this.PassOptionalOverloaded_(&arg0, arg1);
22039
22040 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22041 return true;
22042 }
22043 }
22044 throw_type_error(cx.raw_cx(), "Could not convert JavaScript argument");
22045 return false;
22046 }
22047 3 => {
22048 let arg0: DomRoot<D::TestBinding> = if HandleValue::from_raw(args.get(0)).get().is_object() {
22049 match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
22050 Ok(val) => val,
22051 Err(()) => {
22052 throw_type_error(cx.raw_cx(), "value does not implement interface TestBinding.");
22053 return false;
22054
22055 }
22056 }
22057
22058 } else {
22059 throw_type_error(cx.raw_cx(), "Value is not an object.");
22060 return false;
22061
22062 };
22063 let arg1: u32 = if args.get(1).is_undefined() {
22064 0
22065 } else {
22066 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::Default) {
22067 Ok(ConversionResult::Success(value)) => value,
22068 Ok(ConversionResult::Failure(error)) => {
22069 throw_type_error(cx.raw_cx(), &error);
22070 return false;
22071
22072 }
22073 _ => {
22074 return false;
22075
22076 },
22077 }
22078
22079 };
22080 let arg2: u32 = if args.get(2).is_undefined() {
22081 0
22082 } else {
22083 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
22084 Ok(ConversionResult::Success(value)) => value,
22085 Ok(ConversionResult::Failure(error)) => {
22086 throw_type_error(cx.raw_cx(), &error);
22087 return false;
22088
22089 }
22090 _ => {
22091 return false;
22092
22093 },
22094 }
22095
22096 };
22097 let result: DomRoot<D::TestBinding> = this.PassOptionalOverloaded(&arg0, arg1, arg2);
22098
22099 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22100 return true;
22101 }
22102 _ => {
22103 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passOptionalOverloaded\".");
22104 return false;
22105 }
22106 }
22107 })());
22108 result
22109}
22110
22111
22112static passOptionalOverloaded_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22113
22114pub(crate) fn init_passOptionalOverloaded_methodinfo<D: DomTypes>() {
22115 passOptionalOverloaded_methodinfo.set(JSJitInfo {
22116 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22117 method: Some(passOptionalOverloaded::<D>)
22118 },
22119 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22120 protoID: PrototypeList::ID::TestBinding as u16,
22121 },
22122 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22123 _bitfield_align_1: [],
22124 _bitfield_1: __BindgenBitfieldUnit::new(
22125 new_jsjitinfo_bitfield_1!(
22126 JSJitInfo_OpType::Method as u8,
22127 JSJitInfo_AliasSet::AliasEverything as u8,
22128 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
22129 false,
22130 false,
22131 false,
22132 false,
22133 false,
22134 false,
22135 0,
22136 ).to_ne_bytes()
22137 ),
22138});
22139}
22140unsafe extern "C" fn passVariadicBoolean<D: DomTypes>
22141(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22142 let mut result = false;
22143 wrap_panic(&mut || result = (|| {
22144 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22145 let this = &*(this as *const D::TestBinding);
22146 let args = &*args;
22147 let argc = args.argc_;
22148
22149 let mut arg0 = vec![];
22150 if argc > 0 {
22151 arg0.reserve(argc as usize);
22152 for variadicArg in 0..argc {
22153 let slot: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
22154 Ok(ConversionResult::Success(value)) => value,
22155 Ok(ConversionResult::Failure(error)) => {
22156 throw_type_error(cx.raw_cx(), &error);
22157 return false;
22158
22159 }
22160 _ => {
22161 return false;
22162
22163 },
22164 }
22165 ;
22166 arg0.push(slot);
22167 }
22168 }
22169 let result: () = this.PassVariadicBoolean(arg0);
22170
22171 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22172 return true;
22173 })());
22174 result
22175}
22176
22177
22178static passVariadicBoolean_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22179
22180pub(crate) fn init_passVariadicBoolean_methodinfo<D: DomTypes>() {
22181 passVariadicBoolean_methodinfo.set(JSJitInfo {
22182 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22183 method: Some(passVariadicBoolean::<D>)
22184 },
22185 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22186 protoID: PrototypeList::ID::TestBinding as u16,
22187 },
22188 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22189 _bitfield_align_1: [],
22190 _bitfield_1: __BindgenBitfieldUnit::new(
22191 new_jsjitinfo_bitfield_1!(
22192 JSJitInfo_OpType::Method as u8,
22193 JSJitInfo_AliasSet::AliasEverything as u8,
22194 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22195 false,
22196 false,
22197 false,
22198 false,
22199 false,
22200 false,
22201 0,
22202 ).to_ne_bytes()
22203 ),
22204});
22205}
22206unsafe extern "C" fn passVariadicBooleanAndDefault<D: DomTypes>
22207(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22208 let mut result = false;
22209 wrap_panic(&mut || result = (|| {
22210 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22211 let this = &*(this as *const D::TestBinding);
22212 let args = &*args;
22213 let argc = args.argc_;
22214 let arg0: bool = if args.get(0).is_undefined() {
22215 true
22216 } else {
22217 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
22218 Ok(ConversionResult::Success(value)) => value,
22219 Ok(ConversionResult::Failure(error)) => {
22220 throw_type_error(cx.raw_cx(), &error);
22221 return false;
22222
22223 }
22224 _ => {
22225 return false;
22226
22227 },
22228 }
22229
22230 };
22231
22232 let mut arg1 = vec![];
22233 if argc > 1 {
22234 arg1.reserve(argc as usize- 1);
22235 for variadicArg in 1..argc {
22236 let slot: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
22237 Ok(ConversionResult::Success(value)) => value,
22238 Ok(ConversionResult::Failure(error)) => {
22239 throw_type_error(cx.raw_cx(), &error);
22240 return false;
22241
22242 }
22243 _ => {
22244 return false;
22245
22246 },
22247 }
22248 ;
22249 arg1.push(slot);
22250 }
22251 }
22252 let result: () = this.PassVariadicBooleanAndDefault(arg0, arg1);
22253
22254 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22255 return true;
22256 })());
22257 result
22258}
22259
22260
22261static passVariadicBooleanAndDefault_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22262
22263pub(crate) fn init_passVariadicBooleanAndDefault_methodinfo<D: DomTypes>() {
22264 passVariadicBooleanAndDefault_methodinfo.set(JSJitInfo {
22265 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22266 method: Some(passVariadicBooleanAndDefault::<D>)
22267 },
22268 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22269 protoID: PrototypeList::ID::TestBinding as u16,
22270 },
22271 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22272 _bitfield_align_1: [],
22273 _bitfield_1: __BindgenBitfieldUnit::new(
22274 new_jsjitinfo_bitfield_1!(
22275 JSJitInfo_OpType::Method as u8,
22276 JSJitInfo_AliasSet::AliasEverything as u8,
22277 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22278 false,
22279 false,
22280 false,
22281 false,
22282 false,
22283 false,
22284 0,
22285 ).to_ne_bytes()
22286 ),
22287});
22288}
22289unsafe extern "C" fn passVariadicByte<D: DomTypes>
22290(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22291 let mut result = false;
22292 wrap_panic(&mut || result = (|| {
22293 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22294 let this = &*(this as *const D::TestBinding);
22295 let args = &*args;
22296 let argc = args.argc_;
22297
22298 let mut arg0 = vec![];
22299 if argc > 0 {
22300 arg0.reserve(argc as usize);
22301 for variadicArg in 0..argc {
22302 let slot: i8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22303 Ok(ConversionResult::Success(value)) => value,
22304 Ok(ConversionResult::Failure(error)) => {
22305 throw_type_error(cx.raw_cx(), &error);
22306 return false;
22307
22308 }
22309 _ => {
22310 return false;
22311
22312 },
22313 }
22314 ;
22315 arg0.push(slot);
22316 }
22317 }
22318 let result: () = this.PassVariadicByte(arg0);
22319
22320 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22321 return true;
22322 })());
22323 result
22324}
22325
22326
22327static passVariadicByte_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22328
22329pub(crate) fn init_passVariadicByte_methodinfo<D: DomTypes>() {
22330 passVariadicByte_methodinfo.set(JSJitInfo {
22331 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22332 method: Some(passVariadicByte::<D>)
22333 },
22334 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22335 protoID: PrototypeList::ID::TestBinding as u16,
22336 },
22337 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22338 _bitfield_align_1: [],
22339 _bitfield_1: __BindgenBitfieldUnit::new(
22340 new_jsjitinfo_bitfield_1!(
22341 JSJitInfo_OpType::Method as u8,
22342 JSJitInfo_AliasSet::AliasEverything as u8,
22343 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22344 false,
22345 false,
22346 false,
22347 false,
22348 false,
22349 false,
22350 0,
22351 ).to_ne_bytes()
22352 ),
22353});
22354}
22355unsafe extern "C" fn passVariadicOctet<D: DomTypes>
22356(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22357 let mut result = false;
22358 wrap_panic(&mut || result = (|| {
22359 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22360 let this = &*(this as *const D::TestBinding);
22361 let args = &*args;
22362 let argc = args.argc_;
22363
22364 let mut arg0 = vec![];
22365 if argc > 0 {
22366 arg0.reserve(argc as usize);
22367 for variadicArg in 0..argc {
22368 let slot: u8 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22369 Ok(ConversionResult::Success(value)) => value,
22370 Ok(ConversionResult::Failure(error)) => {
22371 throw_type_error(cx.raw_cx(), &error);
22372 return false;
22373
22374 }
22375 _ => {
22376 return false;
22377
22378 },
22379 }
22380 ;
22381 arg0.push(slot);
22382 }
22383 }
22384 let result: () = this.PassVariadicOctet(arg0);
22385
22386 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22387 return true;
22388 })());
22389 result
22390}
22391
22392
22393static passVariadicOctet_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22394
22395pub(crate) fn init_passVariadicOctet_methodinfo<D: DomTypes>() {
22396 passVariadicOctet_methodinfo.set(JSJitInfo {
22397 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22398 method: Some(passVariadicOctet::<D>)
22399 },
22400 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22401 protoID: PrototypeList::ID::TestBinding as u16,
22402 },
22403 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22404 _bitfield_align_1: [],
22405 _bitfield_1: __BindgenBitfieldUnit::new(
22406 new_jsjitinfo_bitfield_1!(
22407 JSJitInfo_OpType::Method as u8,
22408 JSJitInfo_AliasSet::AliasEverything as u8,
22409 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22410 false,
22411 false,
22412 false,
22413 false,
22414 false,
22415 false,
22416 0,
22417 ).to_ne_bytes()
22418 ),
22419});
22420}
22421unsafe extern "C" fn passVariadicShort<D: DomTypes>
22422(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22423 let mut result = false;
22424 wrap_panic(&mut || result = (|| {
22425 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22426 let this = &*(this as *const D::TestBinding);
22427 let args = &*args;
22428 let argc = args.argc_;
22429
22430 let mut arg0 = vec![];
22431 if argc > 0 {
22432 arg0.reserve(argc as usize);
22433 for variadicArg in 0..argc {
22434 let slot: i16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22435 Ok(ConversionResult::Success(value)) => value,
22436 Ok(ConversionResult::Failure(error)) => {
22437 throw_type_error(cx.raw_cx(), &error);
22438 return false;
22439
22440 }
22441 _ => {
22442 return false;
22443
22444 },
22445 }
22446 ;
22447 arg0.push(slot);
22448 }
22449 }
22450 let result: () = this.PassVariadicShort(arg0);
22451
22452 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22453 return true;
22454 })());
22455 result
22456}
22457
22458
22459static passVariadicShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22460
22461pub(crate) fn init_passVariadicShort_methodinfo<D: DomTypes>() {
22462 passVariadicShort_methodinfo.set(JSJitInfo {
22463 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22464 method: Some(passVariadicShort::<D>)
22465 },
22466 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22467 protoID: PrototypeList::ID::TestBinding as u16,
22468 },
22469 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22470 _bitfield_align_1: [],
22471 _bitfield_1: __BindgenBitfieldUnit::new(
22472 new_jsjitinfo_bitfield_1!(
22473 JSJitInfo_OpType::Method as u8,
22474 JSJitInfo_AliasSet::AliasEverything as u8,
22475 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22476 false,
22477 false,
22478 false,
22479 false,
22480 false,
22481 false,
22482 0,
22483 ).to_ne_bytes()
22484 ),
22485});
22486}
22487unsafe extern "C" fn passVariadicUnsignedShort<D: DomTypes>
22488(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22489 let mut result = false;
22490 wrap_panic(&mut || result = (|| {
22491 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22492 let this = &*(this as *const D::TestBinding);
22493 let args = &*args;
22494 let argc = args.argc_;
22495
22496 let mut arg0 = vec![];
22497 if argc > 0 {
22498 arg0.reserve(argc as usize);
22499 for variadicArg in 0..argc {
22500 let slot: u16 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22501 Ok(ConversionResult::Success(value)) => value,
22502 Ok(ConversionResult::Failure(error)) => {
22503 throw_type_error(cx.raw_cx(), &error);
22504 return false;
22505
22506 }
22507 _ => {
22508 return false;
22509
22510 },
22511 }
22512 ;
22513 arg0.push(slot);
22514 }
22515 }
22516 let result: () = this.PassVariadicUnsignedShort(arg0);
22517
22518 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22519 return true;
22520 })());
22521 result
22522}
22523
22524
22525static passVariadicUnsignedShort_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22526
22527pub(crate) fn init_passVariadicUnsignedShort_methodinfo<D: DomTypes>() {
22528 passVariadicUnsignedShort_methodinfo.set(JSJitInfo {
22529 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22530 method: Some(passVariadicUnsignedShort::<D>)
22531 },
22532 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22533 protoID: PrototypeList::ID::TestBinding as u16,
22534 },
22535 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22536 _bitfield_align_1: [],
22537 _bitfield_1: __BindgenBitfieldUnit::new(
22538 new_jsjitinfo_bitfield_1!(
22539 JSJitInfo_OpType::Method as u8,
22540 JSJitInfo_AliasSet::AliasEverything as u8,
22541 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22542 false,
22543 false,
22544 false,
22545 false,
22546 false,
22547 false,
22548 0,
22549 ).to_ne_bytes()
22550 ),
22551});
22552}
22553unsafe extern "C" fn passVariadicLong<D: DomTypes>
22554(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22555 let mut result = false;
22556 wrap_panic(&mut || result = (|| {
22557 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22558 let this = &*(this as *const D::TestBinding);
22559 let args = &*args;
22560 let argc = args.argc_;
22561
22562 let mut arg0 = vec![];
22563 if argc > 0 {
22564 arg0.reserve(argc as usize);
22565 for variadicArg in 0..argc {
22566 let slot: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22567 Ok(ConversionResult::Success(value)) => value,
22568 Ok(ConversionResult::Failure(error)) => {
22569 throw_type_error(cx.raw_cx(), &error);
22570 return false;
22571
22572 }
22573 _ => {
22574 return false;
22575
22576 },
22577 }
22578 ;
22579 arg0.push(slot);
22580 }
22581 }
22582 let result: () = this.PassVariadicLong(arg0);
22583
22584 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22585 return true;
22586 })());
22587 result
22588}
22589
22590
22591static passVariadicLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22592
22593pub(crate) fn init_passVariadicLong_methodinfo<D: DomTypes>() {
22594 passVariadicLong_methodinfo.set(JSJitInfo {
22595 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22596 method: Some(passVariadicLong::<D>)
22597 },
22598 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22599 protoID: PrototypeList::ID::TestBinding as u16,
22600 },
22601 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22602 _bitfield_align_1: [],
22603 _bitfield_1: __BindgenBitfieldUnit::new(
22604 new_jsjitinfo_bitfield_1!(
22605 JSJitInfo_OpType::Method as u8,
22606 JSJitInfo_AliasSet::AliasEverything as u8,
22607 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22608 false,
22609 false,
22610 false,
22611 false,
22612 false,
22613 false,
22614 0,
22615 ).to_ne_bytes()
22616 ),
22617});
22618}
22619unsafe extern "C" fn passVariadicUnsignedLong<D: DomTypes>
22620(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22621 let mut result = false;
22622 wrap_panic(&mut || result = (|| {
22623 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22624 let this = &*(this as *const D::TestBinding);
22625 let args = &*args;
22626 let argc = args.argc_;
22627
22628 let mut arg0 = vec![];
22629 if argc > 0 {
22630 arg0.reserve(argc as usize);
22631 for variadicArg in 0..argc {
22632 let slot: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22633 Ok(ConversionResult::Success(value)) => value,
22634 Ok(ConversionResult::Failure(error)) => {
22635 throw_type_error(cx.raw_cx(), &error);
22636 return false;
22637
22638 }
22639 _ => {
22640 return false;
22641
22642 },
22643 }
22644 ;
22645 arg0.push(slot);
22646 }
22647 }
22648 let result: () = this.PassVariadicUnsignedLong(arg0);
22649
22650 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22651 return true;
22652 })());
22653 result
22654}
22655
22656
22657static passVariadicUnsignedLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22658
22659pub(crate) fn init_passVariadicUnsignedLong_methodinfo<D: DomTypes>() {
22660 passVariadicUnsignedLong_methodinfo.set(JSJitInfo {
22661 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22662 method: Some(passVariadicUnsignedLong::<D>)
22663 },
22664 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22665 protoID: PrototypeList::ID::TestBinding as u16,
22666 },
22667 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22668 _bitfield_align_1: [],
22669 _bitfield_1: __BindgenBitfieldUnit::new(
22670 new_jsjitinfo_bitfield_1!(
22671 JSJitInfo_OpType::Method as u8,
22672 JSJitInfo_AliasSet::AliasEverything as u8,
22673 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22674 false,
22675 false,
22676 false,
22677 false,
22678 false,
22679 false,
22680 0,
22681 ).to_ne_bytes()
22682 ),
22683});
22684}
22685unsafe extern "C" fn passVariadicLongLong<D: DomTypes>
22686(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22687 let mut result = false;
22688 wrap_panic(&mut || result = (|| {
22689 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22690 let this = &*(this as *const D::TestBinding);
22691 let args = &*args;
22692 let argc = args.argc_;
22693
22694 let mut arg0 = vec![];
22695 if argc > 0 {
22696 arg0.reserve(argc as usize);
22697 for variadicArg in 0..argc {
22698 let slot: i64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22699 Ok(ConversionResult::Success(value)) => value,
22700 Ok(ConversionResult::Failure(error)) => {
22701 throw_type_error(cx.raw_cx(), &error);
22702 return false;
22703
22704 }
22705 _ => {
22706 return false;
22707
22708 },
22709 }
22710 ;
22711 arg0.push(slot);
22712 }
22713 }
22714 let result: () = this.PassVariadicLongLong(arg0);
22715
22716 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22717 return true;
22718 })());
22719 result
22720}
22721
22722
22723static passVariadicLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22724
22725pub(crate) fn init_passVariadicLongLong_methodinfo<D: DomTypes>() {
22726 passVariadicLongLong_methodinfo.set(JSJitInfo {
22727 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22728 method: Some(passVariadicLongLong::<D>)
22729 },
22730 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22731 protoID: PrototypeList::ID::TestBinding as u16,
22732 },
22733 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22734 _bitfield_align_1: [],
22735 _bitfield_1: __BindgenBitfieldUnit::new(
22736 new_jsjitinfo_bitfield_1!(
22737 JSJitInfo_OpType::Method as u8,
22738 JSJitInfo_AliasSet::AliasEverything as u8,
22739 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22740 false,
22741 false,
22742 false,
22743 false,
22744 false,
22745 false,
22746 0,
22747 ).to_ne_bytes()
22748 ),
22749});
22750}
22751unsafe extern "C" fn passVariadicUnsignedLongLong<D: DomTypes>
22752(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22753 let mut result = false;
22754 wrap_panic(&mut || result = (|| {
22755 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22756 let this = &*(this as *const D::TestBinding);
22757 let args = &*args;
22758 let argc = args.argc_;
22759
22760 let mut arg0 = vec![];
22761 if argc > 0 {
22762 arg0.reserve(argc as usize);
22763 for variadicArg in 0..argc {
22764 let slot: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ConversionBehavior::Default) {
22765 Ok(ConversionResult::Success(value)) => value,
22766 Ok(ConversionResult::Failure(error)) => {
22767 throw_type_error(cx.raw_cx(), &error);
22768 return false;
22769
22770 }
22771 _ => {
22772 return false;
22773
22774 },
22775 }
22776 ;
22777 arg0.push(slot);
22778 }
22779 }
22780 let result: () = this.PassVariadicUnsignedLongLong(arg0);
22781
22782 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22783 return true;
22784 })());
22785 result
22786}
22787
22788
22789static passVariadicUnsignedLongLong_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22790
22791pub(crate) fn init_passVariadicUnsignedLongLong_methodinfo<D: DomTypes>() {
22792 passVariadicUnsignedLongLong_methodinfo.set(JSJitInfo {
22793 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22794 method: Some(passVariadicUnsignedLongLong::<D>)
22795 },
22796 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22797 protoID: PrototypeList::ID::TestBinding as u16,
22798 },
22799 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22800 _bitfield_align_1: [],
22801 _bitfield_1: __BindgenBitfieldUnit::new(
22802 new_jsjitinfo_bitfield_1!(
22803 JSJitInfo_OpType::Method as u8,
22804 JSJitInfo_AliasSet::AliasEverything as u8,
22805 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22806 false,
22807 false,
22808 false,
22809 false,
22810 false,
22811 false,
22812 0,
22813 ).to_ne_bytes()
22814 ),
22815});
22816}
22817unsafe extern "C" fn passVariadicUnrestrictedFloat<D: DomTypes>
22818(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22819 let mut result = false;
22820 wrap_panic(&mut || result = (|| {
22821 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22822 let this = &*(this as *const D::TestBinding);
22823 let args = &*args;
22824 let argc = args.argc_;
22825
22826 let mut arg0 = vec![];
22827 if argc > 0 {
22828 arg0.reserve(argc as usize);
22829 for variadicArg in 0..argc {
22830 let slot: f32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
22831 Ok(ConversionResult::Success(value)) => value,
22832 Ok(ConversionResult::Failure(error)) => {
22833 throw_type_error(cx.raw_cx(), &error);
22834 return false;
22835
22836 }
22837 _ => {
22838 return false;
22839
22840 },
22841 }
22842 ;
22843 arg0.push(slot);
22844 }
22845 }
22846 let result: () = this.PassVariadicUnrestrictedFloat(arg0);
22847
22848 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22849 return true;
22850 })());
22851 result
22852}
22853
22854
22855static passVariadicUnrestrictedFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22856
22857pub(crate) fn init_passVariadicUnrestrictedFloat_methodinfo<D: DomTypes>() {
22858 passVariadicUnrestrictedFloat_methodinfo.set(JSJitInfo {
22859 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22860 method: Some(passVariadicUnrestrictedFloat::<D>)
22861 },
22862 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22863 protoID: PrototypeList::ID::TestBinding as u16,
22864 },
22865 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22866 _bitfield_align_1: [],
22867 _bitfield_1: __BindgenBitfieldUnit::new(
22868 new_jsjitinfo_bitfield_1!(
22869 JSJitInfo_OpType::Method as u8,
22870 JSJitInfo_AliasSet::AliasEverything as u8,
22871 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22872 false,
22873 false,
22874 false,
22875 false,
22876 false,
22877 false,
22878 0,
22879 ).to_ne_bytes()
22880 ),
22881});
22882}
22883unsafe extern "C" fn passVariadicFloat<D: DomTypes>
22884(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22885 let mut result = false;
22886 wrap_panic(&mut || result = (|| {
22887 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22888 let this = &*(this as *const D::TestBinding);
22889 let args = &*args;
22890 let argc = args.argc_;
22891
22892 let mut arg0 = vec![];
22893 if argc > 0 {
22894 arg0.reserve(argc as usize);
22895 for variadicArg in 0..argc {
22896 let slot: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
22897 Ok(ConversionResult::Success(value)) => value,
22898 Ok(ConversionResult::Failure(error)) => {
22899 throw_type_error(cx.raw_cx(), &error);
22900 return false;
22901
22902 }
22903 _ => {
22904 return false;
22905
22906 },
22907 }
22908 ;
22909 arg0.push(slot);
22910 }
22911 }
22912 let result: () = this.PassVariadicFloat(arg0);
22913
22914 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22915 return true;
22916 })());
22917 result
22918}
22919
22920
22921static passVariadicFloat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22922
22923pub(crate) fn init_passVariadicFloat_methodinfo<D: DomTypes>() {
22924 passVariadicFloat_methodinfo.set(JSJitInfo {
22925 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22926 method: Some(passVariadicFloat::<D>)
22927 },
22928 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22929 protoID: PrototypeList::ID::TestBinding as u16,
22930 },
22931 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22932 _bitfield_align_1: [],
22933 _bitfield_1: __BindgenBitfieldUnit::new(
22934 new_jsjitinfo_bitfield_1!(
22935 JSJitInfo_OpType::Method as u8,
22936 JSJitInfo_AliasSet::AliasEverything as u8,
22937 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
22938 false,
22939 false,
22940 false,
22941 false,
22942 false,
22943 false,
22944 0,
22945 ).to_ne_bytes()
22946 ),
22947});
22948}
22949unsafe extern "C" fn passVariadicUnrestrictedDouble<D: DomTypes>
22950(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
22951 let mut result = false;
22952 wrap_panic(&mut || result = (|| {
22953 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
22954 let this = &*(this as *const D::TestBinding);
22955 let args = &*args;
22956 let argc = args.argc_;
22957
22958 let mut arg0 = vec![];
22959 if argc > 0 {
22960 arg0.reserve(argc as usize);
22961 for variadicArg in 0..argc {
22962 let slot: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
22963 Ok(ConversionResult::Success(value)) => value,
22964 Ok(ConversionResult::Failure(error)) => {
22965 throw_type_error(cx.raw_cx(), &error);
22966 return false;
22967
22968 }
22969 _ => {
22970 return false;
22971
22972 },
22973 }
22974 ;
22975 arg0.push(slot);
22976 }
22977 }
22978 let result: () = this.PassVariadicUnrestrictedDouble(arg0);
22979
22980 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
22981 return true;
22982 })());
22983 result
22984}
22985
22986
22987static passVariadicUnrestrictedDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
22988
22989pub(crate) fn init_passVariadicUnrestrictedDouble_methodinfo<D: DomTypes>() {
22990 passVariadicUnrestrictedDouble_methodinfo.set(JSJitInfo {
22991 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
22992 method: Some(passVariadicUnrestrictedDouble::<D>)
22993 },
22994 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
22995 protoID: PrototypeList::ID::TestBinding as u16,
22996 },
22997 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
22998 _bitfield_align_1: [],
22999 _bitfield_1: __BindgenBitfieldUnit::new(
23000 new_jsjitinfo_bitfield_1!(
23001 JSJitInfo_OpType::Method as u8,
23002 JSJitInfo_AliasSet::AliasEverything as u8,
23003 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23004 false,
23005 false,
23006 false,
23007 false,
23008 false,
23009 false,
23010 0,
23011 ).to_ne_bytes()
23012 ),
23013});
23014}
23015unsafe extern "C" fn passVariadicDouble<D: DomTypes>
23016(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23017 let mut result = false;
23018 wrap_panic(&mut || result = (|| {
23019 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23020 let this = &*(this as *const D::TestBinding);
23021 let args = &*args;
23022 let argc = args.argc_;
23023
23024 let mut arg0 = vec![];
23025 if argc > 0 {
23026 arg0.reserve(argc as usize);
23027 for variadicArg in 0..argc {
23028 let slot: Finite<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23029 Ok(ConversionResult::Success(value)) => value,
23030 Ok(ConversionResult::Failure(error)) => {
23031 throw_type_error(cx.raw_cx(), &error);
23032 return false;
23033
23034 }
23035 _ => {
23036 return false;
23037
23038 },
23039 }
23040 ;
23041 arg0.push(slot);
23042 }
23043 }
23044 let result: () = this.PassVariadicDouble(arg0);
23045
23046 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23047 return true;
23048 })());
23049 result
23050}
23051
23052
23053static passVariadicDouble_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23054
23055pub(crate) fn init_passVariadicDouble_methodinfo<D: DomTypes>() {
23056 passVariadicDouble_methodinfo.set(JSJitInfo {
23057 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23058 method: Some(passVariadicDouble::<D>)
23059 },
23060 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23061 protoID: PrototypeList::ID::TestBinding as u16,
23062 },
23063 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23064 _bitfield_align_1: [],
23065 _bitfield_1: __BindgenBitfieldUnit::new(
23066 new_jsjitinfo_bitfield_1!(
23067 JSJitInfo_OpType::Method as u8,
23068 JSJitInfo_AliasSet::AliasEverything as u8,
23069 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23070 false,
23071 false,
23072 false,
23073 false,
23074 false,
23075 false,
23076 0,
23077 ).to_ne_bytes()
23078 ),
23079});
23080}
23081unsafe extern "C" fn passVariadicString<D: DomTypes>
23082(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23083 let mut result = false;
23084 wrap_panic(&mut || result = (|| {
23085 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23086 let this = &*(this as *const D::TestBinding);
23087 let args = &*args;
23088 let argc = args.argc_;
23089
23090 let mut arg0 = vec![];
23091 if argc > 0 {
23092 arg0.reserve(argc as usize);
23093 for variadicArg in 0..argc {
23094 let slot: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), StringificationBehavior::Default) {
23095 Ok(ConversionResult::Success(value)) => value,
23096 Ok(ConversionResult::Failure(error)) => {
23097 throw_type_error(cx.raw_cx(), &error);
23098 return false;
23099
23100 }
23101 _ => {
23102 return false;
23103
23104 },
23105 }
23106 ;
23107 arg0.push(slot);
23108 }
23109 }
23110 let result: () = this.PassVariadicString(arg0);
23111
23112 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23113 return true;
23114 })());
23115 result
23116}
23117
23118
23119static passVariadicString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23120
23121pub(crate) fn init_passVariadicString_methodinfo<D: DomTypes>() {
23122 passVariadicString_methodinfo.set(JSJitInfo {
23123 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23124 method: Some(passVariadicString::<D>)
23125 },
23126 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23127 protoID: PrototypeList::ID::TestBinding as u16,
23128 },
23129 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23130 _bitfield_align_1: [],
23131 _bitfield_1: __BindgenBitfieldUnit::new(
23132 new_jsjitinfo_bitfield_1!(
23133 JSJitInfo_OpType::Method as u8,
23134 JSJitInfo_AliasSet::AliasEverything as u8,
23135 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23136 false,
23137 false,
23138 false,
23139 false,
23140 false,
23141 false,
23142 0,
23143 ).to_ne_bytes()
23144 ),
23145});
23146}
23147unsafe extern "C" fn passVariadicUsvstring<D: DomTypes>
23148(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23149 let mut result = false;
23150 wrap_panic(&mut || result = (|| {
23151 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23152 let this = &*(this as *const D::TestBinding);
23153 let args = &*args;
23154 let argc = args.argc_;
23155
23156 let mut arg0 = vec![];
23157 if argc > 0 {
23158 arg0.reserve(argc as usize);
23159 for variadicArg in 0..argc {
23160 let slot: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23161 Ok(ConversionResult::Success(value)) => value,
23162 Ok(ConversionResult::Failure(error)) => {
23163 throw_type_error(cx.raw_cx(), &error);
23164 return false;
23165
23166 }
23167 _ => {
23168 return false;
23169
23170 },
23171 }
23172 ;
23173 arg0.push(slot);
23174 }
23175 }
23176 let result: () = this.PassVariadicUsvstring(arg0);
23177
23178 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23179 return true;
23180 })());
23181 result
23182}
23183
23184
23185static passVariadicUsvstring_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23186
23187pub(crate) fn init_passVariadicUsvstring_methodinfo<D: DomTypes>() {
23188 passVariadicUsvstring_methodinfo.set(JSJitInfo {
23189 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23190 method: Some(passVariadicUsvstring::<D>)
23191 },
23192 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23193 protoID: PrototypeList::ID::TestBinding as u16,
23194 },
23195 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23196 _bitfield_align_1: [],
23197 _bitfield_1: __BindgenBitfieldUnit::new(
23198 new_jsjitinfo_bitfield_1!(
23199 JSJitInfo_OpType::Method as u8,
23200 JSJitInfo_AliasSet::AliasEverything as u8,
23201 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23202 false,
23203 false,
23204 false,
23205 false,
23206 false,
23207 false,
23208 0,
23209 ).to_ne_bytes()
23210 ),
23211});
23212}
23213unsafe extern "C" fn passVariadicByteString<D: DomTypes>
23214(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23215 let mut result = false;
23216 wrap_panic(&mut || result = (|| {
23217 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23218 let this = &*(this as *const D::TestBinding);
23219 let args = &*args;
23220 let argc = args.argc_;
23221
23222 let mut arg0 = vec![];
23223 if argc > 0 {
23224 arg0.reserve(argc as usize);
23225 for variadicArg in 0..argc {
23226 let slot: ByteString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23227 Ok(ConversionResult::Success(value)) => value,
23228 Ok(ConversionResult::Failure(error)) => {
23229 throw_type_error(cx.raw_cx(), &error);
23230 return false;
23231
23232 }
23233 _ => {
23234 return false;
23235
23236 },
23237 }
23238 ;
23239 arg0.push(slot);
23240 }
23241 }
23242 let result: () = this.PassVariadicByteString(arg0);
23243
23244 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23245 return true;
23246 })());
23247 result
23248}
23249
23250
23251static passVariadicByteString_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23252
23253pub(crate) fn init_passVariadicByteString_methodinfo<D: DomTypes>() {
23254 passVariadicByteString_methodinfo.set(JSJitInfo {
23255 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23256 method: Some(passVariadicByteString::<D>)
23257 },
23258 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23259 protoID: PrototypeList::ID::TestBinding as u16,
23260 },
23261 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23262 _bitfield_align_1: [],
23263 _bitfield_1: __BindgenBitfieldUnit::new(
23264 new_jsjitinfo_bitfield_1!(
23265 JSJitInfo_OpType::Method as u8,
23266 JSJitInfo_AliasSet::AliasEverything as u8,
23267 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23268 false,
23269 false,
23270 false,
23271 false,
23272 false,
23273 false,
23274 0,
23275 ).to_ne_bytes()
23276 ),
23277});
23278}
23279unsafe extern "C" fn passVariadicEnum<D: DomTypes>
23280(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23281 let mut result = false;
23282 wrap_panic(&mut || result = (|| {
23283 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23284 let this = &*(this as *const D::TestBinding);
23285 let args = &*args;
23286 let argc = args.argc_;
23287
23288 let mut arg0 = vec![];
23289 if argc > 0 {
23290 arg0.reserve(argc as usize);
23291 for variadicArg in 0..argc {
23292 let slot: TestEnum = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23293 Ok(ConversionResult::Success(value)) => value,
23294 Ok(ConversionResult::Failure(error)) => {
23295 throw_type_error(cx.raw_cx(), &error); return false;
23296
23297 }
23298 _ => {
23299 return false;
23300
23301 },
23302 }
23303 ;
23304 arg0.push(slot);
23305 }
23306 }
23307 let result: () = this.PassVariadicEnum(arg0);
23308
23309 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23310 return true;
23311 })());
23312 result
23313}
23314
23315
23316static passVariadicEnum_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23317
23318pub(crate) fn init_passVariadicEnum_methodinfo<D: DomTypes>() {
23319 passVariadicEnum_methodinfo.set(JSJitInfo {
23320 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23321 method: Some(passVariadicEnum::<D>)
23322 },
23323 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23324 protoID: PrototypeList::ID::TestBinding as u16,
23325 },
23326 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23327 _bitfield_align_1: [],
23328 _bitfield_1: __BindgenBitfieldUnit::new(
23329 new_jsjitinfo_bitfield_1!(
23330 JSJitInfo_OpType::Method as u8,
23331 JSJitInfo_AliasSet::AliasEverything as u8,
23332 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23333 false,
23334 false,
23335 false,
23336 false,
23337 false,
23338 false,
23339 0,
23340 ).to_ne_bytes()
23341 ),
23342});
23343}
23344unsafe extern "C" fn passVariadicInterface<D: DomTypes>
23345(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23346 let mut result = false;
23347 wrap_panic(&mut || result = (|| {
23348 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23349 let this = &*(this as *const D::TestBinding);
23350 let args = &*args;
23351 let argc = args.argc_;
23352
23353 rooted_vec!(let mut arg0);
23354 if argc > 0 {
23355 arg0.reserve(argc as usize);
23356 for variadicArg in 0..argc {
23357 let slot: *const D::Blob = if HandleValue::from_raw(args.get(variadicArg)).get().is_object() {
23358 match native_from_handlevalue(HandleValue::from_raw(args.get(variadicArg)), SafeJSContext::from_ptr(cx.raw_cx())) {
23359 Ok(val) => val,
23360 Err(()) => {
23361 throw_type_error(cx.raw_cx(), "value does not implement interface Blob.");
23362 return false;
23363
23364 }
23365 }
23366
23367 } else {
23368 throw_type_error(cx.raw_cx(), "Value is not an object.");
23369 return false;
23370
23371 };
23372 arg0.push(Dom::from_ref(&*slot));
23373 }
23374 }
23375 let result: () = this.PassVariadicInterface(arg0.r());
23376
23377 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23378 return true;
23379 })());
23380 result
23381}
23382
23383
23384static passVariadicInterface_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23385
23386pub(crate) fn init_passVariadicInterface_methodinfo<D: DomTypes>() {
23387 passVariadicInterface_methodinfo.set(JSJitInfo {
23388 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23389 method: Some(passVariadicInterface::<D>)
23390 },
23391 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23392 protoID: PrototypeList::ID::TestBinding as u16,
23393 },
23394 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23395 _bitfield_align_1: [],
23396 _bitfield_1: __BindgenBitfieldUnit::new(
23397 new_jsjitinfo_bitfield_1!(
23398 JSJitInfo_OpType::Method as u8,
23399 JSJitInfo_AliasSet::AliasEverything as u8,
23400 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23401 false,
23402 false,
23403 false,
23404 false,
23405 false,
23406 false,
23407 0,
23408 ).to_ne_bytes()
23409 ),
23410});
23411}
23412unsafe extern "C" fn passVariadicUnion<D: DomTypes>
23413(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23414 let mut result = false;
23415 wrap_panic(&mut || result = (|| {
23416 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23417 let this = &*(this as *const D::TestBinding);
23418 let args = &*args;
23419 let argc = args.argc_;
23420
23421 let mut arg0 = vec![];
23422 if argc > 0 {
23423 arg0.reserve(argc as usize);
23424 for variadicArg in 0..argc {
23425 let slot: GenericUnionTypes::HTMLElementOrLong::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23426 Ok(ConversionResult::Success(value)) => value,
23427 Ok(ConversionResult::Failure(error)) => {
23428 throw_type_error(cx.raw_cx(), &error);
23429 return false;
23430
23431 }
23432 _ => {
23433 return false;
23434
23435 },
23436 }
23437 ;
23438 arg0.push(slot);
23439 }
23440 }
23441 let result: () = this.PassVariadicUnion(arg0);
23442
23443 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23444 return true;
23445 })());
23446 result
23447}
23448
23449
23450static passVariadicUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23451
23452pub(crate) fn init_passVariadicUnion_methodinfo<D: DomTypes>() {
23453 passVariadicUnion_methodinfo.set(JSJitInfo {
23454 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23455 method: Some(passVariadicUnion::<D>)
23456 },
23457 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23458 protoID: PrototypeList::ID::TestBinding as u16,
23459 },
23460 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23461 _bitfield_align_1: [],
23462 _bitfield_1: __BindgenBitfieldUnit::new(
23463 new_jsjitinfo_bitfield_1!(
23464 JSJitInfo_OpType::Method as u8,
23465 JSJitInfo_AliasSet::AliasEverything as u8,
23466 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23467 false,
23468 false,
23469 false,
23470 false,
23471 false,
23472 false,
23473 0,
23474 ).to_ne_bytes()
23475 ),
23476});
23477}
23478unsafe extern "C" fn passVariadicUnion2<D: DomTypes>
23479(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23480 let mut result = false;
23481 wrap_panic(&mut || result = (|| {
23482 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23483 let this = &*(this as *const D::TestBinding);
23484 let args = &*args;
23485 let argc = args.argc_;
23486
23487 let mut arg0 = vec![];
23488 if argc > 0 {
23489 arg0.reserve(argc as usize);
23490 for variadicArg in 0..argc {
23491 let slot: GenericUnionTypes::EventOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23492 Ok(ConversionResult::Success(value)) => value,
23493 Ok(ConversionResult::Failure(error)) => {
23494 throw_type_error(cx.raw_cx(), &error);
23495 return false;
23496
23497 }
23498 _ => {
23499 return false;
23500
23501 },
23502 }
23503 ;
23504 arg0.push(slot);
23505 }
23506 }
23507 let result: () = this.PassVariadicUnion2(arg0);
23508
23509 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23510 return true;
23511 })());
23512 result
23513}
23514
23515
23516static passVariadicUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23517
23518pub(crate) fn init_passVariadicUnion2_methodinfo<D: DomTypes>() {
23519 passVariadicUnion2_methodinfo.set(JSJitInfo {
23520 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23521 method: Some(passVariadicUnion2::<D>)
23522 },
23523 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23524 protoID: PrototypeList::ID::TestBinding as u16,
23525 },
23526 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23527 _bitfield_align_1: [],
23528 _bitfield_1: __BindgenBitfieldUnit::new(
23529 new_jsjitinfo_bitfield_1!(
23530 JSJitInfo_OpType::Method as u8,
23531 JSJitInfo_AliasSet::AliasEverything as u8,
23532 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23533 false,
23534 false,
23535 false,
23536 false,
23537 false,
23538 false,
23539 0,
23540 ).to_ne_bytes()
23541 ),
23542});
23543}
23544unsafe extern "C" fn passVariadicUnion3<D: DomTypes>
23545(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23546 let mut result = false;
23547 wrap_panic(&mut || result = (|| {
23548 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23549 let this = &*(this as *const D::TestBinding);
23550 let args = &*args;
23551 let argc = args.argc_;
23552
23553 let mut arg0 = vec![];
23554 if argc > 0 {
23555 arg0.reserve(argc as usize);
23556 for variadicArg in 0..argc {
23557 let slot: GenericUnionTypes::BlobOrString::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23558 Ok(ConversionResult::Success(value)) => value,
23559 Ok(ConversionResult::Failure(error)) => {
23560 throw_type_error(cx.raw_cx(), &error);
23561 return false;
23562
23563 }
23564 _ => {
23565 return false;
23566
23567 },
23568 }
23569 ;
23570 arg0.push(slot);
23571 }
23572 }
23573 let result: () = this.PassVariadicUnion3(arg0);
23574
23575 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23576 return true;
23577 })());
23578 result
23579}
23580
23581
23582static passVariadicUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23583
23584pub(crate) fn init_passVariadicUnion3_methodinfo<D: DomTypes>() {
23585 passVariadicUnion3_methodinfo.set(JSJitInfo {
23586 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23587 method: Some(passVariadicUnion3::<D>)
23588 },
23589 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23590 protoID: PrototypeList::ID::TestBinding as u16,
23591 },
23592 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23593 _bitfield_align_1: [],
23594 _bitfield_1: __BindgenBitfieldUnit::new(
23595 new_jsjitinfo_bitfield_1!(
23596 JSJitInfo_OpType::Method as u8,
23597 JSJitInfo_AliasSet::AliasEverything as u8,
23598 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23599 false,
23600 false,
23601 false,
23602 false,
23603 false,
23604 false,
23605 0,
23606 ).to_ne_bytes()
23607 ),
23608});
23609}
23610unsafe extern "C" fn passVariadicUnion4<D: DomTypes>
23611(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23612 let mut result = false;
23613 wrap_panic(&mut || result = (|| {
23614 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23615 let this = &*(this as *const D::TestBinding);
23616 let args = &*args;
23617 let argc = args.argc_;
23618
23619 let mut arg0 = vec![];
23620 if argc > 0 {
23621 arg0.reserve(argc as usize);
23622 for variadicArg in 0..argc {
23623 let slot: GenericUnionTypes::BlobOrBoolean::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23624 Ok(ConversionResult::Success(value)) => value,
23625 Ok(ConversionResult::Failure(error)) => {
23626 throw_type_error(cx.raw_cx(), &error);
23627 return false;
23628
23629 }
23630 _ => {
23631 return false;
23632
23633 },
23634 }
23635 ;
23636 arg0.push(slot);
23637 }
23638 }
23639 let result: () = this.PassVariadicUnion4(arg0);
23640
23641 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23642 return true;
23643 })());
23644 result
23645}
23646
23647
23648static passVariadicUnion4_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23649
23650pub(crate) fn init_passVariadicUnion4_methodinfo<D: DomTypes>() {
23651 passVariadicUnion4_methodinfo.set(JSJitInfo {
23652 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23653 method: Some(passVariadicUnion4::<D>)
23654 },
23655 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23656 protoID: PrototypeList::ID::TestBinding as u16,
23657 },
23658 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23659 _bitfield_align_1: [],
23660 _bitfield_1: __BindgenBitfieldUnit::new(
23661 new_jsjitinfo_bitfield_1!(
23662 JSJitInfo_OpType::Method as u8,
23663 JSJitInfo_AliasSet::AliasEverything as u8,
23664 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23665 false,
23666 false,
23667 false,
23668 false,
23669 false,
23670 false,
23671 0,
23672 ).to_ne_bytes()
23673 ),
23674});
23675}
23676unsafe extern "C" fn passVariadicUnion5<D: DomTypes>
23677(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23678 let mut result = false;
23679 wrap_panic(&mut || result = (|| {
23680 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23681 let this = &*(this as *const D::TestBinding);
23682 let args = &*args;
23683 let argc = args.argc_;
23684
23685 let mut arg0 = vec![];
23686 if argc > 0 {
23687 arg0.reserve(argc as usize);
23688 for variadicArg in 0..argc {
23689 let slot: GenericUnionTypes::StringOrUnsignedLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23690 Ok(ConversionResult::Success(value)) => value,
23691 Ok(ConversionResult::Failure(error)) => {
23692 throw_type_error(cx.raw_cx(), &error);
23693 return false;
23694
23695 }
23696 _ => {
23697 return false;
23698
23699 },
23700 }
23701 ;
23702 arg0.push(slot);
23703 }
23704 }
23705 let result: () = this.PassVariadicUnion5(arg0);
23706
23707 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23708 return true;
23709 })());
23710 result
23711}
23712
23713
23714static passVariadicUnion5_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23715
23716pub(crate) fn init_passVariadicUnion5_methodinfo<D: DomTypes>() {
23717 passVariadicUnion5_methodinfo.set(JSJitInfo {
23718 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23719 method: Some(passVariadicUnion5::<D>)
23720 },
23721 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23722 protoID: PrototypeList::ID::TestBinding as u16,
23723 },
23724 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23725 _bitfield_align_1: [],
23726 _bitfield_1: __BindgenBitfieldUnit::new(
23727 new_jsjitinfo_bitfield_1!(
23728 JSJitInfo_OpType::Method as u8,
23729 JSJitInfo_AliasSet::AliasEverything as u8,
23730 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23731 false,
23732 false,
23733 false,
23734 false,
23735 false,
23736 false,
23737 0,
23738 ).to_ne_bytes()
23739 ),
23740});
23741}
23742unsafe extern "C" fn passVariadicUnion6<D: DomTypes>
23743(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23744 let mut result = false;
23745 wrap_panic(&mut || result = (|| {
23746 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23747 let this = &*(this as *const D::TestBinding);
23748 let args = &*args;
23749 let argc = args.argc_;
23750
23751 let mut arg0 = vec![];
23752 if argc > 0 {
23753 arg0.reserve(argc as usize);
23754 for variadicArg in 0..argc {
23755 let slot: GenericUnionTypes::UnsignedLongOrBoolean = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23756 Ok(ConversionResult::Success(value)) => value,
23757 Ok(ConversionResult::Failure(error)) => {
23758 throw_type_error(cx.raw_cx(), &error);
23759 return false;
23760
23761 }
23762 _ => {
23763 return false;
23764
23765 },
23766 }
23767 ;
23768 arg0.push(slot);
23769 }
23770 }
23771 let result: () = this.PassVariadicUnion6(arg0);
23772
23773 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23774 return true;
23775 })());
23776 result
23777}
23778
23779
23780static passVariadicUnion6_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23781
23782pub(crate) fn init_passVariadicUnion6_methodinfo<D: DomTypes>() {
23783 passVariadicUnion6_methodinfo.set(JSJitInfo {
23784 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23785 method: Some(passVariadicUnion6::<D>)
23786 },
23787 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23788 protoID: PrototypeList::ID::TestBinding as u16,
23789 },
23790 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23791 _bitfield_align_1: [],
23792 _bitfield_1: __BindgenBitfieldUnit::new(
23793 new_jsjitinfo_bitfield_1!(
23794 JSJitInfo_OpType::Method as u8,
23795 JSJitInfo_AliasSet::AliasEverything as u8,
23796 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23797 false,
23798 false,
23799 false,
23800 false,
23801 false,
23802 false,
23803 0,
23804 ).to_ne_bytes()
23805 ),
23806});
23807}
23808unsafe extern "C" fn passVariadicUnion7<D: DomTypes>
23809(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23810 let mut result = false;
23811 wrap_panic(&mut || result = (|| {
23812 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23813 let this = &*(this as *const D::TestBinding);
23814 let args = &*args;
23815 let argc = args.argc_;
23816
23817 let mut arg0 = vec![];
23818 if argc > 0 {
23819 arg0.reserve(argc as usize);
23820 for variadicArg in 0..argc {
23821 let slot: GenericUnionTypes::ByteStringOrLong = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(variadicArg)), ()) {
23822 Ok(ConversionResult::Success(value)) => value,
23823 Ok(ConversionResult::Failure(error)) => {
23824 throw_type_error(cx.raw_cx(), &error);
23825 return false;
23826
23827 }
23828 _ => {
23829 return false;
23830
23831 },
23832 }
23833 ;
23834 arg0.push(slot);
23835 }
23836 }
23837 let result: () = this.PassVariadicUnion7(arg0);
23838
23839 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23840 return true;
23841 })());
23842 result
23843}
23844
23845
23846static passVariadicUnion7_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23847
23848pub(crate) fn init_passVariadicUnion7_methodinfo<D: DomTypes>() {
23849 passVariadicUnion7_methodinfo.set(JSJitInfo {
23850 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23851 method: Some(passVariadicUnion7::<D>)
23852 },
23853 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23854 protoID: PrototypeList::ID::TestBinding as u16,
23855 },
23856 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23857 _bitfield_align_1: [],
23858 _bitfield_1: __BindgenBitfieldUnit::new(
23859 new_jsjitinfo_bitfield_1!(
23860 JSJitInfo_OpType::Method as u8,
23861 JSJitInfo_AliasSet::AliasEverything as u8,
23862 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23863 false,
23864 false,
23865 false,
23866 false,
23867 false,
23868 false,
23869 0,
23870 ).to_ne_bytes()
23871 ),
23872});
23873}
23874unsafe extern "C" fn passVariadicAny<D: DomTypes>
23875(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23876 let mut result = false;
23877 wrap_panic(&mut || result = (|| {
23878 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23879 let this = &*(this as *const D::TestBinding);
23880 let args = &*args;
23881 let argc = args.argc_;
23882
23883 let mut arg0 = vec![];
23884 if argc > 0 {
23885 arg0.reserve(argc as usize);
23886 for variadicArg in 0..argc {
23887 let slot: HandleValue = HandleValue::from_raw(args.get(variadicArg));
23888 arg0.push(slot);
23889 }
23890 }
23891 let result: () = this.PassVariadicAny(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
23892
23893 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23894 return true;
23895 })());
23896 result
23897}
23898
23899
23900static passVariadicAny_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23901
23902pub(crate) fn init_passVariadicAny_methodinfo<D: DomTypes>() {
23903 passVariadicAny_methodinfo.set(JSJitInfo {
23904 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23905 method: Some(passVariadicAny::<D>)
23906 },
23907 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23908 protoID: PrototypeList::ID::TestBinding as u16,
23909 },
23910 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23911 _bitfield_align_1: [],
23912 _bitfield_1: __BindgenBitfieldUnit::new(
23913 new_jsjitinfo_bitfield_1!(
23914 JSJitInfo_OpType::Method as u8,
23915 JSJitInfo_AliasSet::AliasEverything as u8,
23916 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23917 false,
23918 false,
23919 false,
23920 false,
23921 false,
23922 false,
23923 0,
23924 ).to_ne_bytes()
23925 ),
23926});
23927}
23928unsafe extern "C" fn passVariadicObject<D: DomTypes>
23929(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23930 let mut result = false;
23931 wrap_panic(&mut || result = (|| {
23932 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23933 let this = &*(this as *const D::TestBinding);
23934 let args = &*args;
23935 let argc = args.argc_;
23936
23937 let mut arg0 = vec![];
23938 if argc > 0 {
23939 arg0.reserve(argc as usize);
23940 for variadicArg in 0..argc {
23941 let slot: *mut JSObject = if HandleValue::from_raw(args.get(variadicArg)).get().is_object() {
23942 HandleValue::from_raw(args.get(variadicArg)).get().to_object()
23943 } else {
23944 throw_type_error(cx.raw_cx(), "Value is not an object.");
23945 return false;
23946
23947 };
23948 arg0.push(slot);
23949 }
23950 }
23951 let result: () = this.PassVariadicObject(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
23952
23953 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
23954 return true;
23955 })());
23956 result
23957}
23958
23959
23960static passVariadicObject_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
23961
23962pub(crate) fn init_passVariadicObject_methodinfo<D: DomTypes>() {
23963 passVariadicObject_methodinfo.set(JSJitInfo {
23964 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
23965 method: Some(passVariadicObject::<D>)
23966 },
23967 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
23968 protoID: PrototypeList::ID::TestBinding as u16,
23969 },
23970 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
23971 _bitfield_align_1: [],
23972 _bitfield_1: __BindgenBitfieldUnit::new(
23973 new_jsjitinfo_bitfield_1!(
23974 JSJitInfo_OpType::Method as u8,
23975 JSJitInfo_AliasSet::AliasEverything as u8,
23976 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
23977 false,
23978 false,
23979 false,
23980 false,
23981 false,
23982 false,
23983 0,
23984 ).to_ne_bytes()
23985 ),
23986});
23987}
23988unsafe extern "C" fn passSequenceSequence<D: DomTypes>
23989(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
23990 let mut result = false;
23991 wrap_panic(&mut || result = (|| {
23992 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
23993 let this = &*(this as *const D::TestBinding);
23994 let args = &*args;
23995 let argc = args.argc_;
23996
23997 if argc < 1 {
23998 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passSequenceSequence\".");
23999 return false;
24000 }
24001 let arg0: Vec<Vec<i32>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24002 Ok(ConversionResult::Success(value)) => value,
24003 Ok(ConversionResult::Failure(error)) => {
24004 throw_type_error(cx.raw_cx(), &error);
24005 return false;
24006
24007 }
24008 _ => {
24009 return false;
24010
24011 },
24012 }
24013 ;
24014 let result: () = this.PassSequenceSequence(arg0);
24015
24016 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24017 return true;
24018 })());
24019 result
24020}
24021
24022
24023static passSequenceSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24024
24025pub(crate) fn init_passSequenceSequence_methodinfo<D: DomTypes>() {
24026 passSequenceSequence_methodinfo.set(JSJitInfo {
24027 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24028 method: Some(passSequenceSequence::<D>)
24029 },
24030 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24031 protoID: PrototypeList::ID::TestBinding as u16,
24032 },
24033 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24034 _bitfield_align_1: [],
24035 _bitfield_1: __BindgenBitfieldUnit::new(
24036 new_jsjitinfo_bitfield_1!(
24037 JSJitInfo_OpType::Method as u8,
24038 JSJitInfo_AliasSet::AliasEverything as u8,
24039 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24040 false,
24041 false,
24042 false,
24043 false,
24044 false,
24045 false,
24046 0,
24047 ).to_ne_bytes()
24048 ),
24049});
24050}
24051unsafe extern "C" fn returnSequenceSequence<D: DomTypes>
24052(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24053 let mut result = false;
24054 wrap_panic(&mut || result = (|| {
24055 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24056 let this = &*(this as *const D::TestBinding);
24057 let args = &*args;
24058 let argc = args.argc_;
24059 let result: Vec<Vec<i32>> = this.ReturnSequenceSequence();
24060
24061 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24062 return true;
24063 })());
24064 result
24065}
24066
24067
24068static returnSequenceSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24069
24070pub(crate) fn init_returnSequenceSequence_methodinfo<D: DomTypes>() {
24071 returnSequenceSequence_methodinfo.set(JSJitInfo {
24072 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24073 method: Some(returnSequenceSequence::<D>)
24074 },
24075 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24076 protoID: PrototypeList::ID::TestBinding as u16,
24077 },
24078 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24079 _bitfield_align_1: [],
24080 _bitfield_1: __BindgenBitfieldUnit::new(
24081 new_jsjitinfo_bitfield_1!(
24082 JSJitInfo_OpType::Method as u8,
24083 JSJitInfo_AliasSet::AliasEverything as u8,
24084 JSValueType::JSVAL_TYPE_OBJECT as u8,
24085 true,
24086 false,
24087 false,
24088 false,
24089 false,
24090 false,
24091 0,
24092 ).to_ne_bytes()
24093 ),
24094});
24095}
24096unsafe extern "C" fn passUnionSequenceSequence<D: DomTypes>
24097(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24098 let mut result = false;
24099 wrap_panic(&mut || result = (|| {
24100 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24101 let this = &*(this as *const D::TestBinding);
24102 let args = &*args;
24103 let argc = args.argc_;
24104
24105 if argc < 1 {
24106 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passUnionSequenceSequence\".");
24107 return false;
24108 }
24109 let arg0: GenericUnionTypes::LongOrLongSequenceSequence = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24110 Ok(ConversionResult::Success(value)) => value,
24111 Ok(ConversionResult::Failure(error)) => {
24112 throw_type_error(cx.raw_cx(), &error);
24113 return false;
24114
24115 }
24116 _ => {
24117 return false;
24118
24119 },
24120 }
24121 ;
24122 let result: () = this.PassUnionSequenceSequence(arg0);
24123
24124 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24125 return true;
24126 })());
24127 result
24128}
24129
24130
24131static passUnionSequenceSequence_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24132
24133pub(crate) fn init_passUnionSequenceSequence_methodinfo<D: DomTypes>() {
24134 passUnionSequenceSequence_methodinfo.set(JSJitInfo {
24135 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24136 method: Some(passUnionSequenceSequence::<D>)
24137 },
24138 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24139 protoID: PrototypeList::ID::TestBinding as u16,
24140 },
24141 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24142 _bitfield_align_1: [],
24143 _bitfield_1: __BindgenBitfieldUnit::new(
24144 new_jsjitinfo_bitfield_1!(
24145 JSJitInfo_OpType::Method as u8,
24146 JSJitInfo_AliasSet::AliasEverything as u8,
24147 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24148 false,
24149 false,
24150 false,
24151 false,
24152 false,
24153 false,
24154 0,
24155 ).to_ne_bytes()
24156 ),
24157});
24158}
24159unsafe extern "C" fn passRecordPromise<D: DomTypes>
24160(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24161 let mut result = false;
24162 wrap_panic(&mut || result = (|| {
24163 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24164 let this = &*(this as *const D::TestBinding);
24165 let args = &*args;
24166 let argc = args.argc_;
24167
24168 if argc < 1 {
24169 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordPromise\".");
24170 return false;
24171 }
24172 let arg0: Record<DOMString, Rc<D::Promise>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24173 Ok(ConversionResult::Success(value)) => value,
24174 Ok(ConversionResult::Failure(error)) => {
24175 throw_type_error(cx.raw_cx(), &error);
24176 return false;
24177
24178 }
24179 _ => {
24180 return false;
24181
24182 },
24183 }
24184 ;
24185 let result: () = this.PassRecordPromise(arg0);
24186
24187 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24188 return true;
24189 })());
24190 result
24191}
24192
24193
24194static passRecordPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24195
24196pub(crate) fn init_passRecordPromise_methodinfo<D: DomTypes>() {
24197 passRecordPromise_methodinfo.set(JSJitInfo {
24198 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24199 method: Some(passRecordPromise::<D>)
24200 },
24201 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24202 protoID: PrototypeList::ID::TestBinding as u16,
24203 },
24204 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24205 _bitfield_align_1: [],
24206 _bitfield_1: __BindgenBitfieldUnit::new(
24207 new_jsjitinfo_bitfield_1!(
24208 JSJitInfo_OpType::Method as u8,
24209 JSJitInfo_AliasSet::AliasEverything as u8,
24210 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24211 false,
24212 false,
24213 false,
24214 false,
24215 false,
24216 false,
24217 0,
24218 ).to_ne_bytes()
24219 ),
24220});
24221}
24222unsafe extern "C" fn passRecord<D: DomTypes>
24223(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24224 let mut result = false;
24225 wrap_panic(&mut || result = (|| {
24226 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24227 let this = &*(this as *const D::TestBinding);
24228 let args = &*args;
24229 let argc = args.argc_;
24230
24231 if argc < 1 {
24232 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecord\".");
24233 return false;
24234 }
24235 let arg0: Record<DOMString, i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24236 Ok(ConversionResult::Success(value)) => value,
24237 Ok(ConversionResult::Failure(error)) => {
24238 throw_type_error(cx.raw_cx(), &error);
24239 return false;
24240
24241 }
24242 _ => {
24243 return false;
24244
24245 },
24246 }
24247 ;
24248 let result: () = this.PassRecord(arg0);
24249
24250 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24251 return true;
24252 })());
24253 result
24254}
24255
24256
24257static passRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24258
24259pub(crate) fn init_passRecord_methodinfo<D: DomTypes>() {
24260 passRecord_methodinfo.set(JSJitInfo {
24261 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24262 method: Some(passRecord::<D>)
24263 },
24264 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24265 protoID: PrototypeList::ID::TestBinding as u16,
24266 },
24267 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24268 _bitfield_align_1: [],
24269 _bitfield_1: __BindgenBitfieldUnit::new(
24270 new_jsjitinfo_bitfield_1!(
24271 JSJitInfo_OpType::Method as u8,
24272 JSJitInfo_AliasSet::AliasEverything as u8,
24273 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24274 false,
24275 false,
24276 false,
24277 false,
24278 false,
24279 false,
24280 0,
24281 ).to_ne_bytes()
24282 ),
24283});
24284}
24285unsafe extern "C" fn passRecordWithUSVStringKey<D: DomTypes>
24286(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24287 let mut result = false;
24288 wrap_panic(&mut || result = (|| {
24289 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24290 let this = &*(this as *const D::TestBinding);
24291 let args = &*args;
24292 let argc = args.argc_;
24293
24294 if argc < 1 {
24295 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordWithUSVStringKey\".");
24296 return false;
24297 }
24298 let arg0: Record<USVString, i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24299 Ok(ConversionResult::Success(value)) => value,
24300 Ok(ConversionResult::Failure(error)) => {
24301 throw_type_error(cx.raw_cx(), &error);
24302 return false;
24303
24304 }
24305 _ => {
24306 return false;
24307
24308 },
24309 }
24310 ;
24311 let result: () = this.PassRecordWithUSVStringKey(arg0);
24312
24313 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24314 return true;
24315 })());
24316 result
24317}
24318
24319
24320static passRecordWithUSVStringKey_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24321
24322pub(crate) fn init_passRecordWithUSVStringKey_methodinfo<D: DomTypes>() {
24323 passRecordWithUSVStringKey_methodinfo.set(JSJitInfo {
24324 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24325 method: Some(passRecordWithUSVStringKey::<D>)
24326 },
24327 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24328 protoID: PrototypeList::ID::TestBinding as u16,
24329 },
24330 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24331 _bitfield_align_1: [],
24332 _bitfield_1: __BindgenBitfieldUnit::new(
24333 new_jsjitinfo_bitfield_1!(
24334 JSJitInfo_OpType::Method as u8,
24335 JSJitInfo_AliasSet::AliasEverything as u8,
24336 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24337 false,
24338 false,
24339 false,
24340 false,
24341 false,
24342 false,
24343 0,
24344 ).to_ne_bytes()
24345 ),
24346});
24347}
24348unsafe extern "C" fn passRecordWithByteStringKey<D: DomTypes>
24349(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24350 let mut result = false;
24351 wrap_panic(&mut || result = (|| {
24352 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24353 let this = &*(this as *const D::TestBinding);
24354 let args = &*args;
24355 let argc = args.argc_;
24356
24357 if argc < 1 {
24358 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordWithByteStringKey\".");
24359 return false;
24360 }
24361 let arg0: Record<ByteString, i32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24362 Ok(ConversionResult::Success(value)) => value,
24363 Ok(ConversionResult::Failure(error)) => {
24364 throw_type_error(cx.raw_cx(), &error);
24365 return false;
24366
24367 }
24368 _ => {
24369 return false;
24370
24371 },
24372 }
24373 ;
24374 let result: () = this.PassRecordWithByteStringKey(arg0);
24375
24376 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24377 return true;
24378 })());
24379 result
24380}
24381
24382
24383static passRecordWithByteStringKey_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24384
24385pub(crate) fn init_passRecordWithByteStringKey_methodinfo<D: DomTypes>() {
24386 passRecordWithByteStringKey_methodinfo.set(JSJitInfo {
24387 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24388 method: Some(passRecordWithByteStringKey::<D>)
24389 },
24390 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24391 protoID: PrototypeList::ID::TestBinding as u16,
24392 },
24393 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24394 _bitfield_align_1: [],
24395 _bitfield_1: __BindgenBitfieldUnit::new(
24396 new_jsjitinfo_bitfield_1!(
24397 JSJitInfo_OpType::Method as u8,
24398 JSJitInfo_AliasSet::AliasEverything as u8,
24399 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24400 false,
24401 false,
24402 false,
24403 false,
24404 false,
24405 false,
24406 0,
24407 ).to_ne_bytes()
24408 ),
24409});
24410}
24411unsafe extern "C" fn passNullableRecord<D: DomTypes>
24412(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24413 let mut result = false;
24414 wrap_panic(&mut || result = (|| {
24415 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24416 let this = &*(this as *const D::TestBinding);
24417 let args = &*args;
24418 let argc = args.argc_;
24419
24420 if argc < 1 {
24421 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableRecord\".");
24422 return false;
24423 }
24424 let arg0: Option<Record<DOMString, i32> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24425 Ok(ConversionResult::Success(value)) => value,
24426 Ok(ConversionResult::Failure(error)) => {
24427 throw_type_error(cx.raw_cx(), &error);
24428 return false;
24429
24430 }
24431 _ => {
24432 return false;
24433
24434 },
24435 }
24436 ;
24437 let result: () = this.PassNullableRecord(arg0);
24438
24439 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24440 return true;
24441 })());
24442 result
24443}
24444
24445
24446static passNullableRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24447
24448pub(crate) fn init_passNullableRecord_methodinfo<D: DomTypes>() {
24449 passNullableRecord_methodinfo.set(JSJitInfo {
24450 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24451 method: Some(passNullableRecord::<D>)
24452 },
24453 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24454 protoID: PrototypeList::ID::TestBinding as u16,
24455 },
24456 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24457 _bitfield_align_1: [],
24458 _bitfield_1: __BindgenBitfieldUnit::new(
24459 new_jsjitinfo_bitfield_1!(
24460 JSJitInfo_OpType::Method as u8,
24461 JSJitInfo_AliasSet::AliasEverything as u8,
24462 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24463 false,
24464 false,
24465 false,
24466 false,
24467 false,
24468 false,
24469 0,
24470 ).to_ne_bytes()
24471 ),
24472});
24473}
24474unsafe extern "C" fn passRecordOfNullableInts<D: DomTypes>
24475(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24476 let mut result = false;
24477 wrap_panic(&mut || result = (|| {
24478 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24479 let this = &*(this as *const D::TestBinding);
24480 let args = &*args;
24481 let argc = args.argc_;
24482
24483 if argc < 1 {
24484 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordOfNullableInts\".");
24485 return false;
24486 }
24487 let arg0: Record<DOMString, Option<i32>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24488 Ok(ConversionResult::Success(value)) => value,
24489 Ok(ConversionResult::Failure(error)) => {
24490 throw_type_error(cx.raw_cx(), &error);
24491 return false;
24492
24493 }
24494 _ => {
24495 return false;
24496
24497 },
24498 }
24499 ;
24500 let result: () = this.PassRecordOfNullableInts(arg0);
24501
24502 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24503 return true;
24504 })());
24505 result
24506}
24507
24508
24509static passRecordOfNullableInts_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24510
24511pub(crate) fn init_passRecordOfNullableInts_methodinfo<D: DomTypes>() {
24512 passRecordOfNullableInts_methodinfo.set(JSJitInfo {
24513 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24514 method: Some(passRecordOfNullableInts::<D>)
24515 },
24516 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24517 protoID: PrototypeList::ID::TestBinding as u16,
24518 },
24519 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24520 _bitfield_align_1: [],
24521 _bitfield_1: __BindgenBitfieldUnit::new(
24522 new_jsjitinfo_bitfield_1!(
24523 JSJitInfo_OpType::Method as u8,
24524 JSJitInfo_AliasSet::AliasEverything as u8,
24525 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24526 false,
24527 false,
24528 false,
24529 false,
24530 false,
24531 false,
24532 0,
24533 ).to_ne_bytes()
24534 ),
24535});
24536}
24537unsafe extern "C" fn passOptionalRecordOfNullableInts<D: DomTypes>
24538(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24539 let mut result = false;
24540 wrap_panic(&mut || result = (|| {
24541 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24542 let this = &*(this as *const D::TestBinding);
24543 let args = &*args;
24544 let argc = args.argc_;
24545 let arg0: Option<Record<DOMString, Option<i32>>> = if args.get(0).is_undefined() {
24546 None
24547 } else {
24548 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24549 Ok(ConversionResult::Success(value)) => value,
24550 Ok(ConversionResult::Failure(error)) => {
24551 throw_type_error(cx.raw_cx(), &error);
24552 return false;
24553
24554 }
24555 _ => {
24556 return false;
24557
24558 },
24559 }
24560 )
24561 };
24562 let result: () = this.PassOptionalRecordOfNullableInts(arg0);
24563
24564 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24565 return true;
24566 })());
24567 result
24568}
24569
24570
24571static passOptionalRecordOfNullableInts_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24572
24573pub(crate) fn init_passOptionalRecordOfNullableInts_methodinfo<D: DomTypes>() {
24574 passOptionalRecordOfNullableInts_methodinfo.set(JSJitInfo {
24575 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24576 method: Some(passOptionalRecordOfNullableInts::<D>)
24577 },
24578 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24579 protoID: PrototypeList::ID::TestBinding as u16,
24580 },
24581 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24582 _bitfield_align_1: [],
24583 _bitfield_1: __BindgenBitfieldUnit::new(
24584 new_jsjitinfo_bitfield_1!(
24585 JSJitInfo_OpType::Method as u8,
24586 JSJitInfo_AliasSet::AliasEverything as u8,
24587 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24588 false,
24589 false,
24590 false,
24591 false,
24592 false,
24593 false,
24594 0,
24595 ).to_ne_bytes()
24596 ),
24597});
24598}
24599unsafe extern "C" fn passOptionalNullableRecordOfNullableInts<D: DomTypes>
24600(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24601 let mut result = false;
24602 wrap_panic(&mut || result = (|| {
24603 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24604 let this = &*(this as *const D::TestBinding);
24605 let args = &*args;
24606 let argc = args.argc_;
24607 let arg0: Option<Option<Record<DOMString, Option<i32>> >> = if args.get(0).is_undefined() {
24608 None
24609 } else {
24610 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24611 Ok(ConversionResult::Success(value)) => value,
24612 Ok(ConversionResult::Failure(error)) => {
24613 throw_type_error(cx.raw_cx(), &error);
24614 return false;
24615
24616 }
24617 _ => {
24618 return false;
24619
24620 },
24621 }
24622 )
24623 };
24624 let result: () = this.PassOptionalNullableRecordOfNullableInts(arg0);
24625
24626 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24627 return true;
24628 })());
24629 result
24630}
24631
24632
24633static passOptionalNullableRecordOfNullableInts_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24634
24635pub(crate) fn init_passOptionalNullableRecordOfNullableInts_methodinfo<D: DomTypes>() {
24636 passOptionalNullableRecordOfNullableInts_methodinfo.set(JSJitInfo {
24637 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24638 method: Some(passOptionalNullableRecordOfNullableInts::<D>)
24639 },
24640 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24641 protoID: PrototypeList::ID::TestBinding as u16,
24642 },
24643 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24644 _bitfield_align_1: [],
24645 _bitfield_1: __BindgenBitfieldUnit::new(
24646 new_jsjitinfo_bitfield_1!(
24647 JSJitInfo_OpType::Method as u8,
24648 JSJitInfo_AliasSet::AliasEverything as u8,
24649 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24650 false,
24651 false,
24652 false,
24653 false,
24654 false,
24655 false,
24656 0,
24657 ).to_ne_bytes()
24658 ),
24659});
24660}
24661unsafe extern "C" fn passCastableObjectRecord<D: DomTypes>
24662(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24663 let mut result = false;
24664 wrap_panic(&mut || result = (|| {
24665 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24666 let this = &*(this as *const D::TestBinding);
24667 let args = &*args;
24668 let argc = args.argc_;
24669
24670 if argc < 1 {
24671 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passCastableObjectRecord\".");
24672 return false;
24673 }
24674 let arg0: Record<DOMString, DomRoot<D::TestBinding>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24675 Ok(ConversionResult::Success(value)) => value,
24676 Ok(ConversionResult::Failure(error)) => {
24677 throw_type_error(cx.raw_cx(), &error);
24678 return false;
24679
24680 }
24681 _ => {
24682 return false;
24683
24684 },
24685 }
24686 ;
24687 let result: () = this.PassCastableObjectRecord(arg0);
24688
24689 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24690 return true;
24691 })());
24692 result
24693}
24694
24695
24696static passCastableObjectRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24697
24698pub(crate) fn init_passCastableObjectRecord_methodinfo<D: DomTypes>() {
24699 passCastableObjectRecord_methodinfo.set(JSJitInfo {
24700 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24701 method: Some(passCastableObjectRecord::<D>)
24702 },
24703 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24704 protoID: PrototypeList::ID::TestBinding as u16,
24705 },
24706 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24707 _bitfield_align_1: [],
24708 _bitfield_1: __BindgenBitfieldUnit::new(
24709 new_jsjitinfo_bitfield_1!(
24710 JSJitInfo_OpType::Method as u8,
24711 JSJitInfo_AliasSet::AliasEverything as u8,
24712 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24713 false,
24714 false,
24715 false,
24716 false,
24717 false,
24718 false,
24719 0,
24720 ).to_ne_bytes()
24721 ),
24722});
24723}
24724unsafe extern "C" fn passNullableCastableObjectRecord<D: DomTypes>
24725(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24726 let mut result = false;
24727 wrap_panic(&mut || result = (|| {
24728 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24729 let this = &*(this as *const D::TestBinding);
24730 let args = &*args;
24731 let argc = args.argc_;
24732
24733 if argc < 1 {
24734 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableCastableObjectRecord\".");
24735 return false;
24736 }
24737 let arg0: Record<DOMString, Option<DomRoot<D::TestBinding>>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24738 Ok(ConversionResult::Success(value)) => value,
24739 Ok(ConversionResult::Failure(error)) => {
24740 throw_type_error(cx.raw_cx(), &error);
24741 return false;
24742
24743 }
24744 _ => {
24745 return false;
24746
24747 },
24748 }
24749 ;
24750 let result: () = this.PassNullableCastableObjectRecord(arg0);
24751
24752 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24753 return true;
24754 })());
24755 result
24756}
24757
24758
24759static passNullableCastableObjectRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24760
24761pub(crate) fn init_passNullableCastableObjectRecord_methodinfo<D: DomTypes>() {
24762 passNullableCastableObjectRecord_methodinfo.set(JSJitInfo {
24763 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24764 method: Some(passNullableCastableObjectRecord::<D>)
24765 },
24766 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24767 protoID: PrototypeList::ID::TestBinding as u16,
24768 },
24769 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24770 _bitfield_align_1: [],
24771 _bitfield_1: __BindgenBitfieldUnit::new(
24772 new_jsjitinfo_bitfield_1!(
24773 JSJitInfo_OpType::Method as u8,
24774 JSJitInfo_AliasSet::AliasEverything as u8,
24775 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24776 false,
24777 false,
24778 false,
24779 false,
24780 false,
24781 false,
24782 0,
24783 ).to_ne_bytes()
24784 ),
24785});
24786}
24787unsafe extern "C" fn passCastableObjectNullableRecord<D: DomTypes>
24788(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24789 let mut result = false;
24790 wrap_panic(&mut || result = (|| {
24791 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24792 let this = &*(this as *const D::TestBinding);
24793 let args = &*args;
24794 let argc = args.argc_;
24795
24796 if argc < 1 {
24797 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passCastableObjectNullableRecord\".");
24798 return false;
24799 }
24800 let arg0: Option<Record<DOMString, DomRoot<D::TestBinding>> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24801 Ok(ConversionResult::Success(value)) => value,
24802 Ok(ConversionResult::Failure(error)) => {
24803 throw_type_error(cx.raw_cx(), &error);
24804 return false;
24805
24806 }
24807 _ => {
24808 return false;
24809
24810 },
24811 }
24812 ;
24813 let result: () = this.PassCastableObjectNullableRecord(arg0);
24814
24815 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24816 return true;
24817 })());
24818 result
24819}
24820
24821
24822static passCastableObjectNullableRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24823
24824pub(crate) fn init_passCastableObjectNullableRecord_methodinfo<D: DomTypes>() {
24825 passCastableObjectNullableRecord_methodinfo.set(JSJitInfo {
24826 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24827 method: Some(passCastableObjectNullableRecord::<D>)
24828 },
24829 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24830 protoID: PrototypeList::ID::TestBinding as u16,
24831 },
24832 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24833 _bitfield_align_1: [],
24834 _bitfield_1: __BindgenBitfieldUnit::new(
24835 new_jsjitinfo_bitfield_1!(
24836 JSJitInfo_OpType::Method as u8,
24837 JSJitInfo_AliasSet::AliasEverything as u8,
24838 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24839 false,
24840 false,
24841 false,
24842 false,
24843 false,
24844 false,
24845 0,
24846 ).to_ne_bytes()
24847 ),
24848});
24849}
24850unsafe extern "C" fn passNullableCastableObjectNullableRecord<D: DomTypes>
24851(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24852 let mut result = false;
24853 wrap_panic(&mut || result = (|| {
24854 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24855 let this = &*(this as *const D::TestBinding);
24856 let args = &*args;
24857 let argc = args.argc_;
24858
24859 if argc < 1 {
24860 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passNullableCastableObjectNullableRecord\".");
24861 return false;
24862 }
24863 let arg0: Option<Record<DOMString, Option<DomRoot<D::TestBinding>>> > = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
24864 Ok(ConversionResult::Success(value)) => value,
24865 Ok(ConversionResult::Failure(error)) => {
24866 throw_type_error(cx.raw_cx(), &error);
24867 return false;
24868
24869 }
24870 _ => {
24871 return false;
24872
24873 },
24874 }
24875 ;
24876 let result: () = this.PassNullableCastableObjectNullableRecord(arg0);
24877
24878 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24879 return true;
24880 })());
24881 result
24882}
24883
24884
24885static passNullableCastableObjectNullableRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24886
24887pub(crate) fn init_passNullableCastableObjectNullableRecord_methodinfo<D: DomTypes>() {
24888 passNullableCastableObjectNullableRecord_methodinfo.set(JSJitInfo {
24889 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24890 method: Some(passNullableCastableObjectNullableRecord::<D>)
24891 },
24892 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24893 protoID: PrototypeList::ID::TestBinding as u16,
24894 },
24895 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24896 _bitfield_align_1: [],
24897 _bitfield_1: __BindgenBitfieldUnit::new(
24898 new_jsjitinfo_bitfield_1!(
24899 JSJitInfo_OpType::Method as u8,
24900 JSJitInfo_AliasSet::AliasEverything as u8,
24901 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24902 false,
24903 false,
24904 false,
24905 false,
24906 false,
24907 false,
24908 0,
24909 ).to_ne_bytes()
24910 ),
24911});
24912}
24913unsafe extern "C" fn passOptionalRecord<D: DomTypes>
24914(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24915 let mut result = false;
24916 wrap_panic(&mut || result = (|| {
24917 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24918 let this = &*(this as *const D::TestBinding);
24919 let args = &*args;
24920 let argc = args.argc_;
24921 let arg0: Option<Record<DOMString, i32>> = if args.get(0).is_undefined() {
24922 None
24923 } else {
24924 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24925 Ok(ConversionResult::Success(value)) => value,
24926 Ok(ConversionResult::Failure(error)) => {
24927 throw_type_error(cx.raw_cx(), &error);
24928 return false;
24929
24930 }
24931 _ => {
24932 return false;
24933
24934 },
24935 }
24936 )
24937 };
24938 let result: () = this.PassOptionalRecord(arg0);
24939
24940 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
24941 return true;
24942 })());
24943 result
24944}
24945
24946
24947static passOptionalRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
24948
24949pub(crate) fn init_passOptionalRecord_methodinfo<D: DomTypes>() {
24950 passOptionalRecord_methodinfo.set(JSJitInfo {
24951 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
24952 method: Some(passOptionalRecord::<D>)
24953 },
24954 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
24955 protoID: PrototypeList::ID::TestBinding as u16,
24956 },
24957 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
24958 _bitfield_align_1: [],
24959 _bitfield_1: __BindgenBitfieldUnit::new(
24960 new_jsjitinfo_bitfield_1!(
24961 JSJitInfo_OpType::Method as u8,
24962 JSJitInfo_AliasSet::AliasEverything as u8,
24963 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
24964 false,
24965 false,
24966 false,
24967 false,
24968 false,
24969 false,
24970 0,
24971 ).to_ne_bytes()
24972 ),
24973});
24974}
24975unsafe extern "C" fn passOptionalNullableRecord<D: DomTypes>
24976(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
24977 let mut result = false;
24978 wrap_panic(&mut || result = (|| {
24979 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
24980 let this = &*(this as *const D::TestBinding);
24981 let args = &*args;
24982 let argc = args.argc_;
24983 let arg0: Option<Option<Record<DOMString, i32> >> = if args.get(0).is_undefined() {
24984 None
24985 } else {
24986 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
24987 Ok(ConversionResult::Success(value)) => value,
24988 Ok(ConversionResult::Failure(error)) => {
24989 throw_type_error(cx.raw_cx(), &error);
24990 return false;
24991
24992 }
24993 _ => {
24994 return false;
24995
24996 },
24997 }
24998 )
24999 };
25000 let result: () = this.PassOptionalNullableRecord(arg0);
25001
25002 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25003 return true;
25004 })());
25005 result
25006}
25007
25008
25009static passOptionalNullableRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25010
25011pub(crate) fn init_passOptionalNullableRecord_methodinfo<D: DomTypes>() {
25012 passOptionalNullableRecord_methodinfo.set(JSJitInfo {
25013 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25014 method: Some(passOptionalNullableRecord::<D>)
25015 },
25016 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25017 protoID: PrototypeList::ID::TestBinding as u16,
25018 },
25019 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25020 _bitfield_align_1: [],
25021 _bitfield_1: __BindgenBitfieldUnit::new(
25022 new_jsjitinfo_bitfield_1!(
25023 JSJitInfo_OpType::Method as u8,
25024 JSJitInfo_AliasSet::AliasEverything as u8,
25025 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25026 false,
25027 false,
25028 false,
25029 false,
25030 false,
25031 false,
25032 0,
25033 ).to_ne_bytes()
25034 ),
25035});
25036}
25037unsafe extern "C" fn passOptionalNullableRecordWithDefaultValue<D: DomTypes>
25038(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25039 let mut result = false;
25040 wrap_panic(&mut || result = (|| {
25041 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25042 let this = &*(this as *const D::TestBinding);
25043 let args = &*args;
25044 let argc = args.argc_;
25045 let arg0: Option<Record<DOMString, i32> > = if args.get(0).is_undefined() {
25046 None
25047 } else {
25048 match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
25049 Ok(ConversionResult::Success(value)) => value,
25050 Ok(ConversionResult::Failure(error)) => {
25051 throw_type_error(cx.raw_cx(), &error);
25052 return false;
25053
25054 }
25055 _ => {
25056 return false;
25057
25058 },
25059 }
25060
25061 };
25062 let result: () = this.PassOptionalNullableRecordWithDefaultValue(arg0);
25063
25064 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25065 return true;
25066 })());
25067 result
25068}
25069
25070
25071static passOptionalNullableRecordWithDefaultValue_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25072
25073pub(crate) fn init_passOptionalNullableRecordWithDefaultValue_methodinfo<D: DomTypes>() {
25074 passOptionalNullableRecordWithDefaultValue_methodinfo.set(JSJitInfo {
25075 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25076 method: Some(passOptionalNullableRecordWithDefaultValue::<D>)
25077 },
25078 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25079 protoID: PrototypeList::ID::TestBinding as u16,
25080 },
25081 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25082 _bitfield_align_1: [],
25083 _bitfield_1: __BindgenBitfieldUnit::new(
25084 new_jsjitinfo_bitfield_1!(
25085 JSJitInfo_OpType::Method as u8,
25086 JSJitInfo_AliasSet::AliasEverything as u8,
25087 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25088 false,
25089 false,
25090 false,
25091 false,
25092 false,
25093 false,
25094 0,
25095 ).to_ne_bytes()
25096 ),
25097});
25098}
25099unsafe extern "C" fn passOptionalObjectRecord<D: DomTypes>
25100(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25101 let mut result = false;
25102 wrap_panic(&mut || result = (|| {
25103 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25104 let this = &*(this as *const D::TestBinding);
25105 let args = &*args;
25106 let argc = args.argc_;
25107 let arg0: Option<Record<DOMString, DomRoot<D::TestBinding>>> = if args.get(0).is_undefined() {
25108 None
25109 } else {
25110 Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25111 Ok(ConversionResult::Success(value)) => value,
25112 Ok(ConversionResult::Failure(error)) => {
25113 throw_type_error(cx.raw_cx(), &error);
25114 return false;
25115
25116 }
25117 _ => {
25118 return false;
25119
25120 },
25121 }
25122 )
25123 };
25124 let result: () = this.PassOptionalObjectRecord(arg0);
25125
25126 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25127 return true;
25128 })());
25129 result
25130}
25131
25132
25133static passOptionalObjectRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25134
25135pub(crate) fn init_passOptionalObjectRecord_methodinfo<D: DomTypes>() {
25136 passOptionalObjectRecord_methodinfo.set(JSJitInfo {
25137 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25138 method: Some(passOptionalObjectRecord::<D>)
25139 },
25140 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25141 protoID: PrototypeList::ID::TestBinding as u16,
25142 },
25143 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25144 _bitfield_align_1: [],
25145 _bitfield_1: __BindgenBitfieldUnit::new(
25146 new_jsjitinfo_bitfield_1!(
25147 JSJitInfo_OpType::Method as u8,
25148 JSJitInfo_AliasSet::AliasEverything as u8,
25149 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25150 false,
25151 false,
25152 false,
25153 false,
25154 false,
25155 false,
25156 0,
25157 ).to_ne_bytes()
25158 ),
25159});
25160}
25161unsafe extern "C" fn passStringRecord<D: DomTypes>
25162(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25163 let mut result = false;
25164 wrap_panic(&mut || result = (|| {
25165 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25166 let this = &*(this as *const D::TestBinding);
25167 let args = &*args;
25168 let argc = args.argc_;
25169
25170 if argc < 1 {
25171 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passStringRecord\".");
25172 return false;
25173 }
25174 let arg0: Record<DOMString, DOMString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
25175 Ok(ConversionResult::Success(value)) => value,
25176 Ok(ConversionResult::Failure(error)) => {
25177 throw_type_error(cx.raw_cx(), &error);
25178 return false;
25179
25180 }
25181 _ => {
25182 return false;
25183
25184 },
25185 }
25186 ;
25187 let result: () = this.PassStringRecord(arg0);
25188
25189 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25190 return true;
25191 })());
25192 result
25193}
25194
25195
25196static passStringRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25197
25198pub(crate) fn init_passStringRecord_methodinfo<D: DomTypes>() {
25199 passStringRecord_methodinfo.set(JSJitInfo {
25200 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25201 method: Some(passStringRecord::<D>)
25202 },
25203 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25204 protoID: PrototypeList::ID::TestBinding as u16,
25205 },
25206 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25207 _bitfield_align_1: [],
25208 _bitfield_1: __BindgenBitfieldUnit::new(
25209 new_jsjitinfo_bitfield_1!(
25210 JSJitInfo_OpType::Method as u8,
25211 JSJitInfo_AliasSet::AliasEverything as u8,
25212 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25213 false,
25214 false,
25215 false,
25216 false,
25217 false,
25218 false,
25219 0,
25220 ).to_ne_bytes()
25221 ),
25222});
25223}
25224unsafe extern "C" fn passByteStringRecord<D: DomTypes>
25225(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25226 let mut result = false;
25227 wrap_panic(&mut || result = (|| {
25228 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25229 let this = &*(this as *const D::TestBinding);
25230 let args = &*args;
25231 let argc = args.argc_;
25232
25233 if argc < 1 {
25234 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passByteStringRecord\".");
25235 return false;
25236 }
25237 let arg0: Record<DOMString, ByteString> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25238 Ok(ConversionResult::Success(value)) => value,
25239 Ok(ConversionResult::Failure(error)) => {
25240 throw_type_error(cx.raw_cx(), &error);
25241 return false;
25242
25243 }
25244 _ => {
25245 return false;
25246
25247 },
25248 }
25249 ;
25250 let result: () = this.PassByteStringRecord(arg0);
25251
25252 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25253 return true;
25254 })());
25255 result
25256}
25257
25258
25259static passByteStringRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25260
25261pub(crate) fn init_passByteStringRecord_methodinfo<D: DomTypes>() {
25262 passByteStringRecord_methodinfo.set(JSJitInfo {
25263 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25264 method: Some(passByteStringRecord::<D>)
25265 },
25266 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25267 protoID: PrototypeList::ID::TestBinding as u16,
25268 },
25269 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25270 _bitfield_align_1: [],
25271 _bitfield_1: __BindgenBitfieldUnit::new(
25272 new_jsjitinfo_bitfield_1!(
25273 JSJitInfo_OpType::Method as u8,
25274 JSJitInfo_AliasSet::AliasEverything as u8,
25275 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25276 false,
25277 false,
25278 false,
25279 false,
25280 false,
25281 false,
25282 0,
25283 ).to_ne_bytes()
25284 ),
25285});
25286}
25287unsafe extern "C" fn passRecordOfRecords<D: DomTypes>
25288(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25289 let mut result = false;
25290 wrap_panic(&mut || result = (|| {
25291 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25292 let this = &*(this as *const D::TestBinding);
25293 let args = &*args;
25294 let argc = args.argc_;
25295
25296 if argc < 1 {
25297 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordOfRecords\".");
25298 return false;
25299 }
25300 let arg0: Record<DOMString, Record<DOMString, i32>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
25301 Ok(ConversionResult::Success(value)) => value,
25302 Ok(ConversionResult::Failure(error)) => {
25303 throw_type_error(cx.raw_cx(), &error);
25304 return false;
25305
25306 }
25307 _ => {
25308 return false;
25309
25310 },
25311 }
25312 ;
25313 let result: () = this.PassRecordOfRecords(arg0);
25314
25315 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25316 return true;
25317 })());
25318 result
25319}
25320
25321
25322static passRecordOfRecords_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25323
25324pub(crate) fn init_passRecordOfRecords_methodinfo<D: DomTypes>() {
25325 passRecordOfRecords_methodinfo.set(JSJitInfo {
25326 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25327 method: Some(passRecordOfRecords::<D>)
25328 },
25329 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25330 protoID: PrototypeList::ID::TestBinding as u16,
25331 },
25332 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25333 _bitfield_align_1: [],
25334 _bitfield_1: __BindgenBitfieldUnit::new(
25335 new_jsjitinfo_bitfield_1!(
25336 JSJitInfo_OpType::Method as u8,
25337 JSJitInfo_AliasSet::AliasEverything as u8,
25338 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25339 false,
25340 false,
25341 false,
25342 false,
25343 false,
25344 false,
25345 0,
25346 ).to_ne_bytes()
25347 ),
25348});
25349}
25350unsafe extern "C" fn passRecordUnion<D: DomTypes>
25351(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25352 let mut result = false;
25353 wrap_panic(&mut || result = (|| {
25354 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25355 let this = &*(this as *const D::TestBinding);
25356 let args = &*args;
25357 let argc = args.argc_;
25358
25359 if argc < 1 {
25360 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordUnion\".");
25361 return false;
25362 }
25363 let arg0: GenericUnionTypes::LongOrStringByteStringRecord = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25364 Ok(ConversionResult::Success(value)) => value,
25365 Ok(ConversionResult::Failure(error)) => {
25366 throw_type_error(cx.raw_cx(), &error);
25367 return false;
25368
25369 }
25370 _ => {
25371 return false;
25372
25373 },
25374 }
25375 ;
25376 let result: () = this.PassRecordUnion(arg0);
25377
25378 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25379 return true;
25380 })());
25381 result
25382}
25383
25384
25385static passRecordUnion_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25386
25387pub(crate) fn init_passRecordUnion_methodinfo<D: DomTypes>() {
25388 passRecordUnion_methodinfo.set(JSJitInfo {
25389 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25390 method: Some(passRecordUnion::<D>)
25391 },
25392 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25393 protoID: PrototypeList::ID::TestBinding as u16,
25394 },
25395 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25396 _bitfield_align_1: [],
25397 _bitfield_1: __BindgenBitfieldUnit::new(
25398 new_jsjitinfo_bitfield_1!(
25399 JSJitInfo_OpType::Method as u8,
25400 JSJitInfo_AliasSet::AliasEverything as u8,
25401 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25402 false,
25403 false,
25404 false,
25405 false,
25406 false,
25407 false,
25408 0,
25409 ).to_ne_bytes()
25410 ),
25411});
25412}
25413unsafe extern "C" fn passRecordUnion2<D: DomTypes>
25414(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25415 let mut result = false;
25416 wrap_panic(&mut || result = (|| {
25417 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25418 let this = &*(this as *const D::TestBinding);
25419 let args = &*args;
25420 let argc = args.argc_;
25421
25422 if argc < 1 {
25423 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordUnion2\".");
25424 return false;
25425 }
25426 let arg0: GenericUnionTypes::TestBindingOrStringByteStringRecord::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25427 Ok(ConversionResult::Success(value)) => value,
25428 Ok(ConversionResult::Failure(error)) => {
25429 throw_type_error(cx.raw_cx(), &error);
25430 return false;
25431
25432 }
25433 _ => {
25434 return false;
25435
25436 },
25437 }
25438 ;
25439 let result: () = this.PassRecordUnion2(arg0);
25440
25441 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25442 return true;
25443 })());
25444 result
25445}
25446
25447
25448static passRecordUnion2_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25449
25450pub(crate) fn init_passRecordUnion2_methodinfo<D: DomTypes>() {
25451 passRecordUnion2_methodinfo.set(JSJitInfo {
25452 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25453 method: Some(passRecordUnion2::<D>)
25454 },
25455 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25456 protoID: PrototypeList::ID::TestBinding as u16,
25457 },
25458 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25459 _bitfield_align_1: [],
25460 _bitfield_1: __BindgenBitfieldUnit::new(
25461 new_jsjitinfo_bitfield_1!(
25462 JSJitInfo_OpType::Method as u8,
25463 JSJitInfo_AliasSet::AliasEverything as u8,
25464 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25465 false,
25466 false,
25467 false,
25468 false,
25469 false,
25470 false,
25471 0,
25472 ).to_ne_bytes()
25473 ),
25474});
25475}
25476unsafe extern "C" fn passRecordUnion3<D: DomTypes>
25477(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25478 let mut result = false;
25479 wrap_panic(&mut || result = (|| {
25480 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25481 let this = &*(this as *const D::TestBinding);
25482 let args = &*args;
25483 let argc = args.argc_;
25484
25485 if argc < 1 {
25486 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.passRecordUnion3\".");
25487 return false;
25488 }
25489 let arg0: GenericUnionTypes::TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25490 Ok(ConversionResult::Success(value)) => value,
25491 Ok(ConversionResult::Failure(error)) => {
25492 throw_type_error(cx.raw_cx(), &error);
25493 return false;
25494
25495 }
25496 _ => {
25497 return false;
25498
25499 },
25500 }
25501 ;
25502 let result: () = this.PassRecordUnion3(arg0);
25503
25504 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25505 return true;
25506 })());
25507 result
25508}
25509
25510
25511static passRecordUnion3_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25512
25513pub(crate) fn init_passRecordUnion3_methodinfo<D: DomTypes>() {
25514 passRecordUnion3_methodinfo.set(JSJitInfo {
25515 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25516 method: Some(passRecordUnion3::<D>)
25517 },
25518 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25519 protoID: PrototypeList::ID::TestBinding as u16,
25520 },
25521 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25522 _bitfield_align_1: [],
25523 _bitfield_1: __BindgenBitfieldUnit::new(
25524 new_jsjitinfo_bitfield_1!(
25525 JSJitInfo_OpType::Method as u8,
25526 JSJitInfo_AliasSet::AliasEverything as u8,
25527 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
25528 false,
25529 false,
25530 false,
25531 false,
25532 false,
25533 false,
25534 0,
25535 ).to_ne_bytes()
25536 ),
25537});
25538}
25539unsafe extern "C" fn receiveRecord<D: DomTypes>
25540(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25541 let mut result = false;
25542 wrap_panic(&mut || result = (|| {
25543 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25544 let this = &*(this as *const D::TestBinding);
25545 let args = &*args;
25546 let argc = args.argc_;
25547 let result: Record<DOMString, i32> = this.ReceiveRecord();
25548
25549 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25550 return true;
25551 })());
25552 result
25553}
25554
25555
25556static receiveRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25557
25558pub(crate) fn init_receiveRecord_methodinfo<D: DomTypes>() {
25559 receiveRecord_methodinfo.set(JSJitInfo {
25560 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25561 method: Some(receiveRecord::<D>)
25562 },
25563 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25564 protoID: PrototypeList::ID::TestBinding as u16,
25565 },
25566 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25567 _bitfield_align_1: [],
25568 _bitfield_1: __BindgenBitfieldUnit::new(
25569 new_jsjitinfo_bitfield_1!(
25570 JSJitInfo_OpType::Method as u8,
25571 JSJitInfo_AliasSet::AliasEverything as u8,
25572 JSValueType::JSVAL_TYPE_OBJECT as u8,
25573 true,
25574 false,
25575 false,
25576 false,
25577 false,
25578 false,
25579 0,
25580 ).to_ne_bytes()
25581 ),
25582});
25583}
25584unsafe extern "C" fn receiveRecordWithUSVStringKey<D: DomTypes>
25585(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25586 let mut result = false;
25587 wrap_panic(&mut || result = (|| {
25588 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25589 let this = &*(this as *const D::TestBinding);
25590 let args = &*args;
25591 let argc = args.argc_;
25592 let result: Record<USVString, i32> = this.ReceiveRecordWithUSVStringKey();
25593
25594 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25595 return true;
25596 })());
25597 result
25598}
25599
25600
25601static receiveRecordWithUSVStringKey_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25602
25603pub(crate) fn init_receiveRecordWithUSVStringKey_methodinfo<D: DomTypes>() {
25604 receiveRecordWithUSVStringKey_methodinfo.set(JSJitInfo {
25605 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25606 method: Some(receiveRecordWithUSVStringKey::<D>)
25607 },
25608 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25609 protoID: PrototypeList::ID::TestBinding as u16,
25610 },
25611 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25612 _bitfield_align_1: [],
25613 _bitfield_1: __BindgenBitfieldUnit::new(
25614 new_jsjitinfo_bitfield_1!(
25615 JSJitInfo_OpType::Method as u8,
25616 JSJitInfo_AliasSet::AliasEverything as u8,
25617 JSValueType::JSVAL_TYPE_OBJECT as u8,
25618 true,
25619 false,
25620 false,
25621 false,
25622 false,
25623 false,
25624 0,
25625 ).to_ne_bytes()
25626 ),
25627});
25628}
25629unsafe extern "C" fn receiveRecordWithByteStringKey<D: DomTypes>
25630(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25631 let mut result = false;
25632 wrap_panic(&mut || result = (|| {
25633 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25634 let this = &*(this as *const D::TestBinding);
25635 let args = &*args;
25636 let argc = args.argc_;
25637 let result: Record<ByteString, i32> = this.ReceiveRecordWithByteStringKey();
25638
25639 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25640 return true;
25641 })());
25642 result
25643}
25644
25645
25646static receiveRecordWithByteStringKey_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25647
25648pub(crate) fn init_receiveRecordWithByteStringKey_methodinfo<D: DomTypes>() {
25649 receiveRecordWithByteStringKey_methodinfo.set(JSJitInfo {
25650 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25651 method: Some(receiveRecordWithByteStringKey::<D>)
25652 },
25653 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25654 protoID: PrototypeList::ID::TestBinding as u16,
25655 },
25656 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25657 _bitfield_align_1: [],
25658 _bitfield_1: __BindgenBitfieldUnit::new(
25659 new_jsjitinfo_bitfield_1!(
25660 JSJitInfo_OpType::Method as u8,
25661 JSJitInfo_AliasSet::AliasEverything as u8,
25662 JSValueType::JSVAL_TYPE_OBJECT as u8,
25663 true,
25664 false,
25665 false,
25666 false,
25667 false,
25668 false,
25669 0,
25670 ).to_ne_bytes()
25671 ),
25672});
25673}
25674unsafe extern "C" fn receiveNullableRecord<D: DomTypes>
25675(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25676 let mut result = false;
25677 wrap_panic(&mut || result = (|| {
25678 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25679 let this = &*(this as *const D::TestBinding);
25680 let args = &*args;
25681 let argc = args.argc_;
25682 let result: Option<Record<DOMString, i32>> = this.ReceiveNullableRecord();
25683
25684 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25685 return true;
25686 })());
25687 result
25688}
25689
25690
25691static receiveNullableRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25692
25693pub(crate) fn init_receiveNullableRecord_methodinfo<D: DomTypes>() {
25694 receiveNullableRecord_methodinfo.set(JSJitInfo {
25695 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25696 method: Some(receiveNullableRecord::<D>)
25697 },
25698 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25699 protoID: PrototypeList::ID::TestBinding as u16,
25700 },
25701 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25702 _bitfield_align_1: [],
25703 _bitfield_1: __BindgenBitfieldUnit::new(
25704 new_jsjitinfo_bitfield_1!(
25705 JSJitInfo_OpType::Method as u8,
25706 JSJitInfo_AliasSet::AliasEverything as u8,
25707 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
25708 true,
25709 false,
25710 false,
25711 false,
25712 false,
25713 false,
25714 0,
25715 ).to_ne_bytes()
25716 ),
25717});
25718}
25719unsafe extern "C" fn receiveRecordOfNullableInts<D: DomTypes>
25720(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25721 let mut result = false;
25722 wrap_panic(&mut || result = (|| {
25723 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25724 let this = &*(this as *const D::TestBinding);
25725 let args = &*args;
25726 let argc = args.argc_;
25727 let result: Record<DOMString, Option<i32>> = this.ReceiveRecordOfNullableInts();
25728
25729 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25730 return true;
25731 })());
25732 result
25733}
25734
25735
25736static receiveRecordOfNullableInts_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25737
25738pub(crate) fn init_receiveRecordOfNullableInts_methodinfo<D: DomTypes>() {
25739 receiveRecordOfNullableInts_methodinfo.set(JSJitInfo {
25740 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25741 method: Some(receiveRecordOfNullableInts::<D>)
25742 },
25743 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25744 protoID: PrototypeList::ID::TestBinding as u16,
25745 },
25746 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25747 _bitfield_align_1: [],
25748 _bitfield_1: __BindgenBitfieldUnit::new(
25749 new_jsjitinfo_bitfield_1!(
25750 JSJitInfo_OpType::Method as u8,
25751 JSJitInfo_AliasSet::AliasEverything as u8,
25752 JSValueType::JSVAL_TYPE_OBJECT as u8,
25753 true,
25754 false,
25755 false,
25756 false,
25757 false,
25758 false,
25759 0,
25760 ).to_ne_bytes()
25761 ),
25762});
25763}
25764unsafe extern "C" fn receiveNullableRecordOfNullableInts<D: DomTypes>
25765(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25766 let mut result = false;
25767 wrap_panic(&mut || result = (|| {
25768 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25769 let this = &*(this as *const D::TestBinding);
25770 let args = &*args;
25771 let argc = args.argc_;
25772 let result: Option<Record<DOMString, Option<i32>>> = this.ReceiveNullableRecordOfNullableInts();
25773
25774 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25775 return true;
25776 })());
25777 result
25778}
25779
25780
25781static receiveNullableRecordOfNullableInts_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25782
25783pub(crate) fn init_receiveNullableRecordOfNullableInts_methodinfo<D: DomTypes>() {
25784 receiveNullableRecordOfNullableInts_methodinfo.set(JSJitInfo {
25785 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25786 method: Some(receiveNullableRecordOfNullableInts::<D>)
25787 },
25788 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25789 protoID: PrototypeList::ID::TestBinding as u16,
25790 },
25791 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25792 _bitfield_align_1: [],
25793 _bitfield_1: __BindgenBitfieldUnit::new(
25794 new_jsjitinfo_bitfield_1!(
25795 JSJitInfo_OpType::Method as u8,
25796 JSJitInfo_AliasSet::AliasEverything as u8,
25797 JSValueType::JSVAL_TYPE_UNKNOWN as u8,
25798 true,
25799 false,
25800 false,
25801 false,
25802 false,
25803 false,
25804 0,
25805 ).to_ne_bytes()
25806 ),
25807});
25808}
25809unsafe extern "C" fn receiveRecordOfRecords<D: DomTypes>
25810(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25811 let mut result = false;
25812 wrap_panic(&mut || result = (|| {
25813 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25814 let this = &*(this as *const D::TestBinding);
25815 let args = &*args;
25816 let argc = args.argc_;
25817 let result: Record<DOMString, Record<DOMString, i32>> = this.ReceiveRecordOfRecords();
25818
25819 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25820 return true;
25821 })());
25822 result
25823}
25824
25825
25826static receiveRecordOfRecords_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25827
25828pub(crate) fn init_receiveRecordOfRecords_methodinfo<D: DomTypes>() {
25829 receiveRecordOfRecords_methodinfo.set(JSJitInfo {
25830 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25831 method: Some(receiveRecordOfRecords::<D>)
25832 },
25833 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25834 protoID: PrototypeList::ID::TestBinding as u16,
25835 },
25836 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25837 _bitfield_align_1: [],
25838 _bitfield_1: __BindgenBitfieldUnit::new(
25839 new_jsjitinfo_bitfield_1!(
25840 JSJitInfo_OpType::Method as u8,
25841 JSJitInfo_AliasSet::AliasEverything as u8,
25842 JSValueType::JSVAL_TYPE_OBJECT as u8,
25843 true,
25844 false,
25845 false,
25846 false,
25847 false,
25848 false,
25849 0,
25850 ).to_ne_bytes()
25851 ),
25852});
25853}
25854unsafe extern "C" fn receiveAnyRecord<D: DomTypes>
25855(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25856 let mut result = false;
25857 wrap_panic(&mut || result = (|| {
25858 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25859 let this = &*(this as *const D::TestBinding);
25860 let args = &*args;
25861 let argc = args.argc_;
25862 let result: Record<DOMString, JSVal> = this.ReceiveAnyRecord();
25863
25864 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25865 return true;
25866 })());
25867 result
25868}
25869
25870
25871static receiveAnyRecord_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25872
25873pub(crate) fn init_receiveAnyRecord_methodinfo<D: DomTypes>() {
25874 receiveAnyRecord_methodinfo.set(JSJitInfo {
25875 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
25876 method: Some(receiveAnyRecord::<D>)
25877 },
25878 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
25879 protoID: PrototypeList::ID::TestBinding as u16,
25880 },
25881 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
25882 _bitfield_align_1: [],
25883 _bitfield_1: __BindgenBitfieldUnit::new(
25884 new_jsjitinfo_bitfield_1!(
25885 JSJitInfo_OpType::Method as u8,
25886 JSJitInfo_AliasSet::AliasEverything as u8,
25887 JSValueType::JSVAL_TYPE_OBJECT as u8,
25888 true,
25889 false,
25890 false,
25891 false,
25892 false,
25893 false,
25894 0,
25895 ).to_ne_bytes()
25896 ),
25897});
25898}
25899unsafe extern "C" fn get_booleanAttributeStatic<D: DomTypes>
25900(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
25901 let mut result = false;
25902 wrap_panic(&mut || result = (|| {
25903 let args = CallArgs::from_vp(vp, argc);
25904 let global = D::GlobalScope::from_object(args.callee());
25905 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25906 let args = CallArgs::from_vp(vp, argc);
25907 let result: bool = <D::TestBinding>::BooleanAttributeStatic(&global);
25908
25909 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25910 return true;
25911 })());
25912 result
25913}
25914
25915unsafe extern "C" fn set_booleanAttributeStatic<D: DomTypes>
25916(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
25917 let mut result = false;
25918 wrap_panic(&mut || result = (|| {
25919 let args = CallArgs::from_vp(vp, argc);
25920 let global = D::GlobalScope::from_object(args.callee());
25921 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25922 let args = CallArgs::from_vp(vp, argc);
25923 if argc == 0 {
25924 throw_type_error(cx.raw_cx(), "Not enough arguments to booleanAttributeStatic setter.");
25925 return false;
25926 }let arg0: bool = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
25927 Ok(ConversionResult::Success(value)) => value,
25928 Ok(ConversionResult::Failure(error)) => {
25929 throw_type_error(cx.raw_cx(), &error);
25930 return false;
25931
25932 }
25933 _ => {
25934 return false;
25935
25936 },
25937 }
25938 ;
25939 let result: () = <D::TestBinding>::SetBooleanAttributeStatic(&global, arg0);
25940
25941 true
25942 })());
25943 result
25944}
25945
25946unsafe extern "C" fn receiveVoidStatic<D: DomTypes>
25947(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
25948 let mut result = false;
25949 wrap_panic(&mut || result = (|| {
25950 let args = CallArgs::from_vp(vp, argc);
25951 let global = D::GlobalScope::from_object(args.callee());
25952 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25953 let args = CallArgs::from_vp(vp, argc);
25954 let result: () = <D::TestBinding>::ReceiveVoidStatic(&global);
25955
25956 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25957 return true;
25958 })());
25959 result
25960}
25961
25962unsafe extern "C" fn BooleanMozPreference<D: DomTypes>
25963(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
25964 let mut result = false;
25965 wrap_panic(&mut || result = (|| {
25966 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
25967 let this = &*(this as *const D::TestBinding);
25968 let args = &*args;
25969 let argc = args.argc_;
25970
25971 if argc < 1 {
25972 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.BooleanMozPreference\".");
25973 return false;
25974 }
25975 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
25976 Ok(ConversionResult::Success(value)) => value,
25977 Ok(ConversionResult::Failure(error)) => {
25978 throw_type_error(cx.raw_cx(), &error);
25979 return false;
25980
25981 }
25982 _ => {
25983 return false;
25984
25985 },
25986 }
25987 ;
25988 let result: bool = this.BooleanMozPreference(arg0);
25989
25990 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
25991 return true;
25992 })());
25993 result
25994}
25995
25996
25997static BooleanMozPreference_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
25998
25999pub(crate) fn init_BooleanMozPreference_methodinfo<D: DomTypes>() {
26000 BooleanMozPreference_methodinfo.set(JSJitInfo {
26001 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26002 method: Some(BooleanMozPreference::<D>)
26003 },
26004 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26005 protoID: PrototypeList::ID::TestBinding as u16,
26006 },
26007 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26008 _bitfield_align_1: [],
26009 _bitfield_1: __BindgenBitfieldUnit::new(
26010 new_jsjitinfo_bitfield_1!(
26011 JSJitInfo_OpType::Method as u8,
26012 JSJitInfo_AliasSet::AliasEverything as u8,
26013 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
26014 false,
26015 false,
26016 false,
26017 false,
26018 false,
26019 false,
26020 0,
26021 ).to_ne_bytes()
26022 ),
26023});
26024}
26025unsafe extern "C" fn StringMozPreference<D: DomTypes>
26026(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26027 let mut result = false;
26028 wrap_panic(&mut || result = (|| {
26029 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26030 let this = &*(this as *const D::TestBinding);
26031 let args = &*args;
26032 let argc = args.argc_;
26033
26034 if argc < 1 {
26035 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.StringMozPreference\".");
26036 return false;
26037 }
26038 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
26039 Ok(ConversionResult::Success(value)) => value,
26040 Ok(ConversionResult::Failure(error)) => {
26041 throw_type_error(cx.raw_cx(), &error);
26042 return false;
26043
26044 }
26045 _ => {
26046 return false;
26047
26048 },
26049 }
26050 ;
26051 let result: DOMString = this.StringMozPreference(arg0);
26052
26053 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26054 return true;
26055 })());
26056 result
26057}
26058
26059
26060static StringMozPreference_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26061
26062pub(crate) fn init_StringMozPreference_methodinfo<D: DomTypes>() {
26063 StringMozPreference_methodinfo.set(JSJitInfo {
26064 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26065 method: Some(StringMozPreference::<D>)
26066 },
26067 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26068 protoID: PrototypeList::ID::TestBinding as u16,
26069 },
26070 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26071 _bitfield_align_1: [],
26072 _bitfield_1: __BindgenBitfieldUnit::new(
26073 new_jsjitinfo_bitfield_1!(
26074 JSJitInfo_OpType::Method as u8,
26075 JSJitInfo_AliasSet::AliasEverything as u8,
26076 JSValueType::JSVAL_TYPE_STRING as u8,
26077 false,
26078 false,
26079 false,
26080 false,
26081 false,
26082 false,
26083 0,
26084 ).to_ne_bytes()
26085 ),
26086});
26087}
26088unsafe extern "C" fn get_prefControlledAttributeDisabled<D: DomTypes>
26089(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26090 let mut result = false;
26091 wrap_panic(&mut || result = (|| {
26092 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26093 let this = &*(this as *const D::TestBinding);
26094 let result: bool = this.PrefControlledAttributeDisabled();
26095
26096 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26097 return true;
26098 })());
26099 result
26100}
26101
26102
26103static prefControlledAttributeDisabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26104
26105pub(crate) fn init_prefControlledAttributeDisabled_getterinfo<D: DomTypes>() {
26106 prefControlledAttributeDisabled_getterinfo.set(JSJitInfo {
26107 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26108 getter: Some(get_prefControlledAttributeDisabled::<D>)
26109 },
26110 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26111 protoID: PrototypeList::ID::TestBinding as u16,
26112 },
26113 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26114 _bitfield_align_1: [],
26115 _bitfield_1: __BindgenBitfieldUnit::new(
26116 new_jsjitinfo_bitfield_1!(
26117 JSJitInfo_OpType::Getter as u8,
26118 JSJitInfo_AliasSet::AliasEverything as u8,
26119 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
26120 true,
26121 false,
26122 false,
26123 false,
26124 false,
26125 false,
26126 0,
26127 ).to_ne_bytes()
26128 ),
26129});
26130}
26131unsafe extern "C" fn get_prefControlledStaticAttributeDisabled<D: DomTypes>
26132(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26133 let mut result = false;
26134 wrap_panic(&mut || result = (|| {
26135 let args = CallArgs::from_vp(vp, argc);
26136 let global = D::GlobalScope::from_object(args.callee());
26137 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26138 let args = CallArgs::from_vp(vp, argc);
26139 let result: bool = <D::TestBinding>::PrefControlledStaticAttributeDisabled(&global);
26140
26141 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26142 return true;
26143 })());
26144 result
26145}
26146
26147unsafe extern "C" fn prefControlledMethodDisabled<D: DomTypes>
26148(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26149 let mut result = false;
26150 wrap_panic(&mut || result = (|| {
26151 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26152 let this = &*(this as *const D::TestBinding);
26153 let args = &*args;
26154 let argc = args.argc_;
26155 let result: () = this.PrefControlledMethodDisabled();
26156
26157 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26158 return true;
26159 })());
26160 result
26161}
26162
26163
26164static prefControlledMethodDisabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26165
26166pub(crate) fn init_prefControlledMethodDisabled_methodinfo<D: DomTypes>() {
26167 prefControlledMethodDisabled_methodinfo.set(JSJitInfo {
26168 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26169 method: Some(prefControlledMethodDisabled::<D>)
26170 },
26171 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26172 protoID: PrototypeList::ID::TestBinding as u16,
26173 },
26174 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26175 _bitfield_align_1: [],
26176 _bitfield_1: __BindgenBitfieldUnit::new(
26177 new_jsjitinfo_bitfield_1!(
26178 JSJitInfo_OpType::Method as u8,
26179 JSJitInfo_AliasSet::AliasEverything as u8,
26180 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26181 true,
26182 false,
26183 false,
26184 false,
26185 false,
26186 false,
26187 0,
26188 ).to_ne_bytes()
26189 ),
26190});
26191}
26192unsafe extern "C" fn prefControlledStaticMethodDisabled<D: DomTypes>
26193(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26194 let mut result = false;
26195 wrap_panic(&mut || result = (|| {
26196 let args = CallArgs::from_vp(vp, argc);
26197 let global = D::GlobalScope::from_object(args.callee());
26198 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26199 let args = CallArgs::from_vp(vp, argc);
26200 let result: () = <D::TestBinding>::PrefControlledStaticMethodDisabled(&global);
26201
26202 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26203 return true;
26204 })());
26205 result
26206}
26207
26208unsafe extern "C" fn advanceClock<D: DomTypes>
26209(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26210 let mut result = false;
26211 wrap_panic(&mut || result = (|| {
26212 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26213 let this = &*(this as *const D::TestBinding);
26214 let args = &*args;
26215 let argc = args.argc_;
26216
26217 if argc < 1 {
26218 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.advanceClock\".");
26219 return false;
26220 }
26221 let arg0: i32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
26222 Ok(ConversionResult::Success(value)) => value,
26223 Ok(ConversionResult::Failure(error)) => {
26224 throw_type_error(cx.raw_cx(), &error);
26225 return false;
26226
26227 }
26228 _ => {
26229 return false;
26230
26231 },
26232 }
26233 ;
26234 let result: () = this.AdvanceClock(arg0);
26235
26236 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26237 return true;
26238 })());
26239 result
26240}
26241
26242
26243static advanceClock_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26244
26245pub(crate) fn init_advanceClock_methodinfo<D: DomTypes>() {
26246 advanceClock_methodinfo.set(JSJitInfo {
26247 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26248 method: Some(advanceClock::<D>)
26249 },
26250 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26251 protoID: PrototypeList::ID::TestBinding as u16,
26252 },
26253 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26254 _bitfield_align_1: [],
26255 _bitfield_1: __BindgenBitfieldUnit::new(
26256 new_jsjitinfo_bitfield_1!(
26257 JSJitInfo_OpType::Method as u8,
26258 JSJitInfo_AliasSet::AliasEverything as u8,
26259 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26260 false,
26261 false,
26262 false,
26263 false,
26264 false,
26265 false,
26266 0,
26267 ).to_ne_bytes()
26268 ),
26269});
26270}
26271unsafe extern "C" fn get_prefControlledAttributeEnabled<D: DomTypes>
26272(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26273 let mut result = false;
26274 wrap_panic(&mut || result = (|| {
26275 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26276 let this = &*(this as *const D::TestBinding);
26277 let result: bool = this.PrefControlledAttributeEnabled();
26278
26279 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26280 return true;
26281 })());
26282 result
26283}
26284
26285
26286static prefControlledAttributeEnabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26287
26288pub(crate) fn init_prefControlledAttributeEnabled_getterinfo<D: DomTypes>() {
26289 prefControlledAttributeEnabled_getterinfo.set(JSJitInfo {
26290 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26291 getter: Some(get_prefControlledAttributeEnabled::<D>)
26292 },
26293 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26294 protoID: PrototypeList::ID::TestBinding as u16,
26295 },
26296 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26297 _bitfield_align_1: [],
26298 _bitfield_1: __BindgenBitfieldUnit::new(
26299 new_jsjitinfo_bitfield_1!(
26300 JSJitInfo_OpType::Getter as u8,
26301 JSJitInfo_AliasSet::AliasEverything as u8,
26302 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
26303 true,
26304 false,
26305 false,
26306 false,
26307 false,
26308 false,
26309 0,
26310 ).to_ne_bytes()
26311 ),
26312});
26313}
26314unsafe extern "C" fn get_prefControlledStaticAttributeEnabled<D: DomTypes>
26315(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26316 let mut result = false;
26317 wrap_panic(&mut || result = (|| {
26318 let args = CallArgs::from_vp(vp, argc);
26319 let global = D::GlobalScope::from_object(args.callee());
26320 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26321 let args = CallArgs::from_vp(vp, argc);
26322 let result: bool = <D::TestBinding>::PrefControlledStaticAttributeEnabled(&global);
26323
26324 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26325 return true;
26326 })());
26327 result
26328}
26329
26330unsafe extern "C" fn prefControlledMethodEnabled<D: DomTypes>
26331(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26332 let mut result = false;
26333 wrap_panic(&mut || result = (|| {
26334 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26335 let this = &*(this as *const D::TestBinding);
26336 let args = &*args;
26337 let argc = args.argc_;
26338 let result: () = this.PrefControlledMethodEnabled();
26339
26340 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26341 return true;
26342 })());
26343 result
26344}
26345
26346
26347static prefControlledMethodEnabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26348
26349pub(crate) fn init_prefControlledMethodEnabled_methodinfo<D: DomTypes>() {
26350 prefControlledMethodEnabled_methodinfo.set(JSJitInfo {
26351 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26352 method: Some(prefControlledMethodEnabled::<D>)
26353 },
26354 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26355 protoID: PrototypeList::ID::TestBinding as u16,
26356 },
26357 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26358 _bitfield_align_1: [],
26359 _bitfield_1: __BindgenBitfieldUnit::new(
26360 new_jsjitinfo_bitfield_1!(
26361 JSJitInfo_OpType::Method as u8,
26362 JSJitInfo_AliasSet::AliasEverything as u8,
26363 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26364 true,
26365 false,
26366 false,
26367 false,
26368 false,
26369 false,
26370 0,
26371 ).to_ne_bytes()
26372 ),
26373});
26374}
26375unsafe extern "C" fn prefControlledStaticMethodEnabled<D: DomTypes>
26376(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26377 let mut result = false;
26378 wrap_panic(&mut || result = (|| {
26379 let args = CallArgs::from_vp(vp, argc);
26380 let global = D::GlobalScope::from_object(args.callee());
26381 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26382 let args = CallArgs::from_vp(vp, argc);
26383 let result: () = <D::TestBinding>::PrefControlledStaticMethodEnabled(&global);
26384
26385 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26386 return true;
26387 })());
26388 result
26389}
26390
26391unsafe extern "C" fn get_funcControlledAttributeDisabled<D: DomTypes>
26392(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26393 let mut result = false;
26394 wrap_panic(&mut || result = (|| {
26395 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26396 let this = &*(this as *const D::TestBinding);
26397 let result: bool = this.FuncControlledAttributeDisabled();
26398
26399 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26400 return true;
26401 })());
26402 result
26403}
26404
26405
26406static funcControlledAttributeDisabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26407
26408pub(crate) fn init_funcControlledAttributeDisabled_getterinfo<D: DomTypes>() {
26409 funcControlledAttributeDisabled_getterinfo.set(JSJitInfo {
26410 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26411 getter: Some(get_funcControlledAttributeDisabled::<D>)
26412 },
26413 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26414 protoID: PrototypeList::ID::TestBinding as u16,
26415 },
26416 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26417 _bitfield_align_1: [],
26418 _bitfield_1: __BindgenBitfieldUnit::new(
26419 new_jsjitinfo_bitfield_1!(
26420 JSJitInfo_OpType::Getter as u8,
26421 JSJitInfo_AliasSet::AliasEverything as u8,
26422 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
26423 true,
26424 false,
26425 false,
26426 false,
26427 false,
26428 false,
26429 0,
26430 ).to_ne_bytes()
26431 ),
26432});
26433}
26434unsafe extern "C" fn get_funcControlledStaticAttributeDisabled<D: DomTypes>
26435(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26436 let mut result = false;
26437 wrap_panic(&mut || result = (|| {
26438 let args = CallArgs::from_vp(vp, argc);
26439 let global = D::GlobalScope::from_object(args.callee());
26440 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26441 let args = CallArgs::from_vp(vp, argc);
26442 let result: bool = <D::TestBinding>::FuncControlledStaticAttributeDisabled(&global);
26443
26444 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26445 return true;
26446 })());
26447 result
26448}
26449
26450unsafe extern "C" fn funcControlledMethodDisabled<D: DomTypes>
26451(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26452 let mut result = false;
26453 wrap_panic(&mut || result = (|| {
26454 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26455 let this = &*(this as *const D::TestBinding);
26456 let args = &*args;
26457 let argc = args.argc_;
26458 let result: () = this.FuncControlledMethodDisabled();
26459
26460 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26461 return true;
26462 })());
26463 result
26464}
26465
26466
26467static funcControlledMethodDisabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26468
26469pub(crate) fn init_funcControlledMethodDisabled_methodinfo<D: DomTypes>() {
26470 funcControlledMethodDisabled_methodinfo.set(JSJitInfo {
26471 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26472 method: Some(funcControlledMethodDisabled::<D>)
26473 },
26474 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26475 protoID: PrototypeList::ID::TestBinding as u16,
26476 },
26477 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26478 _bitfield_align_1: [],
26479 _bitfield_1: __BindgenBitfieldUnit::new(
26480 new_jsjitinfo_bitfield_1!(
26481 JSJitInfo_OpType::Method as u8,
26482 JSJitInfo_AliasSet::AliasEverything as u8,
26483 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26484 true,
26485 false,
26486 false,
26487 false,
26488 false,
26489 false,
26490 0,
26491 ).to_ne_bytes()
26492 ),
26493});
26494}
26495unsafe extern "C" fn funcControlledStaticMethodDisabled<D: DomTypes>
26496(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26497 let mut result = false;
26498 wrap_panic(&mut || result = (|| {
26499 let args = CallArgs::from_vp(vp, argc);
26500 let global = D::GlobalScope::from_object(args.callee());
26501 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26502 let args = CallArgs::from_vp(vp, argc);
26503 let result: () = <D::TestBinding>::FuncControlledStaticMethodDisabled(&global);
26504
26505 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26506 return true;
26507 })());
26508 result
26509}
26510
26511unsafe extern "C" fn get_funcControlledAttributeEnabled<D: DomTypes>
26512(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26513 let mut result = false;
26514 wrap_panic(&mut || result = (|| {
26515 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26516 let this = &*(this as *const D::TestBinding);
26517 let result: bool = this.FuncControlledAttributeEnabled();
26518
26519 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26520 return true;
26521 })());
26522 result
26523}
26524
26525
26526static funcControlledAttributeEnabled_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26527
26528pub(crate) fn init_funcControlledAttributeEnabled_getterinfo<D: DomTypes>() {
26529 funcControlledAttributeEnabled_getterinfo.set(JSJitInfo {
26530 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26531 getter: Some(get_funcControlledAttributeEnabled::<D>)
26532 },
26533 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26534 protoID: PrototypeList::ID::TestBinding as u16,
26535 },
26536 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26537 _bitfield_align_1: [],
26538 _bitfield_1: __BindgenBitfieldUnit::new(
26539 new_jsjitinfo_bitfield_1!(
26540 JSJitInfo_OpType::Getter as u8,
26541 JSJitInfo_AliasSet::AliasEverything as u8,
26542 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
26543 true,
26544 false,
26545 false,
26546 false,
26547 false,
26548 false,
26549 0,
26550 ).to_ne_bytes()
26551 ),
26552});
26553}
26554unsafe extern "C" fn get_funcControlledStaticAttributeEnabled<D: DomTypes>
26555(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26556 let mut result = false;
26557 wrap_panic(&mut || result = (|| {
26558 let args = CallArgs::from_vp(vp, argc);
26559 let global = D::GlobalScope::from_object(args.callee());
26560 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26561 let args = CallArgs::from_vp(vp, argc);
26562 let result: bool = <D::TestBinding>::FuncControlledStaticAttributeEnabled(&global);
26563
26564 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26565 return true;
26566 })());
26567 result
26568}
26569
26570unsafe extern "C" fn funcControlledMethodEnabled<D: DomTypes>
26571(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26572 let mut result = false;
26573 wrap_panic(&mut || result = (|| {
26574 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26575 let this = &*(this as *const D::TestBinding);
26576 let args = &*args;
26577 let argc = args.argc_;
26578 let result: () = this.FuncControlledMethodEnabled();
26579
26580 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26581 return true;
26582 })());
26583 result
26584}
26585
26586
26587static funcControlledMethodEnabled_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26588
26589pub(crate) fn init_funcControlledMethodEnabled_methodinfo<D: DomTypes>() {
26590 funcControlledMethodEnabled_methodinfo.set(JSJitInfo {
26591 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26592 method: Some(funcControlledMethodEnabled::<D>)
26593 },
26594 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26595 protoID: PrototypeList::ID::TestBinding as u16,
26596 },
26597 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26598 _bitfield_align_1: [],
26599 _bitfield_1: __BindgenBitfieldUnit::new(
26600 new_jsjitinfo_bitfield_1!(
26601 JSJitInfo_OpType::Method as u8,
26602 JSJitInfo_AliasSet::AliasEverything as u8,
26603 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26604 true,
26605 false,
26606 false,
26607 false,
26608 false,
26609 false,
26610 0,
26611 ).to_ne_bytes()
26612 ),
26613});
26614}
26615unsafe extern "C" fn funcControlledStaticMethodEnabled<D: DomTypes>
26616(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
26617 let mut result = false;
26618 wrap_panic(&mut || result = (|| {
26619 let args = CallArgs::from_vp(vp, argc);
26620 let global = D::GlobalScope::from_object(args.callee());
26621 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26622 let args = CallArgs::from_vp(vp, argc);
26623 let result: () = <D::TestBinding>::FuncControlledStaticMethodEnabled(&global);
26624
26625 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26626 return true;
26627 })());
26628 result
26629}
26630
26631unsafe extern "C" fn returnResolvedPromise<D: DomTypes>
26632(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26633 let mut result = false;
26634 wrap_panic(&mut || result = (|| {
26635 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26636 let this = &*(this as *const D::TestBinding);
26637 let args = &*args;
26638 let argc = args.argc_;
26639
26640 if argc < 1 {
26641 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.returnResolvedPromise\".");
26642 return false;
26643 }
26644 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
26645 let result: Rc<D::Promise> = this.ReturnResolvedPromise(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
26646
26647 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26648 return true;
26649 })());
26650 result
26651}
26652
26653unsafe extern "C" fn returnResolvedPromise_promise_wrapper<D: DomTypes>
26654(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26655 let mut result = false;
26656 wrap_panic(&mut || result = (|| {
26657 let ok = returnResolvedPromise::<D>(cx, _obj, this, args);
26658 if ok {
26659 return true;
26660 }
26661 return exception_to_promise(cx, (*args).rval(), CanGc::note());
26662
26663 })());
26664 result
26665}
26666
26667
26668static returnResolvedPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26669
26670pub(crate) fn init_returnResolvedPromise_methodinfo<D: DomTypes>() {
26671 returnResolvedPromise_methodinfo.set(JSJitInfo {
26672 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26673 method: Some(returnResolvedPromise_promise_wrapper::<D>)
26674 },
26675 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26676 protoID: PrototypeList::ID::TestBinding as u16,
26677 },
26678 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26679 _bitfield_align_1: [],
26680 _bitfield_1: __BindgenBitfieldUnit::new(
26681 new_jsjitinfo_bitfield_1!(
26682 JSJitInfo_OpType::Method as u8,
26683 JSJitInfo_AliasSet::AliasEverything as u8,
26684 JSValueType::JSVAL_TYPE_OBJECT as u8,
26685 false,
26686 false,
26687 false,
26688 false,
26689 false,
26690 false,
26691 0,
26692 ).to_ne_bytes()
26693 ),
26694});
26695}
26696unsafe extern "C" fn returnRejectedPromise<D: DomTypes>
26697(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26698 let mut result = false;
26699 wrap_panic(&mut || result = (|| {
26700 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26701 let this = &*(this as *const D::TestBinding);
26702 let args = &*args;
26703 let argc = args.argc_;
26704
26705 if argc < 1 {
26706 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.returnRejectedPromise\".");
26707 return false;
26708 }
26709 let arg0: HandleValue = HandleValue::from_raw(args.get(0));
26710 let result: Rc<D::Promise> = this.ReturnRejectedPromise(SafeJSContext::from_ptr(cx.raw_cx()), arg0);
26711
26712 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26713 return true;
26714 })());
26715 result
26716}
26717
26718unsafe extern "C" fn returnRejectedPromise_promise_wrapper<D: DomTypes>
26719(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26720 let mut result = false;
26721 wrap_panic(&mut || result = (|| {
26722 let ok = returnRejectedPromise::<D>(cx, _obj, this, args);
26723 if ok {
26724 return true;
26725 }
26726 return exception_to_promise(cx, (*args).rval(), CanGc::note());
26727
26728 })());
26729 result
26730}
26731
26732
26733static returnRejectedPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26734
26735pub(crate) fn init_returnRejectedPromise_methodinfo<D: DomTypes>() {
26736 returnRejectedPromise_methodinfo.set(JSJitInfo {
26737 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26738 method: Some(returnRejectedPromise_promise_wrapper::<D>)
26739 },
26740 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26741 protoID: PrototypeList::ID::TestBinding as u16,
26742 },
26743 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26744 _bitfield_align_1: [],
26745 _bitfield_1: __BindgenBitfieldUnit::new(
26746 new_jsjitinfo_bitfield_1!(
26747 JSJitInfo_OpType::Method as u8,
26748 JSJitInfo_AliasSet::AliasEverything as u8,
26749 JSValueType::JSVAL_TYPE_OBJECT as u8,
26750 false,
26751 false,
26752 false,
26753 false,
26754 false,
26755 false,
26756 0,
26757 ).to_ne_bytes()
26758 ),
26759});
26760}
26761unsafe extern "C" fn get_promiseAttribute<D: DomTypes>
26762(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26763 let mut result = false;
26764 wrap_panic(&mut || result = (|| {
26765 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26766 let this = &*(this as *const D::TestBinding);
26767 let result: Rc<D::Promise> = this.PromiseAttribute(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());
26768
26769 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26770 return true;
26771 })());
26772 result
26773}
26774
26775unsafe extern "C" fn get_promiseAttribute_promise_wrapper<D: DomTypes>
26776(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
26777 let mut result = false;
26778 wrap_panic(&mut || result = (|| {
26779 let ok = get_promiseAttribute::<D>(cx, _obj, this, args);
26780 if ok {
26781 return true;
26782 }
26783 return exception_to_promise(cx, args.rval(), CanGc::note());
26784
26785 })());
26786 result
26787}
26788
26789
26790static promiseAttribute_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26791
26792pub(crate) fn init_promiseAttribute_getterinfo<D: DomTypes>() {
26793 promiseAttribute_getterinfo.set(JSJitInfo {
26794 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26795 getter: Some(get_promiseAttribute_promise_wrapper::<D>)
26796 },
26797 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26798 protoID: PrototypeList::ID::TestBinding as u16,
26799 },
26800 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26801 _bitfield_align_1: [],
26802 _bitfield_1: __BindgenBitfieldUnit::new(
26803 new_jsjitinfo_bitfield_1!(
26804 JSJitInfo_OpType::Getter as u8,
26805 JSJitInfo_AliasSet::AliasEverything as u8,
26806 JSValueType::JSVAL_TYPE_OBJECT as u8,
26807 true,
26808 false,
26809 false,
26810 false,
26811 false,
26812 false,
26813 0,
26814 ).to_ne_bytes()
26815 ),
26816});
26817}
26818unsafe extern "C" fn acceptPromise<D: DomTypes>
26819(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26820 let mut result = false;
26821 wrap_panic(&mut || result = (|| {
26822 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26823 let this = &*(this as *const D::TestBinding);
26824 let args = &*args;
26825 let argc = args.argc_;
26826
26827 if argc < 1 {
26828 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.acceptPromise\".");
26829 return false;
26830 }
26831 let arg0: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
26832 Ok(ConversionResult::Success(value)) => value,
26833 Ok(ConversionResult::Failure(error)) => {
26834 throw_type_error(cx.raw_cx(), &error);
26835 return false;
26836
26837 }
26838 _ => {
26839 return false;
26840
26841 },
26842 }
26843 ;
26844 let result: () = this.AcceptPromise(&arg0);
26845
26846 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26847 return true;
26848 })());
26849 result
26850}
26851
26852
26853static acceptPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26854
26855pub(crate) fn init_acceptPromise_methodinfo<D: DomTypes>() {
26856 acceptPromise_methodinfo.set(JSJitInfo {
26857 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26858 method: Some(acceptPromise::<D>)
26859 },
26860 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26861 protoID: PrototypeList::ID::TestBinding as u16,
26862 },
26863 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26864 _bitfield_align_1: [],
26865 _bitfield_1: __BindgenBitfieldUnit::new(
26866 new_jsjitinfo_bitfield_1!(
26867 JSJitInfo_OpType::Method as u8,
26868 JSJitInfo_AliasSet::AliasEverything as u8,
26869 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
26870 false,
26871 false,
26872 false,
26873 false,
26874 false,
26875 false,
26876 0,
26877 ).to_ne_bytes()
26878 ),
26879});
26880}
26881unsafe extern "C" fn promiseNativeHandler<D: DomTypes>
26882(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26883 let mut result = false;
26884 wrap_panic(&mut || result = (|| {
26885 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26886 let this = &*(this as *const D::TestBinding);
26887 let args = &*args;
26888 let argc = args.argc_;
26889
26890 if argc < 2 {
26891 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.promiseNativeHandler\".");
26892 return false;
26893 }
26894 let arg0: Option<Rc<SimpleCallback<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
26895 if IsCallable(HandleValue::from_raw(args.get(0)).get().to_object()) {
26896 Some(SimpleCallback::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
26897 } else {
26898 throw_type_error(cx.raw_cx(), "Value is not callable.");
26899 return false;
26900
26901 }
26902 } else if HandleValue::from_raw(args.get(0)).get().is_null_or_undefined() {
26903 None
26904 } else {
26905 throw_type_error(cx.raw_cx(), "Value is not an object.");
26906 return false;
26907
26908 };
26909 let arg1: Option<Rc<SimpleCallback<D>>> = if HandleValue::from_raw(args.get(1)).get().is_object() {
26910 if IsCallable(HandleValue::from_raw(args.get(1)).get().to_object()) {
26911 Some(SimpleCallback::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(1)).get().to_object()))
26912 } else {
26913 throw_type_error(cx.raw_cx(), "Value is not callable.");
26914 return false;
26915
26916 }
26917 } else if HandleValue::from_raw(args.get(1)).get().is_null_or_undefined() {
26918 None
26919 } else {
26920 throw_type_error(cx.raw_cx(), "Value is not an object.");
26921 return false;
26922
26923 };
26924 let result: Rc<D::Promise> = this.PromiseNativeHandler(arg0, arg1, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());
26925
26926 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
26927 return true;
26928 })());
26929 result
26930}
26931
26932unsafe extern "C" fn promiseNativeHandler_promise_wrapper<D: DomTypes>
26933(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26934 let mut result = false;
26935 wrap_panic(&mut || result = (|| {
26936 let ok = promiseNativeHandler::<D>(cx, _obj, this, args);
26937 if ok {
26938 return true;
26939 }
26940 return exception_to_promise(cx, (*args).rval(), CanGc::note());
26941
26942 })());
26943 result
26944}
26945
26946
26947static promiseNativeHandler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
26948
26949pub(crate) fn init_promiseNativeHandler_methodinfo<D: DomTypes>() {
26950 promiseNativeHandler_methodinfo.set(JSJitInfo {
26951 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
26952 method: Some(promiseNativeHandler_promise_wrapper::<D>)
26953 },
26954 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
26955 protoID: PrototypeList::ID::TestBinding as u16,
26956 },
26957 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
26958 _bitfield_align_1: [],
26959 _bitfield_1: __BindgenBitfieldUnit::new(
26960 new_jsjitinfo_bitfield_1!(
26961 JSJitInfo_OpType::Method as u8,
26962 JSJitInfo_AliasSet::AliasEverything as u8,
26963 JSValueType::JSVAL_TYPE_OBJECT as u8,
26964 false,
26965 false,
26966 false,
26967 false,
26968 false,
26969 false,
26970 0,
26971 ).to_ne_bytes()
26972 ),
26973});
26974}
26975unsafe extern "C" fn promiseResolveNative<D: DomTypes>
26976(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
26977 let mut result = false;
26978 wrap_panic(&mut || result = (|| {
26979 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
26980 let this = &*(this as *const D::TestBinding);
26981 let args = &*args;
26982 let argc = args.argc_;
26983
26984 if argc < 2 {
26985 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.promiseResolveNative\".");
26986 return false;
26987 }
26988 let arg0: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
26989 Ok(ConversionResult::Success(value)) => value,
26990 Ok(ConversionResult::Failure(error)) => {
26991 throw_type_error(cx.raw_cx(), &error);
26992 return false;
26993
26994 }
26995 _ => {
26996 return false;
26997
26998 },
26999 }
27000 ;
27001 let arg1: HandleValue = HandleValue::from_raw(args.get(1));
27002 let result: () = this.PromiseResolveNative(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, CanGc::note());
27003
27004 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27005 return true;
27006 })());
27007 result
27008}
27009
27010
27011static promiseResolveNative_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27012
27013pub(crate) fn init_promiseResolveNative_methodinfo<D: DomTypes>() {
27014 promiseResolveNative_methodinfo.set(JSJitInfo {
27015 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27016 method: Some(promiseResolveNative::<D>)
27017 },
27018 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27019 protoID: PrototypeList::ID::TestBinding as u16,
27020 },
27021 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27022 _bitfield_align_1: [],
27023 _bitfield_1: __BindgenBitfieldUnit::new(
27024 new_jsjitinfo_bitfield_1!(
27025 JSJitInfo_OpType::Method as u8,
27026 JSJitInfo_AliasSet::AliasEverything as u8,
27027 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27028 false,
27029 false,
27030 false,
27031 false,
27032 false,
27033 false,
27034 0,
27035 ).to_ne_bytes()
27036 ),
27037});
27038}
27039unsafe extern "C" fn promiseRejectNative<D: DomTypes>
27040(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27041 let mut result = false;
27042 wrap_panic(&mut || result = (|| {
27043 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27044 let this = &*(this as *const D::TestBinding);
27045 let args = &*args;
27046 let argc = args.argc_;
27047
27048 if argc < 2 {
27049 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.promiseRejectNative\".");
27050 return false;
27051 }
27052 let arg0: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
27053 Ok(ConversionResult::Success(value)) => value,
27054 Ok(ConversionResult::Failure(error)) => {
27055 throw_type_error(cx.raw_cx(), &error);
27056 return false;
27057
27058 }
27059 _ => {
27060 return false;
27061
27062 },
27063 }
27064 ;
27065 let arg1: HandleValue = HandleValue::from_raw(args.get(1));
27066 let result: () = this.PromiseRejectNative(SafeJSContext::from_ptr(cx.raw_cx()), &arg0, arg1, CanGc::note());
27067
27068 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27069 return true;
27070 })());
27071 result
27072}
27073
27074
27075static promiseRejectNative_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27076
27077pub(crate) fn init_promiseRejectNative_methodinfo<D: DomTypes>() {
27078 promiseRejectNative_methodinfo.set(JSJitInfo {
27079 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27080 method: Some(promiseRejectNative::<D>)
27081 },
27082 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27083 protoID: PrototypeList::ID::TestBinding as u16,
27084 },
27085 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27086 _bitfield_align_1: [],
27087 _bitfield_1: __BindgenBitfieldUnit::new(
27088 new_jsjitinfo_bitfield_1!(
27089 JSJitInfo_OpType::Method as u8,
27090 JSJitInfo_AliasSet::AliasEverything as u8,
27091 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27092 false,
27093 false,
27094 false,
27095 false,
27096 false,
27097 false,
27098 0,
27099 ).to_ne_bytes()
27100 ),
27101});
27102}
27103unsafe extern "C" fn promiseRejectWithTypeError<D: DomTypes>
27104(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27105 let mut result = false;
27106 wrap_panic(&mut || result = (|| {
27107 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27108 let this = &*(this as *const D::TestBinding);
27109 let args = &*args;
27110 let argc = args.argc_;
27111
27112 if argc < 2 {
27113 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.promiseRejectWithTypeError\".");
27114 return false;
27115 }
27116 let arg0: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
27117 Ok(ConversionResult::Success(value)) => value,
27118 Ok(ConversionResult::Failure(error)) => {
27119 throw_type_error(cx.raw_cx(), &error);
27120 return false;
27121
27122 }
27123 _ => {
27124 return false;
27125
27126 },
27127 }
27128 ;
27129 let arg1: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
27130 Ok(ConversionResult::Success(value)) => value,
27131 Ok(ConversionResult::Failure(error)) => {
27132 throw_type_error(cx.raw_cx(), &error);
27133 return false;
27134
27135 }
27136 _ => {
27137 return false;
27138
27139 },
27140 }
27141 ;
27142 let result: () = this.PromiseRejectWithTypeError(&arg0, arg1, CanGc::note());
27143
27144 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27145 return true;
27146 })());
27147 result
27148}
27149
27150
27151static promiseRejectWithTypeError_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27152
27153pub(crate) fn init_promiseRejectWithTypeError_methodinfo<D: DomTypes>() {
27154 promiseRejectWithTypeError_methodinfo.set(JSJitInfo {
27155 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27156 method: Some(promiseRejectWithTypeError::<D>)
27157 },
27158 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27159 protoID: PrototypeList::ID::TestBinding as u16,
27160 },
27161 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27162 _bitfield_align_1: [],
27163 _bitfield_1: __BindgenBitfieldUnit::new(
27164 new_jsjitinfo_bitfield_1!(
27165 JSJitInfo_OpType::Method as u8,
27166 JSJitInfo_AliasSet::AliasEverything as u8,
27167 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27168 false,
27169 false,
27170 false,
27171 false,
27172 false,
27173 false,
27174 0,
27175 ).to_ne_bytes()
27176 ),
27177});
27178}
27179unsafe extern "C" fn resolvePromiseDelayed<D: DomTypes>
27180(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27181 let mut result = false;
27182 wrap_panic(&mut || result = (|| {
27183 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27184 let this = &*(this as *const D::TestBinding);
27185 let args = &*args;
27186 let argc = args.argc_;
27187
27188 if argc < 3 {
27189 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.resolvePromiseDelayed\".");
27190 return false;
27191 }
27192 let arg0: Rc<D::Promise> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
27193 Ok(ConversionResult::Success(value)) => value,
27194 Ok(ConversionResult::Failure(error)) => {
27195 throw_type_error(cx.raw_cx(), &error);
27196 return false;
27197
27198 }
27199 _ => {
27200 return false;
27201
27202 },
27203 }
27204 ;
27205 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
27206 Ok(ConversionResult::Success(value)) => value,
27207 Ok(ConversionResult::Failure(error)) => {
27208 throw_type_error(cx.raw_cx(), &error);
27209 return false;
27210
27211 }
27212 _ => {
27213 return false;
27214
27215 },
27216 }
27217 ;
27218 let arg2: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::Default) {
27219 Ok(ConversionResult::Success(value)) => value,
27220 Ok(ConversionResult::Failure(error)) => {
27221 throw_type_error(cx.raw_cx(), &error);
27222 return false;
27223
27224 }
27225 _ => {
27226 return false;
27227
27228 },
27229 }
27230 ;
27231 let result: () = this.ResolvePromiseDelayed(&arg0, arg1, arg2);
27232
27233 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27234 return true;
27235 })());
27236 result
27237}
27238
27239
27240static resolvePromiseDelayed_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27241
27242pub(crate) fn init_resolvePromiseDelayed_methodinfo<D: DomTypes>() {
27243 resolvePromiseDelayed_methodinfo.set(JSJitInfo {
27244 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27245 method: Some(resolvePromiseDelayed::<D>)
27246 },
27247 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27248 protoID: PrototypeList::ID::TestBinding as u16,
27249 },
27250 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27251 _bitfield_align_1: [],
27252 _bitfield_1: __BindgenBitfieldUnit::new(
27253 new_jsjitinfo_bitfield_1!(
27254 JSJitInfo_OpType::Method as u8,
27255 JSJitInfo_AliasSet::AliasEverything as u8,
27256 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27257 false,
27258 false,
27259 false,
27260 false,
27261 false,
27262 false,
27263 0,
27264 ).to_ne_bytes()
27265 ),
27266});
27267}
27268unsafe extern "C" fn staticThrowToRejectPromise<D: DomTypes>
27269(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
27270 let mut result = false;
27271 wrap_panic(&mut || result = (|| {
27272 let args = CallArgs::from_vp(vp, argc);
27273 let global = D::GlobalScope::from_object(args.callee());
27274 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27275 let args = CallArgs::from_vp(vp, argc);
27276 let result: Result<Rc<D::Promise>, Error> = <D::TestBinding>::StaticThrowToRejectPromise(&global);
27277 let result = match result {
27278 Ok(result) => result,
27279 Err(e) => {
27280 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
27281 return false;
27282 },
27283 };
27284
27285 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27286 return true;
27287 })());
27288 result
27289}
27290
27291
27292 static staticThrowToRejectPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27293
27294 pub(crate) fn init_staticThrowToRejectPromise_methodinfo<D: DomTypes>() {
27295 staticThrowToRejectPromise_methodinfo.set(JSJitInfo {
27296 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27297 staticMethod: Some(staticThrowToRejectPromise::<D>)
27298 },
27299 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27300 protoID: PrototypeList::ID::Last as u16,
27301 },
27302 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27303 _bitfield_align_1: [],
27304 _bitfield_1: __BindgenBitfieldUnit::new(
27305 new_jsjitinfo_bitfield_1!(
27306 JSJitInfo_OpType::StaticMethod as u8,
27307 JSJitInfo_AliasSet::AliasEverything as u8,
27308 JSValueType::JSVAL_TYPE_OBJECT as u8,
27309 false,
27310 false,
27311 false,
27312 false,
27313 false,
27314 false,
27315 0,
27316 ).to_ne_bytes()
27317 ),
27318 });
27319 }
27320
27321unsafe extern "C" fn methodThrowToRejectPromise<D: DomTypes>
27322(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27323 let mut result = false;
27324 wrap_panic(&mut || result = (|| {
27325 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27326 let this = &*(this as *const D::TestBinding);
27327 let args = &*args;
27328 let argc = args.argc_;
27329 let result: Result<Rc<D::Promise>, Error> = this.MethodThrowToRejectPromise();
27330 let result = match result {
27331 Ok(result) => result,
27332 Err(e) => {
27333 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
27334 return false;
27335 },
27336 };
27337
27338 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27339 return true;
27340 })());
27341 result
27342}
27343
27344unsafe extern "C" fn methodThrowToRejectPromise_promise_wrapper<D: DomTypes>
27345(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27346 let mut result = false;
27347 wrap_panic(&mut || result = (|| {
27348 let ok = methodThrowToRejectPromise::<D>(cx, _obj, this, args);
27349 if ok {
27350 return true;
27351 }
27352 return exception_to_promise(cx, (*args).rval(), CanGc::note());
27353
27354 })());
27355 result
27356}
27357
27358
27359static methodThrowToRejectPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27360
27361pub(crate) fn init_methodThrowToRejectPromise_methodinfo<D: DomTypes>() {
27362 methodThrowToRejectPromise_methodinfo.set(JSJitInfo {
27363 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27364 method: Some(methodThrowToRejectPromise_promise_wrapper::<D>)
27365 },
27366 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27367 protoID: PrototypeList::ID::TestBinding as u16,
27368 },
27369 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27370 _bitfield_align_1: [],
27371 _bitfield_1: __BindgenBitfieldUnit::new(
27372 new_jsjitinfo_bitfield_1!(
27373 JSJitInfo_OpType::Method as u8,
27374 JSJitInfo_AliasSet::AliasEverything as u8,
27375 JSValueType::JSVAL_TYPE_OBJECT as u8,
27376 false,
27377 false,
27378 false,
27379 false,
27380 false,
27381 false,
27382 0,
27383 ).to_ne_bytes()
27384 ),
27385});
27386}
27387unsafe extern "C" fn get_getterThrowToRejectPromise<D: DomTypes>
27388(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
27389 let mut result = false;
27390 wrap_panic(&mut || result = (|| {
27391 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27392 let this = &*(this as *const D::TestBinding);
27393 let result: Result<Rc<D::Promise>, Error> = this.GetGetterThrowToRejectPromise();
27394 let result = match result {
27395 Ok(result) => result,
27396 Err(e) => {
27397 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
27398 return false;
27399 },
27400 };
27401
27402 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27403 return true;
27404 })());
27405 result
27406}
27407
27408unsafe extern "C" fn get_getterThrowToRejectPromise_promise_wrapper<D: DomTypes>
27409(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
27410 let mut result = false;
27411 wrap_panic(&mut || result = (|| {
27412 let ok = get_getterThrowToRejectPromise::<D>(cx, _obj, this, args);
27413 if ok {
27414 return true;
27415 }
27416 return exception_to_promise(cx, args.rval(), CanGc::note());
27417
27418 })());
27419 result
27420}
27421
27422
27423static getterThrowToRejectPromise_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27424
27425pub(crate) fn init_getterThrowToRejectPromise_getterinfo<D: DomTypes>() {
27426 getterThrowToRejectPromise_getterinfo.set(JSJitInfo {
27427 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27428 getter: Some(get_getterThrowToRejectPromise_promise_wrapper::<D>)
27429 },
27430 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27431 protoID: PrototypeList::ID::TestBinding as u16,
27432 },
27433 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27434 _bitfield_align_1: [],
27435 _bitfield_1: __BindgenBitfieldUnit::new(
27436 new_jsjitinfo_bitfield_1!(
27437 JSJitInfo_OpType::Getter as u8,
27438 JSJitInfo_AliasSet::AliasEverything as u8,
27439 JSValueType::JSVAL_TYPE_OBJECT as u8,
27440 false,
27441 false,
27442 false,
27443 false,
27444 false,
27445 false,
27446 0,
27447 ).to_ne_bytes()
27448 ),
27449});
27450}
27451unsafe extern "C" fn staticInternalThrowToRejectPromise<D: DomTypes>
27452(cx: *mut RawJSContext, argc: libc::c_uint, vp: *mut JSVal) -> bool{
27453 let mut result = false;
27454 wrap_panic(&mut || result = (|| {
27455 let args = CallArgs::from_vp(vp, argc);
27456 let global = D::GlobalScope::from_object(args.callee());
27457 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27458 let args = CallArgs::from_vp(vp, argc);
27459
27460 if argc < 1 {
27461 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.staticInternalThrowToRejectPromise\".");
27462 return false;
27463 }
27464 let arg0: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
27465 Ok(ConversionResult::Success(value)) => value,
27466 Ok(ConversionResult::Failure(error)) => {
27467 throw_type_error(cx.raw_cx(), &error);
27468 return false;
27469
27470 }
27471 _ => {
27472 return false;
27473
27474 },
27475 }
27476 ;
27477 let result: Rc<D::Promise> = <D::TestBinding>::StaticInternalThrowToRejectPromise(&global, arg0);
27478
27479 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27480 return true;
27481 })());
27482 result
27483}
27484
27485
27486 static staticInternalThrowToRejectPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27487
27488 pub(crate) fn init_staticInternalThrowToRejectPromise_methodinfo<D: DomTypes>() {
27489 staticInternalThrowToRejectPromise_methodinfo.set(JSJitInfo {
27490 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27491 staticMethod: Some(staticInternalThrowToRejectPromise::<D>)
27492 },
27493 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27494 protoID: PrototypeList::ID::Last as u16,
27495 },
27496 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27497 _bitfield_align_1: [],
27498 _bitfield_1: __BindgenBitfieldUnit::new(
27499 new_jsjitinfo_bitfield_1!(
27500 JSJitInfo_OpType::StaticMethod as u8,
27501 JSJitInfo_AliasSet::AliasEverything as u8,
27502 JSValueType::JSVAL_TYPE_OBJECT as u8,
27503 false,
27504 false,
27505 false,
27506 false,
27507 false,
27508 false,
27509 0,
27510 ).to_ne_bytes()
27511 ),
27512 });
27513 }
27514
27515unsafe extern "C" fn methodInternalThrowToRejectPromise<D: DomTypes>
27516(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27517 let mut result = false;
27518 wrap_panic(&mut || result = (|| {
27519 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27520 let this = &*(this as *const D::TestBinding);
27521 let args = &*args;
27522 let argc = args.argc_;
27523
27524 if argc < 1 {
27525 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.methodInternalThrowToRejectPromise\".");
27526 return false;
27527 }
27528 let arg0: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
27529 Ok(ConversionResult::Success(value)) => value,
27530 Ok(ConversionResult::Failure(error)) => {
27531 throw_type_error(cx.raw_cx(), &error);
27532 return false;
27533
27534 }
27535 _ => {
27536 return false;
27537
27538 },
27539 }
27540 ;
27541 let result: Rc<D::Promise> = this.MethodInternalThrowToRejectPromise(arg0);
27542
27543 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27544 return true;
27545 })());
27546 result
27547}
27548
27549unsafe extern "C" fn methodInternalThrowToRejectPromise_promise_wrapper<D: DomTypes>
27550(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27551 let mut result = false;
27552 wrap_panic(&mut || result = (|| {
27553 let ok = methodInternalThrowToRejectPromise::<D>(cx, _obj, this, args);
27554 if ok {
27555 return true;
27556 }
27557 return exception_to_promise(cx, (*args).rval(), CanGc::note());
27558
27559 })());
27560 result
27561}
27562
27563
27564static methodInternalThrowToRejectPromise_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27565
27566pub(crate) fn init_methodInternalThrowToRejectPromise_methodinfo<D: DomTypes>() {
27567 methodInternalThrowToRejectPromise_methodinfo.set(JSJitInfo {
27568 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27569 method: Some(methodInternalThrowToRejectPromise_promise_wrapper::<D>)
27570 },
27571 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27572 protoID: PrototypeList::ID::TestBinding as u16,
27573 },
27574 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27575 _bitfield_align_1: [],
27576 _bitfield_1: __BindgenBitfieldUnit::new(
27577 new_jsjitinfo_bitfield_1!(
27578 JSJitInfo_OpType::Method as u8,
27579 JSJitInfo_AliasSet::AliasEverything as u8,
27580 JSValueType::JSVAL_TYPE_OBJECT as u8,
27581 false,
27582 false,
27583 false,
27584 false,
27585 false,
27586 false,
27587 0,
27588 ).to_ne_bytes()
27589 ),
27590});
27591}
27592unsafe extern "C" fn panic<D: DomTypes>
27593(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27594 let mut result = false;
27595 wrap_panic(&mut || result = (|| {
27596 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27597 let this = &*(this as *const D::TestBinding);
27598 let args = &*args;
27599 let argc = args.argc_;
27600 let result: () = this.Panic();
27601
27602 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27603 return true;
27604 })());
27605 result
27606}
27607
27608
27609static panic_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27610
27611pub(crate) fn init_panic_methodinfo<D: DomTypes>() {
27612 panic_methodinfo.set(JSJitInfo {
27613 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27614 method: Some(panic::<D>)
27615 },
27616 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27617 protoID: PrototypeList::ID::TestBinding as u16,
27618 },
27619 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27620 _bitfield_align_1: [],
27621 _bitfield_1: __BindgenBitfieldUnit::new(
27622 new_jsjitinfo_bitfield_1!(
27623 JSJitInfo_OpType::Method as u8,
27624 JSJitInfo_AliasSet::AliasEverything as u8,
27625 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27626 true,
27627 false,
27628 false,
27629 false,
27630 false,
27631 false,
27632 0,
27633 ).to_ne_bytes()
27634 ),
27635});
27636}
27637unsafe extern "C" fn entryGlobal<D: DomTypes>
27638(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27639 let mut result = false;
27640 wrap_panic(&mut || result = (|| {
27641 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27642 let this = &*(this as *const D::TestBinding);
27643 let args = &*args;
27644 let argc = args.argc_;
27645 let result: DomRoot<D::GlobalScope> = this.EntryGlobal();
27646
27647 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27648 return true;
27649 })());
27650 result
27651}
27652
27653
27654static entryGlobal_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27655
27656pub(crate) fn init_entryGlobal_methodinfo<D: DomTypes>() {
27657 entryGlobal_methodinfo.set(JSJitInfo {
27658 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27659 method: Some(entryGlobal::<D>)
27660 },
27661 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27662 protoID: PrototypeList::ID::TestBinding as u16,
27663 },
27664 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27665 _bitfield_align_1: [],
27666 _bitfield_1: __BindgenBitfieldUnit::new(
27667 new_jsjitinfo_bitfield_1!(
27668 JSJitInfo_OpType::Method as u8,
27669 JSJitInfo_AliasSet::AliasEverything as u8,
27670 JSValueType::JSVAL_TYPE_OBJECT as u8,
27671 true,
27672 false,
27673 false,
27674 false,
27675 false,
27676 false,
27677 0,
27678 ).to_ne_bytes()
27679 ),
27680});
27681}
27682unsafe extern "C" fn incumbentGlobal<D: DomTypes>
27683(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27684 let mut result = false;
27685 wrap_panic(&mut || result = (|| {
27686 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27687 let this = &*(this as *const D::TestBinding);
27688 let args = &*args;
27689 let argc = args.argc_;
27690 let result: DomRoot<D::GlobalScope> = this.IncumbentGlobal();
27691
27692 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27693 return true;
27694 })());
27695 result
27696}
27697
27698
27699static incumbentGlobal_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27700
27701pub(crate) fn init_incumbentGlobal_methodinfo<D: DomTypes>() {
27702 incumbentGlobal_methodinfo.set(JSJitInfo {
27703 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27704 method: Some(incumbentGlobal::<D>)
27705 },
27706 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27707 protoID: PrototypeList::ID::TestBinding as u16,
27708 },
27709 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27710 _bitfield_align_1: [],
27711 _bitfield_1: __BindgenBitfieldUnit::new(
27712 new_jsjitinfo_bitfield_1!(
27713 JSJitInfo_OpType::Method as u8,
27714 JSJitInfo_AliasSet::AliasEverything as u8,
27715 JSValueType::JSVAL_TYPE_OBJECT as u8,
27716 true,
27717 false,
27718 false,
27719 false,
27720 false,
27721 false,
27722 0,
27723 ).to_ne_bytes()
27724 ),
27725});
27726}
27727unsafe extern "C" fn get_semiExposedBoolFromInterface<D: DomTypes>
27728(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
27729 let mut result = false;
27730 wrap_panic(&mut || result = (|| {
27731 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27732 let this = &*(this as *const D::TestBinding);
27733 let result: bool = this.SemiExposedBoolFromInterface();
27734
27735 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27736 return true;
27737 })());
27738 result
27739}
27740
27741
27742static semiExposedBoolFromInterface_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27743
27744pub(crate) fn init_semiExposedBoolFromInterface_getterinfo<D: DomTypes>() {
27745 semiExposedBoolFromInterface_getterinfo.set(JSJitInfo {
27746 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27747 getter: Some(get_semiExposedBoolFromInterface::<D>)
27748 },
27749 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27750 protoID: PrototypeList::ID::TestBinding as u16,
27751 },
27752 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27753 _bitfield_align_1: [],
27754 _bitfield_1: __BindgenBitfieldUnit::new(
27755 new_jsjitinfo_bitfield_1!(
27756 JSJitInfo_OpType::Getter as u8,
27757 JSJitInfo_AliasSet::AliasEverything as u8,
27758 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
27759 true,
27760 false,
27761 false,
27762 false,
27763 false,
27764 false,
27765 0,
27766 ).to_ne_bytes()
27767 ),
27768});
27769}
27770unsafe extern "C" fn getDictionaryWithParent<D: DomTypes>
27771(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27772 let mut result = false;
27773 wrap_panic(&mut || result = (|| {
27774 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27775 let this = &*(this as *const D::TestBinding);
27776 let args = &*args;
27777 let argc = args.argc_;
27778
27779 if argc < 2 {
27780 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.getDictionaryWithParent\".");
27781 return false;
27782 }
27783 let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
27784 Ok(ConversionResult::Success(value)) => value,
27785 Ok(ConversionResult::Failure(error)) => {
27786 throw_type_error(cx.raw_cx(), &error);
27787 return false;
27788
27789 }
27790 _ => {
27791 return false;
27792
27793 },
27794 }
27795 ;
27796 let arg1: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), StringificationBehavior::Default) {
27797 Ok(ConversionResult::Success(value)) => value,
27798 Ok(ConversionResult::Failure(error)) => {
27799 throw_type_error(cx.raw_cx(), &error);
27800 return false;
27801
27802 }
27803 _ => {
27804 return false;
27805
27806 },
27807 }
27808 ;
27809 let result: TestDictionaryWithParent = this.GetDictionaryWithParent(arg0, arg1);
27810
27811 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27812 return true;
27813 })());
27814 result
27815}
27816
27817
27818static getDictionaryWithParent_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27819
27820pub(crate) fn init_getDictionaryWithParent_methodinfo<D: DomTypes>() {
27821 getDictionaryWithParent_methodinfo.set(JSJitInfo {
27822 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27823 method: Some(getDictionaryWithParent::<D>)
27824 },
27825 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27826 protoID: PrototypeList::ID::TestBinding as u16,
27827 },
27828 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27829 _bitfield_align_1: [],
27830 _bitfield_1: __BindgenBitfieldUnit::new(
27831 new_jsjitinfo_bitfield_1!(
27832 JSJitInfo_OpType::Method as u8,
27833 JSJitInfo_AliasSet::AliasEverything as u8,
27834 JSValueType::JSVAL_TYPE_OBJECT as u8,
27835 false,
27836 false,
27837 false,
27838 false,
27839 false,
27840 false,
27841 0,
27842 ).to_ne_bytes()
27843 ),
27844});
27845}
27846unsafe extern "C" fn get_boolFromSemiExposedPartialInterface<D: DomTypes>
27847(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
27848 let mut result = false;
27849 wrap_panic(&mut || result = (|| {
27850 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27851 let this = &*(this as *const D::TestBinding);
27852 let result: bool = this.BoolFromSemiExposedPartialInterface();
27853
27854 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27855 return true;
27856 })());
27857 result
27858}
27859
27860
27861static boolFromSemiExposedPartialInterface_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27862
27863pub(crate) fn init_boolFromSemiExposedPartialInterface_getterinfo<D: DomTypes>() {
27864 boolFromSemiExposedPartialInterface_getterinfo.set(JSJitInfo {
27865 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27866 getter: Some(get_boolFromSemiExposedPartialInterface::<D>)
27867 },
27868 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27869 protoID: PrototypeList::ID::TestBinding as u16,
27870 },
27871 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27872 _bitfield_align_1: [],
27873 _bitfield_1: __BindgenBitfieldUnit::new(
27874 new_jsjitinfo_bitfield_1!(
27875 JSJitInfo_OpType::Getter as u8,
27876 JSJitInfo_AliasSet::AliasEverything as u8,
27877 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
27878 true,
27879 false,
27880 false,
27881 false,
27882 false,
27883 false,
27884 0,
27885 ).to_ne_bytes()
27886 ),
27887});
27888}
27889unsafe extern "C" fn get_semiExposedBoolFromPartialInterface<D: DomTypes>
27890(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
27891 let mut result = false;
27892 wrap_panic(&mut || result = (|| {
27893 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27894 let this = &*(this as *const D::TestBinding);
27895 let result: bool = this.SemiExposedBoolFromPartialInterface();
27896
27897 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27898 return true;
27899 })());
27900 result
27901}
27902
27903
27904static semiExposedBoolFromPartialInterface_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27905
27906pub(crate) fn init_semiExposedBoolFromPartialInterface_getterinfo<D: DomTypes>() {
27907 semiExposedBoolFromPartialInterface_getterinfo.set(JSJitInfo {
27908 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27909 getter: Some(get_semiExposedBoolFromPartialInterface::<D>)
27910 },
27911 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27912 protoID: PrototypeList::ID::TestBinding as u16,
27913 },
27914 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27915 _bitfield_align_1: [],
27916 _bitfield_1: __BindgenBitfieldUnit::new(
27917 new_jsjitinfo_bitfield_1!(
27918 JSJitInfo_OpType::Getter as u8,
27919 JSJitInfo_AliasSet::AliasEverything as u8,
27920 JSValueType::JSVAL_TYPE_BOOLEAN as u8,
27921 true,
27922 false,
27923 false,
27924 false,
27925 false,
27926 false,
27927 0,
27928 ).to_ne_bytes()
27929 ),
27930});
27931}
27932unsafe extern "C" fn crashHard<D: DomTypes>
27933(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
27934 let mut result = false;
27935 wrap_panic(&mut || result = (|| {
27936 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
27937 let this = &*(this as *const D::TestBinding);
27938 let args = &*args;
27939 let argc = args.argc_;
27940 let result: () = this.CrashHard();
27941
27942 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
27943 return true;
27944 })());
27945 result
27946}
27947
27948
27949static crashHard_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();
27950
27951pub(crate) fn init_crashHard_methodinfo<D: DomTypes>() {
27952 crashHard_methodinfo.set(JSJitInfo {
27953 __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
27954 method: Some(crashHard::<D>)
27955 },
27956 __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
27957 protoID: PrototypeList::ID::TestBinding as u16,
27958 },
27959 __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
27960 _bitfield_align_1: [],
27961 _bitfield_1: __BindgenBitfieldUnit::new(
27962 new_jsjitinfo_bitfield_1!(
27963 JSJitInfo_OpType::Method as u8,
27964 JSJitInfo_AliasSet::AliasEverything as u8,
27965 JSValueType::JSVAL_TYPE_UNDEFINED as u8,
27966 true,
27967 false,
27968 false,
27969 false,
27970 false,
27971 false,
27972 0,
27973 ).to_ne_bytes()
27974 ),
27975});
27976}
27977unsafe extern "C" fn _finalize<D: DomTypes>
27978(_cx: *mut GCContext, obj: *mut JSObject){
27979 wrap_panic(&mut || {
27980
27981 let this = native_from_object_static::<D::TestBinding>(obj).unwrap();
27982 finalize_common(this);
27983 })
27984}
27985
27986unsafe extern "C" fn _trace<D: DomTypes>
27987(trc: *mut JSTracer, obj: *mut JSObject){
27988 wrap_panic(&mut || {
27989
27990 let this = native_from_object_static::<D::TestBinding>(obj).unwrap();
27991 if this.is_null() { return; } (*this).trace(trc);
27993 })
27994}
27995
27996pub mod TestBindingConstants {
27997 pub const constantInt64: i64 = -1;
27998 pub const constantUint64: u64 = 1;
27999 pub const constantFloat32: f32 = 1.0;
28000 pub const constantFloat64: f64 = 1.0;
28001 pub const constantUnrestrictedFloat32: f32 = 1.0;
28002 pub const constantUnrestrictedFloat64: f64 = 1.0;
28003 pub const prefControlledConstDisabled: u16 = 0;
28004 pub const prefControlledConstEnabled: u16 = 0;
28005 pub const funcControlledConstDisabled: u16 = 0;
28006 pub const funcControlledConstEnabled: u16 = 0;
28007} static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();
28010
28011pub(crate) fn init_class_ops<D: DomTypes>() {
28012 CLASS_OPS.set(JSClassOps {
28013 addProperty: None,
28014 delProperty: None,
28015 enumerate: None,
28016 newEnumerate: None,
28017 resolve: None,
28018 mayResolve: None,
28019 finalize: Some(_finalize::<D>),
28020 call: None,
28021 construct: None,
28022 trace: Some(_trace::<D>),
28023 });
28024}
28025
28026pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();
28027
28028pub(crate) fn init_domjs_class<D: DomTypes>() {
28029 init_class_ops::<D>();
28030 Class.set(DOMJSClass {
28031 base: JSClass {
28032 name: c"TestBinding".as_ptr(),
28033 flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
28034 (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
28035 ,
28036 cOps: unsafe { CLASS_OPS.get() },
28037 spec: ptr::null(),
28038 ext: ptr::null(),
28039 oOps: ptr::null(),
28040 },
28041 dom_class:
28042DOMClass {
28043 interface_chain: [ PrototypeList::ID::TestBinding, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
28044 depth: 0,
28045 type_id: crate::codegen::InheritTypes::TopTypeId { testbinding: (crate::codegen::InheritTypes::TestBindingTypeId::TestBinding) },
28046 malloc_size_of: malloc_size_of_including_raw_self::<D::TestBinding> as unsafe fn(&mut _, _) -> _,
28047 global: Globals::EMPTY,
28048},
28049 });
28050}
28051
28052#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
28053(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::TestBinding>, _can_gc: CanGc) -> DomRoot<D::TestBinding>{
28054
28055 let raw = Root::new(MaybeUnreflectedDom::from_box(object));
28056
28057 let scope = scope.reflector().get_jsobject();
28058 assert!(!scope.get().is_null());
28059 assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
28060 let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());
28061
28062 rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
28063 GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
28064 assert!(!canonical_proto.is_null());
28065
28066
28067 rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
28068 if let Some(given) = given_proto {
28069 proto.set(*given);
28070 if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
28071 assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
28072 }
28073 } else {
28074 proto.set(*canonical_proto);
28075 }
28076 rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
28077 cx.raw_cx(),
28078 &Class.get().base,
28079 proto.handle(),
28080 ));
28081 assert!(!obj.is_null());
28082 JS_SetReservedSlot(
28083 obj.get(),
28084 DOM_OBJECT_SLOT,
28085 &PrivateValue(raw.as_ptr() as *const libc::c_void),
28086 );
28087
28088 let root = raw.reflect_with(obj.get());
28089
28090
28091
28092 DomRoot::from_ref(&*root)
28093}
28094
28095pub trait TestBindingMethods<D: DomTypes> {
28096 fn BooleanAttribute(&self, ) -> bool;
28097 fn SetBooleanAttribute(&self, r#value: bool);
28098 fn ByteAttribute(&self, ) -> i8;
28099 fn SetByteAttribute(&self, r#value: i8);
28100 fn OctetAttribute(&self, ) -> u8;
28101 fn SetOctetAttribute(&self, r#value: u8);
28102 fn ShortAttribute(&self, ) -> i16;
28103 fn SetShortAttribute(&self, r#value: i16);
28104 fn UnsignedShortAttribute(&self, ) -> u16;
28105 fn SetUnsignedShortAttribute(&self, r#value: u16);
28106 fn LongAttribute(&self, ) -> i32;
28107 fn SetLongAttribute(&self, r#value: i32);
28108 fn UnsignedLongAttribute(&self, ) -> u32;
28109 fn SetUnsignedLongAttribute(&self, r#value: u32);
28110 fn LongLongAttribute(&self, ) -> i64;
28111 fn SetLongLongAttribute(&self, r#value: i64);
28112 fn UnsignedLongLongAttribute(&self, ) -> u64;
28113 fn SetUnsignedLongLongAttribute(&self, r#value: u64);
28114 fn UnrestrictedFloatAttribute(&self, ) -> f32;
28115 fn SetUnrestrictedFloatAttribute(&self, r#value: f32);
28116 fn FloatAttribute(&self, ) -> Finite<f32>;
28117 fn SetFloatAttribute(&self, r#value: Finite<f32>);
28118 fn UnrestrictedDoubleAttribute(&self, ) -> f64;
28119 fn SetUnrestrictedDoubleAttribute(&self, r#value: f64);
28120 fn DoubleAttribute(&self, ) -> Finite<f64>;
28121 fn SetDoubleAttribute(&self, r#value: Finite<f64>);
28122 fn StringAttribute(&self, ) -> DOMString;
28123 fn SetStringAttribute(&self, r#value: DOMString);
28124 fn UsvstringAttribute(&self, ) -> USVString;
28125 fn SetUsvstringAttribute(&self, r#value: USVString);
28126 fn ByteStringAttribute(&self, ) -> ByteString;
28127 fn SetByteStringAttribute(&self, r#value: ByteString);
28128 fn EnumAttribute(&self, ) -> TestEnum;
28129 fn SetEnumAttribute(&self, r#value: TestEnum);
28130 fn InterfaceAttribute(&self, r#_can_gc: CanGc) -> DomRoot<D::Blob>;
28131 fn SetInterfaceAttribute(&self, r#value: &D::Blob);
28132 fn UnionAttribute(&self, ) -> GenericUnionTypes::HTMLElementOrLong::<D>;
28133 fn SetUnionAttribute(&self, r#value: GenericUnionTypes::HTMLElementOrLong::<D>);
28134 fn Union2Attribute(&self, ) -> GenericUnionTypes::EventOrString::<D>;
28135 fn SetUnion2Attribute(&self, r#value: GenericUnionTypes::EventOrString::<D>);
28136 fn Union3Attribute(&self, ) -> GenericUnionTypes::EventOrUSVString::<D>;
28137 fn SetUnion3Attribute(&self, r#value: GenericUnionTypes::EventOrUSVString::<D>);
28138 fn Union4Attribute(&self, ) -> GenericUnionTypes::StringOrUnsignedLong;
28139 fn SetUnion4Attribute(&self, r#value: GenericUnionTypes::StringOrUnsignedLong);
28140 fn Union5Attribute(&self, ) -> GenericUnionTypes::StringOrBoolean;
28141 fn SetUnion5Attribute(&self, r#value: GenericUnionTypes::StringOrBoolean);
28142 fn Union6Attribute(&self, ) -> GenericUnionTypes::UnsignedLongOrBoolean;
28143 fn SetUnion6Attribute(&self, r#value: GenericUnionTypes::UnsignedLongOrBoolean);
28144 fn Union7Attribute(&self, ) -> GenericUnionTypes::BlobOrBoolean::<D>;
28145 fn SetUnion7Attribute(&self, r#value: GenericUnionTypes::BlobOrBoolean::<D>);
28146 fn Union8Attribute(&self, ) -> GenericUnionTypes::BlobOrUnsignedLong::<D>;
28147 fn SetUnion8Attribute(&self, r#value: GenericUnionTypes::BlobOrUnsignedLong::<D>);
28148 fn Union9Attribute(&self, ) -> GenericUnionTypes::ByteStringOrLong;
28149 fn SetUnion9Attribute(&self, r#value: GenericUnionTypes::ByteStringOrLong);
28150 fn ArrayAttribute(&self, r#cx: SafeJSContext) -> Uint8ClampedArray;
28151 fn AnyAttribute(&self, r#cx: SafeJSContext, r#retval: MutableHandleValue);
28152 fn SetAnyAttribute(&self, r#cx: SafeJSContext, r#value: HandleValue);
28153 fn ObjectAttribute(&self, r#cx: SafeJSContext) -> NonNull<JSObject>;
28154 fn SetObjectAttribute(&self, r#cx: SafeJSContext, r#value: *mut JSObject);
28155 fn GetBooleanAttributeNullable(&self, ) -> Option<bool>;
28156 fn SetBooleanAttributeNullable(&self, r#value: Option<bool>);
28157 fn GetByteAttributeNullable(&self, ) -> Option<i8>;
28158 fn SetByteAttributeNullable(&self, r#value: Option<i8>);
28159 fn GetOctetAttributeNullable(&self, ) -> Option<u8>;
28160 fn SetOctetAttributeNullable(&self, r#value: Option<u8>);
28161 fn GetShortAttributeNullable(&self, ) -> Option<i16>;
28162 fn SetShortAttributeNullable(&self, r#value: Option<i16>);
28163 fn GetUnsignedShortAttributeNullable(&self, ) -> Option<u16>;
28164 fn SetUnsignedShortAttributeNullable(&self, r#value: Option<u16>);
28165 fn GetLongAttributeNullable(&self, ) -> Option<i32>;
28166 fn SetLongAttributeNullable(&self, r#value: Option<i32>);
28167 fn GetUnsignedLongAttributeNullable(&self, ) -> Option<u32>;
28168 fn SetUnsignedLongAttributeNullable(&self, r#value: Option<u32>);
28169 fn GetLongLongAttributeNullable(&self, ) -> Option<i64>;
28170 fn SetLongLongAttributeNullable(&self, r#value: Option<i64>);
28171 fn GetUnsignedLongLongAttributeNullable(&self, ) -> Option<u64>;
28172 fn SetUnsignedLongLongAttributeNullable(&self, r#value: Option<u64>);
28173 fn GetUnrestrictedFloatAttributeNullable(&self, ) -> Option<f32>;
28174 fn SetUnrestrictedFloatAttributeNullable(&self, r#value: Option<f32>);
28175 fn GetFloatAttributeNullable(&self, ) -> Option<Finite<f32>>;
28176 fn SetFloatAttributeNullable(&self, r#value: Option<Finite<f32>>);
28177 fn GetUnrestrictedDoubleAttributeNullable(&self, ) -> Option<f64>;
28178 fn SetUnrestrictedDoubleAttributeNullable(&self, r#value: Option<f64>);
28179 fn GetDoubleAttributeNullable(&self, ) -> Option<Finite<f64>>;
28180 fn SetDoubleAttributeNullable(&self, r#value: Option<Finite<f64>>);
28181 fn GetStringAttributeNullable(&self, ) -> Option<DOMString>;
28182 fn SetStringAttributeNullable(&self, r#value: Option<DOMString>);
28183 fn GetUsvstringAttributeNullable(&self, ) -> Option<USVString>;
28184 fn SetUsvstringAttributeNullable(&self, r#value: Option<USVString>);
28185 fn GetByteStringAttributeNullable(&self, ) -> Option<ByteString>;
28186 fn SetByteStringAttributeNullable(&self, r#value: Option<ByteString>);
28187 fn GetEnumAttributeNullable(&self, ) -> Option<TestEnum>;
28188 fn GetInterfaceAttributeNullable(&self, r#_can_gc: CanGc) -> Option<DomRoot<D::Blob>>;
28189 fn SetInterfaceAttributeNullable(&self, r#value: Option<&D::Blob>);
28190 fn GetInterfaceAttributeWeak(&self, ) -> Option<DomRoot<D::URL>>;
28191 fn SetInterfaceAttributeWeak(&self, r#value: Option<&D::URL>);
28192 fn GetObjectAttributeNullable(&self, r#cx: SafeJSContext) -> Option<NonNull<JSObject>>;
28193 fn SetObjectAttributeNullable(&self, r#cx: SafeJSContext, r#value: *mut JSObject);
28194 fn GetUnionAttributeNullable(&self, ) -> Option<GenericUnionTypes::HTMLElementOrLong::<D>>;
28195 fn SetUnionAttributeNullable(&self, r#value: Option<GenericUnionTypes::HTMLElementOrLong::<D> >);
28196 fn GetUnion2AttributeNullable(&self, ) -> Option<GenericUnionTypes::EventOrString::<D>>;
28197 fn SetUnion2AttributeNullable(&self, r#value: Option<GenericUnionTypes::EventOrString::<D> >);
28198 fn GetUnion3AttributeNullable(&self, ) -> Option<GenericUnionTypes::BlobOrBoolean::<D>>;
28199 fn SetUnion3AttributeNullable(&self, r#value: Option<GenericUnionTypes::BlobOrBoolean::<D> >);
28200 fn GetUnion4AttributeNullable(&self, ) -> Option<GenericUnionTypes::UnsignedLongOrBoolean>;
28201 fn SetUnion4AttributeNullable(&self, r#value: Option<GenericUnionTypes::UnsignedLongOrBoolean >);
28202 fn GetUnion5AttributeNullable(&self, ) -> Option<GenericUnionTypes::StringOrBoolean>;
28203 fn SetUnion5AttributeNullable(&self, r#value: Option<GenericUnionTypes::StringOrBoolean >);
28204 fn GetUnion6AttributeNullable(&self, ) -> Option<GenericUnionTypes::ByteStringOrLong>;
28205 fn SetUnion6AttributeNullable(&self, r#value: Option<GenericUnionTypes::ByteStringOrLong >);
28206 fn BinaryRenamedAttribute(&self, ) -> DOMString;
28207 fn SetBinaryRenamedAttribute(&self, r#value: DOMString);
28208 fn BinaryRenamedAttribute2(&self, ) -> DOMString;
28209 fn SetBinaryRenamedAttribute2(&self, r#value: DOMString);
28210 fn Attr_to_automatically_rename(&self, ) -> DOMString;
28211 fn SetAttr_to_automatically_rename(&self, r#value: DOMString);
28212 fn ForwardedAttribute(&self, ) -> DomRoot<D::TestBinding>;
28213 fn BinaryRenamedMethod(&self, );
28214 fn ReceiveVoid(&self, );
28215 fn ReceiveBoolean(&self, ) -> bool;
28216 fn ReceiveByte(&self, ) -> i8;
28217 fn ReceiveOctet(&self, ) -> u8;
28218 fn ReceiveShort(&self, ) -> i16;
28219 fn ReceiveUnsignedShort(&self, ) -> u16;
28220 fn ReceiveLong(&self, ) -> i32;
28221 fn ReceiveUnsignedLong(&self, ) -> u32;
28222 fn ReceiveLongLong(&self, ) -> i64;
28223 fn ReceiveUnsignedLongLong(&self, ) -> u64;
28224 fn ReceiveUnrestrictedFloat(&self, ) -> f32;
28225 fn ReceiveFloat(&self, ) -> Finite<f32>;
28226 fn ReceiveUnrestrictedDouble(&self, ) -> f64;
28227 fn ReceiveDouble(&self, ) -> Finite<f64>;
28228 fn ReceiveString(&self, ) -> DOMString;
28229 fn ReceiveUsvstring(&self, ) -> USVString;
28230 fn ReceiveByteString(&self, ) -> ByteString;
28231 fn ReceiveEnum(&self, ) -> TestEnum;
28232 fn ReceiveInterface(&self, r#_can_gc: CanGc) -> DomRoot<D::Blob>;
28233 fn ReceiveAny(&self, r#cx: SafeJSContext, r#rval: MutableHandleValue);
28234 fn ReceiveObject(&self, r#cx: SafeJSContext) -> NonNull<JSObject>;
28235 fn ReceiveUnion(&self, ) -> GenericUnionTypes::HTMLElementOrLong::<D>;
28236 fn ReceiveUnion2(&self, ) -> GenericUnionTypes::EventOrString::<D>;
28237 fn ReceiveUnion3(&self, ) -> GenericUnionTypes::StringOrLongSequence;
28238 fn ReceiveUnion4(&self, ) -> GenericUnionTypes::StringOrStringSequence;
28239 fn ReceiveUnion5(&self, ) -> GenericUnionTypes::BlobOrBlobSequence::<D>;
28240 fn ReceiveUnion6(&self, ) -> GenericUnionTypes::StringOrUnsignedLong;
28241 fn ReceiveUnion7(&self, ) -> GenericUnionTypes::StringOrBoolean;
28242 fn ReceiveUnion8(&self, ) -> GenericUnionTypes::UnsignedLongOrBoolean;
28243 fn ReceiveUnion9(&self, ) -> GenericUnionTypes::HTMLElementOrUnsignedLongOrStringOrBoolean::<D>;
28244 fn ReceiveUnion10(&self, ) -> GenericUnionTypes::ByteStringOrLong;
28245 fn ReceiveUnion11(&self, ) -> GenericUnionTypes::ByteStringSequenceOrLongOrString;
28246 fn ReceiveSequence(&self, ) -> Vec<i32>;
28247 fn ReceiveInterfaceSequence(&self, r#_can_gc: CanGc) -> Vec<DomRoot<D::Blob>>;
28248 fn ReceiveNullableByte(&self, ) -> Option<i8>;
28249 fn ReceiveNullableBoolean(&self, ) -> Option<bool>;
28250 fn ReceiveNullableOctet(&self, ) -> Option<u8>;
28251 fn ReceiveNullableShort(&self, ) -> Option<i16>;
28252 fn ReceiveNullableUnsignedShort(&self, ) -> Option<u16>;
28253 fn ReceiveNullableLong(&self, ) -> Option<i32>;
28254 fn ReceiveNullableUnsignedLong(&self, ) -> Option<u32>;
28255 fn ReceiveNullableLongLong(&self, ) -> Option<i64>;
28256 fn ReceiveNullableUnsignedLongLong(&self, ) -> Option<u64>;
28257 fn ReceiveNullableUnrestrictedFloat(&self, ) -> Option<f32>;
28258 fn ReceiveNullableFloat(&self, ) -> Option<Finite<f32>>;
28259 fn ReceiveNullableUnrestrictedDouble(&self, ) -> Option<f64>;
28260 fn ReceiveNullableDouble(&self, ) -> Option<Finite<f64>>;
28261 fn ReceiveNullableString(&self, ) -> Option<DOMString>;
28262 fn ReceiveNullableUsvstring(&self, ) -> Option<USVString>;
28263 fn ReceiveNullableByteString(&self, ) -> Option<ByteString>;
28264 fn ReceiveNullableEnum(&self, ) -> Option<TestEnum>;
28265 fn ReceiveNullableInterface(&self, r#_can_gc: CanGc) -> Option<DomRoot<D::Blob>>;
28266 fn ReceiveNullableObject(&self, r#cx: SafeJSContext) -> Option<NonNull<JSObject>>;
28267 fn ReceiveNullableUnion(&self, ) -> Option<GenericUnionTypes::HTMLElementOrLong::<D>>;
28268 fn ReceiveNullableUnion2(&self, ) -> Option<GenericUnionTypes::EventOrString::<D>>;
28269 fn ReceiveNullableUnion3(&self, ) -> Option<GenericUnionTypes::StringOrLongSequence>;
28270 fn ReceiveNullableUnion4(&self, ) -> Option<GenericUnionTypes::LongSequenceOrBoolean>;
28271 fn ReceiveNullableUnion5(&self, ) -> Option<GenericUnionTypes::UnsignedLongOrBoolean>;
28272 fn ReceiveNullableUnion6(&self, ) -> Option<GenericUnionTypes::ByteStringOrLong>;
28273 fn ReceiveNullableSequence(&self, ) -> Option<Vec<i32>>;
28274 fn ReceiveTestDictionaryWithSuccessOnKeyword(&self, ) -> RootedTraceableBox<TestDictionary<D>>;
28275 fn DictMatchesPassedValues(&self, r#arg: RootedTraceableBox<crate::codegen::GenericBindings::TestBindingBinding::TestDictionary<D>>) -> bool;
28276 fn ReceiveUnionIdentity(&self, r#cx: SafeJSContext, r#arg: GenericUnionTypes::StringOrObject) -> GenericUnionTypes::StringOrObject;
28277 fn PassBoolean(&self, r#arg: bool);
28278 fn PassByte(&self, r#arg: i8);
28279 fn PassOctet(&self, r#arg: u8);
28280 fn PassShort(&self, r#arg: i16);
28281 fn PassUnsignedShort(&self, r#arg: u16);
28282 fn PassLong(&self, r#arg: i32);
28283 fn PassUnsignedLong(&self, r#arg: u32);
28284 fn PassLongLong(&self, r#arg: i64);
28285 fn PassUnsignedLongLong(&self, r#arg: u64);
28286 fn PassUnrestrictedFloat(&self, r#arg: f32);
28287 fn PassFloat(&self, r#arg: Finite<f32>);
28288 fn PassUnrestrictedDouble(&self, r#arg: f64);
28289 fn PassDouble(&self, r#arg: Finite<f64>);
28290 fn PassString(&self, r#arg: DOMString);
28291 fn PassUsvstring(&self, r#arg: USVString);
28292 fn PassByteString(&self, r#arg: ByteString);
28293 fn PassEnum(&self, r#arg: TestEnum);
28294 fn PassInterface(&self, r#arg: &D::Blob);
28295 fn PassTypedArray(&self, r#arg: CustomAutoRooterGuard<typedarray::Int8Array>);
28296 fn PassTypedArray2(&self, r#arg: CustomAutoRooterGuard<typedarray::ArrayBuffer>);
28297 fn PassTypedArray3(&self, r#arg: CustomAutoRooterGuard<typedarray::ArrayBufferView>);
28298 fn PassUnion(&self, r#arg: GenericUnionTypes::HTMLElementOrLong::<D>);
28299 fn PassUnion2(&self, r#data: GenericUnionTypes::EventOrString::<D>);
28300 fn PassUnion3(&self, r#data: GenericUnionTypes::BlobOrString::<D>);
28301 fn PassUnion4(&self, r#seq: GenericUnionTypes::StringOrStringSequence);
28302 fn PassUnion5(&self, r#data: GenericUnionTypes::StringOrBoolean);
28303 fn PassUnion6(&self, r#bool: GenericUnionTypes::UnsignedLongOrBoolean);
28304 fn PassUnion7(&self, r#arg: GenericUnionTypes::StringSequenceOrUnsignedLong);
28305 fn PassUnion8(&self, r#arg: GenericUnionTypes::ByteStringSequenceOrLong);
28306 fn PassUnion9(&self, r#arg: GenericUnionTypes::TestDictionaryOrLong::<D>);
28307 fn PassUnion10(&self, r#cx: SafeJSContext, r#arg: GenericUnionTypes::StringOrObject);
28308 fn PassUnion11(&self, r#arg: GenericUnionTypes::ArrayBufferOrArrayBufferView);
28309 fn PassUnionWithTypedef(&self, r#arg: GenericUnionTypes::DocumentOrStringOrURLOrBlob::<D>);
28310 fn PassUnionWithTypedef2(&self, r#arg: GenericUnionTypes::LongSequenceOrStringOrURLOrBlob::<D>);
28311 fn PassAny(&self, r#cx: SafeJSContext, r#arg: HandleValue);
28312 fn PassObject(&self, r#cx: SafeJSContext, r#arg: *mut JSObject);
28313 fn PassCallbackFunction(&self, r#fun: Rc<Function<D>>);
28314 fn PassCallbackInterface(&self, r#listener: Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>);
28315 fn PassSequence(&self, r#seq: Vec<i32>);
28316 fn PassAnySequence(&self, r#cx: SafeJSContext, r#seq: CustomAutoRooterGuard<Vec<JSVal>>);
28317 fn AnySequencePassthrough(&self, r#cx: SafeJSContext, r#seq: CustomAutoRooterGuard<Vec<JSVal>>) -> Vec<JSVal>;
28318 fn PassObjectSequence(&self, r#cx: SafeJSContext, r#seq: CustomAutoRooterGuard<Vec<*mut JSObject>>);
28319 fn PassStringSequence(&self, r#seq: Vec<DOMString>);
28320 fn PassInterfaceSequence(&self, r#seq: Vec<DomRoot<D::Blob>>);
28321 fn PassOverloaded(&self, r#arg: CustomAutoRooterGuard<typedarray::ArrayBuffer>);
28322 fn PassOverloaded_(&self, r#arg: DOMString);
28323 fn PassOverloadedDict(&self, r#arg: &D::Node) -> DOMString;
28324 fn PassOverloadedDict_(&self, r#arg: &crate::codegen::GenericBindings::TestBindingBinding::TestURLLike) -> DOMString;
28325 fn PassNullableBoolean(&self, r#arg: Option<bool>);
28326 fn PassNullableByte(&self, r#arg: Option<i8>);
28327 fn PassNullableOctet(&self, r#arg: Option<u8>);
28328 fn PassNullableShort(&self, r#arg: Option<i16>);
28329 fn PassNullableUnsignedShort(&self, r#arg: Option<u16>);
28330 fn PassNullableLong(&self, r#arg: Option<i32>);
28331 fn PassNullableUnsignedLong(&self, r#arg: Option<u32>);
28332 fn PassNullableLongLong(&self, r#arg: Option<i64>);
28333 fn PassNullableUnsignedLongLong(&self, r#arg: Option<u64>);
28334 fn PassNullableUnrestrictedFloat(&self, r#arg: Option<f32>);
28335 fn PassNullableFloat(&self, r#arg: Option<Finite<f32>>);
28336 fn PassNullableUnrestrictedDouble(&self, r#arg: Option<f64>);
28337 fn PassNullableDouble(&self, r#arg: Option<Finite<f64>>);
28338 fn PassNullableString(&self, r#arg: Option<DOMString>);
28339 fn PassNullableUsvstring(&self, r#arg: Option<USVString>);
28340 fn PassNullableByteString(&self, r#arg: Option<ByteString>);
28341 fn PassNullableInterface(&self, r#arg: Option<&D::Blob>);
28342 fn PassNullableObject(&self, r#cx: SafeJSContext, r#arg: *mut JSObject);
28343 fn PassNullableTypedArray(&self, r#arg: CustomAutoRooterGuard<Option<typedarray::Int8Array>>);
28344 fn PassNullableUnion(&self, r#arg: Option<GenericUnionTypes::HTMLElementOrLong::<D> >);
28345 fn PassNullableUnion2(&self, r#data: Option<GenericUnionTypes::EventOrString::<D> >);
28346 fn PassNullableUnion3(&self, r#data: Option<GenericUnionTypes::StringOrLongSequence >);
28347 fn PassNullableUnion4(&self, r#bool: Option<GenericUnionTypes::LongSequenceOrBoolean >);
28348 fn PassNullableUnion5(&self, r#arg: Option<GenericUnionTypes::UnsignedLongOrBoolean >);
28349 fn PassNullableUnion6(&self, r#arg: Option<GenericUnionTypes::ByteStringOrLong >);
28350 fn PassNullableCallbackFunction(&self, r#fun: Option<Rc<Function<D>>>);
28351 fn PassNullableCallbackInterface(&self, r#listener: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>>);
28352 fn PassNullableSequence(&self, r#seq: Option<Vec<i32> >);
28353 fn PassOptionalBoolean(&self, r#arg: Option<bool>);
28354 fn PassOptionalByte(&self, r#arg: Option<i8>);
28355 fn PassOptionalOctet(&self, r#arg: Option<u8>);
28356 fn PassOptionalShort(&self, r#arg: Option<i16>);
28357 fn PassOptionalUnsignedShort(&self, r#arg: Option<u16>);
28358 fn PassOptionalLong(&self, r#arg: Option<i32>);
28359 fn PassOptionalUnsignedLong(&self, r#arg: Option<u32>);
28360 fn PassOptionalLongLong(&self, r#arg: Option<i64>);
28361 fn PassOptionalUnsignedLongLong(&self, r#arg: Option<u64>);
28362 fn PassOptionalUnrestrictedFloat(&self, r#arg: Option<f32>);
28363 fn PassOptionalFloat(&self, r#arg: Option<Finite<f32>>);
28364 fn PassOptionalUnrestrictedDouble(&self, r#arg: Option<f64>);
28365 fn PassOptionalDouble(&self, r#arg: Option<Finite<f64>>);
28366 fn PassOptionalString(&self, r#arg: Option<DOMString>);
28367 fn PassOptionalUsvstring(&self, r#arg: Option<USVString>);
28368 fn PassOptionalByteString(&self, r#arg: Option<ByteString>);
28369 fn PassOptionalEnum(&self, r#arg: Option<TestEnum>);
28370 fn PassOptionalInterface(&self, r#arg: Option<&D::Blob>);
28371 fn PassOptionalUnion(&self, r#arg: Option<GenericUnionTypes::HTMLElementOrLong::<D>>);
28372 fn PassOptionalUnion2(&self, r#data: Option<GenericUnionTypes::EventOrString::<D>>);
28373 fn PassOptionalUnion3(&self, r#arg: Option<GenericUnionTypes::StringOrLongSequence>);
28374 fn PassOptionalUnion4(&self, r#data: Option<GenericUnionTypes::LongSequenceOrBoolean>);
28375 fn PassOptionalUnion5(&self, r#bool: Option<GenericUnionTypes::UnsignedLongOrBoolean>);
28376 fn PassOptionalUnion6(&self, r#arg: Option<GenericUnionTypes::ByteStringOrLong>);
28377 fn PassOptionalAny(&self, r#cx: SafeJSContext, r#arg: HandleValue);
28378 fn PassOptionalObject(&self, r#cx: SafeJSContext, r#arg: Option<*mut JSObject>);
28379 fn PassOptionalCallbackFunction(&self, r#fun: Option<Rc<Function<D>>>);
28380 fn PassOptionalCallbackInterface(&self, r#listener: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>>);
28381 fn PassOptionalSequence(&self, r#seq: Option<Vec<i32>>);
28382 fn PassOptionalNullableBoolean(&self, r#arg: Option<Option<bool>>);
28383 fn PassOptionalNullableByte(&self, r#arg: Option<Option<i8>>);
28384 fn PassOptionalNullableOctet(&self, r#arg: Option<Option<u8>>);
28385 fn PassOptionalNullableShort(&self, r#arg: Option<Option<i16>>);
28386 fn PassOptionalNullableUnsignedShort(&self, r#arg: Option<Option<u16>>);
28387 fn PassOptionalNullableLong(&self, r#arg: Option<Option<i32>>);
28388 fn PassOptionalNullableUnsignedLong(&self, r#arg: Option<Option<u32>>);
28389 fn PassOptionalNullableLongLong(&self, r#arg: Option<Option<i64>>);
28390 fn PassOptionalNullableUnsignedLongLong(&self, r#arg: Option<Option<u64>>);
28391 fn PassOptionalNullableUnrestrictedFloat(&self, r#arg: Option<Option<f32>>);
28392 fn PassOptionalNullableFloat(&self, r#arg: Option<Option<Finite<f32>>>);
28393 fn PassOptionalNullableUnrestrictedDouble(&self, r#arg: Option<Option<f64>>);
28394 fn PassOptionalNullableDouble(&self, r#arg: Option<Option<Finite<f64>>>);
28395 fn PassOptionalNullableString(&self, r#arg: Option<Option<DOMString>>);
28396 fn PassOptionalNullableUsvstring(&self, r#arg: Option<Option<USVString>>);
28397 fn PassOptionalNullableByteString(&self, r#arg: Option<Option<ByteString>>);
28398 fn PassOptionalNullableInterface(&self, r#arg: Option<Option<&D::Blob>>);
28399 fn PassOptionalNullableObject(&self, r#cx: SafeJSContext, r#arg: Option<*mut JSObject>);
28400 fn PassOptionalNullableUnion(&self, r#arg: Option<Option<GenericUnionTypes::HTMLElementOrLong::<D> >>);
28401 fn PassOptionalNullableUnion2(&self, r#data: Option<Option<GenericUnionTypes::EventOrString::<D> >>);
28402 fn PassOptionalNullableUnion3(&self, r#arg: Option<Option<GenericUnionTypes::StringOrLongSequence >>);
28403 fn PassOptionalNullableUnion4(&self, r#data: Option<Option<GenericUnionTypes::LongSequenceOrBoolean >>);
28404 fn PassOptionalNullableUnion5(&self, r#bool: Option<Option<GenericUnionTypes::UnsignedLongOrBoolean >>);
28405 fn PassOptionalNullableUnion6(&self, r#arg: Option<Option<GenericUnionTypes::ByteStringOrLong >>);
28406 fn PassOptionalNullableCallbackFunction(&self, r#fun: Option<Option<Rc<Function<D>>>>);
28407 fn PassOptionalNullableCallbackInterface(&self, r#listener: Option<Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>>>);
28408 fn PassOptionalNullableSequence(&self, r#seq: Option<Option<Vec<i32> >>);
28409 fn PassOptionalBooleanWithDefault(&self, r#arg: bool);
28410 fn PassOptionalByteWithDefault(&self, r#arg: i8);
28411 fn PassOptionalOctetWithDefault(&self, r#arg: u8);
28412 fn PassOptionalShortWithDefault(&self, r#arg: i16);
28413 fn PassOptionalUnsignedShortWithDefault(&self, r#arg: u16);
28414 fn PassOptionalLongWithDefault(&self, r#arg: i32);
28415 fn PassOptionalUnsignedLongWithDefault(&self, r#arg: u32);
28416 fn PassOptionalLongLongWithDefault(&self, r#arg: i64);
28417 fn PassOptionalUnsignedLongLongWithDefault(&self, r#arg: u64);
28418 fn PassOptionalBytestringWithDefault(&self, r#arg: ByteString);
28419 fn PassOptionalStringWithDefault(&self, r#arg: DOMString);
28420 fn PassOptionalUsvstringWithDefault(&self, r#arg: USVString);
28421 fn PassOptionalEnumWithDefault(&self, r#arg: TestEnum);
28422 fn PassOptionalSequenceWithDefault(&self, r#seq: Vec<i32>);
28423 fn PassOptionalNullableBooleanWithDefault(&self, r#arg: Option<bool>);
28424 fn PassOptionalNullableByteWithDefault(&self, r#arg: Option<i8>);
28425 fn PassOptionalNullableOctetWithDefault(&self, r#arg: Option<u8>);
28426 fn PassOptionalNullableShortWithDefault(&self, r#arg: Option<i16>);
28427 fn PassOptionalNullableUnsignedShortWithDefault(&self, r#arg: Option<u16>);
28428 fn PassOptionalNullableLongWithDefault(&self, r#arg: Option<i32>);
28429 fn PassOptionalNullableUnsignedLongWithDefault(&self, r#arg: Option<u32>);
28430 fn PassOptionalNullableLongLongWithDefault(&self, r#arg: Option<i64>);
28431 fn PassOptionalNullableUnsignedLongLongWithDefault(&self, r#arg: Option<u64>);
28432 fn PassOptionalNullableStringWithDefault(&self, r#arg: Option<DOMString>);
28433 fn PassOptionalNullableUsvstringWithDefault(&self, r#arg: Option<USVString>);
28434 fn PassOptionalNullableByteStringWithDefault(&self, r#arg: Option<ByteString>);
28435 fn PassOptionalNullableInterfaceWithDefault(&self, r#arg: Option<&D::Blob>);
28436 fn PassOptionalNullableObjectWithDefault(&self, r#cx: SafeJSContext, r#arg: *mut JSObject);
28437 fn PassOptionalNullableUnionWithDefault(&self, r#arg: Option<GenericUnionTypes::HTMLElementOrLong::<D> >);
28438 fn PassOptionalNullableUnion2WithDefault(&self, r#data: Option<GenericUnionTypes::EventOrString::<D> >);
28439 fn PassOptionalNullableCallbackInterfaceWithDefault(&self, r#listener: Option<Rc<crate::codegen::GenericBindings::EventListenerBinding::EventListener<D>>>);
28440 fn PassOptionalAnyWithDefault(&self, r#cx: SafeJSContext, r#arg: HandleValue);
28441 fn PassOptionalNullableBooleanWithNonNullDefault(&self, r#arg: Option<bool>);
28442 fn PassOptionalNullableByteWithNonNullDefault(&self, r#arg: Option<i8>);
28443 fn PassOptionalNullableOctetWithNonNullDefault(&self, r#arg: Option<u8>);
28444 fn PassOptionalNullableShortWithNonNullDefault(&self, r#arg: Option<i16>);
28445 fn PassOptionalNullableUnsignedShortWithNonNullDefault(&self, r#arg: Option<u16>);
28446 fn PassOptionalNullableLongWithNonNullDefault(&self, r#arg: Option<i32>);
28447 fn PassOptionalNullableUnsignedLongWithNonNullDefault(&self, r#arg: Option<u32>);
28448 fn PassOptionalNullableLongLongWithNonNullDefault(&self, r#arg: Option<i64>);
28449 fn PassOptionalNullableUnsignedLongLongWithNonNullDefault(&self, r#arg: Option<u64>);
28450 fn PassOptionalNullableStringWithNonNullDefault(&self, r#arg: Option<DOMString>);
28451 fn PassOptionalNullableUsvstringWithNonNullDefault(&self, r#arg: Option<USVString>);
28452 fn PassOptionalOverloaded(&self, r#arg0: &D::TestBinding, r#arg1: u32, r#arg2: u32) -> DomRoot<D::TestBinding>;
28453 fn PassOptionalOverloaded_(&self, r#arg0: &D::Blob, r#arg1: u32);
28454 fn PassVariadicBoolean(&self, r#args: Vec<bool>);
28455 fn PassVariadicBooleanAndDefault(&self, r#arg: bool, r#args: Vec<bool>);
28456 fn PassVariadicByte(&self, r#args: Vec<i8>);
28457 fn PassVariadicOctet(&self, r#args: Vec<u8>);
28458 fn PassVariadicShort(&self, r#args: Vec<i16>);
28459 fn PassVariadicUnsignedShort(&self, r#args: Vec<u16>);
28460 fn PassVariadicLong(&self, r#args: Vec<i32>);
28461 fn PassVariadicUnsignedLong(&self, r#args: Vec<u32>);
28462 fn PassVariadicLongLong(&self, r#args: Vec<i64>);
28463 fn PassVariadicUnsignedLongLong(&self, r#args: Vec<u64>);
28464 fn PassVariadicUnrestrictedFloat(&self, r#args: Vec<f32>);
28465 fn PassVariadicFloat(&self, r#args: Vec<Finite<f32>>);
28466 fn PassVariadicUnrestrictedDouble(&self, r#args: Vec<f64>);
28467 fn PassVariadicDouble(&self, r#args: Vec<Finite<f64>>);
28468 fn PassVariadicString(&self, r#args: Vec<DOMString>);
28469 fn PassVariadicUsvstring(&self, r#args: Vec<USVString>);
28470 fn PassVariadicByteString(&self, r#args: Vec<ByteString>);
28471 fn PassVariadicEnum(&self, r#args: Vec<TestEnum>);
28472 fn PassVariadicInterface(&self, r#args: &[&D::Blob]);
28473 fn PassVariadicUnion(&self, r#args: Vec<GenericUnionTypes::HTMLElementOrLong::<D>>);
28474 fn PassVariadicUnion2(&self, r#args: Vec<GenericUnionTypes::EventOrString::<D>>);
28475 fn PassVariadicUnion3(&self, r#args: Vec<GenericUnionTypes::BlobOrString::<D>>);
28476 fn PassVariadicUnion4(&self, r#args: Vec<GenericUnionTypes::BlobOrBoolean::<D>>);
28477 fn PassVariadicUnion5(&self, r#args: Vec<GenericUnionTypes::StringOrUnsignedLong>);
28478 fn PassVariadicUnion6(&self, r#args: Vec<GenericUnionTypes::UnsignedLongOrBoolean>);
28479 fn PassVariadicUnion7(&self, r#args: Vec<GenericUnionTypes::ByteStringOrLong>);
28480 fn PassVariadicAny(&self, r#cx: SafeJSContext, r#args: Vec<HandleValue>);
28481 fn PassVariadicObject(&self, r#cx: SafeJSContext, r#args: Vec<*mut JSObject>);
28482 fn PassSequenceSequence(&self, r#seq: Vec<Vec<i32>>);
28483 fn ReturnSequenceSequence(&self, ) -> Vec<Vec<i32>>;
28484 fn PassUnionSequenceSequence(&self, r#seq: GenericUnionTypes::LongOrLongSequenceSequence);
28485 fn PassRecordPromise(&self, r#arg: Record<DOMString, Rc<D::Promise>>);
28486 fn PassRecord(&self, r#arg: Record<DOMString, i32>);
28487 fn PassRecordWithUSVStringKey(&self, r#arg: Record<USVString, i32>);
28488 fn PassRecordWithByteStringKey(&self, r#arg: Record<ByteString, i32>);
28489 fn PassNullableRecord(&self, r#arg: Option<Record<DOMString, i32> >);
28490 fn PassRecordOfNullableInts(&self, r#arg: Record<DOMString, Option<i32>>);
28491 fn PassOptionalRecordOfNullableInts(&self, r#arg: Option<Record<DOMString, Option<i32>>>);
28492 fn PassOptionalNullableRecordOfNullableInts(&self, r#arg: Option<Option<Record<DOMString, Option<i32>> >>);
28493 fn PassCastableObjectRecord(&self, r#arg: Record<DOMString, DomRoot<D::TestBinding>>);
28494 fn PassNullableCastableObjectRecord(&self, r#arg: Record<DOMString, Option<DomRoot<D::TestBinding>>>);
28495 fn PassCastableObjectNullableRecord(&self, r#arg: Option<Record<DOMString, DomRoot<D::TestBinding>> >);
28496 fn PassNullableCastableObjectNullableRecord(&self, r#arg: Option<Record<DOMString, Option<DomRoot<D::TestBinding>>> >);
28497 fn PassOptionalRecord(&self, r#arg: Option<Record<DOMString, i32>>);
28498 fn PassOptionalNullableRecord(&self, r#arg: Option<Option<Record<DOMString, i32> >>);
28499 fn PassOptionalNullableRecordWithDefaultValue(&self, r#arg: Option<Record<DOMString, i32> >);
28500 fn PassOptionalObjectRecord(&self, r#arg: Option<Record<DOMString, DomRoot<D::TestBinding>>>);
28501 fn PassStringRecord(&self, r#arg: Record<DOMString, DOMString>);
28502 fn PassByteStringRecord(&self, r#arg: Record<DOMString, ByteString>);
28503 fn PassRecordOfRecords(&self, r#arg: Record<DOMString, Record<DOMString, i32>>);
28504 fn PassRecordUnion(&self, r#init: GenericUnionTypes::LongOrStringByteStringRecord);
28505 fn PassRecordUnion2(&self, r#init: GenericUnionTypes::TestBindingOrStringByteStringRecord::<D>);
28506 fn PassRecordUnion3(&self, r#init: GenericUnionTypes::TestBindingOrByteStringSequenceSequenceOrStringByteStringRecord::<D>);
28507 fn ReceiveRecord(&self, ) -> Record<DOMString, i32>;
28508 fn ReceiveRecordWithUSVStringKey(&self, ) -> Record<USVString, i32>;
28509 fn ReceiveRecordWithByteStringKey(&self, ) -> Record<ByteString, i32>;
28510 fn ReceiveNullableRecord(&self, ) -> Option<Record<DOMString, i32>>;
28511 fn ReceiveRecordOfNullableInts(&self, ) -> Record<DOMString, Option<i32>>;
28512 fn ReceiveNullableRecordOfNullableInts(&self, ) -> Option<Record<DOMString, Option<i32>>>;
28513 fn ReceiveRecordOfRecords(&self, ) -> Record<DOMString, Record<DOMString, i32>>;
28514 fn ReceiveAnyRecord(&self, ) -> Record<DOMString, JSVal>;
28515 fn BooleanAttributeStatic(r#global: &D::GlobalScope) -> bool;
28516 fn SetBooleanAttributeStatic(r#global: &D::GlobalScope, r#value: bool);
28517 fn ReceiveVoidStatic(r#global: &D::GlobalScope);
28518 fn BooleanMozPreference(&self, r#pref_name: DOMString) -> bool;
28519 fn StringMozPreference(&self, r#pref_name: DOMString) -> DOMString;
28520 fn PrefControlledAttributeDisabled(&self, ) -> bool;
28521 fn PrefControlledStaticAttributeDisabled(r#global: &D::GlobalScope) -> bool;
28522 fn PrefControlledMethodDisabled(&self, );
28523 fn PrefControlledStaticMethodDisabled(r#global: &D::GlobalScope);
28524 fn AdvanceClock(&self, r#millis: i32);
28525 fn PrefControlledAttributeEnabled(&self, ) -> bool;
28526 fn PrefControlledStaticAttributeEnabled(r#global: &D::GlobalScope) -> bool;
28527 fn PrefControlledMethodEnabled(&self, );
28528 fn PrefControlledStaticMethodEnabled(r#global: &D::GlobalScope);
28529 fn FuncControlledAttributeDisabled(&self, ) -> bool;
28530 fn FuncControlledStaticAttributeDisabled(r#global: &D::GlobalScope) -> bool;
28531 fn FuncControlledMethodDisabled(&self, );
28532 fn FuncControlledStaticMethodDisabled(r#global: &D::GlobalScope);
28533 fn FuncControlledAttributeEnabled(&self, ) -> bool;
28534 fn FuncControlledStaticAttributeEnabled(r#global: &D::GlobalScope) -> bool;
28535 fn FuncControlledMethodEnabled(&self, );
28536 fn FuncControlledStaticMethodEnabled(r#global: &D::GlobalScope);
28537 fn ReturnResolvedPromise(&self, r#cx: SafeJSContext, r#value: HandleValue) -> Rc<D::Promise>;
28538 fn ReturnRejectedPromise(&self, r#cx: SafeJSContext, r#value: HandleValue) -> Rc<D::Promise>;
28539 fn PromiseAttribute(&self, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
28540 fn AcceptPromise(&self, r#string: &D::Promise);
28541 fn PromiseNativeHandler(&self, r#resolve: Option<Rc<SimpleCallback<D>>>, r#reject: Option<Rc<SimpleCallback<D>>>, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
28542 fn PromiseResolveNative(&self, r#cx: SafeJSContext, r#p: &D::Promise, r#value: HandleValue, r#_can_gc: CanGc);
28543 fn PromiseRejectNative(&self, r#cx: SafeJSContext, r#p: &D::Promise, r#value: HandleValue, r#_can_gc: CanGc);
28544 fn PromiseRejectWithTypeError(&self, r#p: &D::Promise, r#message: USVString, r#_can_gc: CanGc);
28545 fn ResolvePromiseDelayed(&self, r#p: &D::Promise, r#value: DOMString, r#ms: u64);
28546 fn StaticThrowToRejectPromise(r#global: &D::GlobalScope) -> Fallible<Rc<D::Promise>>;
28547 fn MethodThrowToRejectPromise(&self, ) -> Fallible<Rc<D::Promise>>;
28548 fn GetGetterThrowToRejectPromise(&self, ) -> Fallible<Rc<D::Promise>>;
28549 fn StaticInternalThrowToRejectPromise(r#global: &D::GlobalScope, r#arg: u64) -> Rc<D::Promise>;
28550 fn MethodInternalThrowToRejectPromise(&self, r#arg: u64) -> Rc<D::Promise>;
28551 fn Panic(&self, );
28552 fn EntryGlobal(&self, ) -> DomRoot<D::GlobalScope>;
28553 fn IncumbentGlobal(&self, ) -> DomRoot<D::GlobalScope>;
28554 fn SemiExposedBoolFromInterface(&self, ) -> bool;
28555 fn GetDictionaryWithParent(&self, r#parent: DOMString, r#child: DOMString) -> TestDictionaryWithParent;
28556 fn BoolFromSemiExposedPartialInterface(&self, ) -> bool;
28557 fn SemiExposedBoolFromPartialInterface(&self, ) -> bool;
28558 fn CrashHard(&self, );
28559 fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc) -> Fallible<DomRoot<D::TestBinding>>;
28560 fn Constructor_(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#numberSequence: Vec<f64>) -> Fallible<DomRoot<D::TestBinding>>;
28561 fn Constructor__(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#num: f64) -> Fallible<DomRoot<D::TestBinding>>;
28562}
28563static sStaticMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
28564
28565pub(crate) fn init_sStaticMethods_specs<D: DomTypes>() {
28566 sStaticMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
28567 JSFunctionSpec {
28568 name: JSPropertySpec_Name { string_: c"receiveVoidStatic".as_ptr() },
28569 call: JSNativeWrapper { op: Some(receiveVoidStatic::<D>), info: ptr::null() },
28570 nargs: 0,
28571 flags: (JSPROP_ENUMERATE) as u16,
28572 selfHostedName: ptr::null()
28573 },
28574 JSFunctionSpec {
28575 name: JSPropertySpec_Name { string_: ptr::null() },
28576 call: JSNativeWrapper { op: None, info: ptr::null() },
28577 nargs: 0,
28578 flags: 0,
28579 selfHostedName: ptr::null()
28580 }]))[..]
28581,
28582&Box::leak(Box::new([
28583 JSFunctionSpec {
28584 name: JSPropertySpec_Name { string_: c"prefControlledStaticMethodDisabled".as_ptr() },
28585 call: JSNativeWrapper { op: Some(prefControlledStaticMethodDisabled::<D>), info: ptr::null() },
28586 nargs: 0,
28587 flags: (JSPROP_ENUMERATE) as u16,
28588 selfHostedName: ptr::null()
28589 },
28590 JSFunctionSpec {
28591 name: JSPropertySpec_Name { string_: ptr::null() },
28592 call: JSNativeWrapper { op: None, info: ptr::null() },
28593 nargs: 0,
28594 flags: 0,
28595 selfHostedName: ptr::null()
28596 }]))[..]
28597,
28598&Box::leak(Box::new([
28599 JSFunctionSpec {
28600 name: JSPropertySpec_Name { string_: c"prefControlledStaticMethodEnabled".as_ptr() },
28601 call: JSNativeWrapper { op: Some(prefControlledStaticMethodEnabled::<D>), info: ptr::null() },
28602 nargs: 0,
28603 flags: (JSPROP_ENUMERATE) as u16,
28604 selfHostedName: ptr::null()
28605 },
28606 JSFunctionSpec {
28607 name: JSPropertySpec_Name { string_: ptr::null() },
28608 call: JSNativeWrapper { op: None, info: ptr::null() },
28609 nargs: 0,
28610 flags: 0,
28611 selfHostedName: ptr::null()
28612 }]))[..]
28613,
28614&Box::leak(Box::new([
28615 JSFunctionSpec {
28616 name: JSPropertySpec_Name { string_: c"funcControlledStaticMethodDisabled".as_ptr() },
28617 call: JSNativeWrapper { op: Some(funcControlledStaticMethodDisabled::<D>), info: ptr::null() },
28618 nargs: 0,
28619 flags: (JSPROP_ENUMERATE) as u16,
28620 selfHostedName: ptr::null()
28621 },
28622 JSFunctionSpec {
28623 name: JSPropertySpec_Name { string_: ptr::null() },
28624 call: JSNativeWrapper { op: None, info: ptr::null() },
28625 nargs: 0,
28626 flags: 0,
28627 selfHostedName: ptr::null()
28628 }]))[..]
28629,
28630&Box::leak(Box::new([
28631 JSFunctionSpec {
28632 name: JSPropertySpec_Name { string_: c"funcControlledStaticMethodEnabled".as_ptr() },
28633 call: JSNativeWrapper { op: Some(funcControlledStaticMethodEnabled::<D>), info: ptr::null() },
28634 nargs: 0,
28635 flags: (JSPROP_ENUMERATE) as u16,
28636 selfHostedName: ptr::null()
28637 },
28638 JSFunctionSpec {
28639 name: JSPropertySpec_Name { string_: ptr::null() },
28640 call: JSNativeWrapper { op: None, info: ptr::null() },
28641 nargs: 0,
28642 flags: 0,
28643 selfHostedName: ptr::null()
28644 }]))[..]
28645,
28646&Box::leak(Box::new([
28647 JSFunctionSpec {
28648 name: JSPropertySpec_Name { string_: c"staticThrowToRejectPromise".as_ptr() },
28649 call: JSNativeWrapper { op: Some(generic_static_promise_method), info: unsafe { staticThrowToRejectPromise_methodinfo.get() } },
28650 nargs: 0,
28651 flags: (JSPROP_ENUMERATE) as u16,
28652 selfHostedName: ptr::null()
28653 },
28654 JSFunctionSpec {
28655 name: JSPropertySpec_Name { string_: c"staticInternalThrowToRejectPromise".as_ptr() },
28656 call: JSNativeWrapper { op: Some(generic_static_promise_method), info: unsafe { staticInternalThrowToRejectPromise_methodinfo.get() } },
28657 nargs: 1,
28658 flags: (JSPROP_ENUMERATE) as u16,
28659 selfHostedName: ptr::null()
28660 },
28661 JSFunctionSpec {
28662 name: JSPropertySpec_Name { string_: ptr::null() },
28663 call: JSNativeWrapper { op: None, info: ptr::null() },
28664 nargs: 0,
28665 flags: 0,
28666 selfHostedName: ptr::null()
28667 }]))[..]
28668])));
28669}static sStaticMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
28670
28671pub(crate) fn init_sStaticMethods_prefs<D: DomTypes>() {
28672 sStaticMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[0]),
28673 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[1]),
28674 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled2_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[2]),
28675 Guard::new(&[Condition::Func(D::TestBinding::condition_unsatisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[3]),
28676 Guard::new(&[Condition::Func(D::TestBinding::condition_satisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[4]),
28677 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticMethods_specs.get() })[5])])));
28678}static sStaticAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
28679
28680pub(crate) fn init_sStaticAttributes_specs<D: DomTypes>() {
28681 sStaticAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
28682 JSPropertySpec {
28683 name: JSPropertySpec_Name { string_: c"booleanAttributeStatic".as_ptr() },
28684 attributes_: (JSPROP_ENUMERATE),
28685 kind_: (JSPropertySpec_Kind::NativeAccessor),
28686 u: JSPropertySpec_AccessorsOrValue {
28687 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
28688 getter: JSPropertySpec_Accessor {
28689 native: JSNativeWrapper { op: Some(get_booleanAttributeStatic::<D>), info: ptr::null() },
28690 },
28691 setter: JSPropertySpec_Accessor {
28692 native: JSNativeWrapper { op: Some(set_booleanAttributeStatic::<D>), info: ptr::null() },
28693 }
28694 }
28695 }
28696 }
28697,
28698 JSPropertySpec::ZERO]))[..]
28699,
28700&Box::leak(Box::new([
28701 JSPropertySpec {
28702 name: JSPropertySpec_Name { string_: c"prefControlledStaticAttributeDisabled".as_ptr() },
28703 attributes_: (JSPROP_ENUMERATE),
28704 kind_: (JSPropertySpec_Kind::NativeAccessor),
28705 u: JSPropertySpec_AccessorsOrValue {
28706 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
28707 getter: JSPropertySpec_Accessor {
28708 native: JSNativeWrapper { op: Some(get_prefControlledStaticAttributeDisabled::<D>), info: ptr::null() },
28709 },
28710 setter: JSPropertySpec_Accessor {
28711 native: JSNativeWrapper { op: None, info: ptr::null() },
28712 }
28713 }
28714 }
28715 }
28716,
28717 JSPropertySpec::ZERO]))[..]
28718,
28719&Box::leak(Box::new([
28720 JSPropertySpec {
28721 name: JSPropertySpec_Name { string_: c"prefControlledStaticAttributeEnabled".as_ptr() },
28722 attributes_: (JSPROP_ENUMERATE),
28723 kind_: (JSPropertySpec_Kind::NativeAccessor),
28724 u: JSPropertySpec_AccessorsOrValue {
28725 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
28726 getter: JSPropertySpec_Accessor {
28727 native: JSNativeWrapper { op: Some(get_prefControlledStaticAttributeEnabled::<D>), info: ptr::null() },
28728 },
28729 setter: JSPropertySpec_Accessor {
28730 native: JSNativeWrapper { op: None, info: ptr::null() },
28731 }
28732 }
28733 }
28734 }
28735,
28736 JSPropertySpec::ZERO]))[..]
28737,
28738&Box::leak(Box::new([
28739 JSPropertySpec {
28740 name: JSPropertySpec_Name { string_: c"funcControlledStaticAttributeDisabled".as_ptr() },
28741 attributes_: (JSPROP_ENUMERATE),
28742 kind_: (JSPropertySpec_Kind::NativeAccessor),
28743 u: JSPropertySpec_AccessorsOrValue {
28744 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
28745 getter: JSPropertySpec_Accessor {
28746 native: JSNativeWrapper { op: Some(get_funcControlledStaticAttributeDisabled::<D>), info: ptr::null() },
28747 },
28748 setter: JSPropertySpec_Accessor {
28749 native: JSNativeWrapper { op: None, info: ptr::null() },
28750 }
28751 }
28752 }
28753 }
28754,
28755 JSPropertySpec::ZERO]))[..]
28756,
28757&Box::leak(Box::new([
28758 JSPropertySpec {
28759 name: JSPropertySpec_Name { string_: c"funcControlledStaticAttributeEnabled".as_ptr() },
28760 attributes_: (JSPROP_ENUMERATE),
28761 kind_: (JSPropertySpec_Kind::NativeAccessor),
28762 u: JSPropertySpec_AccessorsOrValue {
28763 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
28764 getter: JSPropertySpec_Accessor {
28765 native: JSNativeWrapper { op: Some(get_funcControlledStaticAttributeEnabled::<D>), info: ptr::null() },
28766 },
28767 setter: JSPropertySpec_Accessor {
28768 native: JSNativeWrapper { op: None, info: ptr::null() },
28769 }
28770 }
28771 }
28772 }
28773,
28774 JSPropertySpec::ZERO]))[..]
28775])));
28776}static sStaticAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
28777
28778pub(crate) fn init_sStaticAttributes_prefs<D: DomTypes>() {
28779 sStaticAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticAttributes_specs.get() })[0]),
28780 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticAttributes_specs.get() })[1]),
28781 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled2_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticAttributes_specs.get() })[2]),
28782 Guard::new(&[Condition::Func(D::TestBinding::condition_unsatisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticAttributes_specs.get() })[3]),
28783 Guard::new(&[Condition::Func(D::TestBinding::condition_satisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sStaticAttributes_specs.get() })[4])])));
28784}static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();
28785
28786pub(crate) fn init_sMethods_specs<D: DomTypes>() {
28787 sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
28788 JSFunctionSpec {
28789 name: JSPropertySpec_Name { string_: c"methToBinaryRename".as_ptr() },
28790 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { methToBinaryRename_methodinfo.get() } as *const _ as *const JSJitInfo },
28791 nargs: 0,
28792 flags: (JSPROP_ENUMERATE) as u16,
28793 selfHostedName: ptr::null()
28794 },
28795 JSFunctionSpec {
28796 name: JSPropertySpec_Name { string_: c"receiveVoid".as_ptr() },
28797 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveVoid_methodinfo.get() } as *const _ as *const JSJitInfo },
28798 nargs: 0,
28799 flags: (JSPROP_ENUMERATE) as u16,
28800 selfHostedName: ptr::null()
28801 },
28802 JSFunctionSpec {
28803 name: JSPropertySpec_Name { string_: c"receiveBoolean".as_ptr() },
28804 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
28805 nargs: 0,
28806 flags: (JSPROP_ENUMERATE) as u16,
28807 selfHostedName: ptr::null()
28808 },
28809 JSFunctionSpec {
28810 name: JSPropertySpec_Name { string_: c"receiveByte".as_ptr() },
28811 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveByte_methodinfo.get() } as *const _ as *const JSJitInfo },
28812 nargs: 0,
28813 flags: (JSPROP_ENUMERATE) as u16,
28814 selfHostedName: ptr::null()
28815 },
28816 JSFunctionSpec {
28817 name: JSPropertySpec_Name { string_: c"receiveOctet".as_ptr() },
28818 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
28819 nargs: 0,
28820 flags: (JSPROP_ENUMERATE) as u16,
28821 selfHostedName: ptr::null()
28822 },
28823 JSFunctionSpec {
28824 name: JSPropertySpec_Name { string_: c"receiveShort".as_ptr() },
28825 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveShort_methodinfo.get() } as *const _ as *const JSJitInfo },
28826 nargs: 0,
28827 flags: (JSPROP_ENUMERATE) as u16,
28828 selfHostedName: ptr::null()
28829 },
28830 JSFunctionSpec {
28831 name: JSPropertySpec_Name { string_: c"receiveUnsignedShort".as_ptr() },
28832 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
28833 nargs: 0,
28834 flags: (JSPROP_ENUMERATE) as u16,
28835 selfHostedName: ptr::null()
28836 },
28837 JSFunctionSpec {
28838 name: JSPropertySpec_Name { string_: c"receiveLong".as_ptr() },
28839 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveLong_methodinfo.get() } as *const _ as *const JSJitInfo },
28840 nargs: 0,
28841 flags: (JSPROP_ENUMERATE) as u16,
28842 selfHostedName: ptr::null()
28843 },
28844 JSFunctionSpec {
28845 name: JSPropertySpec_Name { string_: c"receiveUnsignedLong".as_ptr() },
28846 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
28847 nargs: 0,
28848 flags: (JSPROP_ENUMERATE) as u16,
28849 selfHostedName: ptr::null()
28850 },
28851 JSFunctionSpec {
28852 name: JSPropertySpec_Name { string_: c"receiveLongLong".as_ptr() },
28853 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
28854 nargs: 0,
28855 flags: (JSPROP_ENUMERATE) as u16,
28856 selfHostedName: ptr::null()
28857 },
28858 JSFunctionSpec {
28859 name: JSPropertySpec_Name { string_: c"receiveUnsignedLongLong".as_ptr() },
28860 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
28861 nargs: 0,
28862 flags: (JSPROP_ENUMERATE) as u16,
28863 selfHostedName: ptr::null()
28864 },
28865 JSFunctionSpec {
28866 name: JSPropertySpec_Name { string_: c"receiveUnrestrictedFloat".as_ptr() },
28867 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
28868 nargs: 0,
28869 flags: (JSPROP_ENUMERATE) as u16,
28870 selfHostedName: ptr::null()
28871 },
28872 JSFunctionSpec {
28873 name: JSPropertySpec_Name { string_: c"receiveFloat".as_ptr() },
28874 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
28875 nargs: 0,
28876 flags: (JSPROP_ENUMERATE) as u16,
28877 selfHostedName: ptr::null()
28878 },
28879 JSFunctionSpec {
28880 name: JSPropertySpec_Name { string_: c"receiveUnrestrictedDouble".as_ptr() },
28881 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
28882 nargs: 0,
28883 flags: (JSPROP_ENUMERATE) as u16,
28884 selfHostedName: ptr::null()
28885 },
28886 JSFunctionSpec {
28887 name: JSPropertySpec_Name { string_: c"receiveDouble".as_ptr() },
28888 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
28889 nargs: 0,
28890 flags: (JSPROP_ENUMERATE) as u16,
28891 selfHostedName: ptr::null()
28892 },
28893 JSFunctionSpec {
28894 name: JSPropertySpec_Name { string_: c"receiveString".as_ptr() },
28895 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveString_methodinfo.get() } as *const _ as *const JSJitInfo },
28896 nargs: 0,
28897 flags: (JSPROP_ENUMERATE) as u16,
28898 selfHostedName: ptr::null()
28899 },
28900 JSFunctionSpec {
28901 name: JSPropertySpec_Name { string_: c"receiveUsvstring".as_ptr() },
28902 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
28903 nargs: 0,
28904 flags: (JSPROP_ENUMERATE) as u16,
28905 selfHostedName: ptr::null()
28906 },
28907 JSFunctionSpec {
28908 name: JSPropertySpec_Name { string_: c"receiveByteString".as_ptr() },
28909 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
28910 nargs: 0,
28911 flags: (JSPROP_ENUMERATE) as u16,
28912 selfHostedName: ptr::null()
28913 },
28914 JSFunctionSpec {
28915 name: JSPropertySpec_Name { string_: c"receiveEnum".as_ptr() },
28916 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveEnum_methodinfo.get() } as *const _ as *const JSJitInfo },
28917 nargs: 0,
28918 flags: (JSPROP_ENUMERATE) as u16,
28919 selfHostedName: ptr::null()
28920 },
28921 JSFunctionSpec {
28922 name: JSPropertySpec_Name { string_: c"receiveInterface".as_ptr() },
28923 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
28924 nargs: 0,
28925 flags: (JSPROP_ENUMERATE) as u16,
28926 selfHostedName: ptr::null()
28927 },
28928 JSFunctionSpec {
28929 name: JSPropertySpec_Name { string_: c"receiveAny".as_ptr() },
28930 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveAny_methodinfo.get() } as *const _ as *const JSJitInfo },
28931 nargs: 0,
28932 flags: (JSPROP_ENUMERATE) as u16,
28933 selfHostedName: ptr::null()
28934 },
28935 JSFunctionSpec {
28936 name: JSPropertySpec_Name { string_: c"receiveObject".as_ptr() },
28937 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveObject_methodinfo.get() } as *const _ as *const JSJitInfo },
28938 nargs: 0,
28939 flags: (JSPROP_ENUMERATE) as u16,
28940 selfHostedName: ptr::null()
28941 },
28942 JSFunctionSpec {
28943 name: JSPropertySpec_Name { string_: c"receiveUnion".as_ptr() },
28944 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
28945 nargs: 0,
28946 flags: (JSPROP_ENUMERATE) as u16,
28947 selfHostedName: ptr::null()
28948 },
28949 JSFunctionSpec {
28950 name: JSPropertySpec_Name { string_: c"receiveUnion2".as_ptr() },
28951 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
28952 nargs: 0,
28953 flags: (JSPROP_ENUMERATE) as u16,
28954 selfHostedName: ptr::null()
28955 },
28956 JSFunctionSpec {
28957 name: JSPropertySpec_Name { string_: c"receiveUnion3".as_ptr() },
28958 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
28959 nargs: 0,
28960 flags: (JSPROP_ENUMERATE) as u16,
28961 selfHostedName: ptr::null()
28962 },
28963 JSFunctionSpec {
28964 name: JSPropertySpec_Name { string_: c"receiveUnion4".as_ptr() },
28965 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
28966 nargs: 0,
28967 flags: (JSPROP_ENUMERATE) as u16,
28968 selfHostedName: ptr::null()
28969 },
28970 JSFunctionSpec {
28971 name: JSPropertySpec_Name { string_: c"receiveUnion5".as_ptr() },
28972 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
28973 nargs: 0,
28974 flags: (JSPROP_ENUMERATE) as u16,
28975 selfHostedName: ptr::null()
28976 },
28977 JSFunctionSpec {
28978 name: JSPropertySpec_Name { string_: c"receiveUnion6".as_ptr() },
28979 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
28980 nargs: 0,
28981 flags: (JSPROP_ENUMERATE) as u16,
28982 selfHostedName: ptr::null()
28983 },
28984 JSFunctionSpec {
28985 name: JSPropertySpec_Name { string_: c"receiveUnion7".as_ptr() },
28986 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion7_methodinfo.get() } as *const _ as *const JSJitInfo },
28987 nargs: 0,
28988 flags: (JSPROP_ENUMERATE) as u16,
28989 selfHostedName: ptr::null()
28990 },
28991 JSFunctionSpec {
28992 name: JSPropertySpec_Name { string_: c"receiveUnion8".as_ptr() },
28993 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion8_methodinfo.get() } as *const _ as *const JSJitInfo },
28994 nargs: 0,
28995 flags: (JSPROP_ENUMERATE) as u16,
28996 selfHostedName: ptr::null()
28997 },
28998 JSFunctionSpec {
28999 name: JSPropertySpec_Name { string_: c"receiveUnion9".as_ptr() },
29000 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion9_methodinfo.get() } as *const _ as *const JSJitInfo },
29001 nargs: 0,
29002 flags: (JSPROP_ENUMERATE) as u16,
29003 selfHostedName: ptr::null()
29004 },
29005 JSFunctionSpec {
29006 name: JSPropertySpec_Name { string_: c"receiveUnion10".as_ptr() },
29007 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion10_methodinfo.get() } as *const _ as *const JSJitInfo },
29008 nargs: 0,
29009 flags: (JSPROP_ENUMERATE) as u16,
29010 selfHostedName: ptr::null()
29011 },
29012 JSFunctionSpec {
29013 name: JSPropertySpec_Name { string_: c"receiveUnion11".as_ptr() },
29014 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnion11_methodinfo.get() } as *const _ as *const JSJitInfo },
29015 nargs: 0,
29016 flags: (JSPROP_ENUMERATE) as u16,
29017 selfHostedName: ptr::null()
29018 },
29019 JSFunctionSpec {
29020 name: JSPropertySpec_Name { string_: c"receiveSequence".as_ptr() },
29021 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29022 nargs: 0,
29023 flags: (JSPROP_ENUMERATE) as u16,
29024 selfHostedName: ptr::null()
29025 },
29026 JSFunctionSpec {
29027 name: JSPropertySpec_Name { string_: c"receiveInterfaceSequence".as_ptr() },
29028 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveInterfaceSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29029 nargs: 0,
29030 flags: (JSPROP_ENUMERATE) as u16,
29031 selfHostedName: ptr::null()
29032 },
29033 JSFunctionSpec {
29034 name: JSPropertySpec_Name { string_: c"receiveNullableByte".as_ptr() },
29035 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableByte_methodinfo.get() } as *const _ as *const JSJitInfo },
29036 nargs: 0,
29037 flags: (JSPROP_ENUMERATE) as u16,
29038 selfHostedName: ptr::null()
29039 },
29040 JSFunctionSpec {
29041 name: JSPropertySpec_Name { string_: c"receiveNullableBoolean".as_ptr() },
29042 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
29043 nargs: 0,
29044 flags: (JSPROP_ENUMERATE) as u16,
29045 selfHostedName: ptr::null()
29046 },
29047 JSFunctionSpec {
29048 name: JSPropertySpec_Name { string_: c"receiveNullableOctet".as_ptr() },
29049 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
29050 nargs: 0,
29051 flags: (JSPROP_ENUMERATE) as u16,
29052 selfHostedName: ptr::null()
29053 },
29054 JSFunctionSpec {
29055 name: JSPropertySpec_Name { string_: c"receiveNullableShort".as_ptr() },
29056 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29057 nargs: 0,
29058 flags: (JSPROP_ENUMERATE) as u16,
29059 selfHostedName: ptr::null()
29060 },
29061 JSFunctionSpec {
29062 name: JSPropertySpec_Name { string_: c"receiveNullableUnsignedShort".as_ptr() },
29063 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29064 nargs: 0,
29065 flags: (JSPROP_ENUMERATE) as u16,
29066 selfHostedName: ptr::null()
29067 },
29068 JSFunctionSpec {
29069 name: JSPropertySpec_Name { string_: c"receiveNullableLong".as_ptr() },
29070 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29071 nargs: 0,
29072 flags: (JSPROP_ENUMERATE) as u16,
29073 selfHostedName: ptr::null()
29074 },
29075 JSFunctionSpec {
29076 name: JSPropertySpec_Name { string_: c"receiveNullableUnsignedLong".as_ptr() },
29077 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29078 nargs: 0,
29079 flags: (JSPROP_ENUMERATE) as u16,
29080 selfHostedName: ptr::null()
29081 },
29082 JSFunctionSpec {
29083 name: JSPropertySpec_Name { string_: c"receiveNullableLongLong".as_ptr() },
29084 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29085 nargs: 0,
29086 flags: (JSPROP_ENUMERATE) as u16,
29087 selfHostedName: ptr::null()
29088 },
29089 JSFunctionSpec {
29090 name: JSPropertySpec_Name { string_: c"receiveNullableUnsignedLongLong".as_ptr() },
29091 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29092 nargs: 0,
29093 flags: (JSPROP_ENUMERATE) as u16,
29094 selfHostedName: ptr::null()
29095 },
29096 JSFunctionSpec {
29097 name: JSPropertySpec_Name { string_: c"receiveNullableUnrestrictedFloat".as_ptr() },
29098 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29099 nargs: 0,
29100 flags: (JSPROP_ENUMERATE) as u16,
29101 selfHostedName: ptr::null()
29102 },
29103 JSFunctionSpec {
29104 name: JSPropertySpec_Name { string_: c"receiveNullableFloat".as_ptr() },
29105 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29106 nargs: 0,
29107 flags: (JSPROP_ENUMERATE) as u16,
29108 selfHostedName: ptr::null()
29109 },
29110 JSFunctionSpec {
29111 name: JSPropertySpec_Name { string_: c"receiveNullableUnrestrictedDouble".as_ptr() },
29112 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29113 nargs: 0,
29114 flags: (JSPROP_ENUMERATE) as u16,
29115 selfHostedName: ptr::null()
29116 },
29117 JSFunctionSpec {
29118 name: JSPropertySpec_Name { string_: c"receiveNullableDouble".as_ptr() },
29119 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29120 nargs: 0,
29121 flags: (JSPROP_ENUMERATE) as u16,
29122 selfHostedName: ptr::null()
29123 },
29124 JSFunctionSpec {
29125 name: JSPropertySpec_Name { string_: c"receiveNullableString".as_ptr() },
29126 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableString_methodinfo.get() } as *const _ as *const JSJitInfo },
29127 nargs: 0,
29128 flags: (JSPROP_ENUMERATE) as u16,
29129 selfHostedName: ptr::null()
29130 },
29131 JSFunctionSpec {
29132 name: JSPropertySpec_Name { string_: c"receiveNullableUsvstring".as_ptr() },
29133 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
29134 nargs: 0,
29135 flags: (JSPROP_ENUMERATE) as u16,
29136 selfHostedName: ptr::null()
29137 },
29138 JSFunctionSpec {
29139 name: JSPropertySpec_Name { string_: c"receiveNullableByteString".as_ptr() },
29140 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
29141 nargs: 0,
29142 flags: (JSPROP_ENUMERATE) as u16,
29143 selfHostedName: ptr::null()
29144 },
29145 JSFunctionSpec {
29146 name: JSPropertySpec_Name { string_: c"receiveNullableEnum".as_ptr() },
29147 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableEnum_methodinfo.get() } as *const _ as *const JSJitInfo },
29148 nargs: 0,
29149 flags: (JSPROP_ENUMERATE) as u16,
29150 selfHostedName: ptr::null()
29151 },
29152 JSFunctionSpec {
29153 name: JSPropertySpec_Name { string_: c"receiveNullableInterface".as_ptr() },
29154 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29155 nargs: 0,
29156 flags: (JSPROP_ENUMERATE) as u16,
29157 selfHostedName: ptr::null()
29158 },
29159 JSFunctionSpec {
29160 name: JSPropertySpec_Name { string_: c"receiveNullableObject".as_ptr() },
29161 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableObject_methodinfo.get() } as *const _ as *const JSJitInfo },
29162 nargs: 0,
29163 flags: (JSPROP_ENUMERATE) as u16,
29164 selfHostedName: ptr::null()
29165 },
29166 JSFunctionSpec {
29167 name: JSPropertySpec_Name { string_: c"receiveNullableUnion".as_ptr() },
29168 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
29169 nargs: 0,
29170 flags: (JSPROP_ENUMERATE) as u16,
29171 selfHostedName: ptr::null()
29172 },
29173 JSFunctionSpec {
29174 name: JSPropertySpec_Name { string_: c"receiveNullableUnion2".as_ptr() },
29175 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
29176 nargs: 0,
29177 flags: (JSPROP_ENUMERATE) as u16,
29178 selfHostedName: ptr::null()
29179 },
29180 JSFunctionSpec {
29181 name: JSPropertySpec_Name { string_: c"receiveNullableUnion3".as_ptr() },
29182 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
29183 nargs: 0,
29184 flags: (JSPROP_ENUMERATE) as u16,
29185 selfHostedName: ptr::null()
29186 },
29187 JSFunctionSpec {
29188 name: JSPropertySpec_Name { string_: c"receiveNullableUnion4".as_ptr() },
29189 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
29190 nargs: 0,
29191 flags: (JSPROP_ENUMERATE) as u16,
29192 selfHostedName: ptr::null()
29193 },
29194 JSFunctionSpec {
29195 name: JSPropertySpec_Name { string_: c"receiveNullableUnion5".as_ptr() },
29196 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
29197 nargs: 0,
29198 flags: (JSPROP_ENUMERATE) as u16,
29199 selfHostedName: ptr::null()
29200 },
29201 JSFunctionSpec {
29202 name: JSPropertySpec_Name { string_: c"receiveNullableUnion6".as_ptr() },
29203 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
29204 nargs: 0,
29205 flags: (JSPROP_ENUMERATE) as u16,
29206 selfHostedName: ptr::null()
29207 },
29208 JSFunctionSpec {
29209 name: JSPropertySpec_Name { string_: c"receiveNullableSequence".as_ptr() },
29210 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29211 nargs: 0,
29212 flags: (JSPROP_ENUMERATE) as u16,
29213 selfHostedName: ptr::null()
29214 },
29215 JSFunctionSpec {
29216 name: JSPropertySpec_Name { string_: c"receiveTestDictionaryWithSuccessOnKeyword".as_ptr() },
29217 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveTestDictionaryWithSuccessOnKeyword_methodinfo.get() } as *const _ as *const JSJitInfo },
29218 nargs: 0,
29219 flags: (JSPROP_ENUMERATE) as u16,
29220 selfHostedName: ptr::null()
29221 },
29222 JSFunctionSpec {
29223 name: JSPropertySpec_Name { string_: c"dictMatchesPassedValues".as_ptr() },
29224 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { dictMatchesPassedValues_methodinfo.get() } as *const _ as *const JSJitInfo },
29225 nargs: 1,
29226 flags: (JSPROP_ENUMERATE) as u16,
29227 selfHostedName: ptr::null()
29228 },
29229 JSFunctionSpec {
29230 name: JSPropertySpec_Name { string_: c"receiveUnionIdentity".as_ptr() },
29231 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveUnionIdentity_methodinfo.get() } as *const _ as *const JSJitInfo },
29232 nargs: 1,
29233 flags: (JSPROP_ENUMERATE) as u16,
29234 selfHostedName: ptr::null()
29235 },
29236 JSFunctionSpec {
29237 name: JSPropertySpec_Name { string_: c"passBoolean".as_ptr() },
29238 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
29239 nargs: 1,
29240 flags: (JSPROP_ENUMERATE) as u16,
29241 selfHostedName: ptr::null()
29242 },
29243 JSFunctionSpec {
29244 name: JSPropertySpec_Name { string_: c"passByte".as_ptr() },
29245 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passByte_methodinfo.get() } as *const _ as *const JSJitInfo },
29246 nargs: 1,
29247 flags: (JSPROP_ENUMERATE) as u16,
29248 selfHostedName: ptr::null()
29249 },
29250 JSFunctionSpec {
29251 name: JSPropertySpec_Name { string_: c"passOctet".as_ptr() },
29252 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
29253 nargs: 1,
29254 flags: (JSPROP_ENUMERATE) as u16,
29255 selfHostedName: ptr::null()
29256 },
29257 JSFunctionSpec {
29258 name: JSPropertySpec_Name { string_: c"passShort".as_ptr() },
29259 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29260 nargs: 1,
29261 flags: (JSPROP_ENUMERATE) as u16,
29262 selfHostedName: ptr::null()
29263 },
29264 JSFunctionSpec {
29265 name: JSPropertySpec_Name { string_: c"passUnsignedShort".as_ptr() },
29266 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29267 nargs: 1,
29268 flags: (JSPROP_ENUMERATE) as u16,
29269 selfHostedName: ptr::null()
29270 },
29271 JSFunctionSpec {
29272 name: JSPropertySpec_Name { string_: c"passLong".as_ptr() },
29273 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29274 nargs: 1,
29275 flags: (JSPROP_ENUMERATE) as u16,
29276 selfHostedName: ptr::null()
29277 },
29278 JSFunctionSpec {
29279 name: JSPropertySpec_Name { string_: c"passUnsignedLong".as_ptr() },
29280 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29281 nargs: 1,
29282 flags: (JSPROP_ENUMERATE) as u16,
29283 selfHostedName: ptr::null()
29284 },
29285 JSFunctionSpec {
29286 name: JSPropertySpec_Name { string_: c"passLongLong".as_ptr() },
29287 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29288 nargs: 1,
29289 flags: (JSPROP_ENUMERATE) as u16,
29290 selfHostedName: ptr::null()
29291 },
29292 JSFunctionSpec {
29293 name: JSPropertySpec_Name { string_: c"passUnsignedLongLong".as_ptr() },
29294 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29295 nargs: 1,
29296 flags: (JSPROP_ENUMERATE) as u16,
29297 selfHostedName: ptr::null()
29298 },
29299 JSFunctionSpec {
29300 name: JSPropertySpec_Name { string_: c"passUnrestrictedFloat".as_ptr() },
29301 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29302 nargs: 1,
29303 flags: (JSPROP_ENUMERATE) as u16,
29304 selfHostedName: ptr::null()
29305 },
29306 JSFunctionSpec {
29307 name: JSPropertySpec_Name { string_: c"passFloat".as_ptr() },
29308 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29309 nargs: 1,
29310 flags: (JSPROP_ENUMERATE) as u16,
29311 selfHostedName: ptr::null()
29312 },
29313 JSFunctionSpec {
29314 name: JSPropertySpec_Name { string_: c"passUnrestrictedDouble".as_ptr() },
29315 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29316 nargs: 1,
29317 flags: (JSPROP_ENUMERATE) as u16,
29318 selfHostedName: ptr::null()
29319 },
29320 JSFunctionSpec {
29321 name: JSPropertySpec_Name { string_: c"passDouble".as_ptr() },
29322 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29323 nargs: 1,
29324 flags: (JSPROP_ENUMERATE) as u16,
29325 selfHostedName: ptr::null()
29326 },
29327 JSFunctionSpec {
29328 name: JSPropertySpec_Name { string_: c"passString".as_ptr() },
29329 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passString_methodinfo.get() } as *const _ as *const JSJitInfo },
29330 nargs: 1,
29331 flags: (JSPROP_ENUMERATE) as u16,
29332 selfHostedName: ptr::null()
29333 },
29334 JSFunctionSpec {
29335 name: JSPropertySpec_Name { string_: c"passUsvstring".as_ptr() },
29336 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
29337 nargs: 1,
29338 flags: (JSPROP_ENUMERATE) as u16,
29339 selfHostedName: ptr::null()
29340 },
29341 JSFunctionSpec {
29342 name: JSPropertySpec_Name { string_: c"passByteString".as_ptr() },
29343 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
29344 nargs: 1,
29345 flags: (JSPROP_ENUMERATE) as u16,
29346 selfHostedName: ptr::null()
29347 },
29348 JSFunctionSpec {
29349 name: JSPropertySpec_Name { string_: c"passEnum".as_ptr() },
29350 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passEnum_methodinfo.get() } as *const _ as *const JSJitInfo },
29351 nargs: 1,
29352 flags: (JSPROP_ENUMERATE) as u16,
29353 selfHostedName: ptr::null()
29354 },
29355 JSFunctionSpec {
29356 name: JSPropertySpec_Name { string_: c"passInterface".as_ptr() },
29357 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29358 nargs: 1,
29359 flags: (JSPROP_ENUMERATE) as u16,
29360 selfHostedName: ptr::null()
29361 },
29362 JSFunctionSpec {
29363 name: JSPropertySpec_Name { string_: c"passTypedArray".as_ptr() },
29364 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passTypedArray_methodinfo.get() } as *const _ as *const JSJitInfo },
29365 nargs: 1,
29366 flags: (JSPROP_ENUMERATE) as u16,
29367 selfHostedName: ptr::null()
29368 },
29369 JSFunctionSpec {
29370 name: JSPropertySpec_Name { string_: c"passTypedArray2".as_ptr() },
29371 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passTypedArray2_methodinfo.get() } as *const _ as *const JSJitInfo },
29372 nargs: 1,
29373 flags: (JSPROP_ENUMERATE) as u16,
29374 selfHostedName: ptr::null()
29375 },
29376 JSFunctionSpec {
29377 name: JSPropertySpec_Name { string_: c"passTypedArray3".as_ptr() },
29378 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passTypedArray3_methodinfo.get() } as *const _ as *const JSJitInfo },
29379 nargs: 1,
29380 flags: (JSPROP_ENUMERATE) as u16,
29381 selfHostedName: ptr::null()
29382 },
29383 JSFunctionSpec {
29384 name: JSPropertySpec_Name { string_: c"passUnion".as_ptr() },
29385 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
29386 nargs: 1,
29387 flags: (JSPROP_ENUMERATE) as u16,
29388 selfHostedName: ptr::null()
29389 },
29390 JSFunctionSpec {
29391 name: JSPropertySpec_Name { string_: c"passUnion2".as_ptr() },
29392 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
29393 nargs: 1,
29394 flags: (JSPROP_ENUMERATE) as u16,
29395 selfHostedName: ptr::null()
29396 },
29397 JSFunctionSpec {
29398 name: JSPropertySpec_Name { string_: c"passUnion3".as_ptr() },
29399 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
29400 nargs: 1,
29401 flags: (JSPROP_ENUMERATE) as u16,
29402 selfHostedName: ptr::null()
29403 },
29404 JSFunctionSpec {
29405 name: JSPropertySpec_Name { string_: c"passUnion4".as_ptr() },
29406 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
29407 nargs: 1,
29408 flags: (JSPROP_ENUMERATE) as u16,
29409 selfHostedName: ptr::null()
29410 },
29411 JSFunctionSpec {
29412 name: JSPropertySpec_Name { string_: c"passUnion5".as_ptr() },
29413 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
29414 nargs: 1,
29415 flags: (JSPROP_ENUMERATE) as u16,
29416 selfHostedName: ptr::null()
29417 },
29418 JSFunctionSpec {
29419 name: JSPropertySpec_Name { string_: c"passUnion6".as_ptr() },
29420 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
29421 nargs: 1,
29422 flags: (JSPROP_ENUMERATE) as u16,
29423 selfHostedName: ptr::null()
29424 },
29425 JSFunctionSpec {
29426 name: JSPropertySpec_Name { string_: c"passUnion7".as_ptr() },
29427 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion7_methodinfo.get() } as *const _ as *const JSJitInfo },
29428 nargs: 1,
29429 flags: (JSPROP_ENUMERATE) as u16,
29430 selfHostedName: ptr::null()
29431 },
29432 JSFunctionSpec {
29433 name: JSPropertySpec_Name { string_: c"passUnion8".as_ptr() },
29434 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion8_methodinfo.get() } as *const _ as *const JSJitInfo },
29435 nargs: 1,
29436 flags: (JSPROP_ENUMERATE) as u16,
29437 selfHostedName: ptr::null()
29438 },
29439 JSFunctionSpec {
29440 name: JSPropertySpec_Name { string_: c"passUnion9".as_ptr() },
29441 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion9_methodinfo.get() } as *const _ as *const JSJitInfo },
29442 nargs: 1,
29443 flags: (JSPROP_ENUMERATE) as u16,
29444 selfHostedName: ptr::null()
29445 },
29446 JSFunctionSpec {
29447 name: JSPropertySpec_Name { string_: c"passUnion10".as_ptr() },
29448 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion10_methodinfo.get() } as *const _ as *const JSJitInfo },
29449 nargs: 1,
29450 flags: (JSPROP_ENUMERATE) as u16,
29451 selfHostedName: ptr::null()
29452 },
29453 JSFunctionSpec {
29454 name: JSPropertySpec_Name { string_: c"passUnion11".as_ptr() },
29455 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnion11_methodinfo.get() } as *const _ as *const JSJitInfo },
29456 nargs: 1,
29457 flags: (JSPROP_ENUMERATE) as u16,
29458 selfHostedName: ptr::null()
29459 },
29460 JSFunctionSpec {
29461 name: JSPropertySpec_Name { string_: c"passUnionWithTypedef".as_ptr() },
29462 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnionWithTypedef_methodinfo.get() } as *const _ as *const JSJitInfo },
29463 nargs: 1,
29464 flags: (JSPROP_ENUMERATE) as u16,
29465 selfHostedName: ptr::null()
29466 },
29467 JSFunctionSpec {
29468 name: JSPropertySpec_Name { string_: c"passUnionWithTypedef2".as_ptr() },
29469 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnionWithTypedef2_methodinfo.get() } as *const _ as *const JSJitInfo },
29470 nargs: 1,
29471 flags: (JSPROP_ENUMERATE) as u16,
29472 selfHostedName: ptr::null()
29473 },
29474 JSFunctionSpec {
29475 name: JSPropertySpec_Name { string_: c"passAny".as_ptr() },
29476 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passAny_methodinfo.get() } as *const _ as *const JSJitInfo },
29477 nargs: 1,
29478 flags: (JSPROP_ENUMERATE) as u16,
29479 selfHostedName: ptr::null()
29480 },
29481 JSFunctionSpec {
29482 name: JSPropertySpec_Name { string_: c"passObject".as_ptr() },
29483 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passObject_methodinfo.get() } as *const _ as *const JSJitInfo },
29484 nargs: 1,
29485 flags: (JSPROP_ENUMERATE) as u16,
29486 selfHostedName: ptr::null()
29487 },
29488 JSFunctionSpec {
29489 name: JSPropertySpec_Name { string_: c"passCallbackFunction".as_ptr() },
29490 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passCallbackFunction_methodinfo.get() } as *const _ as *const JSJitInfo },
29491 nargs: 1,
29492 flags: (JSPROP_ENUMERATE) as u16,
29493 selfHostedName: ptr::null()
29494 },
29495 JSFunctionSpec {
29496 name: JSPropertySpec_Name { string_: c"passCallbackInterface".as_ptr() },
29497 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passCallbackInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29498 nargs: 1,
29499 flags: (JSPROP_ENUMERATE) as u16,
29500 selfHostedName: ptr::null()
29501 },
29502 JSFunctionSpec {
29503 name: JSPropertySpec_Name { string_: c"passSequence".as_ptr() },
29504 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29505 nargs: 1,
29506 flags: (JSPROP_ENUMERATE) as u16,
29507 selfHostedName: ptr::null()
29508 },
29509 JSFunctionSpec {
29510 name: JSPropertySpec_Name { string_: c"passAnySequence".as_ptr() },
29511 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passAnySequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29512 nargs: 1,
29513 flags: (JSPROP_ENUMERATE) as u16,
29514 selfHostedName: ptr::null()
29515 },
29516 JSFunctionSpec {
29517 name: JSPropertySpec_Name { string_: c"anySequencePassthrough".as_ptr() },
29518 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { anySequencePassthrough_methodinfo.get() } as *const _ as *const JSJitInfo },
29519 nargs: 1,
29520 flags: (JSPROP_ENUMERATE) as u16,
29521 selfHostedName: ptr::null()
29522 },
29523 JSFunctionSpec {
29524 name: JSPropertySpec_Name { string_: c"passObjectSequence".as_ptr() },
29525 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passObjectSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29526 nargs: 1,
29527 flags: (JSPROP_ENUMERATE) as u16,
29528 selfHostedName: ptr::null()
29529 },
29530 JSFunctionSpec {
29531 name: JSPropertySpec_Name { string_: c"passStringSequence".as_ptr() },
29532 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passStringSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29533 nargs: 1,
29534 flags: (JSPROP_ENUMERATE) as u16,
29535 selfHostedName: ptr::null()
29536 },
29537 JSFunctionSpec {
29538 name: JSPropertySpec_Name { string_: c"passInterfaceSequence".as_ptr() },
29539 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passInterfaceSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29540 nargs: 1,
29541 flags: (JSPROP_ENUMERATE) as u16,
29542 selfHostedName: ptr::null()
29543 },
29544 JSFunctionSpec {
29545 name: JSPropertySpec_Name { string_: c"passOverloaded".as_ptr() },
29546 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOverloaded_methodinfo.get() } as *const _ as *const JSJitInfo },
29547 nargs: 1,
29548 flags: (JSPROP_ENUMERATE) as u16,
29549 selfHostedName: ptr::null()
29550 },
29551 JSFunctionSpec {
29552 name: JSPropertySpec_Name { string_: c"passOverloadedDict".as_ptr() },
29553 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOverloadedDict_methodinfo.get() } as *const _ as *const JSJitInfo },
29554 nargs: 1,
29555 flags: (JSPROP_ENUMERATE) as u16,
29556 selfHostedName: ptr::null()
29557 },
29558 JSFunctionSpec {
29559 name: JSPropertySpec_Name { string_: c"passNullableBoolean".as_ptr() },
29560 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
29561 nargs: 1,
29562 flags: (JSPROP_ENUMERATE) as u16,
29563 selfHostedName: ptr::null()
29564 },
29565 JSFunctionSpec {
29566 name: JSPropertySpec_Name { string_: c"passNullableByte".as_ptr() },
29567 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableByte_methodinfo.get() } as *const _ as *const JSJitInfo },
29568 nargs: 1,
29569 flags: (JSPROP_ENUMERATE) as u16,
29570 selfHostedName: ptr::null()
29571 },
29572 JSFunctionSpec {
29573 name: JSPropertySpec_Name { string_: c"passNullableOctet".as_ptr() },
29574 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
29575 nargs: 1,
29576 flags: (JSPROP_ENUMERATE) as u16,
29577 selfHostedName: ptr::null()
29578 },
29579 JSFunctionSpec {
29580 name: JSPropertySpec_Name { string_: c"passNullableShort".as_ptr() },
29581 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29582 nargs: 1,
29583 flags: (JSPROP_ENUMERATE) as u16,
29584 selfHostedName: ptr::null()
29585 },
29586 JSFunctionSpec {
29587 name: JSPropertySpec_Name { string_: c"passNullableUnsignedShort".as_ptr() },
29588 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29589 nargs: 1,
29590 flags: (JSPROP_ENUMERATE) as u16,
29591 selfHostedName: ptr::null()
29592 },
29593 JSFunctionSpec {
29594 name: JSPropertySpec_Name { string_: c"passNullableLong".as_ptr() },
29595 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29596 nargs: 1,
29597 flags: (JSPROP_ENUMERATE) as u16,
29598 selfHostedName: ptr::null()
29599 },
29600 JSFunctionSpec {
29601 name: JSPropertySpec_Name { string_: c"passNullableUnsignedLong".as_ptr() },
29602 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29603 nargs: 1,
29604 flags: (JSPROP_ENUMERATE) as u16,
29605 selfHostedName: ptr::null()
29606 },
29607 JSFunctionSpec {
29608 name: JSPropertySpec_Name { string_: c"passNullableLongLong".as_ptr() },
29609 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29610 nargs: 1,
29611 flags: (JSPROP_ENUMERATE) as u16,
29612 selfHostedName: ptr::null()
29613 },
29614 JSFunctionSpec {
29615 name: JSPropertySpec_Name { string_: c"passNullableUnsignedLongLong".as_ptr() },
29616 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29617 nargs: 1,
29618 flags: (JSPROP_ENUMERATE) as u16,
29619 selfHostedName: ptr::null()
29620 },
29621 JSFunctionSpec {
29622 name: JSPropertySpec_Name { string_: c"passNullableUnrestrictedFloat".as_ptr() },
29623 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29624 nargs: 1,
29625 flags: (JSPROP_ENUMERATE) as u16,
29626 selfHostedName: ptr::null()
29627 },
29628 JSFunctionSpec {
29629 name: JSPropertySpec_Name { string_: c"passNullableFloat".as_ptr() },
29630 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29631 nargs: 1,
29632 flags: (JSPROP_ENUMERATE) as u16,
29633 selfHostedName: ptr::null()
29634 },
29635 JSFunctionSpec {
29636 name: JSPropertySpec_Name { string_: c"passNullableUnrestrictedDouble".as_ptr() },
29637 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29638 nargs: 1,
29639 flags: (JSPROP_ENUMERATE) as u16,
29640 selfHostedName: ptr::null()
29641 },
29642 JSFunctionSpec {
29643 name: JSPropertySpec_Name { string_: c"passNullableDouble".as_ptr() },
29644 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29645 nargs: 1,
29646 flags: (JSPROP_ENUMERATE) as u16,
29647 selfHostedName: ptr::null()
29648 },
29649 JSFunctionSpec {
29650 name: JSPropertySpec_Name { string_: c"passNullableString".as_ptr() },
29651 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableString_methodinfo.get() } as *const _ as *const JSJitInfo },
29652 nargs: 1,
29653 flags: (JSPROP_ENUMERATE) as u16,
29654 selfHostedName: ptr::null()
29655 },
29656 JSFunctionSpec {
29657 name: JSPropertySpec_Name { string_: c"passNullableUsvstring".as_ptr() },
29658 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
29659 nargs: 1,
29660 flags: (JSPROP_ENUMERATE) as u16,
29661 selfHostedName: ptr::null()
29662 },
29663 JSFunctionSpec {
29664 name: JSPropertySpec_Name { string_: c"passNullableByteString".as_ptr() },
29665 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
29666 nargs: 1,
29667 flags: (JSPROP_ENUMERATE) as u16,
29668 selfHostedName: ptr::null()
29669 },
29670 JSFunctionSpec {
29671 name: JSPropertySpec_Name { string_: c"passNullableInterface".as_ptr() },
29672 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29673 nargs: 1,
29674 flags: (JSPROP_ENUMERATE) as u16,
29675 selfHostedName: ptr::null()
29676 },
29677 JSFunctionSpec {
29678 name: JSPropertySpec_Name { string_: c"passNullableObject".as_ptr() },
29679 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableObject_methodinfo.get() } as *const _ as *const JSJitInfo },
29680 nargs: 1,
29681 flags: (JSPROP_ENUMERATE) as u16,
29682 selfHostedName: ptr::null()
29683 },
29684 JSFunctionSpec {
29685 name: JSPropertySpec_Name { string_: c"passNullableTypedArray".as_ptr() },
29686 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableTypedArray_methodinfo.get() } as *const _ as *const JSJitInfo },
29687 nargs: 1,
29688 flags: (JSPROP_ENUMERATE) as u16,
29689 selfHostedName: ptr::null()
29690 },
29691 JSFunctionSpec {
29692 name: JSPropertySpec_Name { string_: c"passNullableUnion".as_ptr() },
29693 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
29694 nargs: 1,
29695 flags: (JSPROP_ENUMERATE) as u16,
29696 selfHostedName: ptr::null()
29697 },
29698 JSFunctionSpec {
29699 name: JSPropertySpec_Name { string_: c"passNullableUnion2".as_ptr() },
29700 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
29701 nargs: 1,
29702 flags: (JSPROP_ENUMERATE) as u16,
29703 selfHostedName: ptr::null()
29704 },
29705 JSFunctionSpec {
29706 name: JSPropertySpec_Name { string_: c"passNullableUnion3".as_ptr() },
29707 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
29708 nargs: 1,
29709 flags: (JSPROP_ENUMERATE) as u16,
29710 selfHostedName: ptr::null()
29711 },
29712 JSFunctionSpec {
29713 name: JSPropertySpec_Name { string_: c"passNullableUnion4".as_ptr() },
29714 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
29715 nargs: 1,
29716 flags: (JSPROP_ENUMERATE) as u16,
29717 selfHostedName: ptr::null()
29718 },
29719 JSFunctionSpec {
29720 name: JSPropertySpec_Name { string_: c"passNullableUnion5".as_ptr() },
29721 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
29722 nargs: 1,
29723 flags: (JSPROP_ENUMERATE) as u16,
29724 selfHostedName: ptr::null()
29725 },
29726 JSFunctionSpec {
29727 name: JSPropertySpec_Name { string_: c"passNullableUnion6".as_ptr() },
29728 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
29729 nargs: 1,
29730 flags: (JSPROP_ENUMERATE) as u16,
29731 selfHostedName: ptr::null()
29732 },
29733 JSFunctionSpec {
29734 name: JSPropertySpec_Name { string_: c"passNullableCallbackFunction".as_ptr() },
29735 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableCallbackFunction_methodinfo.get() } as *const _ as *const JSJitInfo },
29736 nargs: 1,
29737 flags: (JSPROP_ENUMERATE) as u16,
29738 selfHostedName: ptr::null()
29739 },
29740 JSFunctionSpec {
29741 name: JSPropertySpec_Name { string_: c"passNullableCallbackInterface".as_ptr() },
29742 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableCallbackInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29743 nargs: 1,
29744 flags: (JSPROP_ENUMERATE) as u16,
29745 selfHostedName: ptr::null()
29746 },
29747 JSFunctionSpec {
29748 name: JSPropertySpec_Name { string_: c"passNullableSequence".as_ptr() },
29749 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29750 nargs: 1,
29751 flags: (JSPROP_ENUMERATE) as u16,
29752 selfHostedName: ptr::null()
29753 },
29754 JSFunctionSpec {
29755 name: JSPropertySpec_Name { string_: c"passOptionalBoolean".as_ptr() },
29756 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
29757 nargs: 0,
29758 flags: (JSPROP_ENUMERATE) as u16,
29759 selfHostedName: ptr::null()
29760 },
29761 JSFunctionSpec {
29762 name: JSPropertySpec_Name { string_: c"passOptionalByte".as_ptr() },
29763 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalByte_methodinfo.get() } as *const _ as *const JSJitInfo },
29764 nargs: 0,
29765 flags: (JSPROP_ENUMERATE) as u16,
29766 selfHostedName: ptr::null()
29767 },
29768 JSFunctionSpec {
29769 name: JSPropertySpec_Name { string_: c"passOptionalOctet".as_ptr() },
29770 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
29771 nargs: 0,
29772 flags: (JSPROP_ENUMERATE) as u16,
29773 selfHostedName: ptr::null()
29774 },
29775 JSFunctionSpec {
29776 name: JSPropertySpec_Name { string_: c"passOptionalShort".as_ptr() },
29777 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29778 nargs: 0,
29779 flags: (JSPROP_ENUMERATE) as u16,
29780 selfHostedName: ptr::null()
29781 },
29782 JSFunctionSpec {
29783 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedShort".as_ptr() },
29784 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29785 nargs: 0,
29786 flags: (JSPROP_ENUMERATE) as u16,
29787 selfHostedName: ptr::null()
29788 },
29789 JSFunctionSpec {
29790 name: JSPropertySpec_Name { string_: c"passOptionalLong".as_ptr() },
29791 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29792 nargs: 0,
29793 flags: (JSPROP_ENUMERATE) as u16,
29794 selfHostedName: ptr::null()
29795 },
29796 JSFunctionSpec {
29797 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedLong".as_ptr() },
29798 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29799 nargs: 0,
29800 flags: (JSPROP_ENUMERATE) as u16,
29801 selfHostedName: ptr::null()
29802 },
29803 JSFunctionSpec {
29804 name: JSPropertySpec_Name { string_: c"passOptionalLongLong".as_ptr() },
29805 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29806 nargs: 0,
29807 flags: (JSPROP_ENUMERATE) as u16,
29808 selfHostedName: ptr::null()
29809 },
29810 JSFunctionSpec {
29811 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedLongLong".as_ptr() },
29812 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29813 nargs: 0,
29814 flags: (JSPROP_ENUMERATE) as u16,
29815 selfHostedName: ptr::null()
29816 },
29817 JSFunctionSpec {
29818 name: JSPropertySpec_Name { string_: c"passOptionalUnrestrictedFloat".as_ptr() },
29819 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29820 nargs: 0,
29821 flags: (JSPROP_ENUMERATE) as u16,
29822 selfHostedName: ptr::null()
29823 },
29824 JSFunctionSpec {
29825 name: JSPropertySpec_Name { string_: c"passOptionalFloat".as_ptr() },
29826 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
29827 nargs: 0,
29828 flags: (JSPROP_ENUMERATE) as u16,
29829 selfHostedName: ptr::null()
29830 },
29831 JSFunctionSpec {
29832 name: JSPropertySpec_Name { string_: c"passOptionalUnrestrictedDouble".as_ptr() },
29833 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29834 nargs: 0,
29835 flags: (JSPROP_ENUMERATE) as u16,
29836 selfHostedName: ptr::null()
29837 },
29838 JSFunctionSpec {
29839 name: JSPropertySpec_Name { string_: c"passOptionalDouble".as_ptr() },
29840 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
29841 nargs: 0,
29842 flags: (JSPROP_ENUMERATE) as u16,
29843 selfHostedName: ptr::null()
29844 },
29845 JSFunctionSpec {
29846 name: JSPropertySpec_Name { string_: c"passOptionalString".as_ptr() },
29847 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalString_methodinfo.get() } as *const _ as *const JSJitInfo },
29848 nargs: 0,
29849 flags: (JSPROP_ENUMERATE) as u16,
29850 selfHostedName: ptr::null()
29851 },
29852 JSFunctionSpec {
29853 name: JSPropertySpec_Name { string_: c"passOptionalUsvstring".as_ptr() },
29854 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
29855 nargs: 0,
29856 flags: (JSPROP_ENUMERATE) as u16,
29857 selfHostedName: ptr::null()
29858 },
29859 JSFunctionSpec {
29860 name: JSPropertySpec_Name { string_: c"passOptionalByteString".as_ptr() },
29861 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
29862 nargs: 0,
29863 flags: (JSPROP_ENUMERATE) as u16,
29864 selfHostedName: ptr::null()
29865 },
29866 JSFunctionSpec {
29867 name: JSPropertySpec_Name { string_: c"passOptionalEnum".as_ptr() },
29868 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalEnum_methodinfo.get() } as *const _ as *const JSJitInfo },
29869 nargs: 0,
29870 flags: (JSPROP_ENUMERATE) as u16,
29871 selfHostedName: ptr::null()
29872 },
29873 JSFunctionSpec {
29874 name: JSPropertySpec_Name { string_: c"passOptionalInterface".as_ptr() },
29875 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29876 nargs: 0,
29877 flags: (JSPROP_ENUMERATE) as u16,
29878 selfHostedName: ptr::null()
29879 },
29880 JSFunctionSpec {
29881 name: JSPropertySpec_Name { string_: c"passOptionalUnion".as_ptr() },
29882 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
29883 nargs: 0,
29884 flags: (JSPROP_ENUMERATE) as u16,
29885 selfHostedName: ptr::null()
29886 },
29887 JSFunctionSpec {
29888 name: JSPropertySpec_Name { string_: c"passOptionalUnion2".as_ptr() },
29889 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
29890 nargs: 0,
29891 flags: (JSPROP_ENUMERATE) as u16,
29892 selfHostedName: ptr::null()
29893 },
29894 JSFunctionSpec {
29895 name: JSPropertySpec_Name { string_: c"passOptionalUnion3".as_ptr() },
29896 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
29897 nargs: 0,
29898 flags: (JSPROP_ENUMERATE) as u16,
29899 selfHostedName: ptr::null()
29900 },
29901 JSFunctionSpec {
29902 name: JSPropertySpec_Name { string_: c"passOptionalUnion4".as_ptr() },
29903 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
29904 nargs: 0,
29905 flags: (JSPROP_ENUMERATE) as u16,
29906 selfHostedName: ptr::null()
29907 },
29908 JSFunctionSpec {
29909 name: JSPropertySpec_Name { string_: c"passOptionalUnion5".as_ptr() },
29910 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
29911 nargs: 0,
29912 flags: (JSPROP_ENUMERATE) as u16,
29913 selfHostedName: ptr::null()
29914 },
29915 JSFunctionSpec {
29916 name: JSPropertySpec_Name { string_: c"passOptionalUnion6".as_ptr() },
29917 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
29918 nargs: 0,
29919 flags: (JSPROP_ENUMERATE) as u16,
29920 selfHostedName: ptr::null()
29921 },
29922 JSFunctionSpec {
29923 name: JSPropertySpec_Name { string_: c"passOptionalAny".as_ptr() },
29924 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalAny_methodinfo.get() } as *const _ as *const JSJitInfo },
29925 nargs: 0,
29926 flags: (JSPROP_ENUMERATE) as u16,
29927 selfHostedName: ptr::null()
29928 },
29929 JSFunctionSpec {
29930 name: JSPropertySpec_Name { string_: c"passOptionalObject".as_ptr() },
29931 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalObject_methodinfo.get() } as *const _ as *const JSJitInfo },
29932 nargs: 0,
29933 flags: (JSPROP_ENUMERATE) as u16,
29934 selfHostedName: ptr::null()
29935 },
29936 JSFunctionSpec {
29937 name: JSPropertySpec_Name { string_: c"passOptionalCallbackFunction".as_ptr() },
29938 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalCallbackFunction_methodinfo.get() } as *const _ as *const JSJitInfo },
29939 nargs: 0,
29940 flags: (JSPROP_ENUMERATE) as u16,
29941 selfHostedName: ptr::null()
29942 },
29943 JSFunctionSpec {
29944 name: JSPropertySpec_Name { string_: c"passOptionalCallbackInterface".as_ptr() },
29945 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalCallbackInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
29946 nargs: 0,
29947 flags: (JSPROP_ENUMERATE) as u16,
29948 selfHostedName: ptr::null()
29949 },
29950 JSFunctionSpec {
29951 name: JSPropertySpec_Name { string_: c"passOptionalSequence".as_ptr() },
29952 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
29953 nargs: 0,
29954 flags: (JSPROP_ENUMERATE) as u16,
29955 selfHostedName: ptr::null()
29956 },
29957 JSFunctionSpec {
29958 name: JSPropertySpec_Name { string_: c"passOptionalNullableBoolean".as_ptr() },
29959 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
29960 nargs: 0,
29961 flags: (JSPROP_ENUMERATE) as u16,
29962 selfHostedName: ptr::null()
29963 },
29964 JSFunctionSpec {
29965 name: JSPropertySpec_Name { string_: c"passOptionalNullableByte".as_ptr() },
29966 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableByte_methodinfo.get() } as *const _ as *const JSJitInfo },
29967 nargs: 0,
29968 flags: (JSPROP_ENUMERATE) as u16,
29969 selfHostedName: ptr::null()
29970 },
29971 JSFunctionSpec {
29972 name: JSPropertySpec_Name { string_: c"passOptionalNullableOctet".as_ptr() },
29973 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
29974 nargs: 0,
29975 flags: (JSPROP_ENUMERATE) as u16,
29976 selfHostedName: ptr::null()
29977 },
29978 JSFunctionSpec {
29979 name: JSPropertySpec_Name { string_: c"passOptionalNullableShort".as_ptr() },
29980 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29981 nargs: 0,
29982 flags: (JSPROP_ENUMERATE) as u16,
29983 selfHostedName: ptr::null()
29984 },
29985 JSFunctionSpec {
29986 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedShort".as_ptr() },
29987 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
29988 nargs: 0,
29989 flags: (JSPROP_ENUMERATE) as u16,
29990 selfHostedName: ptr::null()
29991 },
29992 JSFunctionSpec {
29993 name: JSPropertySpec_Name { string_: c"passOptionalNullableLong".as_ptr() },
29994 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLong_methodinfo.get() } as *const _ as *const JSJitInfo },
29995 nargs: 0,
29996 flags: (JSPROP_ENUMERATE) as u16,
29997 selfHostedName: ptr::null()
29998 },
29999 JSFunctionSpec {
30000 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLong".as_ptr() },
30001 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30002 nargs: 0,
30003 flags: (JSPROP_ENUMERATE) as u16,
30004 selfHostedName: ptr::null()
30005 },
30006 JSFunctionSpec {
30007 name: JSPropertySpec_Name { string_: c"passOptionalNullableLongLong".as_ptr() },
30008 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30009 nargs: 0,
30010 flags: (JSPROP_ENUMERATE) as u16,
30011 selfHostedName: ptr::null()
30012 },
30013 JSFunctionSpec {
30014 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLongLong".as_ptr() },
30015 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30016 nargs: 0,
30017 flags: (JSPROP_ENUMERATE) as u16,
30018 selfHostedName: ptr::null()
30019 },
30020 JSFunctionSpec {
30021 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnrestrictedFloat".as_ptr() },
30022 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
30023 nargs: 0,
30024 flags: (JSPROP_ENUMERATE) as u16,
30025 selfHostedName: ptr::null()
30026 },
30027 JSFunctionSpec {
30028 name: JSPropertySpec_Name { string_: c"passOptionalNullableFloat".as_ptr() },
30029 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
30030 nargs: 0,
30031 flags: (JSPROP_ENUMERATE) as u16,
30032 selfHostedName: ptr::null()
30033 },
30034 JSFunctionSpec {
30035 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnrestrictedDouble".as_ptr() },
30036 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
30037 nargs: 0,
30038 flags: (JSPROP_ENUMERATE) as u16,
30039 selfHostedName: ptr::null()
30040 },
30041 JSFunctionSpec {
30042 name: JSPropertySpec_Name { string_: c"passOptionalNullableDouble".as_ptr() },
30043 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
30044 nargs: 0,
30045 flags: (JSPROP_ENUMERATE) as u16,
30046 selfHostedName: ptr::null()
30047 },
30048 JSFunctionSpec {
30049 name: JSPropertySpec_Name { string_: c"passOptionalNullableString".as_ptr() },
30050 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableString_methodinfo.get() } as *const _ as *const JSJitInfo },
30051 nargs: 0,
30052 flags: (JSPROP_ENUMERATE) as u16,
30053 selfHostedName: ptr::null()
30054 },
30055 JSFunctionSpec {
30056 name: JSPropertySpec_Name { string_: c"passOptionalNullableUsvstring".as_ptr() },
30057 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
30058 nargs: 0,
30059 flags: (JSPROP_ENUMERATE) as u16,
30060 selfHostedName: ptr::null()
30061 },
30062 JSFunctionSpec {
30063 name: JSPropertySpec_Name { string_: c"passOptionalNullableByteString".as_ptr() },
30064 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
30065 nargs: 0,
30066 flags: (JSPROP_ENUMERATE) as u16,
30067 selfHostedName: ptr::null()
30068 },
30069 JSFunctionSpec {
30070 name: JSPropertySpec_Name { string_: c"passOptionalNullableInterface".as_ptr() },
30071 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
30072 nargs: 0,
30073 flags: (JSPROP_ENUMERATE) as u16,
30074 selfHostedName: ptr::null()
30075 },
30076 JSFunctionSpec {
30077 name: JSPropertySpec_Name { string_: c"passOptionalNullableObject".as_ptr() },
30078 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableObject_methodinfo.get() } as *const _ as *const JSJitInfo },
30079 nargs: 0,
30080 flags: (JSPROP_ENUMERATE) as u16,
30081 selfHostedName: ptr::null()
30082 },
30083 JSFunctionSpec {
30084 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion".as_ptr() },
30085 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
30086 nargs: 0,
30087 flags: (JSPROP_ENUMERATE) as u16,
30088 selfHostedName: ptr::null()
30089 },
30090 JSFunctionSpec {
30091 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion2".as_ptr() },
30092 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
30093 nargs: 0,
30094 flags: (JSPROP_ENUMERATE) as u16,
30095 selfHostedName: ptr::null()
30096 },
30097 JSFunctionSpec {
30098 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion3".as_ptr() },
30099 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
30100 nargs: 0,
30101 flags: (JSPROP_ENUMERATE) as u16,
30102 selfHostedName: ptr::null()
30103 },
30104 JSFunctionSpec {
30105 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion4".as_ptr() },
30106 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
30107 nargs: 0,
30108 flags: (JSPROP_ENUMERATE) as u16,
30109 selfHostedName: ptr::null()
30110 },
30111 JSFunctionSpec {
30112 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion5".as_ptr() },
30113 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
30114 nargs: 0,
30115 flags: (JSPROP_ENUMERATE) as u16,
30116 selfHostedName: ptr::null()
30117 },
30118 JSFunctionSpec {
30119 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion6".as_ptr() },
30120 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
30121 nargs: 0,
30122 flags: (JSPROP_ENUMERATE) as u16,
30123 selfHostedName: ptr::null()
30124 },
30125 JSFunctionSpec {
30126 name: JSPropertySpec_Name { string_: c"passOptionalNullableCallbackFunction".as_ptr() },
30127 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableCallbackFunction_methodinfo.get() } as *const _ as *const JSJitInfo },
30128 nargs: 0,
30129 flags: (JSPROP_ENUMERATE) as u16,
30130 selfHostedName: ptr::null()
30131 },
30132 JSFunctionSpec {
30133 name: JSPropertySpec_Name { string_: c"passOptionalNullableCallbackInterface".as_ptr() },
30134 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableCallbackInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
30135 nargs: 0,
30136 flags: (JSPROP_ENUMERATE) as u16,
30137 selfHostedName: ptr::null()
30138 },
30139 JSFunctionSpec {
30140 name: JSPropertySpec_Name { string_: c"passOptionalNullableSequence".as_ptr() },
30141 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
30142 nargs: 0,
30143 flags: (JSPROP_ENUMERATE) as u16,
30144 selfHostedName: ptr::null()
30145 },
30146 JSFunctionSpec {
30147 name: JSPropertySpec_Name { string_: c"passOptionalBooleanWithDefault".as_ptr() },
30148 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalBooleanWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30149 nargs: 0,
30150 flags: (JSPROP_ENUMERATE) as u16,
30151 selfHostedName: ptr::null()
30152 },
30153 JSFunctionSpec {
30154 name: JSPropertySpec_Name { string_: c"passOptionalByteWithDefault".as_ptr() },
30155 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalByteWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30156 nargs: 0,
30157 flags: (JSPROP_ENUMERATE) as u16,
30158 selfHostedName: ptr::null()
30159 },
30160 JSFunctionSpec {
30161 name: JSPropertySpec_Name { string_: c"passOptionalOctetWithDefault".as_ptr() },
30162 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalOctetWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30163 nargs: 0,
30164 flags: (JSPROP_ENUMERATE) as u16,
30165 selfHostedName: ptr::null()
30166 },
30167 JSFunctionSpec {
30168 name: JSPropertySpec_Name { string_: c"passOptionalShortWithDefault".as_ptr() },
30169 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalShortWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30170 nargs: 0,
30171 flags: (JSPROP_ENUMERATE) as u16,
30172 selfHostedName: ptr::null()
30173 },
30174 JSFunctionSpec {
30175 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedShortWithDefault".as_ptr() },
30176 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedShortWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30177 nargs: 0,
30178 flags: (JSPROP_ENUMERATE) as u16,
30179 selfHostedName: ptr::null()
30180 },
30181 JSFunctionSpec {
30182 name: JSPropertySpec_Name { string_: c"passOptionalLongWithDefault".as_ptr() },
30183 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30184 nargs: 0,
30185 flags: (JSPROP_ENUMERATE) as u16,
30186 selfHostedName: ptr::null()
30187 },
30188 JSFunctionSpec {
30189 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedLongWithDefault".as_ptr() },
30190 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30191 nargs: 0,
30192 flags: (JSPROP_ENUMERATE) as u16,
30193 selfHostedName: ptr::null()
30194 },
30195 JSFunctionSpec {
30196 name: JSPropertySpec_Name { string_: c"passOptionalLongLongWithDefault".as_ptr() },
30197 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalLongLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30198 nargs: 0,
30199 flags: (JSPROP_ENUMERATE) as u16,
30200 selfHostedName: ptr::null()
30201 },
30202 JSFunctionSpec {
30203 name: JSPropertySpec_Name { string_: c"passOptionalUnsignedLongLongWithDefault".as_ptr() },
30204 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUnsignedLongLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30205 nargs: 0,
30206 flags: (JSPROP_ENUMERATE) as u16,
30207 selfHostedName: ptr::null()
30208 },
30209 JSFunctionSpec {
30210 name: JSPropertySpec_Name { string_: c"passOptionalBytestringWithDefault".as_ptr() },
30211 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalBytestringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30212 nargs: 0,
30213 flags: (JSPROP_ENUMERATE) as u16,
30214 selfHostedName: ptr::null()
30215 },
30216 JSFunctionSpec {
30217 name: JSPropertySpec_Name { string_: c"passOptionalStringWithDefault".as_ptr() },
30218 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalStringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30219 nargs: 0,
30220 flags: (JSPROP_ENUMERATE) as u16,
30221 selfHostedName: ptr::null()
30222 },
30223 JSFunctionSpec {
30224 name: JSPropertySpec_Name { string_: c"passOptionalUsvstringWithDefault".as_ptr() },
30225 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalUsvstringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30226 nargs: 0,
30227 flags: (JSPROP_ENUMERATE) as u16,
30228 selfHostedName: ptr::null()
30229 },
30230 JSFunctionSpec {
30231 name: JSPropertySpec_Name { string_: c"passOptionalEnumWithDefault".as_ptr() },
30232 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalEnumWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30233 nargs: 0,
30234 flags: (JSPROP_ENUMERATE) as u16,
30235 selfHostedName: ptr::null()
30236 },
30237 JSFunctionSpec {
30238 name: JSPropertySpec_Name { string_: c"passOptionalSequenceWithDefault".as_ptr() },
30239 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalSequenceWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30240 nargs: 0,
30241 flags: (JSPROP_ENUMERATE) as u16,
30242 selfHostedName: ptr::null()
30243 },
30244 JSFunctionSpec {
30245 name: JSPropertySpec_Name { string_: c"passOptionalNullableBooleanWithDefault".as_ptr() },
30246 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableBooleanWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30247 nargs: 0,
30248 flags: (JSPROP_ENUMERATE) as u16,
30249 selfHostedName: ptr::null()
30250 },
30251 JSFunctionSpec {
30252 name: JSPropertySpec_Name { string_: c"passOptionalNullableByteWithDefault".as_ptr() },
30253 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableByteWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30254 nargs: 0,
30255 flags: (JSPROP_ENUMERATE) as u16,
30256 selfHostedName: ptr::null()
30257 },
30258 JSFunctionSpec {
30259 name: JSPropertySpec_Name { string_: c"passOptionalNullableOctetWithDefault".as_ptr() },
30260 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableOctetWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30261 nargs: 0,
30262 flags: (JSPROP_ENUMERATE) as u16,
30263 selfHostedName: ptr::null()
30264 },
30265 JSFunctionSpec {
30266 name: JSPropertySpec_Name { string_: c"passOptionalNullableShortWithDefault".as_ptr() },
30267 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableShortWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30268 nargs: 0,
30269 flags: (JSPROP_ENUMERATE) as u16,
30270 selfHostedName: ptr::null()
30271 },
30272 JSFunctionSpec {
30273 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedShortWithDefault".as_ptr() },
30274 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedShortWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30275 nargs: 0,
30276 flags: (JSPROP_ENUMERATE) as u16,
30277 selfHostedName: ptr::null()
30278 },
30279 JSFunctionSpec {
30280 name: JSPropertySpec_Name { string_: c"passOptionalNullableLongWithDefault".as_ptr() },
30281 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30282 nargs: 0,
30283 flags: (JSPROP_ENUMERATE) as u16,
30284 selfHostedName: ptr::null()
30285 },
30286 JSFunctionSpec {
30287 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLongWithDefault".as_ptr() },
30288 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30289 nargs: 0,
30290 flags: (JSPROP_ENUMERATE) as u16,
30291 selfHostedName: ptr::null()
30292 },
30293 JSFunctionSpec {
30294 name: JSPropertySpec_Name { string_: c"passOptionalNullableLongLongWithDefault".as_ptr() },
30295 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLongLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30296 nargs: 0,
30297 flags: (JSPROP_ENUMERATE) as u16,
30298 selfHostedName: ptr::null()
30299 },
30300 JSFunctionSpec {
30301 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLongLongWithDefault".as_ptr() },
30302 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLongLongWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30303 nargs: 0,
30304 flags: (JSPROP_ENUMERATE) as u16,
30305 selfHostedName: ptr::null()
30306 },
30307 JSFunctionSpec {
30308 name: JSPropertySpec_Name { string_: c"passOptionalNullableStringWithDefault".as_ptr() },
30309 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableStringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30310 nargs: 0,
30311 flags: (JSPROP_ENUMERATE) as u16,
30312 selfHostedName: ptr::null()
30313 },
30314 JSFunctionSpec {
30315 name: JSPropertySpec_Name { string_: c"passOptionalNullableUsvstringWithDefault".as_ptr() },
30316 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUsvstringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30317 nargs: 0,
30318 flags: (JSPROP_ENUMERATE) as u16,
30319 selfHostedName: ptr::null()
30320 },
30321 JSFunctionSpec {
30322 name: JSPropertySpec_Name { string_: c"passOptionalNullableByteStringWithDefault".as_ptr() },
30323 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableByteStringWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30324 nargs: 0,
30325 flags: (JSPROP_ENUMERATE) as u16,
30326 selfHostedName: ptr::null()
30327 },
30328 JSFunctionSpec {
30329 name: JSPropertySpec_Name { string_: c"passOptionalNullableInterfaceWithDefault".as_ptr() },
30330 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableInterfaceWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30331 nargs: 0,
30332 flags: (JSPROP_ENUMERATE) as u16,
30333 selfHostedName: ptr::null()
30334 },
30335 JSFunctionSpec {
30336 name: JSPropertySpec_Name { string_: c"passOptionalNullableObjectWithDefault".as_ptr() },
30337 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableObjectWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30338 nargs: 0,
30339 flags: (JSPROP_ENUMERATE) as u16,
30340 selfHostedName: ptr::null()
30341 },
30342 JSFunctionSpec {
30343 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnionWithDefault".as_ptr() },
30344 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnionWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30345 nargs: 0,
30346 flags: (JSPROP_ENUMERATE) as u16,
30347 selfHostedName: ptr::null()
30348 },
30349 JSFunctionSpec {
30350 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnion2WithDefault".as_ptr() },
30351 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnion2WithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30352 nargs: 0,
30353 flags: (JSPROP_ENUMERATE) as u16,
30354 selfHostedName: ptr::null()
30355 },
30356 JSFunctionSpec {
30357 name: JSPropertySpec_Name { string_: c"passOptionalNullableCallbackInterfaceWithDefault".as_ptr() },
30358 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableCallbackInterfaceWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30359 nargs: 0,
30360 flags: (JSPROP_ENUMERATE) as u16,
30361 selfHostedName: ptr::null()
30362 },
30363 JSFunctionSpec {
30364 name: JSPropertySpec_Name { string_: c"passOptionalAnyWithDefault".as_ptr() },
30365 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalAnyWithDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30366 nargs: 0,
30367 flags: (JSPROP_ENUMERATE) as u16,
30368 selfHostedName: ptr::null()
30369 },
30370 JSFunctionSpec {
30371 name: JSPropertySpec_Name { string_: c"passOptionalNullableBooleanWithNonNullDefault".as_ptr() },
30372 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableBooleanWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30373 nargs: 0,
30374 flags: (JSPROP_ENUMERATE) as u16,
30375 selfHostedName: ptr::null()
30376 },
30377 JSFunctionSpec {
30378 name: JSPropertySpec_Name { string_: c"passOptionalNullableByteWithNonNullDefault".as_ptr() },
30379 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableByteWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30380 nargs: 0,
30381 flags: (JSPROP_ENUMERATE) as u16,
30382 selfHostedName: ptr::null()
30383 },
30384 JSFunctionSpec {
30385 name: JSPropertySpec_Name { string_: c"passOptionalNullableOctetWithNonNullDefault".as_ptr() },
30386 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableOctetWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30387 nargs: 0,
30388 flags: (JSPROP_ENUMERATE) as u16,
30389 selfHostedName: ptr::null()
30390 },
30391 JSFunctionSpec {
30392 name: JSPropertySpec_Name { string_: c"passOptionalNullableShortWithNonNullDefault".as_ptr() },
30393 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableShortWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30394 nargs: 0,
30395 flags: (JSPROP_ENUMERATE) as u16,
30396 selfHostedName: ptr::null()
30397 },
30398 JSFunctionSpec {
30399 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedShortWithNonNullDefault".as_ptr() },
30400 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30401 nargs: 0,
30402 flags: (JSPROP_ENUMERATE) as u16,
30403 selfHostedName: ptr::null()
30404 },
30405 JSFunctionSpec {
30406 name: JSPropertySpec_Name { string_: c"passOptionalNullableLongWithNonNullDefault".as_ptr() },
30407 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLongWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30408 nargs: 0,
30409 flags: (JSPROP_ENUMERATE) as u16,
30410 selfHostedName: ptr::null()
30411 },
30412 JSFunctionSpec {
30413 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLongWithNonNullDefault".as_ptr() },
30414 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30415 nargs: 0,
30416 flags: (JSPROP_ENUMERATE) as u16,
30417 selfHostedName: ptr::null()
30418 },
30419 JSFunctionSpec {
30420 name: JSPropertySpec_Name { string_: c"passOptionalNullableLongLongWithNonNullDefault".as_ptr() },
30421 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableLongLongWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30422 nargs: 0,
30423 flags: (JSPROP_ENUMERATE) as u16,
30424 selfHostedName: ptr::null()
30425 },
30426 JSFunctionSpec {
30427 name: JSPropertySpec_Name { string_: c"passOptionalNullableUnsignedLongLongWithNonNullDefault".as_ptr() },
30428 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30429 nargs: 0,
30430 flags: (JSPROP_ENUMERATE) as u16,
30431 selfHostedName: ptr::null()
30432 },
30433 JSFunctionSpec {
30434 name: JSPropertySpec_Name { string_: c"passOptionalNullableStringWithNonNullDefault".as_ptr() },
30435 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableStringWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30436 nargs: 0,
30437 flags: (JSPROP_ENUMERATE) as u16,
30438 selfHostedName: ptr::null()
30439 },
30440 JSFunctionSpec {
30441 name: JSPropertySpec_Name { string_: c"passOptionalNullableUsvstringWithNonNullDefault".as_ptr() },
30442 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableUsvstringWithNonNullDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30443 nargs: 0,
30444 flags: (JSPROP_ENUMERATE) as u16,
30445 selfHostedName: ptr::null()
30446 },
30447 JSFunctionSpec {
30448 name: JSPropertySpec_Name { string_: c"passOptionalOverloaded".as_ptr() },
30449 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalOverloaded_methodinfo.get() } as *const _ as *const JSJitInfo },
30450 nargs: 1,
30451 flags: (JSPROP_ENUMERATE) as u16,
30452 selfHostedName: ptr::null()
30453 },
30454 JSFunctionSpec {
30455 name: JSPropertySpec_Name { string_: c"passVariadicBoolean".as_ptr() },
30456 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicBoolean_methodinfo.get() } as *const _ as *const JSJitInfo },
30457 nargs: 0,
30458 flags: (JSPROP_ENUMERATE) as u16,
30459 selfHostedName: ptr::null()
30460 },
30461 JSFunctionSpec {
30462 name: JSPropertySpec_Name { string_: c"passVariadicBooleanAndDefault".as_ptr() },
30463 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicBooleanAndDefault_methodinfo.get() } as *const _ as *const JSJitInfo },
30464 nargs: 0,
30465 flags: (JSPROP_ENUMERATE) as u16,
30466 selfHostedName: ptr::null()
30467 },
30468 JSFunctionSpec {
30469 name: JSPropertySpec_Name { string_: c"passVariadicByte".as_ptr() },
30470 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicByte_methodinfo.get() } as *const _ as *const JSJitInfo },
30471 nargs: 0,
30472 flags: (JSPROP_ENUMERATE) as u16,
30473 selfHostedName: ptr::null()
30474 },
30475 JSFunctionSpec {
30476 name: JSPropertySpec_Name { string_: c"passVariadicOctet".as_ptr() },
30477 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicOctet_methodinfo.get() } as *const _ as *const JSJitInfo },
30478 nargs: 0,
30479 flags: (JSPROP_ENUMERATE) as u16,
30480 selfHostedName: ptr::null()
30481 },
30482 JSFunctionSpec {
30483 name: JSPropertySpec_Name { string_: c"passVariadicShort".as_ptr() },
30484 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicShort_methodinfo.get() } as *const _ as *const JSJitInfo },
30485 nargs: 0,
30486 flags: (JSPROP_ENUMERATE) as u16,
30487 selfHostedName: ptr::null()
30488 },
30489 JSFunctionSpec {
30490 name: JSPropertySpec_Name { string_: c"passVariadicUnsignedShort".as_ptr() },
30491 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnsignedShort_methodinfo.get() } as *const _ as *const JSJitInfo },
30492 nargs: 0,
30493 flags: (JSPROP_ENUMERATE) as u16,
30494 selfHostedName: ptr::null()
30495 },
30496 JSFunctionSpec {
30497 name: JSPropertySpec_Name { string_: c"passVariadicLong".as_ptr() },
30498 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30499 nargs: 0,
30500 flags: (JSPROP_ENUMERATE) as u16,
30501 selfHostedName: ptr::null()
30502 },
30503 JSFunctionSpec {
30504 name: JSPropertySpec_Name { string_: c"passVariadicUnsignedLong".as_ptr() },
30505 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnsignedLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30506 nargs: 0,
30507 flags: (JSPROP_ENUMERATE) as u16,
30508 selfHostedName: ptr::null()
30509 },
30510 JSFunctionSpec {
30511 name: JSPropertySpec_Name { string_: c"passVariadicLongLong".as_ptr() },
30512 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30513 nargs: 0,
30514 flags: (JSPROP_ENUMERATE) as u16,
30515 selfHostedName: ptr::null()
30516 },
30517 JSFunctionSpec {
30518 name: JSPropertySpec_Name { string_: c"passVariadicUnsignedLongLong".as_ptr() },
30519 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnsignedLongLong_methodinfo.get() } as *const _ as *const JSJitInfo },
30520 nargs: 0,
30521 flags: (JSPROP_ENUMERATE) as u16,
30522 selfHostedName: ptr::null()
30523 },
30524 JSFunctionSpec {
30525 name: JSPropertySpec_Name { string_: c"passVariadicUnrestrictedFloat".as_ptr() },
30526 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnrestrictedFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
30527 nargs: 0,
30528 flags: (JSPROP_ENUMERATE) as u16,
30529 selfHostedName: ptr::null()
30530 },
30531 JSFunctionSpec {
30532 name: JSPropertySpec_Name { string_: c"passVariadicFloat".as_ptr() },
30533 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicFloat_methodinfo.get() } as *const _ as *const JSJitInfo },
30534 nargs: 0,
30535 flags: (JSPROP_ENUMERATE) as u16,
30536 selfHostedName: ptr::null()
30537 },
30538 JSFunctionSpec {
30539 name: JSPropertySpec_Name { string_: c"passVariadicUnrestrictedDouble".as_ptr() },
30540 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnrestrictedDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
30541 nargs: 0,
30542 flags: (JSPROP_ENUMERATE) as u16,
30543 selfHostedName: ptr::null()
30544 },
30545 JSFunctionSpec {
30546 name: JSPropertySpec_Name { string_: c"passVariadicDouble".as_ptr() },
30547 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicDouble_methodinfo.get() } as *const _ as *const JSJitInfo },
30548 nargs: 0,
30549 flags: (JSPROP_ENUMERATE) as u16,
30550 selfHostedName: ptr::null()
30551 },
30552 JSFunctionSpec {
30553 name: JSPropertySpec_Name { string_: c"passVariadicString".as_ptr() },
30554 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicString_methodinfo.get() } as *const _ as *const JSJitInfo },
30555 nargs: 0,
30556 flags: (JSPROP_ENUMERATE) as u16,
30557 selfHostedName: ptr::null()
30558 },
30559 JSFunctionSpec {
30560 name: JSPropertySpec_Name { string_: c"passVariadicUsvstring".as_ptr() },
30561 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUsvstring_methodinfo.get() } as *const _ as *const JSJitInfo },
30562 nargs: 0,
30563 flags: (JSPROP_ENUMERATE) as u16,
30564 selfHostedName: ptr::null()
30565 },
30566 JSFunctionSpec {
30567 name: JSPropertySpec_Name { string_: c"passVariadicByteString".as_ptr() },
30568 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicByteString_methodinfo.get() } as *const _ as *const JSJitInfo },
30569 nargs: 0,
30570 flags: (JSPROP_ENUMERATE) as u16,
30571 selfHostedName: ptr::null()
30572 },
30573 JSFunctionSpec {
30574 name: JSPropertySpec_Name { string_: c"passVariadicEnum".as_ptr() },
30575 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicEnum_methodinfo.get() } as *const _ as *const JSJitInfo },
30576 nargs: 0,
30577 flags: (JSPROP_ENUMERATE) as u16,
30578 selfHostedName: ptr::null()
30579 },
30580 JSFunctionSpec {
30581 name: JSPropertySpec_Name { string_: c"passVariadicInterface".as_ptr() },
30582 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicInterface_methodinfo.get() } as *const _ as *const JSJitInfo },
30583 nargs: 0,
30584 flags: (JSPROP_ENUMERATE) as u16,
30585 selfHostedName: ptr::null()
30586 },
30587 JSFunctionSpec {
30588 name: JSPropertySpec_Name { string_: c"passVariadicUnion".as_ptr() },
30589 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
30590 nargs: 0,
30591 flags: (JSPROP_ENUMERATE) as u16,
30592 selfHostedName: ptr::null()
30593 },
30594 JSFunctionSpec {
30595 name: JSPropertySpec_Name { string_: c"passVariadicUnion2".as_ptr() },
30596 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
30597 nargs: 0,
30598 flags: (JSPROP_ENUMERATE) as u16,
30599 selfHostedName: ptr::null()
30600 },
30601 JSFunctionSpec {
30602 name: JSPropertySpec_Name { string_: c"passVariadicUnion3".as_ptr() },
30603 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
30604 nargs: 0,
30605 flags: (JSPROP_ENUMERATE) as u16,
30606 selfHostedName: ptr::null()
30607 },
30608 JSFunctionSpec {
30609 name: JSPropertySpec_Name { string_: c"passVariadicUnion4".as_ptr() },
30610 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion4_methodinfo.get() } as *const _ as *const JSJitInfo },
30611 nargs: 0,
30612 flags: (JSPROP_ENUMERATE) as u16,
30613 selfHostedName: ptr::null()
30614 },
30615 JSFunctionSpec {
30616 name: JSPropertySpec_Name { string_: c"passVariadicUnion5".as_ptr() },
30617 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion5_methodinfo.get() } as *const _ as *const JSJitInfo },
30618 nargs: 0,
30619 flags: (JSPROP_ENUMERATE) as u16,
30620 selfHostedName: ptr::null()
30621 },
30622 JSFunctionSpec {
30623 name: JSPropertySpec_Name { string_: c"passVariadicUnion6".as_ptr() },
30624 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion6_methodinfo.get() } as *const _ as *const JSJitInfo },
30625 nargs: 0,
30626 flags: (JSPROP_ENUMERATE) as u16,
30627 selfHostedName: ptr::null()
30628 },
30629 JSFunctionSpec {
30630 name: JSPropertySpec_Name { string_: c"passVariadicUnion7".as_ptr() },
30631 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicUnion7_methodinfo.get() } as *const _ as *const JSJitInfo },
30632 nargs: 0,
30633 flags: (JSPROP_ENUMERATE) as u16,
30634 selfHostedName: ptr::null()
30635 },
30636 JSFunctionSpec {
30637 name: JSPropertySpec_Name { string_: c"passVariadicAny".as_ptr() },
30638 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicAny_methodinfo.get() } as *const _ as *const JSJitInfo },
30639 nargs: 0,
30640 flags: (JSPROP_ENUMERATE) as u16,
30641 selfHostedName: ptr::null()
30642 },
30643 JSFunctionSpec {
30644 name: JSPropertySpec_Name { string_: c"passVariadicObject".as_ptr() },
30645 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passVariadicObject_methodinfo.get() } as *const _ as *const JSJitInfo },
30646 nargs: 0,
30647 flags: (JSPROP_ENUMERATE) as u16,
30648 selfHostedName: ptr::null()
30649 },
30650 JSFunctionSpec {
30651 name: JSPropertySpec_Name { string_: c"passSequenceSequence".as_ptr() },
30652 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passSequenceSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
30653 nargs: 1,
30654 flags: (JSPROP_ENUMERATE) as u16,
30655 selfHostedName: ptr::null()
30656 },
30657 JSFunctionSpec {
30658 name: JSPropertySpec_Name { string_: c"returnSequenceSequence".as_ptr() },
30659 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { returnSequenceSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
30660 nargs: 0,
30661 flags: (JSPROP_ENUMERATE) as u16,
30662 selfHostedName: ptr::null()
30663 },
30664 JSFunctionSpec {
30665 name: JSPropertySpec_Name { string_: c"passUnionSequenceSequence".as_ptr() },
30666 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passUnionSequenceSequence_methodinfo.get() } as *const _ as *const JSJitInfo },
30667 nargs: 1,
30668 flags: (JSPROP_ENUMERATE) as u16,
30669 selfHostedName: ptr::null()
30670 },
30671 JSFunctionSpec {
30672 name: JSPropertySpec_Name { string_: c"passRecordPromise".as_ptr() },
30673 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
30674 nargs: 1,
30675 flags: (JSPROP_ENUMERATE) as u16,
30676 selfHostedName: ptr::null()
30677 },
30678 JSFunctionSpec {
30679 name: JSPropertySpec_Name { string_: c"passRecord".as_ptr() },
30680 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30681 nargs: 1,
30682 flags: (JSPROP_ENUMERATE) as u16,
30683 selfHostedName: ptr::null()
30684 },
30685 JSFunctionSpec {
30686 name: JSPropertySpec_Name { string_: c"passRecordWithUSVStringKey".as_ptr() },
30687 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordWithUSVStringKey_methodinfo.get() } as *const _ as *const JSJitInfo },
30688 nargs: 1,
30689 flags: (JSPROP_ENUMERATE) as u16,
30690 selfHostedName: ptr::null()
30691 },
30692 JSFunctionSpec {
30693 name: JSPropertySpec_Name { string_: c"passRecordWithByteStringKey".as_ptr() },
30694 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordWithByteStringKey_methodinfo.get() } as *const _ as *const JSJitInfo },
30695 nargs: 1,
30696 flags: (JSPROP_ENUMERATE) as u16,
30697 selfHostedName: ptr::null()
30698 },
30699 JSFunctionSpec {
30700 name: JSPropertySpec_Name { string_: c"passNullableRecord".as_ptr() },
30701 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30702 nargs: 1,
30703 flags: (JSPROP_ENUMERATE) as u16,
30704 selfHostedName: ptr::null()
30705 },
30706 JSFunctionSpec {
30707 name: JSPropertySpec_Name { string_: c"passRecordOfNullableInts".as_ptr() },
30708 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordOfNullableInts_methodinfo.get() } as *const _ as *const JSJitInfo },
30709 nargs: 1,
30710 flags: (JSPROP_ENUMERATE) as u16,
30711 selfHostedName: ptr::null()
30712 },
30713 JSFunctionSpec {
30714 name: JSPropertySpec_Name { string_: c"passOptionalRecordOfNullableInts".as_ptr() },
30715 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalRecordOfNullableInts_methodinfo.get() } as *const _ as *const JSJitInfo },
30716 nargs: 0,
30717 flags: (JSPROP_ENUMERATE) as u16,
30718 selfHostedName: ptr::null()
30719 },
30720 JSFunctionSpec {
30721 name: JSPropertySpec_Name { string_: c"passOptionalNullableRecordOfNullableInts".as_ptr() },
30722 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableRecordOfNullableInts_methodinfo.get() } as *const _ as *const JSJitInfo },
30723 nargs: 0,
30724 flags: (JSPROP_ENUMERATE) as u16,
30725 selfHostedName: ptr::null()
30726 },
30727 JSFunctionSpec {
30728 name: JSPropertySpec_Name { string_: c"passCastableObjectRecord".as_ptr() },
30729 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passCastableObjectRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30730 nargs: 1,
30731 flags: (JSPROP_ENUMERATE) as u16,
30732 selfHostedName: ptr::null()
30733 },
30734 JSFunctionSpec {
30735 name: JSPropertySpec_Name { string_: c"passNullableCastableObjectRecord".as_ptr() },
30736 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableCastableObjectRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30737 nargs: 1,
30738 flags: (JSPROP_ENUMERATE) as u16,
30739 selfHostedName: ptr::null()
30740 },
30741 JSFunctionSpec {
30742 name: JSPropertySpec_Name { string_: c"passCastableObjectNullableRecord".as_ptr() },
30743 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passCastableObjectNullableRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30744 nargs: 1,
30745 flags: (JSPROP_ENUMERATE) as u16,
30746 selfHostedName: ptr::null()
30747 },
30748 JSFunctionSpec {
30749 name: JSPropertySpec_Name { string_: c"passNullableCastableObjectNullableRecord".as_ptr() },
30750 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passNullableCastableObjectNullableRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30751 nargs: 1,
30752 flags: (JSPROP_ENUMERATE) as u16,
30753 selfHostedName: ptr::null()
30754 },
30755 JSFunctionSpec {
30756 name: JSPropertySpec_Name { string_: c"passOptionalRecord".as_ptr() },
30757 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30758 nargs: 0,
30759 flags: (JSPROP_ENUMERATE) as u16,
30760 selfHostedName: ptr::null()
30761 },
30762 JSFunctionSpec {
30763 name: JSPropertySpec_Name { string_: c"passOptionalNullableRecord".as_ptr() },
30764 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30765 nargs: 0,
30766 flags: (JSPROP_ENUMERATE) as u16,
30767 selfHostedName: ptr::null()
30768 },
30769 JSFunctionSpec {
30770 name: JSPropertySpec_Name { string_: c"passOptionalNullableRecordWithDefaultValue".as_ptr() },
30771 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalNullableRecordWithDefaultValue_methodinfo.get() } as *const _ as *const JSJitInfo },
30772 nargs: 0,
30773 flags: (JSPROP_ENUMERATE) as u16,
30774 selfHostedName: ptr::null()
30775 },
30776 JSFunctionSpec {
30777 name: JSPropertySpec_Name { string_: c"passOptionalObjectRecord".as_ptr() },
30778 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passOptionalObjectRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30779 nargs: 0,
30780 flags: (JSPROP_ENUMERATE) as u16,
30781 selfHostedName: ptr::null()
30782 },
30783 JSFunctionSpec {
30784 name: JSPropertySpec_Name { string_: c"passStringRecord".as_ptr() },
30785 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passStringRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30786 nargs: 1,
30787 flags: (JSPROP_ENUMERATE) as u16,
30788 selfHostedName: ptr::null()
30789 },
30790 JSFunctionSpec {
30791 name: JSPropertySpec_Name { string_: c"passByteStringRecord".as_ptr() },
30792 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passByteStringRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30793 nargs: 1,
30794 flags: (JSPROP_ENUMERATE) as u16,
30795 selfHostedName: ptr::null()
30796 },
30797 JSFunctionSpec {
30798 name: JSPropertySpec_Name { string_: c"passRecordOfRecords".as_ptr() },
30799 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordOfRecords_methodinfo.get() } as *const _ as *const JSJitInfo },
30800 nargs: 1,
30801 flags: (JSPROP_ENUMERATE) as u16,
30802 selfHostedName: ptr::null()
30803 },
30804 JSFunctionSpec {
30805 name: JSPropertySpec_Name { string_: c"passRecordUnion".as_ptr() },
30806 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordUnion_methodinfo.get() } as *const _ as *const JSJitInfo },
30807 nargs: 1,
30808 flags: (JSPROP_ENUMERATE) as u16,
30809 selfHostedName: ptr::null()
30810 },
30811 JSFunctionSpec {
30812 name: JSPropertySpec_Name { string_: c"passRecordUnion2".as_ptr() },
30813 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordUnion2_methodinfo.get() } as *const _ as *const JSJitInfo },
30814 nargs: 1,
30815 flags: (JSPROP_ENUMERATE) as u16,
30816 selfHostedName: ptr::null()
30817 },
30818 JSFunctionSpec {
30819 name: JSPropertySpec_Name { string_: c"passRecordUnion3".as_ptr() },
30820 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { passRecordUnion3_methodinfo.get() } as *const _ as *const JSJitInfo },
30821 nargs: 1,
30822 flags: (JSPROP_ENUMERATE) as u16,
30823 selfHostedName: ptr::null()
30824 },
30825 JSFunctionSpec {
30826 name: JSPropertySpec_Name { string_: c"receiveRecord".as_ptr() },
30827 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30828 nargs: 0,
30829 flags: (JSPROP_ENUMERATE) as u16,
30830 selfHostedName: ptr::null()
30831 },
30832 JSFunctionSpec {
30833 name: JSPropertySpec_Name { string_: c"receiveRecordWithUSVStringKey".as_ptr() },
30834 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveRecordWithUSVStringKey_methodinfo.get() } as *const _ as *const JSJitInfo },
30835 nargs: 0,
30836 flags: (JSPROP_ENUMERATE) as u16,
30837 selfHostedName: ptr::null()
30838 },
30839 JSFunctionSpec {
30840 name: JSPropertySpec_Name { string_: c"receiveRecordWithByteStringKey".as_ptr() },
30841 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveRecordWithByteStringKey_methodinfo.get() } as *const _ as *const JSJitInfo },
30842 nargs: 0,
30843 flags: (JSPROP_ENUMERATE) as u16,
30844 selfHostedName: ptr::null()
30845 },
30846 JSFunctionSpec {
30847 name: JSPropertySpec_Name { string_: c"receiveNullableRecord".as_ptr() },
30848 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30849 nargs: 0,
30850 flags: (JSPROP_ENUMERATE) as u16,
30851 selfHostedName: ptr::null()
30852 },
30853 JSFunctionSpec {
30854 name: JSPropertySpec_Name { string_: c"receiveRecordOfNullableInts".as_ptr() },
30855 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveRecordOfNullableInts_methodinfo.get() } as *const _ as *const JSJitInfo },
30856 nargs: 0,
30857 flags: (JSPROP_ENUMERATE) as u16,
30858 selfHostedName: ptr::null()
30859 },
30860 JSFunctionSpec {
30861 name: JSPropertySpec_Name { string_: c"receiveNullableRecordOfNullableInts".as_ptr() },
30862 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveNullableRecordOfNullableInts_methodinfo.get() } as *const _ as *const JSJitInfo },
30863 nargs: 0,
30864 flags: (JSPROP_ENUMERATE) as u16,
30865 selfHostedName: ptr::null()
30866 },
30867 JSFunctionSpec {
30868 name: JSPropertySpec_Name { string_: c"receiveRecordOfRecords".as_ptr() },
30869 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveRecordOfRecords_methodinfo.get() } as *const _ as *const JSJitInfo },
30870 nargs: 0,
30871 flags: (JSPROP_ENUMERATE) as u16,
30872 selfHostedName: ptr::null()
30873 },
30874 JSFunctionSpec {
30875 name: JSPropertySpec_Name { string_: c"receiveAnyRecord".as_ptr() },
30876 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { receiveAnyRecord_methodinfo.get() } as *const _ as *const JSJitInfo },
30877 nargs: 0,
30878 flags: (JSPROP_ENUMERATE) as u16,
30879 selfHostedName: ptr::null()
30880 },
30881 JSFunctionSpec {
30882 name: JSPropertySpec_Name { string_: c"BooleanMozPreference".as_ptr() },
30883 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { BooleanMozPreference_methodinfo.get() } as *const _ as *const JSJitInfo },
30884 nargs: 1,
30885 flags: (JSPROP_ENUMERATE) as u16,
30886 selfHostedName: ptr::null()
30887 },
30888 JSFunctionSpec {
30889 name: JSPropertySpec_Name { string_: c"StringMozPreference".as_ptr() },
30890 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { StringMozPreference_methodinfo.get() } as *const _ as *const JSJitInfo },
30891 nargs: 1,
30892 flags: (JSPROP_ENUMERATE) as u16,
30893 selfHostedName: ptr::null()
30894 },
30895 JSFunctionSpec {
30896 name: JSPropertySpec_Name { string_: ptr::null() },
30897 call: JSNativeWrapper { op: None, info: ptr::null() },
30898 nargs: 0,
30899 flags: 0,
30900 selfHostedName: ptr::null()
30901 }]))[..]
30902,
30903&Box::leak(Box::new([
30904 JSFunctionSpec {
30905 name: JSPropertySpec_Name { string_: c"prefControlledMethodDisabled".as_ptr() },
30906 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { prefControlledMethodDisabled_methodinfo.get() } as *const _ as *const JSJitInfo },
30907 nargs: 0,
30908 flags: (JSPROP_ENUMERATE) as u16,
30909 selfHostedName: ptr::null()
30910 },
30911 JSFunctionSpec {
30912 name: JSPropertySpec_Name { string_: ptr::null() },
30913 call: JSNativeWrapper { op: None, info: ptr::null() },
30914 nargs: 0,
30915 flags: 0,
30916 selfHostedName: ptr::null()
30917 }]))[..]
30918,
30919&Box::leak(Box::new([
30920 JSFunctionSpec {
30921 name: JSPropertySpec_Name { string_: c"advanceClock".as_ptr() },
30922 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { advanceClock_methodinfo.get() } as *const _ as *const JSJitInfo },
30923 nargs: 1,
30924 flags: (JSPROP_ENUMERATE) as u16,
30925 selfHostedName: ptr::null()
30926 },
30927 JSFunctionSpec {
30928 name: JSPropertySpec_Name { string_: ptr::null() },
30929 call: JSNativeWrapper { op: None, info: ptr::null() },
30930 nargs: 0,
30931 flags: 0,
30932 selfHostedName: ptr::null()
30933 }]))[..]
30934,
30935&Box::leak(Box::new([
30936 JSFunctionSpec {
30937 name: JSPropertySpec_Name { string_: c"prefControlledMethodEnabled".as_ptr() },
30938 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { prefControlledMethodEnabled_methodinfo.get() } as *const _ as *const JSJitInfo },
30939 nargs: 0,
30940 flags: (JSPROP_ENUMERATE) as u16,
30941 selfHostedName: ptr::null()
30942 },
30943 JSFunctionSpec {
30944 name: JSPropertySpec_Name { string_: ptr::null() },
30945 call: JSNativeWrapper { op: None, info: ptr::null() },
30946 nargs: 0,
30947 flags: 0,
30948 selfHostedName: ptr::null()
30949 }]))[..]
30950,
30951&Box::leak(Box::new([
30952 JSFunctionSpec {
30953 name: JSPropertySpec_Name { string_: c"funcControlledMethodDisabled".as_ptr() },
30954 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { funcControlledMethodDisabled_methodinfo.get() } as *const _ as *const JSJitInfo },
30955 nargs: 0,
30956 flags: (JSPROP_ENUMERATE) as u16,
30957 selfHostedName: ptr::null()
30958 },
30959 JSFunctionSpec {
30960 name: JSPropertySpec_Name { string_: ptr::null() },
30961 call: JSNativeWrapper { op: None, info: ptr::null() },
30962 nargs: 0,
30963 flags: 0,
30964 selfHostedName: ptr::null()
30965 }]))[..]
30966,
30967&Box::leak(Box::new([
30968 JSFunctionSpec {
30969 name: JSPropertySpec_Name { string_: c"funcControlledMethodEnabled".as_ptr() },
30970 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { funcControlledMethodEnabled_methodinfo.get() } as *const _ as *const JSJitInfo },
30971 nargs: 0,
30972 flags: (JSPROP_ENUMERATE) as u16,
30973 selfHostedName: ptr::null()
30974 },
30975 JSFunctionSpec {
30976 name: JSPropertySpec_Name { string_: ptr::null() },
30977 call: JSNativeWrapper { op: None, info: ptr::null() },
30978 nargs: 0,
30979 flags: 0,
30980 selfHostedName: ptr::null()
30981 }]))[..]
30982,
30983&Box::leak(Box::new([
30984 JSFunctionSpec {
30985 name: JSPropertySpec_Name { string_: c"returnResolvedPromise".as_ptr() },
30986 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { returnResolvedPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
30987 nargs: 1,
30988 flags: (JSPROP_ENUMERATE) as u16,
30989 selfHostedName: ptr::null()
30990 },
30991 JSFunctionSpec {
30992 name: JSPropertySpec_Name { string_: c"returnRejectedPromise".as_ptr() },
30993 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { returnRejectedPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
30994 nargs: 1,
30995 flags: (JSPROP_ENUMERATE) as u16,
30996 selfHostedName: ptr::null()
30997 },
30998 JSFunctionSpec {
30999 name: JSPropertySpec_Name { string_: c"acceptPromise".as_ptr() },
31000 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { acceptPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
31001 nargs: 1,
31002 flags: (JSPROP_ENUMERATE) as u16,
31003 selfHostedName: ptr::null()
31004 },
31005 JSFunctionSpec {
31006 name: JSPropertySpec_Name { string_: c"promiseNativeHandler".as_ptr() },
31007 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { promiseNativeHandler_methodinfo.get() } as *const _ as *const JSJitInfo },
31008 nargs: 2,
31009 flags: (JSPROP_ENUMERATE) as u16,
31010 selfHostedName: ptr::null()
31011 },
31012 JSFunctionSpec {
31013 name: JSPropertySpec_Name { string_: c"promiseResolveNative".as_ptr() },
31014 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { promiseResolveNative_methodinfo.get() } as *const _ as *const JSJitInfo },
31015 nargs: 2,
31016 flags: (JSPROP_ENUMERATE) as u16,
31017 selfHostedName: ptr::null()
31018 },
31019 JSFunctionSpec {
31020 name: JSPropertySpec_Name { string_: c"promiseRejectNative".as_ptr() },
31021 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { promiseRejectNative_methodinfo.get() } as *const _ as *const JSJitInfo },
31022 nargs: 2,
31023 flags: (JSPROP_ENUMERATE) as u16,
31024 selfHostedName: ptr::null()
31025 },
31026 JSFunctionSpec {
31027 name: JSPropertySpec_Name { string_: c"promiseRejectWithTypeError".as_ptr() },
31028 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { promiseRejectWithTypeError_methodinfo.get() } as *const _ as *const JSJitInfo },
31029 nargs: 2,
31030 flags: (JSPROP_ENUMERATE) as u16,
31031 selfHostedName: ptr::null()
31032 },
31033 JSFunctionSpec {
31034 name: JSPropertySpec_Name { string_: c"resolvePromiseDelayed".as_ptr() },
31035 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { resolvePromiseDelayed_methodinfo.get() } as *const _ as *const JSJitInfo },
31036 nargs: 3,
31037 flags: (JSPROP_ENUMERATE) as u16,
31038 selfHostedName: ptr::null()
31039 },
31040 JSFunctionSpec {
31041 name: JSPropertySpec_Name { string_: c"methodThrowToRejectPromise".as_ptr() },
31042 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { methodThrowToRejectPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
31043 nargs: 0,
31044 flags: (JSPROP_ENUMERATE) as u16,
31045 selfHostedName: ptr::null()
31046 },
31047 JSFunctionSpec {
31048 name: JSPropertySpec_Name { string_: c"methodInternalThrowToRejectPromise".as_ptr() },
31049 call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { methodInternalThrowToRejectPromise_methodinfo.get() } as *const _ as *const JSJitInfo },
31050 nargs: 1,
31051 flags: (JSPROP_ENUMERATE) as u16,
31052 selfHostedName: ptr::null()
31053 },
31054 JSFunctionSpec {
31055 name: JSPropertySpec_Name { string_: c"panic".as_ptr() },
31056 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { panic_methodinfo.get() } as *const _ as *const JSJitInfo },
31057 nargs: 0,
31058 flags: (JSPROP_ENUMERATE) as u16,
31059 selfHostedName: ptr::null()
31060 },
31061 JSFunctionSpec {
31062 name: JSPropertySpec_Name { string_: c"entryGlobal".as_ptr() },
31063 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { entryGlobal_methodinfo.get() } as *const _ as *const JSJitInfo },
31064 nargs: 0,
31065 flags: (JSPROP_ENUMERATE) as u16,
31066 selfHostedName: ptr::null()
31067 },
31068 JSFunctionSpec {
31069 name: JSPropertySpec_Name { string_: c"incumbentGlobal".as_ptr() },
31070 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { incumbentGlobal_methodinfo.get() } as *const _ as *const JSJitInfo },
31071 nargs: 0,
31072 flags: (JSPROP_ENUMERATE) as u16,
31073 selfHostedName: ptr::null()
31074 },
31075 JSFunctionSpec {
31076 name: JSPropertySpec_Name { string_: c"getDictionaryWithParent".as_ptr() },
31077 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getDictionaryWithParent_methodinfo.get() } as *const _ as *const JSJitInfo },
31078 nargs: 2,
31079 flags: (JSPROP_ENUMERATE) as u16,
31080 selfHostedName: ptr::null()
31081 },
31082 JSFunctionSpec {
31083 name: JSPropertySpec_Name { string_: ptr::null() },
31084 call: JSNativeWrapper { op: None, info: ptr::null() },
31085 nargs: 0,
31086 flags: 0,
31087 selfHostedName: ptr::null()
31088 }]))[..]
31089,
31090&Box::leak(Box::new([
31091 JSFunctionSpec {
31092 name: JSPropertySpec_Name { string_: c"crashHard".as_ptr() },
31093 call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { crashHard_methodinfo.get() } as *const _ as *const JSJitInfo },
31094 nargs: 0,
31095 flags: (JSPROP_ENUMERATE) as u16,
31096 selfHostedName: ptr::null()
31097 },
31098 JSFunctionSpec {
31099 name: JSPropertySpec_Name { string_: ptr::null() },
31100 call: JSNativeWrapper { op: None, info: ptr::null() },
31101 nargs: 0,
31102 flags: 0,
31103 selfHostedName: ptr::null()
31104 }]))[..]
31105])));
31106}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();
31107
31108pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
31109 sMethods.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0]),
31110 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[1]),
31111 Guard::new(&[Condition::Pref("layout_animations_test_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[2]),
31112 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled2_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[3]),
31113 Guard::new(&[Condition::Func(D::TestBinding::condition_unsatisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[4]),
31114 Guard::new(&[Condition::Func(D::TestBinding::condition_satisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[5]),
31115 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[6]),
31116 Guard::new(&[Condition::Pref("dom_testable_crash_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[7])])));
31117}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();
31118
31119pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
31120 sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
31121 JSPropertySpec {
31122 name: JSPropertySpec_Name { string_: c"booleanAttribute".as_ptr() },
31123 attributes_: (JSPROP_ENUMERATE),
31124 kind_: (JSPropertySpec_Kind::NativeAccessor),
31125 u: JSPropertySpec_AccessorsOrValue {
31126 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31127 getter: JSPropertySpec_Accessor {
31128 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { booleanAttribute_getterinfo.get() } },
31129 },
31130 setter: JSPropertySpec_Accessor {
31131 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { booleanAttribute_setterinfo.get() } },
31132 }
31133 }
31134 }
31135 }
31136,
31137 JSPropertySpec {
31138 name: JSPropertySpec_Name { string_: c"byteAttribute".as_ptr() },
31139 attributes_: (JSPROP_ENUMERATE),
31140 kind_: (JSPropertySpec_Kind::NativeAccessor),
31141 u: JSPropertySpec_AccessorsOrValue {
31142 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31143 getter: JSPropertySpec_Accessor {
31144 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { byteAttribute_getterinfo.get() } },
31145 },
31146 setter: JSPropertySpec_Accessor {
31147 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { byteAttribute_setterinfo.get() } },
31148 }
31149 }
31150 }
31151 }
31152,
31153 JSPropertySpec {
31154 name: JSPropertySpec_Name { string_: c"octetAttribute".as_ptr() },
31155 attributes_: (JSPROP_ENUMERATE),
31156 kind_: (JSPropertySpec_Kind::NativeAccessor),
31157 u: JSPropertySpec_AccessorsOrValue {
31158 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31159 getter: JSPropertySpec_Accessor {
31160 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { octetAttribute_getterinfo.get() } },
31161 },
31162 setter: JSPropertySpec_Accessor {
31163 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { octetAttribute_setterinfo.get() } },
31164 }
31165 }
31166 }
31167 }
31168,
31169 JSPropertySpec {
31170 name: JSPropertySpec_Name { string_: c"shortAttribute".as_ptr() },
31171 attributes_: (JSPROP_ENUMERATE),
31172 kind_: (JSPropertySpec_Kind::NativeAccessor),
31173 u: JSPropertySpec_AccessorsOrValue {
31174 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31175 getter: JSPropertySpec_Accessor {
31176 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { shortAttribute_getterinfo.get() } },
31177 },
31178 setter: JSPropertySpec_Accessor {
31179 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { shortAttribute_setterinfo.get() } },
31180 }
31181 }
31182 }
31183 }
31184,
31185 JSPropertySpec {
31186 name: JSPropertySpec_Name { string_: c"unsignedShortAttribute".as_ptr() },
31187 attributes_: (JSPROP_ENUMERATE),
31188 kind_: (JSPropertySpec_Kind::NativeAccessor),
31189 u: JSPropertySpec_AccessorsOrValue {
31190 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31191 getter: JSPropertySpec_Accessor {
31192 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedShortAttribute_getterinfo.get() } },
31193 },
31194 setter: JSPropertySpec_Accessor {
31195 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedShortAttribute_setterinfo.get() } },
31196 }
31197 }
31198 }
31199 }
31200,
31201 JSPropertySpec {
31202 name: JSPropertySpec_Name { string_: c"longAttribute".as_ptr() },
31203 attributes_: (JSPROP_ENUMERATE),
31204 kind_: (JSPropertySpec_Kind::NativeAccessor),
31205 u: JSPropertySpec_AccessorsOrValue {
31206 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31207 getter: JSPropertySpec_Accessor {
31208 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { longAttribute_getterinfo.get() } },
31209 },
31210 setter: JSPropertySpec_Accessor {
31211 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { longAttribute_setterinfo.get() } },
31212 }
31213 }
31214 }
31215 }
31216,
31217 JSPropertySpec {
31218 name: JSPropertySpec_Name { string_: c"unsignedLongAttribute".as_ptr() },
31219 attributes_: (JSPROP_ENUMERATE),
31220 kind_: (JSPropertySpec_Kind::NativeAccessor),
31221 u: JSPropertySpec_AccessorsOrValue {
31222 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31223 getter: JSPropertySpec_Accessor {
31224 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedLongAttribute_getterinfo.get() } },
31225 },
31226 setter: JSPropertySpec_Accessor {
31227 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedLongAttribute_setterinfo.get() } },
31228 }
31229 }
31230 }
31231 }
31232,
31233 JSPropertySpec {
31234 name: JSPropertySpec_Name { string_: c"longLongAttribute".as_ptr() },
31235 attributes_: (JSPROP_ENUMERATE),
31236 kind_: (JSPropertySpec_Kind::NativeAccessor),
31237 u: JSPropertySpec_AccessorsOrValue {
31238 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31239 getter: JSPropertySpec_Accessor {
31240 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { longLongAttribute_getterinfo.get() } },
31241 },
31242 setter: JSPropertySpec_Accessor {
31243 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { longLongAttribute_setterinfo.get() } },
31244 }
31245 }
31246 }
31247 }
31248,
31249 JSPropertySpec {
31250 name: JSPropertySpec_Name { string_: c"unsignedLongLongAttribute".as_ptr() },
31251 attributes_: (JSPROP_ENUMERATE),
31252 kind_: (JSPropertySpec_Kind::NativeAccessor),
31253 u: JSPropertySpec_AccessorsOrValue {
31254 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31255 getter: JSPropertySpec_Accessor {
31256 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedLongLongAttribute_getterinfo.get() } },
31257 },
31258 setter: JSPropertySpec_Accessor {
31259 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedLongLongAttribute_setterinfo.get() } },
31260 }
31261 }
31262 }
31263 }
31264,
31265 JSPropertySpec {
31266 name: JSPropertySpec_Name { string_: c"unrestrictedFloatAttribute".as_ptr() },
31267 attributes_: (JSPROP_ENUMERATE),
31268 kind_: (JSPropertySpec_Kind::NativeAccessor),
31269 u: JSPropertySpec_AccessorsOrValue {
31270 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31271 getter: JSPropertySpec_Accessor {
31272 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unrestrictedFloatAttribute_getterinfo.get() } },
31273 },
31274 setter: JSPropertySpec_Accessor {
31275 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unrestrictedFloatAttribute_setterinfo.get() } },
31276 }
31277 }
31278 }
31279 }
31280,
31281 JSPropertySpec {
31282 name: JSPropertySpec_Name { string_: c"floatAttribute".as_ptr() },
31283 attributes_: (JSPROP_ENUMERATE),
31284 kind_: (JSPropertySpec_Kind::NativeAccessor),
31285 u: JSPropertySpec_AccessorsOrValue {
31286 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31287 getter: JSPropertySpec_Accessor {
31288 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { floatAttribute_getterinfo.get() } },
31289 },
31290 setter: JSPropertySpec_Accessor {
31291 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { floatAttribute_setterinfo.get() } },
31292 }
31293 }
31294 }
31295 }
31296,
31297 JSPropertySpec {
31298 name: JSPropertySpec_Name { string_: c"unrestrictedDoubleAttribute".as_ptr() },
31299 attributes_: (JSPROP_ENUMERATE),
31300 kind_: (JSPropertySpec_Kind::NativeAccessor),
31301 u: JSPropertySpec_AccessorsOrValue {
31302 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31303 getter: JSPropertySpec_Accessor {
31304 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unrestrictedDoubleAttribute_getterinfo.get() } },
31305 },
31306 setter: JSPropertySpec_Accessor {
31307 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unrestrictedDoubleAttribute_setterinfo.get() } },
31308 }
31309 }
31310 }
31311 }
31312,
31313 JSPropertySpec {
31314 name: JSPropertySpec_Name { string_: c"doubleAttribute".as_ptr() },
31315 attributes_: (JSPROP_ENUMERATE),
31316 kind_: (JSPropertySpec_Kind::NativeAccessor),
31317 u: JSPropertySpec_AccessorsOrValue {
31318 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31319 getter: JSPropertySpec_Accessor {
31320 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { doubleAttribute_getterinfo.get() } },
31321 },
31322 setter: JSPropertySpec_Accessor {
31323 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { doubleAttribute_setterinfo.get() } },
31324 }
31325 }
31326 }
31327 }
31328,
31329 JSPropertySpec {
31330 name: JSPropertySpec_Name { string_: c"stringAttribute".as_ptr() },
31331 attributes_: (JSPROP_ENUMERATE),
31332 kind_: (JSPropertySpec_Kind::NativeAccessor),
31333 u: JSPropertySpec_AccessorsOrValue {
31334 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31335 getter: JSPropertySpec_Accessor {
31336 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { stringAttribute_getterinfo.get() } },
31337 },
31338 setter: JSPropertySpec_Accessor {
31339 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { stringAttribute_setterinfo.get() } },
31340 }
31341 }
31342 }
31343 }
31344,
31345 JSPropertySpec {
31346 name: JSPropertySpec_Name { string_: c"usvstringAttribute".as_ptr() },
31347 attributes_: (JSPROP_ENUMERATE),
31348 kind_: (JSPropertySpec_Kind::NativeAccessor),
31349 u: JSPropertySpec_AccessorsOrValue {
31350 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31351 getter: JSPropertySpec_Accessor {
31352 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { usvstringAttribute_getterinfo.get() } },
31353 },
31354 setter: JSPropertySpec_Accessor {
31355 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { usvstringAttribute_setterinfo.get() } },
31356 }
31357 }
31358 }
31359 }
31360,
31361 JSPropertySpec {
31362 name: JSPropertySpec_Name { string_: c"byteStringAttribute".as_ptr() },
31363 attributes_: (JSPROP_ENUMERATE),
31364 kind_: (JSPropertySpec_Kind::NativeAccessor),
31365 u: JSPropertySpec_AccessorsOrValue {
31366 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31367 getter: JSPropertySpec_Accessor {
31368 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { byteStringAttribute_getterinfo.get() } },
31369 },
31370 setter: JSPropertySpec_Accessor {
31371 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { byteStringAttribute_setterinfo.get() } },
31372 }
31373 }
31374 }
31375 }
31376,
31377 JSPropertySpec {
31378 name: JSPropertySpec_Name { string_: c"enumAttribute".as_ptr() },
31379 attributes_: (JSPROP_ENUMERATE),
31380 kind_: (JSPropertySpec_Kind::NativeAccessor),
31381 u: JSPropertySpec_AccessorsOrValue {
31382 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31383 getter: JSPropertySpec_Accessor {
31384 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { enumAttribute_getterinfo.get() } },
31385 },
31386 setter: JSPropertySpec_Accessor {
31387 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { enumAttribute_setterinfo.get() } },
31388 }
31389 }
31390 }
31391 }
31392,
31393 JSPropertySpec {
31394 name: JSPropertySpec_Name { string_: c"interfaceAttribute".as_ptr() },
31395 attributes_: (JSPROP_ENUMERATE),
31396 kind_: (JSPropertySpec_Kind::NativeAccessor),
31397 u: JSPropertySpec_AccessorsOrValue {
31398 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31399 getter: JSPropertySpec_Accessor {
31400 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { interfaceAttribute_getterinfo.get() } },
31401 },
31402 setter: JSPropertySpec_Accessor {
31403 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { interfaceAttribute_setterinfo.get() } },
31404 }
31405 }
31406 }
31407 }
31408,
31409 JSPropertySpec {
31410 name: JSPropertySpec_Name { string_: c"unionAttribute".as_ptr() },
31411 attributes_: (JSPROP_ENUMERATE),
31412 kind_: (JSPropertySpec_Kind::NativeAccessor),
31413 u: JSPropertySpec_AccessorsOrValue {
31414 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31415 getter: JSPropertySpec_Accessor {
31416 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unionAttribute_getterinfo.get() } },
31417 },
31418 setter: JSPropertySpec_Accessor {
31419 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unionAttribute_setterinfo.get() } },
31420 }
31421 }
31422 }
31423 }
31424,
31425 JSPropertySpec {
31426 name: JSPropertySpec_Name { string_: c"union2Attribute".as_ptr() },
31427 attributes_: (JSPROP_ENUMERATE),
31428 kind_: (JSPropertySpec_Kind::NativeAccessor),
31429 u: JSPropertySpec_AccessorsOrValue {
31430 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31431 getter: JSPropertySpec_Accessor {
31432 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union2Attribute_getterinfo.get() } },
31433 },
31434 setter: JSPropertySpec_Accessor {
31435 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union2Attribute_setterinfo.get() } },
31436 }
31437 }
31438 }
31439 }
31440,
31441 JSPropertySpec {
31442 name: JSPropertySpec_Name { string_: c"union3Attribute".as_ptr() },
31443 attributes_: (JSPROP_ENUMERATE),
31444 kind_: (JSPropertySpec_Kind::NativeAccessor),
31445 u: JSPropertySpec_AccessorsOrValue {
31446 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31447 getter: JSPropertySpec_Accessor {
31448 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union3Attribute_getterinfo.get() } },
31449 },
31450 setter: JSPropertySpec_Accessor {
31451 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union3Attribute_setterinfo.get() } },
31452 }
31453 }
31454 }
31455 }
31456,
31457 JSPropertySpec {
31458 name: JSPropertySpec_Name { string_: c"union4Attribute".as_ptr() },
31459 attributes_: (JSPROP_ENUMERATE),
31460 kind_: (JSPropertySpec_Kind::NativeAccessor),
31461 u: JSPropertySpec_AccessorsOrValue {
31462 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31463 getter: JSPropertySpec_Accessor {
31464 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union4Attribute_getterinfo.get() } },
31465 },
31466 setter: JSPropertySpec_Accessor {
31467 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union4Attribute_setterinfo.get() } },
31468 }
31469 }
31470 }
31471 }
31472,
31473 JSPropertySpec {
31474 name: JSPropertySpec_Name { string_: c"union5Attribute".as_ptr() },
31475 attributes_: (JSPROP_ENUMERATE),
31476 kind_: (JSPropertySpec_Kind::NativeAccessor),
31477 u: JSPropertySpec_AccessorsOrValue {
31478 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31479 getter: JSPropertySpec_Accessor {
31480 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union5Attribute_getterinfo.get() } },
31481 },
31482 setter: JSPropertySpec_Accessor {
31483 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union5Attribute_setterinfo.get() } },
31484 }
31485 }
31486 }
31487 }
31488,
31489 JSPropertySpec {
31490 name: JSPropertySpec_Name { string_: c"union6Attribute".as_ptr() },
31491 attributes_: (JSPROP_ENUMERATE),
31492 kind_: (JSPropertySpec_Kind::NativeAccessor),
31493 u: JSPropertySpec_AccessorsOrValue {
31494 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31495 getter: JSPropertySpec_Accessor {
31496 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union6Attribute_getterinfo.get() } },
31497 },
31498 setter: JSPropertySpec_Accessor {
31499 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union6Attribute_setterinfo.get() } },
31500 }
31501 }
31502 }
31503 }
31504,
31505 JSPropertySpec {
31506 name: JSPropertySpec_Name { string_: c"union7Attribute".as_ptr() },
31507 attributes_: (JSPROP_ENUMERATE),
31508 kind_: (JSPropertySpec_Kind::NativeAccessor),
31509 u: JSPropertySpec_AccessorsOrValue {
31510 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31511 getter: JSPropertySpec_Accessor {
31512 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union7Attribute_getterinfo.get() } },
31513 },
31514 setter: JSPropertySpec_Accessor {
31515 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union7Attribute_setterinfo.get() } },
31516 }
31517 }
31518 }
31519 }
31520,
31521 JSPropertySpec {
31522 name: JSPropertySpec_Name { string_: c"union8Attribute".as_ptr() },
31523 attributes_: (JSPROP_ENUMERATE),
31524 kind_: (JSPropertySpec_Kind::NativeAccessor),
31525 u: JSPropertySpec_AccessorsOrValue {
31526 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31527 getter: JSPropertySpec_Accessor {
31528 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union8Attribute_getterinfo.get() } },
31529 },
31530 setter: JSPropertySpec_Accessor {
31531 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union8Attribute_setterinfo.get() } },
31532 }
31533 }
31534 }
31535 }
31536,
31537 JSPropertySpec {
31538 name: JSPropertySpec_Name { string_: c"union9Attribute".as_ptr() },
31539 attributes_: (JSPROP_ENUMERATE),
31540 kind_: (JSPropertySpec_Kind::NativeAccessor),
31541 u: JSPropertySpec_AccessorsOrValue {
31542 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31543 getter: JSPropertySpec_Accessor {
31544 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union9Attribute_getterinfo.get() } },
31545 },
31546 setter: JSPropertySpec_Accessor {
31547 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union9Attribute_setterinfo.get() } },
31548 }
31549 }
31550 }
31551 }
31552,
31553 JSPropertySpec {
31554 name: JSPropertySpec_Name { string_: c"arrayAttribute".as_ptr() },
31555 attributes_: (JSPROP_ENUMERATE),
31556 kind_: (JSPropertySpec_Kind::NativeAccessor),
31557 u: JSPropertySpec_AccessorsOrValue {
31558 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31559 getter: JSPropertySpec_Accessor {
31560 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { arrayAttribute_getterinfo.get() } },
31561 },
31562 setter: JSPropertySpec_Accessor {
31563 native: JSNativeWrapper { op: None, info: ptr::null() },
31564 }
31565 }
31566 }
31567 }
31568,
31569 JSPropertySpec {
31570 name: JSPropertySpec_Name { string_: c"anyAttribute".as_ptr() },
31571 attributes_: (JSPROP_ENUMERATE),
31572 kind_: (JSPropertySpec_Kind::NativeAccessor),
31573 u: JSPropertySpec_AccessorsOrValue {
31574 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31575 getter: JSPropertySpec_Accessor {
31576 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { anyAttribute_getterinfo.get() } },
31577 },
31578 setter: JSPropertySpec_Accessor {
31579 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { anyAttribute_setterinfo.get() } },
31580 }
31581 }
31582 }
31583 }
31584,
31585 JSPropertySpec {
31586 name: JSPropertySpec_Name { string_: c"objectAttribute".as_ptr() },
31587 attributes_: (JSPROP_ENUMERATE),
31588 kind_: (JSPropertySpec_Kind::NativeAccessor),
31589 u: JSPropertySpec_AccessorsOrValue {
31590 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31591 getter: JSPropertySpec_Accessor {
31592 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { objectAttribute_getterinfo.get() } },
31593 },
31594 setter: JSPropertySpec_Accessor {
31595 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { objectAttribute_setterinfo.get() } },
31596 }
31597 }
31598 }
31599 }
31600,
31601 JSPropertySpec {
31602 name: JSPropertySpec_Name { string_: c"booleanAttributeNullable".as_ptr() },
31603 attributes_: (JSPROP_ENUMERATE),
31604 kind_: (JSPropertySpec_Kind::NativeAccessor),
31605 u: JSPropertySpec_AccessorsOrValue {
31606 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31607 getter: JSPropertySpec_Accessor {
31608 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { booleanAttributeNullable_getterinfo.get() } },
31609 },
31610 setter: JSPropertySpec_Accessor {
31611 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { booleanAttributeNullable_setterinfo.get() } },
31612 }
31613 }
31614 }
31615 }
31616,
31617 JSPropertySpec {
31618 name: JSPropertySpec_Name { string_: c"byteAttributeNullable".as_ptr() },
31619 attributes_: (JSPROP_ENUMERATE),
31620 kind_: (JSPropertySpec_Kind::NativeAccessor),
31621 u: JSPropertySpec_AccessorsOrValue {
31622 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31623 getter: JSPropertySpec_Accessor {
31624 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { byteAttributeNullable_getterinfo.get() } },
31625 },
31626 setter: JSPropertySpec_Accessor {
31627 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { byteAttributeNullable_setterinfo.get() } },
31628 }
31629 }
31630 }
31631 }
31632,
31633 JSPropertySpec {
31634 name: JSPropertySpec_Name { string_: c"octetAttributeNullable".as_ptr() },
31635 attributes_: (JSPROP_ENUMERATE),
31636 kind_: (JSPropertySpec_Kind::NativeAccessor),
31637 u: JSPropertySpec_AccessorsOrValue {
31638 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31639 getter: JSPropertySpec_Accessor {
31640 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { octetAttributeNullable_getterinfo.get() } },
31641 },
31642 setter: JSPropertySpec_Accessor {
31643 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { octetAttributeNullable_setterinfo.get() } },
31644 }
31645 }
31646 }
31647 }
31648,
31649 JSPropertySpec {
31650 name: JSPropertySpec_Name { string_: c"shortAttributeNullable".as_ptr() },
31651 attributes_: (JSPROP_ENUMERATE),
31652 kind_: (JSPropertySpec_Kind::NativeAccessor),
31653 u: JSPropertySpec_AccessorsOrValue {
31654 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31655 getter: JSPropertySpec_Accessor {
31656 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { shortAttributeNullable_getterinfo.get() } },
31657 },
31658 setter: JSPropertySpec_Accessor {
31659 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { shortAttributeNullable_setterinfo.get() } },
31660 }
31661 }
31662 }
31663 }
31664,
31665 JSPropertySpec {
31666 name: JSPropertySpec_Name { string_: c"unsignedShortAttributeNullable".as_ptr() },
31667 attributes_: (JSPROP_ENUMERATE),
31668 kind_: (JSPropertySpec_Kind::NativeAccessor),
31669 u: JSPropertySpec_AccessorsOrValue {
31670 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31671 getter: JSPropertySpec_Accessor {
31672 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedShortAttributeNullable_getterinfo.get() } },
31673 },
31674 setter: JSPropertySpec_Accessor {
31675 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedShortAttributeNullable_setterinfo.get() } },
31676 }
31677 }
31678 }
31679 }
31680,
31681 JSPropertySpec {
31682 name: JSPropertySpec_Name { string_: c"longAttributeNullable".as_ptr() },
31683 attributes_: (JSPROP_ENUMERATE),
31684 kind_: (JSPropertySpec_Kind::NativeAccessor),
31685 u: JSPropertySpec_AccessorsOrValue {
31686 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31687 getter: JSPropertySpec_Accessor {
31688 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { longAttributeNullable_getterinfo.get() } },
31689 },
31690 setter: JSPropertySpec_Accessor {
31691 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { longAttributeNullable_setterinfo.get() } },
31692 }
31693 }
31694 }
31695 }
31696,
31697 JSPropertySpec {
31698 name: JSPropertySpec_Name { string_: c"unsignedLongAttributeNullable".as_ptr() },
31699 attributes_: (JSPROP_ENUMERATE),
31700 kind_: (JSPropertySpec_Kind::NativeAccessor),
31701 u: JSPropertySpec_AccessorsOrValue {
31702 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31703 getter: JSPropertySpec_Accessor {
31704 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedLongAttributeNullable_getterinfo.get() } },
31705 },
31706 setter: JSPropertySpec_Accessor {
31707 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedLongAttributeNullable_setterinfo.get() } },
31708 }
31709 }
31710 }
31711 }
31712,
31713 JSPropertySpec {
31714 name: JSPropertySpec_Name { string_: c"longLongAttributeNullable".as_ptr() },
31715 attributes_: (JSPROP_ENUMERATE),
31716 kind_: (JSPropertySpec_Kind::NativeAccessor),
31717 u: JSPropertySpec_AccessorsOrValue {
31718 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31719 getter: JSPropertySpec_Accessor {
31720 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { longLongAttributeNullable_getterinfo.get() } },
31721 },
31722 setter: JSPropertySpec_Accessor {
31723 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { longLongAttributeNullable_setterinfo.get() } },
31724 }
31725 }
31726 }
31727 }
31728,
31729 JSPropertySpec {
31730 name: JSPropertySpec_Name { string_: c"unsignedLongLongAttributeNullable".as_ptr() },
31731 attributes_: (JSPROP_ENUMERATE),
31732 kind_: (JSPropertySpec_Kind::NativeAccessor),
31733 u: JSPropertySpec_AccessorsOrValue {
31734 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31735 getter: JSPropertySpec_Accessor {
31736 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unsignedLongLongAttributeNullable_getterinfo.get() } },
31737 },
31738 setter: JSPropertySpec_Accessor {
31739 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unsignedLongLongAttributeNullable_setterinfo.get() } },
31740 }
31741 }
31742 }
31743 }
31744,
31745 JSPropertySpec {
31746 name: JSPropertySpec_Name { string_: c"unrestrictedFloatAttributeNullable".as_ptr() },
31747 attributes_: (JSPROP_ENUMERATE),
31748 kind_: (JSPropertySpec_Kind::NativeAccessor),
31749 u: JSPropertySpec_AccessorsOrValue {
31750 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31751 getter: JSPropertySpec_Accessor {
31752 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unrestrictedFloatAttributeNullable_getterinfo.get() } },
31753 },
31754 setter: JSPropertySpec_Accessor {
31755 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unrestrictedFloatAttributeNullable_setterinfo.get() } },
31756 }
31757 }
31758 }
31759 }
31760,
31761 JSPropertySpec {
31762 name: JSPropertySpec_Name { string_: c"floatAttributeNullable".as_ptr() },
31763 attributes_: (JSPROP_ENUMERATE),
31764 kind_: (JSPropertySpec_Kind::NativeAccessor),
31765 u: JSPropertySpec_AccessorsOrValue {
31766 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31767 getter: JSPropertySpec_Accessor {
31768 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { floatAttributeNullable_getterinfo.get() } },
31769 },
31770 setter: JSPropertySpec_Accessor {
31771 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { floatAttributeNullable_setterinfo.get() } },
31772 }
31773 }
31774 }
31775 }
31776,
31777 JSPropertySpec {
31778 name: JSPropertySpec_Name { string_: c"unrestrictedDoubleAttributeNullable".as_ptr() },
31779 attributes_: (JSPROP_ENUMERATE),
31780 kind_: (JSPropertySpec_Kind::NativeAccessor),
31781 u: JSPropertySpec_AccessorsOrValue {
31782 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31783 getter: JSPropertySpec_Accessor {
31784 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unrestrictedDoubleAttributeNullable_getterinfo.get() } },
31785 },
31786 setter: JSPropertySpec_Accessor {
31787 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unrestrictedDoubleAttributeNullable_setterinfo.get() } },
31788 }
31789 }
31790 }
31791 }
31792,
31793 JSPropertySpec {
31794 name: JSPropertySpec_Name { string_: c"doubleAttributeNullable".as_ptr() },
31795 attributes_: (JSPROP_ENUMERATE),
31796 kind_: (JSPropertySpec_Kind::NativeAccessor),
31797 u: JSPropertySpec_AccessorsOrValue {
31798 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31799 getter: JSPropertySpec_Accessor {
31800 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { doubleAttributeNullable_getterinfo.get() } },
31801 },
31802 setter: JSPropertySpec_Accessor {
31803 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { doubleAttributeNullable_setterinfo.get() } },
31804 }
31805 }
31806 }
31807 }
31808,
31809 JSPropertySpec {
31810 name: JSPropertySpec_Name { string_: c"stringAttributeNullable".as_ptr() },
31811 attributes_: (JSPROP_ENUMERATE),
31812 kind_: (JSPropertySpec_Kind::NativeAccessor),
31813 u: JSPropertySpec_AccessorsOrValue {
31814 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31815 getter: JSPropertySpec_Accessor {
31816 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { stringAttributeNullable_getterinfo.get() } },
31817 },
31818 setter: JSPropertySpec_Accessor {
31819 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { stringAttributeNullable_setterinfo.get() } },
31820 }
31821 }
31822 }
31823 }
31824,
31825 JSPropertySpec {
31826 name: JSPropertySpec_Name { string_: c"usvstringAttributeNullable".as_ptr() },
31827 attributes_: (JSPROP_ENUMERATE),
31828 kind_: (JSPropertySpec_Kind::NativeAccessor),
31829 u: JSPropertySpec_AccessorsOrValue {
31830 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31831 getter: JSPropertySpec_Accessor {
31832 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { usvstringAttributeNullable_getterinfo.get() } },
31833 },
31834 setter: JSPropertySpec_Accessor {
31835 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { usvstringAttributeNullable_setterinfo.get() } },
31836 }
31837 }
31838 }
31839 }
31840,
31841 JSPropertySpec {
31842 name: JSPropertySpec_Name { string_: c"byteStringAttributeNullable".as_ptr() },
31843 attributes_: (JSPROP_ENUMERATE),
31844 kind_: (JSPropertySpec_Kind::NativeAccessor),
31845 u: JSPropertySpec_AccessorsOrValue {
31846 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31847 getter: JSPropertySpec_Accessor {
31848 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { byteStringAttributeNullable_getterinfo.get() } },
31849 },
31850 setter: JSPropertySpec_Accessor {
31851 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { byteStringAttributeNullable_setterinfo.get() } },
31852 }
31853 }
31854 }
31855 }
31856,
31857 JSPropertySpec {
31858 name: JSPropertySpec_Name { string_: c"enumAttributeNullable".as_ptr() },
31859 attributes_: (JSPROP_ENUMERATE),
31860 kind_: (JSPropertySpec_Kind::NativeAccessor),
31861 u: JSPropertySpec_AccessorsOrValue {
31862 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31863 getter: JSPropertySpec_Accessor {
31864 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { enumAttributeNullable_getterinfo.get() } },
31865 },
31866 setter: JSPropertySpec_Accessor {
31867 native: JSNativeWrapper { op: None, info: ptr::null() },
31868 }
31869 }
31870 }
31871 }
31872,
31873 JSPropertySpec {
31874 name: JSPropertySpec_Name { string_: c"interfaceAttributeNullable".as_ptr() },
31875 attributes_: (JSPROP_ENUMERATE),
31876 kind_: (JSPropertySpec_Kind::NativeAccessor),
31877 u: JSPropertySpec_AccessorsOrValue {
31878 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31879 getter: JSPropertySpec_Accessor {
31880 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { interfaceAttributeNullable_getterinfo.get() } },
31881 },
31882 setter: JSPropertySpec_Accessor {
31883 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { interfaceAttributeNullable_setterinfo.get() } },
31884 }
31885 }
31886 }
31887 }
31888,
31889 JSPropertySpec {
31890 name: JSPropertySpec_Name { string_: c"interfaceAttributeWeak".as_ptr() },
31891 attributes_: (JSPROP_ENUMERATE),
31892 kind_: (JSPropertySpec_Kind::NativeAccessor),
31893 u: JSPropertySpec_AccessorsOrValue {
31894 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31895 getter: JSPropertySpec_Accessor {
31896 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { interfaceAttributeWeak_getterinfo.get() } },
31897 },
31898 setter: JSPropertySpec_Accessor {
31899 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { interfaceAttributeWeak_setterinfo.get() } },
31900 }
31901 }
31902 }
31903 }
31904,
31905 JSPropertySpec {
31906 name: JSPropertySpec_Name { string_: c"objectAttributeNullable".as_ptr() },
31907 attributes_: (JSPROP_ENUMERATE),
31908 kind_: (JSPropertySpec_Kind::NativeAccessor),
31909 u: JSPropertySpec_AccessorsOrValue {
31910 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31911 getter: JSPropertySpec_Accessor {
31912 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { objectAttributeNullable_getterinfo.get() } },
31913 },
31914 setter: JSPropertySpec_Accessor {
31915 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { objectAttributeNullable_setterinfo.get() } },
31916 }
31917 }
31918 }
31919 }
31920,
31921 JSPropertySpec {
31922 name: JSPropertySpec_Name { string_: c"unionAttributeNullable".as_ptr() },
31923 attributes_: (JSPROP_ENUMERATE),
31924 kind_: (JSPropertySpec_Kind::NativeAccessor),
31925 u: JSPropertySpec_AccessorsOrValue {
31926 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31927 getter: JSPropertySpec_Accessor {
31928 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { unionAttributeNullable_getterinfo.get() } },
31929 },
31930 setter: JSPropertySpec_Accessor {
31931 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { unionAttributeNullable_setterinfo.get() } },
31932 }
31933 }
31934 }
31935 }
31936,
31937 JSPropertySpec {
31938 name: JSPropertySpec_Name { string_: c"union2AttributeNullable".as_ptr() },
31939 attributes_: (JSPROP_ENUMERATE),
31940 kind_: (JSPropertySpec_Kind::NativeAccessor),
31941 u: JSPropertySpec_AccessorsOrValue {
31942 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31943 getter: JSPropertySpec_Accessor {
31944 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union2AttributeNullable_getterinfo.get() } },
31945 },
31946 setter: JSPropertySpec_Accessor {
31947 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union2AttributeNullable_setterinfo.get() } },
31948 }
31949 }
31950 }
31951 }
31952,
31953 JSPropertySpec {
31954 name: JSPropertySpec_Name { string_: c"union3AttributeNullable".as_ptr() },
31955 attributes_: (JSPROP_ENUMERATE),
31956 kind_: (JSPropertySpec_Kind::NativeAccessor),
31957 u: JSPropertySpec_AccessorsOrValue {
31958 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31959 getter: JSPropertySpec_Accessor {
31960 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union3AttributeNullable_getterinfo.get() } },
31961 },
31962 setter: JSPropertySpec_Accessor {
31963 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union3AttributeNullable_setterinfo.get() } },
31964 }
31965 }
31966 }
31967 }
31968,
31969 JSPropertySpec {
31970 name: JSPropertySpec_Name { string_: c"union4AttributeNullable".as_ptr() },
31971 attributes_: (JSPROP_ENUMERATE),
31972 kind_: (JSPropertySpec_Kind::NativeAccessor),
31973 u: JSPropertySpec_AccessorsOrValue {
31974 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31975 getter: JSPropertySpec_Accessor {
31976 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union4AttributeNullable_getterinfo.get() } },
31977 },
31978 setter: JSPropertySpec_Accessor {
31979 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union4AttributeNullable_setterinfo.get() } },
31980 }
31981 }
31982 }
31983 }
31984,
31985 JSPropertySpec {
31986 name: JSPropertySpec_Name { string_: c"union5AttributeNullable".as_ptr() },
31987 attributes_: (JSPROP_ENUMERATE),
31988 kind_: (JSPropertySpec_Kind::NativeAccessor),
31989 u: JSPropertySpec_AccessorsOrValue {
31990 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
31991 getter: JSPropertySpec_Accessor {
31992 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union5AttributeNullable_getterinfo.get() } },
31993 },
31994 setter: JSPropertySpec_Accessor {
31995 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union5AttributeNullable_setterinfo.get() } },
31996 }
31997 }
31998 }
31999 }
32000,
32001 JSPropertySpec {
32002 name: JSPropertySpec_Name { string_: c"union6AttributeNullable".as_ptr() },
32003 attributes_: (JSPROP_ENUMERATE),
32004 kind_: (JSPropertySpec_Kind::NativeAccessor),
32005 u: JSPropertySpec_AccessorsOrValue {
32006 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32007 getter: JSPropertySpec_Accessor {
32008 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { union6AttributeNullable_getterinfo.get() } },
32009 },
32010 setter: JSPropertySpec_Accessor {
32011 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { union6AttributeNullable_setterinfo.get() } },
32012 }
32013 }
32014 }
32015 }
32016,
32017 JSPropertySpec {
32018 name: JSPropertySpec_Name { string_: c"attrToBinaryRename".as_ptr() },
32019 attributes_: (JSPROP_ENUMERATE),
32020 kind_: (JSPropertySpec_Kind::NativeAccessor),
32021 u: JSPropertySpec_AccessorsOrValue {
32022 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32023 getter: JSPropertySpec_Accessor {
32024 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { attrToBinaryRename_getterinfo.get() } },
32025 },
32026 setter: JSPropertySpec_Accessor {
32027 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { attrToBinaryRename_setterinfo.get() } },
32028 }
32029 }
32030 }
32031 }
32032,
32033 JSPropertySpec {
32034 name: JSPropertySpec_Name { string_: c"attr-to-binary-rename".as_ptr() },
32035 attributes_: (JSPROP_ENUMERATE),
32036 kind_: (JSPropertySpec_Kind::NativeAccessor),
32037 u: JSPropertySpec_AccessorsOrValue {
32038 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32039 getter: JSPropertySpec_Accessor {
32040 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { attr_to_binary_rename_getterinfo.get() } },
32041 },
32042 setter: JSPropertySpec_Accessor {
32043 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { attr_to_binary_rename_setterinfo.get() } },
32044 }
32045 }
32046 }
32047 }
32048,
32049 JSPropertySpec {
32050 name: JSPropertySpec_Name { string_: c"attr-to-automatically-rename".as_ptr() },
32051 attributes_: (JSPROP_ENUMERATE),
32052 kind_: (JSPropertySpec_Kind::NativeAccessor),
32053 u: JSPropertySpec_AccessorsOrValue {
32054 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32055 getter: JSPropertySpec_Accessor {
32056 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { attr_to_automatically_rename_getterinfo.get() } },
32057 },
32058 setter: JSPropertySpec_Accessor {
32059 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { attr_to_automatically_rename_setterinfo.get() } },
32060 }
32061 }
32062 }
32063 }
32064,
32065 JSPropertySpec {
32066 name: JSPropertySpec_Name { string_: c"forwardedAttribute".as_ptr() },
32067 attributes_: (JSPROP_ENUMERATE),
32068 kind_: (JSPropertySpec_Kind::NativeAccessor),
32069 u: JSPropertySpec_AccessorsOrValue {
32070 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32071 getter: JSPropertySpec_Accessor {
32072 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { forwardedAttribute_getterinfo.get() } },
32073 },
32074 setter: JSPropertySpec_Accessor {
32075 native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { forwardedAttribute_setterinfo.get() } },
32076 }
32077 }
32078 }
32079 }
32080,
32081 JSPropertySpec::ZERO]))[..]
32082,
32083&Box::leak(Box::new([
32084 JSPropertySpec {
32085 name: JSPropertySpec_Name { string_: c"prefControlledAttributeDisabled".as_ptr() },
32086 attributes_: (JSPROP_ENUMERATE),
32087 kind_: (JSPropertySpec_Kind::NativeAccessor),
32088 u: JSPropertySpec_AccessorsOrValue {
32089 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32090 getter: JSPropertySpec_Accessor {
32091 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { prefControlledAttributeDisabled_getterinfo.get() } },
32092 },
32093 setter: JSPropertySpec_Accessor {
32094 native: JSNativeWrapper { op: None, info: ptr::null() },
32095 }
32096 }
32097 }
32098 }
32099,
32100 JSPropertySpec::ZERO]))[..]
32101,
32102&Box::leak(Box::new([
32103 JSPropertySpec {
32104 name: JSPropertySpec_Name { string_: c"prefControlledAttributeEnabled".as_ptr() },
32105 attributes_: (JSPROP_ENUMERATE),
32106 kind_: (JSPropertySpec_Kind::NativeAccessor),
32107 u: JSPropertySpec_AccessorsOrValue {
32108 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32109 getter: JSPropertySpec_Accessor {
32110 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { prefControlledAttributeEnabled_getterinfo.get() } },
32111 },
32112 setter: JSPropertySpec_Accessor {
32113 native: JSNativeWrapper { op: None, info: ptr::null() },
32114 }
32115 }
32116 }
32117 }
32118,
32119 JSPropertySpec::ZERO]))[..]
32120,
32121&Box::leak(Box::new([
32122 JSPropertySpec {
32123 name: JSPropertySpec_Name { string_: c"funcControlledAttributeDisabled".as_ptr() },
32124 attributes_: (JSPROP_ENUMERATE),
32125 kind_: (JSPropertySpec_Kind::NativeAccessor),
32126 u: JSPropertySpec_AccessorsOrValue {
32127 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32128 getter: JSPropertySpec_Accessor {
32129 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { funcControlledAttributeDisabled_getterinfo.get() } },
32130 },
32131 setter: JSPropertySpec_Accessor {
32132 native: JSNativeWrapper { op: None, info: ptr::null() },
32133 }
32134 }
32135 }
32136 }
32137,
32138 JSPropertySpec::ZERO]))[..]
32139,
32140&Box::leak(Box::new([
32141 JSPropertySpec {
32142 name: JSPropertySpec_Name { string_: c"funcControlledAttributeEnabled".as_ptr() },
32143 attributes_: (JSPROP_ENUMERATE),
32144 kind_: (JSPropertySpec_Kind::NativeAccessor),
32145 u: JSPropertySpec_AccessorsOrValue {
32146 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32147 getter: JSPropertySpec_Accessor {
32148 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { funcControlledAttributeEnabled_getterinfo.get() } },
32149 },
32150 setter: JSPropertySpec_Accessor {
32151 native: JSNativeWrapper { op: None, info: ptr::null() },
32152 }
32153 }
32154 }
32155 }
32156,
32157 JSPropertySpec::ZERO]))[..]
32158,
32159&Box::leak(Box::new([
32160 JSPropertySpec {
32161 name: JSPropertySpec_Name { string_: c"promiseAttribute".as_ptr() },
32162 attributes_: (JSPROP_ENUMERATE),
32163 kind_: (JSPropertySpec_Kind::NativeAccessor),
32164 u: JSPropertySpec_AccessorsOrValue {
32165 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32166 getter: JSPropertySpec_Accessor {
32167 native: JSNativeWrapper { op: Some(generic_getter::<true>), info: unsafe { promiseAttribute_getterinfo.get() } },
32168 },
32169 setter: JSPropertySpec_Accessor {
32170 native: JSNativeWrapper { op: None, info: ptr::null() },
32171 }
32172 }
32173 }
32174 }
32175,
32176 JSPropertySpec {
32177 name: JSPropertySpec_Name { string_: c"getterThrowToRejectPromise".as_ptr() },
32178 attributes_: (JSPROP_ENUMERATE),
32179 kind_: (JSPropertySpec_Kind::NativeAccessor),
32180 u: JSPropertySpec_AccessorsOrValue {
32181 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32182 getter: JSPropertySpec_Accessor {
32183 native: JSNativeWrapper { op: Some(generic_getter::<true>), info: unsafe { getterThrowToRejectPromise_getterinfo.get() } },
32184 },
32185 setter: JSPropertySpec_Accessor {
32186 native: JSNativeWrapper { op: None, info: ptr::null() },
32187 }
32188 }
32189 }
32190 }
32191,
32192 JSPropertySpec::ZERO]))[..]
32193,
32194&Box::leak(Box::new([
32195 JSPropertySpec {
32196 name: JSPropertySpec_Name { string_: c"semiExposedBoolFromInterface".as_ptr() },
32197 attributes_: (JSPROP_ENUMERATE),
32198 kind_: (JSPropertySpec_Kind::NativeAccessor),
32199 u: JSPropertySpec_AccessorsOrValue {
32200 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32201 getter: JSPropertySpec_Accessor {
32202 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { semiExposedBoolFromInterface_getterinfo.get() } },
32203 },
32204 setter: JSPropertySpec_Accessor {
32205 native: JSNativeWrapper { op: None, info: ptr::null() },
32206 }
32207 }
32208 }
32209 }
32210,
32211 JSPropertySpec {
32212 name: JSPropertySpec_Name { string_: c"boolFromSemiExposedPartialInterface".as_ptr() },
32213 attributes_: (JSPROP_ENUMERATE),
32214 kind_: (JSPropertySpec_Kind::NativeAccessor),
32215 u: JSPropertySpec_AccessorsOrValue {
32216 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32217 getter: JSPropertySpec_Accessor {
32218 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { boolFromSemiExposedPartialInterface_getterinfo.get() } },
32219 },
32220 setter: JSPropertySpec_Accessor {
32221 native: JSNativeWrapper { op: None, info: ptr::null() },
32222 }
32223 }
32224 }
32225 }
32226,
32227 JSPropertySpec {
32228 name: JSPropertySpec_Name { string_: c"semiExposedBoolFromPartialInterface".as_ptr() },
32229 attributes_: (JSPROP_ENUMERATE),
32230 kind_: (JSPropertySpec_Kind::NativeAccessor),
32231 u: JSPropertySpec_AccessorsOrValue {
32232 accessors: JSPropertySpec_AccessorsOrValue_Accessors {
32233 getter: JSPropertySpec_Accessor {
32234 native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { semiExposedBoolFromPartialInterface_getterinfo.get() } },
32235 },
32236 setter: JSPropertySpec_Accessor {
32237 native: JSNativeWrapper { op: None, info: ptr::null() },
32238 }
32239 }
32240 }
32241 }
32242,
32243 JSPropertySpec::ZERO]))[..]
32244,
32245&Box::leak(Box::new([
32246 JSPropertySpec {
32247 name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
32248 attributes_: (JSPROP_READONLY),
32249 kind_: (JSPropertySpec_Kind::Value),
32250 u: JSPropertySpec_AccessorsOrValue {
32251 value: JSPropertySpec_ValueWrapper {
32252 type_: JSPropertySpec_ValueWrapper_Type::String,
32253 __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
32254 string: c"TestBinding".as_ptr(),
32255 }
32256 }
32257 }
32258 }
32259,
32260 JSPropertySpec::ZERO]))[..]
32261])));
32262}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();
32263
32264pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
32265 sAttributes.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
32266 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[1]),
32267 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled2_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[2]),
32268 Guard::new(&[Condition::Func(D::TestBinding::condition_unsatisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[3]),
32269 Guard::new(&[Condition::Func(D::TestBinding::condition_satisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[4]),
32270 Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[5]),
32271 Guard::new(&[Condition::Exposed(Globals::WINDOW)], (unsafe { sAttributes_specs.get() })[6]),
32272 Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[7])])));
32273}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();
32274
32275pub(crate) fn init_sConstants_specs<D: DomTypes>() {
32276 sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
32277 ConstantSpec { name: c"constantInt64", value: ConstantVal::Double(-1 as f64) },
32278 ConstantSpec { name: c"constantUint64", value: ConstantVal::Double(1 as f64) },
32279 ConstantSpec { name: c"constantFloat32", value: ConstantVal::Double(1.0 as f64) },
32280 ConstantSpec { name: c"constantFloat64", value: ConstantVal::Double(1.0 as f64) },
32281 ConstantSpec { name: c"constantUnrestrictedFloat32", value: ConstantVal::Double(1.0 as f64) },
32282 ConstantSpec { name: c"constantUnrestrictedFloat64", value: ConstantVal::Double(1.0 as f64) }]))[..]
32283,
32284&Box::leak(Box::new([
32285 ConstantSpec { name: c"prefControlledConstDisabled", value: ConstantVal::Int(0) }]))[..]
32286,
32287&Box::leak(Box::new([
32288 ConstantSpec { name: c"prefControlledConstEnabled", value: ConstantVal::Int(0) }]))[..]
32289,
32290&Box::leak(Box::new([
32291 ConstantSpec { name: c"funcControlledConstDisabled", value: ConstantVal::Int(0) }]))[..]
32292,
32293&Box::leak(Box::new([
32294 ConstantSpec { name: c"funcControlledConstEnabled", value: ConstantVal::Int(0) }]))[..]
32295])));
32296}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();
32297
32298pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
32299 sConstants.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0]),
32300 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[1]),
32301 Guard::new(&[Condition::Pref("dom_testbinding_prefcontrolled2_enabled"),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[2]),
32302 Guard::new(&[Condition::Func(D::TestBinding::condition_unsatisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[3]),
32303 Guard::new(&[Condition::Func(D::TestBinding::condition_satisfied),Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[4])])));
32304}
32305pub fn GetProtoObject<D: DomTypes>
32306(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
32307 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::TestBinding), CreateInterfaceObjects::<D>, rval)
32309}
32310
32311
32312static PrototypeClass: JSClass = JSClass {
32313 name: c"TestBindingPrototype".as_ptr(),
32314 flags:
32315 (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
32317 cOps: ptr::null(),
32318 spec: ptr::null(),
32319 ext: ptr::null(),
32320 oOps: ptr::null(),
32321};
32322
32323unsafe extern "C" fn _constructor<D: DomTypes>
32324(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
32325 let mut result = false;
32326 wrap_panic(&mut || result = {
32327 let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
32328 let args = CallArgs::from_vp(vp, argc);
32329 let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());
32330
32331 call_default_constructor::<D>(
32332 SafeJSContext::from_ptr(cx.raw_cx()),
32333 &args,
32334 &global,
32335 PrototypeList::ID::TestBinding,
32336 "TestBinding",
32337 CreateInterfaceObjects::<D>,
32338 |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {
32339
32340 let argcount = cmp::min(argc, 1);
32341 match argcount {
32342 0 => {
32343 let result: Result<DomRoot<D::TestBinding>, Error> = <D::TestBinding>::Constructor(global, Some(desired_proto), CanGc::note());
32344 let result = match result {
32345 Ok(result) => result,
32346 Err(e) => {
32347 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
32348 return false;
32349 },
32350 };
32351
32352 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
32353 return true;
32354 }
32355 1 => {
32356 if HandleValue::from_raw(args.get(0)).get().is_object() && is_array_like::<D>(cx.raw_cx(), HandleValue::from_raw(args.get(0))) {
32357 let arg0: Vec<f64> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
32358 Ok(ConversionResult::Success(value)) => value,
32359 Ok(ConversionResult::Failure(error)) => {
32360 throw_type_error(cx.raw_cx(), &error);
32361 return false;
32362
32363 }
32364 _ => {
32365 return false;
32366
32367 },
32368 }
32369 ;
32370 let result: Result<DomRoot<D::TestBinding>, Error> = <D::TestBinding>::Constructor_(global, Some(desired_proto), CanGc::note(), arg0);
32371 let result = match result {
32372 Ok(result) => result,
32373 Err(e) => {
32374 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
32375 return false;
32376 },
32377 };
32378
32379 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
32380 return true;
32381 }
32382 let arg0: f64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
32383 Ok(ConversionResult::Success(value)) => value,
32384 Ok(ConversionResult::Failure(error)) => {
32385 throw_type_error(cx.raw_cx(), &error);
32386 return false;
32387
32388 }
32389 _ => {
32390 return false;
32391
32392 },
32393 }
32394 ;
32395 let result: Result<DomRoot<D::TestBinding>, Error> = <D::TestBinding>::Constructor__(global, Some(desired_proto), CanGc::note(), arg0);
32396 let result = match result {
32397 Ok(result) => result,
32398 Err(e) => {
32399 <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), global.upcast::<D::GlobalScope>(), e, CanGc::note());
32400 return false;
32401 },
32402 };
32403
32404 (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
32405 return true;
32406 }
32407 _ => {
32408 throw_type_error(cx.raw_cx(), "Not enough arguments to \"TestBinding.constructor\".");
32409 return false;
32410 }
32411 }
32412 }
32413 )
32414
32415 });
32416 result
32417}
32418
32419
32420static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();
32421
32422pub(crate) fn init_interface_object<D: DomTypes>() {
32423 INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
32424 Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
32425 b"function TestBinding() {\n [native code]\n}",
32426 PrototypeList::ID::TestBinding,
32427 0,
32428 ));
32429}
32430
32431pub fn GetConstructorObject<D: DomTypes>
32432(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
32433 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::TestBinding), CreateInterfaceObjects::<D>, rval)
32435}
32436
32437pub fn DefineDOMInterface<D: DomTypes>
32438(cx: SafeJSContext, global: HandleObject){
32439 define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::TestBinding),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
32440}
32441
32442pub fn ConstructorEnabled<D: DomTypes>
32443(aCx: SafeJSContext, aObj: HandleObject) -> bool{
32444 is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
32445 pref!(dom_testbinding_enabled)
32446}
32447
32448unsafe fn CreateInterfaceObjects<D: DomTypes>
32449(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
32450
32451 rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
32452 prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
32453 assert!(!prototype_proto.is_null());
32454
32455 rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
32456 create_interface_prototype_object::<D>(cx,
32457 global,
32458 prototype_proto.handle(),
32459 &PrototypeClass,
32460 sMethods.get(),
32461 sAttributes.get(),
32462 sConstants.get(),
32463 &[],
32464 prototype.handle_mut());
32465 assert!(!prototype.is_null());
32466 assert!((*cache)[PrototypeList::ID::TestBinding as usize].is_null());
32467 (*cache)[PrototypeList::ID::TestBinding as usize] = prototype.get();
32468 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::TestBinding as isize),
32469 ptr::null_mut(),
32470 prototype.get());
32471
32472 rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
32473 interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));
32474
32475 assert!(!interface_proto.is_null());
32476
32477 rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
32478 create_noncallback_interface_object::<D>(cx,
32479 global,
32480 interface_proto.handle(),
32481 INTERFACE_OBJECT_CLASS.get(),
32482 sStaticMethods.get(),
32483 sStaticAttributes.get(),
32484 sConstants.get(),
32485 prototype.handle(),
32486 c"TestBinding",
32487 0,
32488 &[],
32489 interface.handle_mut());
32490 assert!(!interface.is_null());
32491
32492 assert!((*cache)[PrototypeList::Constructor::TestBinding as usize].is_null());
32493 (*cache)[PrototypeList::Constructor::TestBinding as usize] = interface.get();
32494 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::TestBinding as isize),
32495 ptr::null_mut(),
32496 interface.get());
32497
32498}
32499
32500
32501 pub(crate) fn init_statics<D: DomTypes>() {
32502 init_interface_object::<D>();
32503 init_domjs_class::<D>();
32504 crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_methToBinaryRename_methodinfo::<D>();
32505crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveVoid_methodinfo::<D>();
32506crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveBoolean_methodinfo::<D>();
32507crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveByte_methodinfo::<D>();
32508crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveOctet_methodinfo::<D>();
32509crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveShort_methodinfo::<D>();
32510crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnsignedShort_methodinfo::<D>();
32511crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveLong_methodinfo::<D>();
32512crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnsignedLong_methodinfo::<D>();
32513crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveLongLong_methodinfo::<D>();
32514crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnsignedLongLong_methodinfo::<D>();
32515crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnrestrictedFloat_methodinfo::<D>();
32516crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveFloat_methodinfo::<D>();
32517crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnrestrictedDouble_methodinfo::<D>();
32518crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveDouble_methodinfo::<D>();
32519crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveString_methodinfo::<D>();
32520crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUsvstring_methodinfo::<D>();
32521crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveByteString_methodinfo::<D>();
32522crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveEnum_methodinfo::<D>();
32523crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveInterface_methodinfo::<D>();
32524crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveAny_methodinfo::<D>();
32525crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveObject_methodinfo::<D>();
32526crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion_methodinfo::<D>();
32527crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion2_methodinfo::<D>();
32528crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion3_methodinfo::<D>();
32529crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion4_methodinfo::<D>();
32530crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion5_methodinfo::<D>();
32531crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion6_methodinfo::<D>();
32532crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion7_methodinfo::<D>();
32533crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion8_methodinfo::<D>();
32534crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion9_methodinfo::<D>();
32535crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion10_methodinfo::<D>();
32536crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnion11_methodinfo::<D>();
32537crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveSequence_methodinfo::<D>();
32538crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveInterfaceSequence_methodinfo::<D>();
32539crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableByte_methodinfo::<D>();
32540crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableBoolean_methodinfo::<D>();
32541crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableOctet_methodinfo::<D>();
32542crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableShort_methodinfo::<D>();
32543crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnsignedShort_methodinfo::<D>();
32544crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableLong_methodinfo::<D>();
32545crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnsignedLong_methodinfo::<D>();
32546crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableLongLong_methodinfo::<D>();
32547crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnsignedLongLong_methodinfo::<D>();
32548crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnrestrictedFloat_methodinfo::<D>();
32549crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableFloat_methodinfo::<D>();
32550crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnrestrictedDouble_methodinfo::<D>();
32551crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableDouble_methodinfo::<D>();
32552crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableString_methodinfo::<D>();
32553crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUsvstring_methodinfo::<D>();
32554crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableByteString_methodinfo::<D>();
32555crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableEnum_methodinfo::<D>();
32556crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableInterface_methodinfo::<D>();
32557crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableObject_methodinfo::<D>();
32558crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion_methodinfo::<D>();
32559crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion2_methodinfo::<D>();
32560crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion3_methodinfo::<D>();
32561crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion4_methodinfo::<D>();
32562crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion5_methodinfo::<D>();
32563crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableUnion6_methodinfo::<D>();
32564crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableSequence_methodinfo::<D>();
32565crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveTestDictionaryWithSuccessOnKeyword_methodinfo::<D>();
32566crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_dictMatchesPassedValues_methodinfo::<D>();
32567crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveUnionIdentity_methodinfo::<D>();
32568crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passBoolean_methodinfo::<D>();
32569crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passByte_methodinfo::<D>();
32570crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOctet_methodinfo::<D>();
32571crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passShort_methodinfo::<D>();
32572crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnsignedShort_methodinfo::<D>();
32573crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passLong_methodinfo::<D>();
32574crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnsignedLong_methodinfo::<D>();
32575crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passLongLong_methodinfo::<D>();
32576crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnsignedLongLong_methodinfo::<D>();
32577crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnrestrictedFloat_methodinfo::<D>();
32578crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passFloat_methodinfo::<D>();
32579crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnrestrictedDouble_methodinfo::<D>();
32580crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passDouble_methodinfo::<D>();
32581crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passString_methodinfo::<D>();
32582crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUsvstring_methodinfo::<D>();
32583crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passByteString_methodinfo::<D>();
32584crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passEnum_methodinfo::<D>();
32585crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passInterface_methodinfo::<D>();
32586crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passTypedArray_methodinfo::<D>();
32587crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passTypedArray2_methodinfo::<D>();
32588crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passTypedArray3_methodinfo::<D>();
32589crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion_methodinfo::<D>();
32590crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion2_methodinfo::<D>();
32591crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion3_methodinfo::<D>();
32592crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion4_methodinfo::<D>();
32593crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion5_methodinfo::<D>();
32594crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion6_methodinfo::<D>();
32595crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion7_methodinfo::<D>();
32596crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion8_methodinfo::<D>();
32597crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion9_methodinfo::<D>();
32598crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion10_methodinfo::<D>();
32599crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnion11_methodinfo::<D>();
32600crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnionWithTypedef_methodinfo::<D>();
32601crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnionWithTypedef2_methodinfo::<D>();
32602crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passAny_methodinfo::<D>();
32603crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passObject_methodinfo::<D>();
32604crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passCallbackFunction_methodinfo::<D>();
32605crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passCallbackInterface_methodinfo::<D>();
32606crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passSequence_methodinfo::<D>();
32607crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passAnySequence_methodinfo::<D>();
32608crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_anySequencePassthrough_methodinfo::<D>();
32609crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passObjectSequence_methodinfo::<D>();
32610crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passStringSequence_methodinfo::<D>();
32611crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passInterfaceSequence_methodinfo::<D>();
32612crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOverloaded_methodinfo::<D>();
32613crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOverloadedDict_methodinfo::<D>();
32614crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableBoolean_methodinfo::<D>();
32615crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableByte_methodinfo::<D>();
32616crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableOctet_methodinfo::<D>();
32617crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableShort_methodinfo::<D>();
32618crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnsignedShort_methodinfo::<D>();
32619crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableLong_methodinfo::<D>();
32620crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnsignedLong_methodinfo::<D>();
32621crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableLongLong_methodinfo::<D>();
32622crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnsignedLongLong_methodinfo::<D>();
32623crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnrestrictedFloat_methodinfo::<D>();
32624crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableFloat_methodinfo::<D>();
32625crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnrestrictedDouble_methodinfo::<D>();
32626crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableDouble_methodinfo::<D>();
32627crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableString_methodinfo::<D>();
32628crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUsvstring_methodinfo::<D>();
32629crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableByteString_methodinfo::<D>();
32630crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableInterface_methodinfo::<D>();
32631crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableObject_methodinfo::<D>();
32632crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableTypedArray_methodinfo::<D>();
32633crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion_methodinfo::<D>();
32634crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion2_methodinfo::<D>();
32635crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion3_methodinfo::<D>();
32636crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion4_methodinfo::<D>();
32637crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion5_methodinfo::<D>();
32638crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableUnion6_methodinfo::<D>();
32639crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableCallbackFunction_methodinfo::<D>();
32640crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableCallbackInterface_methodinfo::<D>();
32641crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableSequence_methodinfo::<D>();
32642crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalBoolean_methodinfo::<D>();
32643crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalByte_methodinfo::<D>();
32644crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalOctet_methodinfo::<D>();
32645crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalShort_methodinfo::<D>();
32646crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedShort_methodinfo::<D>();
32647crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalLong_methodinfo::<D>();
32648crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedLong_methodinfo::<D>();
32649crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalLongLong_methodinfo::<D>();
32650crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedLongLong_methodinfo::<D>();
32651crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnrestrictedFloat_methodinfo::<D>();
32652crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalFloat_methodinfo::<D>();
32653crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnrestrictedDouble_methodinfo::<D>();
32654crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalDouble_methodinfo::<D>();
32655crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalString_methodinfo::<D>();
32656crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUsvstring_methodinfo::<D>();
32657crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalByteString_methodinfo::<D>();
32658crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalEnum_methodinfo::<D>();
32659crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalInterface_methodinfo::<D>();
32660crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion_methodinfo::<D>();
32661crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion2_methodinfo::<D>();
32662crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion3_methodinfo::<D>();
32663crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion4_methodinfo::<D>();
32664crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion5_methodinfo::<D>();
32665crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnion6_methodinfo::<D>();
32666crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalAny_methodinfo::<D>();
32667crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalObject_methodinfo::<D>();
32668crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalCallbackFunction_methodinfo::<D>();
32669crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalCallbackInterface_methodinfo::<D>();
32670crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalSequence_methodinfo::<D>();
32671crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableBoolean_methodinfo::<D>();
32672crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableByte_methodinfo::<D>();
32673crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableOctet_methodinfo::<D>();
32674crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableShort_methodinfo::<D>();
32675crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedShort_methodinfo::<D>();
32676crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLong_methodinfo::<D>();
32677crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLong_methodinfo::<D>();
32678crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLongLong_methodinfo::<D>();
32679crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLongLong_methodinfo::<D>();
32680crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnrestrictedFloat_methodinfo::<D>();
32681crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableFloat_methodinfo::<D>();
32682crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnrestrictedDouble_methodinfo::<D>();
32683crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableDouble_methodinfo::<D>();
32684crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableString_methodinfo::<D>();
32685crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUsvstring_methodinfo::<D>();
32686crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableByteString_methodinfo::<D>();
32687crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableInterface_methodinfo::<D>();
32688crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableObject_methodinfo::<D>();
32689crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion_methodinfo::<D>();
32690crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion2_methodinfo::<D>();
32691crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion3_methodinfo::<D>();
32692crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion4_methodinfo::<D>();
32693crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion5_methodinfo::<D>();
32694crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion6_methodinfo::<D>();
32695crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableCallbackFunction_methodinfo::<D>();
32696crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableCallbackInterface_methodinfo::<D>();
32697crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableSequence_methodinfo::<D>();
32698crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalBooleanWithDefault_methodinfo::<D>();
32699crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalByteWithDefault_methodinfo::<D>();
32700crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalOctetWithDefault_methodinfo::<D>();
32701crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalShortWithDefault_methodinfo::<D>();
32702crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedShortWithDefault_methodinfo::<D>();
32703crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalLongWithDefault_methodinfo::<D>();
32704crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedLongWithDefault_methodinfo::<D>();
32705crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalLongLongWithDefault_methodinfo::<D>();
32706crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUnsignedLongLongWithDefault_methodinfo::<D>();
32707crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalBytestringWithDefault_methodinfo::<D>();
32708crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalStringWithDefault_methodinfo::<D>();
32709crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalUsvstringWithDefault_methodinfo::<D>();
32710crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalEnumWithDefault_methodinfo::<D>();
32711crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalSequenceWithDefault_methodinfo::<D>();
32712crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableBooleanWithDefault_methodinfo::<D>();
32713crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableByteWithDefault_methodinfo::<D>();
32714crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableOctetWithDefault_methodinfo::<D>();
32715crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableShortWithDefault_methodinfo::<D>();
32716crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedShortWithDefault_methodinfo::<D>();
32717crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLongWithDefault_methodinfo::<D>();
32718crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLongWithDefault_methodinfo::<D>();
32719crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLongLongWithDefault_methodinfo::<D>();
32720crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLongLongWithDefault_methodinfo::<D>();
32721crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableStringWithDefault_methodinfo::<D>();
32722crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUsvstringWithDefault_methodinfo::<D>();
32723crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableByteStringWithDefault_methodinfo::<D>();
32724crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableInterfaceWithDefault_methodinfo::<D>();
32725crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableObjectWithDefault_methodinfo::<D>();
32726crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnionWithDefault_methodinfo::<D>();
32727crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnion2WithDefault_methodinfo::<D>();
32728crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableCallbackInterfaceWithDefault_methodinfo::<D>();
32729crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalAnyWithDefault_methodinfo::<D>();
32730crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableBooleanWithNonNullDefault_methodinfo::<D>();
32731crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableByteWithNonNullDefault_methodinfo::<D>();
32732crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableOctetWithNonNullDefault_methodinfo::<D>();
32733crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableShortWithNonNullDefault_methodinfo::<D>();
32734crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedShortWithNonNullDefault_methodinfo::<D>();
32735crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLongWithNonNullDefault_methodinfo::<D>();
32736crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLongWithNonNullDefault_methodinfo::<D>();
32737crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableLongLongWithNonNullDefault_methodinfo::<D>();
32738crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUnsignedLongLongWithNonNullDefault_methodinfo::<D>();
32739crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableStringWithNonNullDefault_methodinfo::<D>();
32740crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableUsvstringWithNonNullDefault_methodinfo::<D>();
32741crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalOverloaded_methodinfo::<D>();
32742crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicBoolean_methodinfo::<D>();
32743crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicBooleanAndDefault_methodinfo::<D>();
32744crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicByte_methodinfo::<D>();
32745crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicOctet_methodinfo::<D>();
32746crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicShort_methodinfo::<D>();
32747crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnsignedShort_methodinfo::<D>();
32748crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicLong_methodinfo::<D>();
32749crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnsignedLong_methodinfo::<D>();
32750crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicLongLong_methodinfo::<D>();
32751crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnsignedLongLong_methodinfo::<D>();
32752crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnrestrictedFloat_methodinfo::<D>();
32753crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicFloat_methodinfo::<D>();
32754crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnrestrictedDouble_methodinfo::<D>();
32755crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicDouble_methodinfo::<D>();
32756crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicString_methodinfo::<D>();
32757crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUsvstring_methodinfo::<D>();
32758crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicByteString_methodinfo::<D>();
32759crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicEnum_methodinfo::<D>();
32760crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicInterface_methodinfo::<D>();
32761crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion_methodinfo::<D>();
32762crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion2_methodinfo::<D>();
32763crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion3_methodinfo::<D>();
32764crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion4_methodinfo::<D>();
32765crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion5_methodinfo::<D>();
32766crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion6_methodinfo::<D>();
32767crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicUnion7_methodinfo::<D>();
32768crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicAny_methodinfo::<D>();
32769crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passVariadicObject_methodinfo::<D>();
32770crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passSequenceSequence_methodinfo::<D>();
32771crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_returnSequenceSequence_methodinfo::<D>();
32772crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passUnionSequenceSequence_methodinfo::<D>();
32773crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordPromise_methodinfo::<D>();
32774crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecord_methodinfo::<D>();
32775crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordWithUSVStringKey_methodinfo::<D>();
32776crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordWithByteStringKey_methodinfo::<D>();
32777crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableRecord_methodinfo::<D>();
32778crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordOfNullableInts_methodinfo::<D>();
32779crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalRecordOfNullableInts_methodinfo::<D>();
32780crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableRecordOfNullableInts_methodinfo::<D>();
32781crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passCastableObjectRecord_methodinfo::<D>();
32782crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableCastableObjectRecord_methodinfo::<D>();
32783crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passCastableObjectNullableRecord_methodinfo::<D>();
32784crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passNullableCastableObjectNullableRecord_methodinfo::<D>();
32785crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalRecord_methodinfo::<D>();
32786crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableRecord_methodinfo::<D>();
32787crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalNullableRecordWithDefaultValue_methodinfo::<D>();
32788crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passOptionalObjectRecord_methodinfo::<D>();
32789crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passStringRecord_methodinfo::<D>();
32790crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passByteStringRecord_methodinfo::<D>();
32791crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordOfRecords_methodinfo::<D>();
32792crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordUnion_methodinfo::<D>();
32793crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordUnion2_methodinfo::<D>();
32794crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_passRecordUnion3_methodinfo::<D>();
32795crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveRecord_methodinfo::<D>();
32796crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveRecordWithUSVStringKey_methodinfo::<D>();
32797crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveRecordWithByteStringKey_methodinfo::<D>();
32798crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableRecord_methodinfo::<D>();
32799crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveRecordOfNullableInts_methodinfo::<D>();
32800crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveNullableRecordOfNullableInts_methodinfo::<D>();
32801crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveRecordOfRecords_methodinfo::<D>();
32802crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_receiveAnyRecord_methodinfo::<D>();
32803crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_BooleanMozPreference_methodinfo::<D>();
32804crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_StringMozPreference_methodinfo::<D>();
32805crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_prefControlledMethodDisabled_methodinfo::<D>();
32806crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_advanceClock_methodinfo::<D>();
32807crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_prefControlledMethodEnabled_methodinfo::<D>();
32808crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_funcControlledMethodDisabled_methodinfo::<D>();
32809crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_funcControlledMethodEnabled_methodinfo::<D>();
32810crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_returnResolvedPromise_methodinfo::<D>();
32811crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_returnRejectedPromise_methodinfo::<D>();
32812crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_acceptPromise_methodinfo::<D>();
32813crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_promiseNativeHandler_methodinfo::<D>();
32814crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_promiseResolveNative_methodinfo::<D>();
32815crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_promiseRejectNative_methodinfo::<D>();
32816crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_promiseRejectWithTypeError_methodinfo::<D>();
32817crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_resolvePromiseDelayed_methodinfo::<D>();
32818crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_staticThrowToRejectPromise_methodinfo::<D>();
32819crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_methodThrowToRejectPromise_methodinfo::<D>();
32820crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_staticInternalThrowToRejectPromise_methodinfo::<D>();
32821crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_methodInternalThrowToRejectPromise_methodinfo::<D>();
32822crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_panic_methodinfo::<D>();
32823crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_entryGlobal_methodinfo::<D>();
32824crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_incumbentGlobal_methodinfo::<D>();
32825crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_getDictionaryWithParent_methodinfo::<D>();
32826crate::codegen::GenericBindings::TestBindingBinding::TestBinding_Binding::init_crashHard_methodinfo::<D>();
32827 init_booleanAttribute_getterinfo::<D>();
32828init_byteAttribute_getterinfo::<D>();
32829init_octetAttribute_getterinfo::<D>();
32830init_shortAttribute_getterinfo::<D>();
32831init_unsignedShortAttribute_getterinfo::<D>();
32832init_longAttribute_getterinfo::<D>();
32833init_unsignedLongAttribute_getterinfo::<D>();
32834init_longLongAttribute_getterinfo::<D>();
32835init_unsignedLongLongAttribute_getterinfo::<D>();
32836init_unrestrictedFloatAttribute_getterinfo::<D>();
32837init_floatAttribute_getterinfo::<D>();
32838init_unrestrictedDoubleAttribute_getterinfo::<D>();
32839init_doubleAttribute_getterinfo::<D>();
32840init_stringAttribute_getterinfo::<D>();
32841init_usvstringAttribute_getterinfo::<D>();
32842init_byteStringAttribute_getterinfo::<D>();
32843init_enumAttribute_getterinfo::<D>();
32844init_interfaceAttribute_getterinfo::<D>();
32845init_unionAttribute_getterinfo::<D>();
32846init_union2Attribute_getterinfo::<D>();
32847init_union3Attribute_getterinfo::<D>();
32848init_union4Attribute_getterinfo::<D>();
32849init_union5Attribute_getterinfo::<D>();
32850init_union6Attribute_getterinfo::<D>();
32851init_union7Attribute_getterinfo::<D>();
32852init_union8Attribute_getterinfo::<D>();
32853init_union9Attribute_getterinfo::<D>();
32854init_arrayAttribute_getterinfo::<D>();
32855init_anyAttribute_getterinfo::<D>();
32856init_objectAttribute_getterinfo::<D>();
32857init_booleanAttributeNullable_getterinfo::<D>();
32858init_byteAttributeNullable_getterinfo::<D>();
32859init_octetAttributeNullable_getterinfo::<D>();
32860init_shortAttributeNullable_getterinfo::<D>();
32861init_unsignedShortAttributeNullable_getterinfo::<D>();
32862init_longAttributeNullable_getterinfo::<D>();
32863init_unsignedLongAttributeNullable_getterinfo::<D>();
32864init_longLongAttributeNullable_getterinfo::<D>();
32865init_unsignedLongLongAttributeNullable_getterinfo::<D>();
32866init_unrestrictedFloatAttributeNullable_getterinfo::<D>();
32867init_floatAttributeNullable_getterinfo::<D>();
32868init_unrestrictedDoubleAttributeNullable_getterinfo::<D>();
32869init_doubleAttributeNullable_getterinfo::<D>();
32870init_stringAttributeNullable_getterinfo::<D>();
32871init_usvstringAttributeNullable_getterinfo::<D>();
32872init_byteStringAttributeNullable_getterinfo::<D>();
32873init_enumAttributeNullable_getterinfo::<D>();
32874init_interfaceAttributeNullable_getterinfo::<D>();
32875init_interfaceAttributeWeak_getterinfo::<D>();
32876init_objectAttributeNullable_getterinfo::<D>();
32877init_unionAttributeNullable_getterinfo::<D>();
32878init_union2AttributeNullable_getterinfo::<D>();
32879init_union3AttributeNullable_getterinfo::<D>();
32880init_union4AttributeNullable_getterinfo::<D>();
32881init_union5AttributeNullable_getterinfo::<D>();
32882init_union6AttributeNullable_getterinfo::<D>();
32883init_attrToBinaryRename_getterinfo::<D>();
32884init_attr_to_binary_rename_getterinfo::<D>();
32885init_attr_to_automatically_rename_getterinfo::<D>();
32886init_forwardedAttribute_getterinfo::<D>();
32887init_prefControlledAttributeDisabled_getterinfo::<D>();
32888init_prefControlledAttributeEnabled_getterinfo::<D>();
32889init_funcControlledAttributeDisabled_getterinfo::<D>();
32890init_funcControlledAttributeEnabled_getterinfo::<D>();
32891init_promiseAttribute_getterinfo::<D>();
32892init_getterThrowToRejectPromise_getterinfo::<D>();
32893init_semiExposedBoolFromInterface_getterinfo::<D>();
32894init_boolFromSemiExposedPartialInterface_getterinfo::<D>();
32895init_semiExposedBoolFromPartialInterface_getterinfo::<D>();
32896 init_booleanAttribute_setterinfo::<D>();
32897init_byteAttribute_setterinfo::<D>();
32898init_octetAttribute_setterinfo::<D>();
32899init_shortAttribute_setterinfo::<D>();
32900init_unsignedShortAttribute_setterinfo::<D>();
32901init_longAttribute_setterinfo::<D>();
32902init_unsignedLongAttribute_setterinfo::<D>();
32903init_longLongAttribute_setterinfo::<D>();
32904init_unsignedLongLongAttribute_setterinfo::<D>();
32905init_unrestrictedFloatAttribute_setterinfo::<D>();
32906init_floatAttribute_setterinfo::<D>();
32907init_unrestrictedDoubleAttribute_setterinfo::<D>();
32908init_doubleAttribute_setterinfo::<D>();
32909init_stringAttribute_setterinfo::<D>();
32910init_usvstringAttribute_setterinfo::<D>();
32911init_byteStringAttribute_setterinfo::<D>();
32912init_enumAttribute_setterinfo::<D>();
32913init_interfaceAttribute_setterinfo::<D>();
32914init_unionAttribute_setterinfo::<D>();
32915init_union2Attribute_setterinfo::<D>();
32916init_union3Attribute_setterinfo::<D>();
32917init_union4Attribute_setterinfo::<D>();
32918init_union5Attribute_setterinfo::<D>();
32919init_union6Attribute_setterinfo::<D>();
32920init_union7Attribute_setterinfo::<D>();
32921init_union8Attribute_setterinfo::<D>();
32922init_union9Attribute_setterinfo::<D>();
32923init_anyAttribute_setterinfo::<D>();
32924init_objectAttribute_setterinfo::<D>();
32925init_booleanAttributeNullable_setterinfo::<D>();
32926init_byteAttributeNullable_setterinfo::<D>();
32927init_octetAttributeNullable_setterinfo::<D>();
32928init_shortAttributeNullable_setterinfo::<D>();
32929init_unsignedShortAttributeNullable_setterinfo::<D>();
32930init_longAttributeNullable_setterinfo::<D>();
32931init_unsignedLongAttributeNullable_setterinfo::<D>();
32932init_longLongAttributeNullable_setterinfo::<D>();
32933init_unsignedLongLongAttributeNullable_setterinfo::<D>();
32934init_unrestrictedFloatAttributeNullable_setterinfo::<D>();
32935init_floatAttributeNullable_setterinfo::<D>();
32936init_unrestrictedDoubleAttributeNullable_setterinfo::<D>();
32937init_doubleAttributeNullable_setterinfo::<D>();
32938init_stringAttributeNullable_setterinfo::<D>();
32939init_usvstringAttributeNullable_setterinfo::<D>();
32940init_byteStringAttributeNullable_setterinfo::<D>();
32941init_interfaceAttributeNullable_setterinfo::<D>();
32942init_interfaceAttributeWeak_setterinfo::<D>();
32943init_objectAttributeNullable_setterinfo::<D>();
32944init_unionAttributeNullable_setterinfo::<D>();
32945init_union2AttributeNullable_setterinfo::<D>();
32946init_union3AttributeNullable_setterinfo::<D>();
32947init_union4AttributeNullable_setterinfo::<D>();
32948init_union5AttributeNullable_setterinfo::<D>();
32949init_union6AttributeNullable_setterinfo::<D>();
32950init_attrToBinaryRename_setterinfo::<D>();
32951init_attr_to_binary_rename_setterinfo::<D>();
32952init_attr_to_automatically_rename_setterinfo::<D>();
32953init_forwardedAttribute_setterinfo::<D>();
32954
32955 init_sStaticMethods_specs::<D>();
32956init_sStaticMethods_prefs::<D>();
32957init_sStaticAttributes_specs::<D>();
32958init_sStaticAttributes_prefs::<D>();
32959init_sMethods_specs::<D>();
32960init_sMethods_prefs::<D>();
32961init_sAttributes_specs::<D>();
32962init_sAttributes_prefs::<D>();
32963init_sConstants_specs::<D>();
32964init_sConstants_prefs::<D>();
32965 }
32966 } pub use self::TestNS_Binding::{TestNSConstants, GetConstructorObject as TestNSGetConstructorObject, DefineDOMInterface as TestNSDefineDOMInterface};
32970pub mod TestNS_Binding {
32971use crate::import::module::*;
32972
32973pub mod TestNSConstants {
32974 pub const ONE: u32 = 1;
32975 pub const TWO: u32 = 2;
32976} pub trait TestNSMethods<D: DomTypes> {
32978}
32979static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();
32980
32981pub(crate) fn init_sConstants_specs<D: DomTypes>() {
32982 sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
32983 ConstantSpec { name: c"ONE", value: ConstantVal::Uint(1) },
32984 ConstantSpec { name: c"TWO", value: ConstantVal::Uint(2) }]))[..]
32985])));
32986}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();
32987
32988pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
32989 sConstants.set(Box::leak(Box::new([ Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
32990}
32991
32992static NAMESPACE_OBJECT_CLASS: NamespaceObjectClass = unsafe {
32993 NamespaceObjectClass::new(c"Object")
32994};
32995
32996pub fn GetConstructorObject<D: DomTypes>
32997(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
32998 get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::TestNS), CreateInterfaceObjects::<D>, rval)
33000}
33001
33002pub fn DefineDOMInterface<D: DomTypes>
33003(cx: SafeJSContext, global: HandleObject){
33004 define_dom_interface(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::TestNS),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
33005}
33006
33007pub fn ConstructorEnabled<D: DomTypes>
33008(aCx: SafeJSContext, aObj: HandleObject) -> bool{
33009 is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
33010 pref!(dom_testbinding_enabled)
33011}
33012
33013unsafe fn CreateInterfaceObjects<D: DomTypes>
33014(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){
33015
33016 rooted!(&in(cx) let proto = JS_NewPlainObject(cx.raw_cx()));
33017 assert!(!proto.is_null());
33018 rooted!(&in(cx) let mut namespace = ptr::null_mut::<JSObject>());
33019 create_namespace_object::<D>(cx, global, proto.handle(), &NAMESPACE_OBJECT_CLASS,
33020 &[], sConstants.get(), c"TestNS", namespace.handle_mut());
33021 assert!(!namespace.is_null());
33022 assert!((*cache)[PrototypeList::Constructor::TestNS as usize].is_null());
33023 (*cache)[PrototypeList::Constructor::TestNS as usize] = namespace.get();
33024 <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::TestNS as isize),
33025 ptr::null_mut(),
33026 namespace.get());
33027
33028}
33029
33030
33031 pub(crate) fn init_statics<D: DomTypes>() {
33032
33033
33034
33035
33036
33037
33038 init_sConstants_specs::<D>();
33039init_sConstants_prefs::<D>();
33040 }
33041 }