feat: add a histrical wit-bindgen

__wasm/wit-bindgen-sample/wit-bindgen/crates/wit-component/tests/interfaces/variants/variants.wat

@@ -0,0 +1,92 @@
+(component
+  (type (;0;) (enum "a"))
+  (type (;1;) (func (param "x" 0)))
+  (type (;2;) (func (result 0)))
+  (type (;3;) (union u32 float32))
+  (type (;4;) (func (param "x" 3)))
+  (type (;5;) (func (result 3)))
+  (type (;6;) (record))
+  (type (;7;) (variant (case $c0 "a" unit) (case $c1 "b" 3) (case $c2 "c" 0) (case $c3 "d" string) (case $c4 "e" 6) (case $c5 "f" unit) (case $c6 "g" u32)))
+  (type (;8;) (func (param "x" 7)))
+  (type (;9;) (func (result 7)))
+  (type (;10;) (func (param "x" bool)))
+  (type (;11;) (func (result bool)))
+  (type (;12;) (option bool))
+  (type (;13;) (tuple))
+  (type (;14;) (option 13))
+  (type (;15;) (option u32))
+  (type (;16;) (option 0))
+  (type (;17;) (option float32))
+  (type (;18;) (option 3))
+  (type (;19;) (option 12))
+  (type (;20;) (func (param "a" 12) (param "b" 14) (param "c" 15) (param "d" 16) (param "e" 17) (param "f" 18) (param "g" 19)))
+  (type (;21;) (tuple 12 14 15 16 17 18 19))
+  (type (;22;) (func (result 21)))
+  (type (;23;) (variant (case $c0 "a" s32) (case $c1 "b" float32)))
+  (type (;24;) (variant (case $c0 "a" float64) (case $c1 "b" float32)))
+  (type (;25;) (variant (case $c0 "a" float64) (case $c1 "b" u64)))
+  (type (;26;) (variant (case $c0 "a" u32) (case $c1 "b" s64)))
+  (type (;27;) (variant (case $c0 "a" float32) (case $c1 "b" s64)))
+  (type (;28;) (tuple float32 u32))
+  (type (;29;) (tuple u32 u32))
+  (type (;30;) (variant (case $c0 "a" 28) (case $c1 "b" 29)))
+  (type (;31;) (tuple 23 24 25 26 27 30))
+  (type (;32;) (func (param "a" 23) (param "b" 24) (param "c" 25) (param "d" 26) (param "e" 27) (param "f" 30) (result 31)))
+  (type (;33;) (expected unit unit))
+  (type (;34;) (expected unit 0))
+  (type (;35;) (expected 0 unit))
+  (type (;36;) (expected 13 13))
+  (type (;37;) (expected u32 7))
+  (type (;38;) (list u8))
+  (type (;39;) (expected string 38))
+  (type (;40;) (func (param "a" 33) (param "b" 34) (param "c" 35) (param "d" 36) (param "e" 37) (param "f" 39)))
+  (type (;41;) (tuple 33 34 35 36 37 39))
+  (type (;42;) (func (result 41)))
+  (type (;43;) (enum "bad1" "bad2"))
+  (type (;44;) (expected s32 43))
+  (type (;45;) (func (result 44)))
+  (type (;46;) (expected unit 43))
+  (type (;47;) (func (result 46)))
+  (type (;48;) (expected 43 43))
+  (type (;49;) (func (result 48)))
+  (type (;50;) (tuple s32 u32))
+  (type (;51;) (expected 50 43))
+  (type (;52;) (func (result 51)))
+  (type (;53;) (option s32))
+  (type (;54;) (func (result 53)))
+  (type (;55;) (option 43))
+  (type (;56;) (func (result 55)))
+  (type (;57;) (expected u32 s32))
+  (type (;58;) (func (result 57)))
+  (export "e1" (type 0))
+  (export "e1-arg" (type 1))
+  (export "e1-result" (type 2))
+  (export "u1" (type 3))
+  (export "u1-arg" (type 4))
+  (export "u1-result" (type 5))
+  (export "empty" (type 6))
+  (export "v1" (type 7))
+  (export "v1-arg" (type 8))
+  (export "v1-result" (type 9))
+  (export "bool-arg" (type 10))
+  (export "bool-result" (type 11))
+  (export "option-arg" (type 20))
+  (export "option-result" (type 22))
+  (export "casts1" (type 23))
+  (export "casts2" (type 24))
+  (export "casts3" (type 25))
+  (export "casts4" (type 26))
+  (export "casts5" (type 27))
+  (export "casts6" (type 30))
+  (export "casts" (type 32))
+  (export "expected-arg" (type 40))
+  (export "expected-result" (type 42))
+  (export "my-errno" (type 43))
+  (export "return-expected-sugar" (type 45))
+  (export "return-expected-sugar2" (type 47))
+  (export "return-expected-sugar3" (type 49))
+  (export "return-expected-sugar4" (type 52))
+  (export "return-option-sugar" (type 54))
+  (export "return-option-sugar2" (type 56))
+  (export "expected-simple" (type 58))
+)

