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