Debian Codegraph @

.cargo/vendor/wasm-bindgen/tests/wasm/classes.rs

raw
1 #[allow(unused_imports)] // test for #919
2 use std::borrow::BorrowMut;
3
4 use wasm_bindgen::prelude::*;
5 use wasm_bindgen_test::*;
6
7 #[wasm_bindgen(module = "tests/wasm/classes.js")]
8 extern "C" {
9 fn js_simple();
10 fn js_strings();
11 fn js_exceptions();
12 fn js_pass_one_to_another();
13 fn take_class(foo: ClassesIntoJs);
14 #[wasm_bindgen(js_name = take_class)]
15 fn take_class_as_jsvalue(foo: JsValue);
16 fn js_constructors();
17 fn js_empty_structs();
18 fn js_public_fields();
19 fn js_getter_with_clone();
20 fn js_using_self();
21 fn js_readonly_fields();
22 fn js_double_consume();
23 fn js_js_rename();
24 fn js_access_fields();
25 fn js_renamed_export();
26 fn js_renamed_field();
27 fn js_conditional_bindings();
28
29 fn js_assert_none(a: Option<OptionClass>);
30 fn js_assert_some(a: Option<OptionClass>);
31 fn js_return_none1() -> Option<OptionClass>;
32 fn js_return_none2() -> Option<OptionClass>;
33 fn js_return_some(a: OptionClass) -> Option<OptionClass>;
34 fn js_test_option_classes();
35 fn js_test_inspectable_classes();
36 fn js_test_inspectable_classes_can_override_generated_methods();
37 fn js_test_class_defined_in_macro();
38 }
39
40 #[wasm_bindgen_test]
41 fn simple() {
42 js_simple();
43 }
44
45 #[wasm_bindgen]
46 pub struct ClassesSimple {
47 contents: u32,
48 }
49
50 #[wasm_bindgen]
51 impl ClassesSimple {
52 #[wasm_bindgen(constructor)]
53 pub fn new() -> ClassesSimple {
54 ClassesSimple::with_contents(0)
55 }
56
57 pub fn with_contents(a: u32) -> ClassesSimple {
58 ClassesSimple { contents: a }
59 }
60
61 pub fn add(&mut self, amt: u32) -> u32 {
62 self.contents += amt;
63 self.contents
64 }
65
66 pub fn consume(self) -> u32 {
67 self.contents
68 }
69 }
70
71 #[wasm_bindgen_test]
72 fn strings() {
73 js_strings()
74 }
75
76 #[wasm_bindgen]
77 pub struct ClassesStrings1 {
78 name: u32,
79 }
80
81 #[wasm_bindgen]
82 pub struct ClassesStrings2 {
83 contents: String,
84 }
85
86 #[wasm_bindgen]
87 impl ClassesStrings1 {
88 pub fn new() -> ClassesStrings1 {
89 ClassesStrings1 { name: 0 }
90 }
91
92 pub fn set(&mut self, amt: u32) {
93 self.name = amt;
94 }
95
96 pub fn bar(&self, mix: &str) -> ClassesStrings2 {
97 ClassesStrings2 {
98 contents: format!("foo-{}-{}", mix, self.name),
99 }
100 }
101 }
102
103 #[wasm_bindgen]
104 impl ClassesStrings2 {
105 pub fn name(&self) -> String {
106 self.contents.clone()
107 }
108 }
109
110 #[wasm_bindgen_test]
111 fn exceptions() {
112 js_exceptions();
113 }
114
115 #[wasm_bindgen]
116 pub struct ClassesExceptions1 {}
117
118 #[wasm_bindgen]
119 impl ClassesExceptions1 {
120 pub fn new() -> ClassesExceptions1 {
121 ClassesExceptions1 {}
122 }
123
124 pub fn foo(&self, _: &ClassesExceptions1) {}
125
126 pub fn bar(&mut self, _: &mut ClassesExceptions1) {}
127 }
128
129 #[wasm_bindgen]
130 pub struct ClassesExceptions2 {}
131
132 #[wasm_bindgen]
133 impl ClassesExceptions2 {
134 pub fn new() -> ClassesExceptions2 {
135 ClassesExceptions2 {}
136 }
137 }
138
139 #[wasm_bindgen_test]
140 fn pass_one_to_another() {
141 js_pass_one_to_another();
142 }
143
144 #[wasm_bindgen]
145 pub struct ClassesPassA {}
146
147 #[wasm_bindgen]
148 impl ClassesPassA {
149 pub fn new() -> ClassesPassA {
150 ClassesPassA {}
151 }
152
153 pub fn foo(&self, _other: &ClassesPassB) {}
154
155 pub fn bar(&self, _other: ClassesPassB) {}
156 }
157
158 #[wasm_bindgen]
159 pub struct ClassesPassB {}
160
161 #[wasm_bindgen]
162 impl ClassesPassB {
163 pub fn new() -> ClassesPassB {
164 ClassesPassB {}
165 }
166 }
167
168 #[wasm_bindgen_test]
169 fn pass_into_js() {
170 take_class(ClassesIntoJs(13));
171 }
172
173 #[wasm_bindgen]
174 pub struct ClassesIntoJs(i32);
175
176 #[wasm_bindgen]
177 impl ClassesIntoJs {
178 pub fn inner(&self) -> i32 {
179 self.0
180 }
181 }
182
183 #[wasm_bindgen]
184 pub struct Issue27Context {}
185
186 #[wasm_bindgen]
187 impl Issue27Context {
188 pub fn parse(&self, _expr: &str) -> Issue27Expr {
189 panic!()
190 }
191 pub fn eval(&self, _expr: &Issue27Expr) -> f64 {
192 panic!()
193 }
194 pub fn set(&mut self, _var: &str, _val: f64) {
195 panic!()
196 }
197 }
198
199 #[wasm_bindgen]
200 pub struct Issue27Expr {}
201
202 #[wasm_bindgen_test]
203 fn pass_into_js_as_js_class() {
204 take_class_as_jsvalue(ClassesIntoJs(13).into());
205 }
206
207 #[wasm_bindgen_test]
208 fn constructors() {
209 js_constructors();
210 }
211
212 #[wasm_bindgen]
213 pub fn cross_item_construction() -> ConstructorsBar {
214 ConstructorsBar::other_name(7, 8)
215 }
216
217 #[wasm_bindgen]
218 pub struct ConstructorsFoo {
219 number: u32,
220 }
221
222 #[wasm_bindgen]
223 impl ConstructorsFoo {
224 #[wasm_bindgen(constructor)]
225 pub fn new(number: u32) -> ConstructorsFoo {
226 ConstructorsFoo { number }
227 }
228
229 pub fn get_number(&self) -> u32 {
230 self.number
231 }
232 }
233
234 #[wasm_bindgen]
235 pub struct ConstructorsBar {
236 number: u32,
237 number2: u32,
238 }
239
240 #[wasm_bindgen]
241 impl ConstructorsBar {
242 #[wasm_bindgen(constructor)]
243 pub fn other_name(number: u32, number2: u32) -> ConstructorsBar {
244 ConstructorsBar { number, number2 }
245 }
246
247 pub fn get_sum(&self) -> u32 {
248 self.number + self.number2
249 }
250 }
251
252 #[wasm_bindgen_test]
253 fn empty_structs() {
254 js_empty_structs();
255 }
256
257 #[wasm_bindgen]
258 pub struct MissingClass {}
259
260 #[wasm_bindgen]
261 pub struct OtherEmpty {}
262
263 #[wasm_bindgen]
264 impl OtherEmpty {
265 pub fn return_a_value() -> MissingClass {
266 MissingClass {}
267 }
268 }
269
270 #[wasm_bindgen_test]
271 fn public_fields() {
272 js_public_fields();
273 }
274
275 #[wasm_bindgen]
276 #[derive(Default)]
277 pub struct PublicFields {
278 pub a: u32,
279 pub b: f32,
280 pub c: f64,
281 pub d: i32,
282 #[wasm_bindgen(skip)]
283 pub skipped: u32,
284 }
285
286 #[wasm_bindgen]
287 impl PublicFields {
288 pub fn new() -> PublicFields {
289 PublicFields::default()
290 }
291 }
292
293 #[wasm_bindgen_test]
294 fn getter_with_clone() {
295 js_getter_with_clone();
296 }
297
298 #[wasm_bindgen(getter_with_clone)]
299 #[derive(Default)]
300 pub struct GetterWithCloneStruct {
301 pub a: String,
302 }
303
304 #[wasm_bindgen]
305 impl GetterWithCloneStruct {
306 pub fn new() -> GetterWithCloneStruct {
307 GetterWithCloneStruct::default()
308 }
309 }
310
311 #[wasm_bindgen]
312 #[derive(Default)]
313 pub struct GetterWithCloneStructField {
314 #[wasm_bindgen(getter_with_clone)]
315 pub a: String,
316 }
317
318 #[wasm_bindgen]
319 impl GetterWithCloneStructField {
320 pub fn new() -> GetterWithCloneStructField {
321 GetterWithCloneStructField::default()
322 }
323 }
324
325 #[wasm_bindgen_test]
326 fn using_self() {
327 js_using_self();
328 }
329
330 #[wasm_bindgen]
331 pub struct UseSelf {}
332
333 #[wasm_bindgen]
334 impl UseSelf {
335 pub fn new() -> Self {
336 UseSelf {}
337 }
338 }
339
340 #[wasm_bindgen_test]
341 fn readonly_fields() {
342 js_readonly_fields();
343 }
344
345 #[wasm_bindgen]
346 #[derive(Default)]
347 pub struct Readonly {
348 #[wasm_bindgen(readonly)]
349 pub a: u32,
350 }
351
352 #[wasm_bindgen]
353 impl Readonly {
354 pub fn new() -> Readonly {
355 Readonly::default()
356 }
357 }
358
359 #[wasm_bindgen_test]
360 fn double_consume() {
361 js_double_consume();
362 }
363
364 #[wasm_bindgen]
365 pub struct DoubleConsume {}
366
367 #[wasm_bindgen]
368 impl DoubleConsume {
369 #[wasm_bindgen(constructor)]
370 pub fn new() -> DoubleConsume {
371 DoubleConsume {}
372 }
373
374 pub fn consume(self, other: DoubleConsume) {
375 drop(other);
376 }
377 }
378
379 #[wasm_bindgen_test]
380 fn rename_function_for_js() {
381 js_js_rename();
382 foo();
383 }
384
385 #[wasm_bindgen]
386 pub struct JsRename {}
387
388 #[wasm_bindgen]
389 impl JsRename {
390 #[wasm_bindgen(constructor)]
391 pub fn new() -> JsRename {
392 let f = JsRename {};
393 f.foo();
394 f
395 }
396
397 #[wasm_bindgen(js_name = bar)]
398 pub fn foo(&self) {}
399 }
400
401 #[wasm_bindgen(js_name = classes_foo)]
402 pub fn foo() {}
403
404 #[wasm_bindgen]
405 pub struct AccessFieldFoo {
406 pub bar: AccessFieldBar,
407 }
408
409 #[wasm_bindgen]
410 pub struct AccessField0(pub AccessFieldBar);
411
412 #[wasm_bindgen]
413 #[derive(Copy, Clone)]
414 pub struct AccessFieldBar {
415 _value: u32,
416 }
417
418 #[wasm_bindgen]
419 impl AccessFieldFoo {
420 #[wasm_bindgen(constructor)]
421 pub fn new() -> AccessFieldFoo {
422 AccessFieldFoo {
423 bar: AccessFieldBar { _value: 2 },
424 }
425 }
426 }
427
428 #[wasm_bindgen]
429 impl AccessField0 {
430 #[wasm_bindgen(constructor)]
431 pub fn new() -> AccessField0 {
432 AccessField0(AccessFieldBar { _value: 2 })
433 }
434 }
435
436 #[wasm_bindgen_test]
437 fn access_fields() {
438 js_access_fields();
439 }
440
441 #[wasm_bindgen(js_name = JsRenamedExport)]
442 pub struct RenamedExport {
443 pub x: u32,
444 }
445
446 #[wasm_bindgen(js_class = JsRenamedExport)]
447 impl RenamedExport {
448 #[wasm_bindgen(constructor)]
449 pub fn new() -> RenamedExport {
450 RenamedExport { x: 3 }
451 }
452 pub fn foo(&self) {}
453
454 pub fn bar(&self, _: &RenamedExport) {}
455 }
456
457 #[wasm_bindgen_test]
458 fn renamed_export() {
459 js_renamed_export();
460 }
461
462 #[wasm_bindgen]
463 pub struct RenamedField {
464 #[wasm_bindgen(js_name = bar)]
465 pub foo: u32,
466 }
467
468 #[wasm_bindgen(js_class = RenamedField)]
469 impl RenamedField {
470 #[wasm_bindgen(constructor)]
471 pub fn new() -> RenamedField {
472 RenamedField { foo: 3 }
473 }
474
475 pub fn foo(&self) {}
476 }
477
478 #[wasm_bindgen_test]
479 fn renamed_field() {
480 js_renamed_field();
481 }
482
483 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
484 pub struct ConditionalBindings {}
485
486 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
487 impl ConditionalBindings {
488 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
489 pub fn new() -> ConditionalBindings {
490 ConditionalBindings {}
491 }
492 }
493
494 #[wasm_bindgen_test]
495 fn conditional_bindings() {
496 js_conditional_bindings();
497 }
498
499 #[wasm_bindgen]
500 pub struct OptionClass(u32);
501
502 #[wasm_bindgen_test]
503 fn option_class() {
504 js_assert_none(None);
505 js_assert_some(Some(OptionClass(1)));
506 assert!(js_return_none1().is_none());
507 assert!(js_return_none2().is_none());
508 assert_eq!(js_return_some(OptionClass(2)).unwrap().0, 2);
509 js_test_option_classes();
510 }
511
512 #[wasm_bindgen]
513 pub fn option_class_none() -> Option<OptionClass> {
514 None
515 }
516
517 #[wasm_bindgen]
518 pub fn option_class_some() -> Option<OptionClass> {
519 Some(OptionClass(3))
520 }
521
522 #[wasm_bindgen]
523 pub fn option_class_assert_none(x: Option<OptionClass>) {
524 assert!(x.is_none());
525 }
526
527 #[wasm_bindgen]
528 pub fn option_class_assert_some(x: Option<OptionClass>) {
529 assert_eq!(x.unwrap().0, 3);
530 }
531
532 mod works_in_module {
533 use wasm_bindgen::prelude::wasm_bindgen;
534
535 #[wasm_bindgen]
536 pub struct WorksInModule(u32);
537
538 #[wasm_bindgen]
539 impl WorksInModule {
540 #[wasm_bindgen(constructor)]
541 pub fn new() -> WorksInModule {
542 WorksInModule(1)
543 }
544
545 pub fn foo(&self) {}
546 }
547 }
548
549 #[wasm_bindgen_test]
550 fn inspectable_classes() {
551 js_test_inspectable_classes();
552 }
553
554 #[wasm_bindgen(inspectable)]
555 #[derive(Default)]
556 pub struct Inspectable {
557 pub a: u32,
558 // This private field will not be exposed unless a getter is provided for it
559 #[allow(dead_code)]
560 private: u32,
561 }
562
563 #[wasm_bindgen]
564 impl Inspectable {
565 pub fn new() -> Self {
566 Self::default()
567 }
568 }
569
570 #[wasm_bindgen]
571 #[derive(Default)]
572 pub struct NotInspectable {
573 pub a: u32,
574 }
575
576 #[wasm_bindgen]
577 impl NotInspectable {
578 pub fn new() -> Self {
579 Self::default()
580 }
581 }
582
583 #[wasm_bindgen_test]
584 fn inspectable_classes_can_override_generated_methods() {
585 js_test_inspectable_classes_can_override_generated_methods();
586 }
587
588 #[wasm_bindgen(inspectable)]
589 #[derive(Default)]
590 pub struct OverriddenInspectable {
591 pub a: u32,
592 }
593
594 #[wasm_bindgen]
595 impl OverriddenInspectable {
596 pub fn new() -> Self {
597 Self::default()
598 }
599
600 #[wasm_bindgen(js_name = toJSON)]
601 pub fn js_to_json(&self) -> String {
602 String::from("JSON was overwritten")
603 }
604
605 #[wasm_bindgen(js_name = toString)]
606 pub fn js_to_string(&self) -> String {
607 String::from("string was overwritten")
608 }
609 }
610
611 macro_rules! make_struct {
612 ($field:ident) => {
613 #[wasm_bindgen]
614 pub struct InsideMacro {
615 pub $field: u32,
616 }
617 };
618 }
619
620 make_struct!(a);
621
622 #[wasm_bindgen]
623 impl InsideMacro {
624 #[wasm_bindgen(constructor)]
625 pub fn new() -> Self {
626 Self { a: 3 }
627 }
628 }
629
630 #[wasm_bindgen_test]
631 fn class_defined_in_macro() {
632 js_test_class_defined_in_macro();
633 }