__wasm/wit-bindgen-sample/wit-bindgen/crates/wit-component/tests/interfaces/variants/variants.wit

@@ -0,0 +1,97 @@
+enum e1 {
+  a,
+}
+
+union u1 {
+  u32,
+  float32,
+}
+
+record empty {
+}
+
+variant v1 {
+  a,
+  b(u1),
+  c(e1),
+  d(string),
+  e(empty),
+  f,
+  g(u32),
+}
+
+variant casts1 {
+  a(s32),
+  b(float32),
+}
+
+variant casts2 {
+  a(float64),
+  b(float32),
+}
+
+variant casts3 {
+  a(float64),
+  b(u64),
+}
+
+variant casts4 {
+  a(u32),
+  b(s64),
+}
+
+variant casts5 {
+  a(float32),
+  b(s64),
+}
+
+variant casts6 {
+  a(tuple<float32, u32>),
+  b(tuple<u32, u32>),
+}
+
+enum my-errno {
+  bad1,
+  bad2,
+}
+
+e1-arg: func(x: e1)
+
+e1-result: func() -> e1
+
+u1-arg: func(x: u1)
+
+u1-result: func() -> u1
+
+v1-arg: func(x: v1)
+
+v1-result: func() -> v1
+
+bool-arg: func(x: bool)
+
+bool-result: func() -> bool
+
+option-arg: func(a: option<bool>, b: option<tuple<>>, c: option<u32>, d: option<e1>, e: option<float32>, f: option<u1>, g: option<option<bool>>)
+
+option-result: func() -> tuple<option<bool>, option<tuple<>>, option<u32>, option<e1>, option<float32>, option<u1>, option<option<bool>>>
+
+casts: func(a: casts1, b: casts2, c: casts3, d: casts4, e: casts5, f: casts6) -> tuple<casts1, casts2, casts3, casts4, casts5, casts6>
+
+expected-arg: func(a: expected<unit, unit>, b: expected<unit, e1>, c: expected<e1, unit>, d: expected<tuple<>, tuple<>>, e: expected<u32, v1>, f: expected<string, list<u8>>)
+
+expected-result: func() -> tuple<expected<unit, unit>, expected<unit, e1>, expected<e1, unit>, expected<tuple<>, tuple<>>, expected<u32, v1>, expected<string, list<u8>>>
+
+return-expected-sugar: func() -> expected<s32, my-errno>
+
+return-expected-sugar2: func() -> expected<unit, my-errno>
+
+return-expected-sugar3: func() -> expected<my-errno, my-errno>
+
+return-expected-sugar4: func() -> expected<tuple<s32, u32>, my-errno>
+
+return-option-sugar: func() -> option<s32>
+
+return-option-sugar2: func() -> option<my-errno>
+
+expected-simple: func() -> expected<u32, s32>
+