more tests

WebAssembly · Jan 26, 2024 · 2f6e59a · 2f6e59a
1 parent 37fb96d
commit 2f6e59a
Show file tree

Hide file tree

Showing 9 changed files with 49 additions and 49 deletions.
diff --git a/test/gtest/cfg.cpp b/test/gtest/cfg.cpp
@@ -270,9 +270,9 @@ TEST_F(CFGTest, LinearReachingDefinitions) {
   auto moduleText = R"wasm(
     (module
       (func $bar
-        (local $a (i32))
-        (local $b (i32))
-        (local $c (i32))
+        (local $a i32)
+        (local $b i32)
+        (local $c i32)
         (local.set $a
           (i32.const 1)
         )
@@ -335,8 +335,8 @@ TEST_F(CFGTest, ReachingDefinitionsIf) {
   auto moduleText = R"wasm(
     (module
       (func $bar
-        (local $a (i32))
-        (local $b (i32))
+        (local $a i32)
+        (local $b i32)
         (local.set $a
           (i32.const 1)
         )
@@ -406,7 +406,7 @@ TEST_F(CFGTest, ReachingDefinitionsIf) {
 TEST_F(CFGTest, ReachingDefinitionsLoop) {
   auto moduleText = R"wasm(
     (module
-      (func $bar (param $a (i32)) (param $b (i32))
+      (func $bar (param $a i32) (param $b i32)
         (loop $loop
           (drop
             (local.get $a)

diff --git a/test/lit/blocktype.wast b/test/lit/blocktype.wast
@@ -25,8 +25,8 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $f1 (type $f1) (result (ref $f1) (ref $f2))
- ;; RTRIP-NEXT:  (local $0 ((ref $f1) (ref $f2)))
- ;; RTRIP-NEXT:  (local $1 ((ref $f1) (ref $f2)))
+ ;; RTRIP-NEXT:  (local $0 (tuple (ref $f1) (ref $f2)))
+ ;; RTRIP-NEXT:  (local $1 (tuple (ref $f1) (ref $f2)))
  ;; RTRIP-NEXT:  (local.set $1
  ;; RTRIP-NEXT:   (loop $label$1 (type $f1) (result (ref $f1) (ref $f2))
  ;; RTRIP-NEXT:    (local.set $0
@@ -64,8 +64,8 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; RTRIP:      (func $f2 (type $f2) (result (ref $f2) (ref $f1))
- ;; RTRIP-NEXT:  (local $0 ((ref $f2) (ref $f1)))
- ;; RTRIP-NEXT:  (local $1 ((ref $f2) (ref $f1)))
+ ;; RTRIP-NEXT:  (local $0 (tuple (ref $f2) (ref $f1)))
+ ;; RTRIP-NEXT:  (local $1 (tuple (ref $f2) (ref $f1)))
  ;; RTRIP-NEXT:  (local.set $1
  ;; RTRIP-NEXT:   (loop $label$1 (type $f2) (result (ref $f2) (ref $f1))
  ;; RTRIP-NEXT:    (local.set $0

diff --git a/test/lit/multivalue-stack-ir.wast b/test/lit/multivalue-stack-ir.wast
@@ -26,7 +26,7 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $test
-  (local $pair (f32 i32))
+  (local $pair (tuple f32 i32))
   (local $f32 f32)
   ;; Normally this get-set pair would be eliminated by stack IR optimizations,
   ;; but then the binary writer's tuple optimizations would leave the only the

diff --git a/test/lit/multivalue.wast b/test/lit/multivalue.wast
@@ -8,9 +8,9 @@
  ;; CHECK:      (import "env" "pair" (func $pair (type $0) (result i32 i64)))
  (import "env" "pair" (func $pair (result i32 i64)))
  ;; CHECK:      (global $g1 (mut i32) (i32.const 0))
- (global $g1 (mut (i32 i64)) (tuple.make 2 (i32.const 0) (i64.const 0)))
+ (global $g1 (mut (tuple i32 i64)) (tuple.make 2 (i32.const 0) (i64.const 0)))
  ;; CHECK:      (global $g2 (mut i64) (i64.const 0))
- (global $g2 (i32 i64) (tuple.make 2 (i32.const 0) (i64.const 0)))
+ (global $g2 (tuple i32 i64) (tuple.make 2 (i32.const 0) (i64.const 0)))
 
  ;; CHECK:      (func $triple (type $5) (result i32 i64 f32)
  ;; CHECK-NEXT:  (tuple.make 3
@@ -28,7 +28,7 @@
  )
 
  ;; CHECK:      (func $get-first (type $6) (result i32)
- ;; CHECK-NEXT:  (local $0 (i32 i64 f32))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64 f32))
  ;; CHECK-NEXT:  (local $1 i64)
  ;; CHECK-NEXT:  (local $2 i32)
  ;; CHECK-NEXT:  (local.set $0
@@ -66,7 +66,7 @@
 
  ;; CHECK:      (func $get-second (type $3) (result i64)
  ;; CHECK-NEXT:  (local $0 i64)
- ;; CHECK-NEXT:  (local $1 (i32 i64 f32))
+ ;; CHECK-NEXT:  (local $1 (tuple i32 i64 f32))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
@@ -107,7 +107,7 @@
 
  ;; CHECK:      (func $get-third (type $7) (result f32)
  ;; CHECK-NEXT:  (local $0 f32)
- ;; CHECK-NEXT:  (local $1 (i32 i64 f32))
+ ;; CHECK-NEXT:  (local $1 (tuple i32 i64 f32))
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 i32)
  ;; CHECK-NEXT:  (local.set $1
@@ -152,7 +152,7 @@
  ;; CHECK-NEXT:  (local $2 i64)
  ;; CHECK-NEXT:  (local $3 f32)
  ;; CHECK-NEXT:  (local $4 f32)
- ;; CHECK-NEXT:  (local $5 (i32 i64 f32))
+ ;; CHECK-NEXT:  (local $5 (tuple i32 i64 f32))
  ;; CHECK-NEXT:  (local $6 i64)
  ;; CHECK-NEXT:  (local $7 i32)
  ;; CHECK-NEXT:  (local.set $5
@@ -190,7 +190,7 @@
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $reverse (result f32 i64 i32)
-  (local $x (i32 i64 f32))
+  (local $x (tuple i32 i64 f32))
   (local.set $x
    (call $triple)
   )
@@ -266,7 +266,7 @@
 
  ;; Test lowering of multivalue drops
  ;; CHECK:      (func $drop-call (type $1)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (call $pair)
@@ -317,7 +317,7 @@
  )
 
  ;; CHECK:      (func $drop-block (type $1)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (block $label$1 (type $0) (result i32 i64)
@@ -392,7 +392,7 @@
  )
 
  ;; CHECK:      (func $mv-block-break (type $0) (result i32 i64)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (block $label$1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:    (br $label$1
@@ -424,8 +424,8 @@
  )
 
  ;; CHECK:      (func $mv-block-br-if (type $0) (result i32 i64)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
- ;; CHECK-NEXT:  (local $1 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
+ ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (block $label$1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:    (local.set $0
@@ -469,7 +469,7 @@
  )
 
  ;; CHECK:      (func $mv-if (type $2) (result i32 i64 externref)
- ;; CHECK-NEXT:  (local $0 (i32 i64 externref))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64 externref))
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (if (type $2) (result i32 i64 externref)
  ;; CHECK-NEXT:    (i32.const 1)
@@ -522,7 +522,7 @@
  )
 
  ;; CHECK:      (func $mv-loop (type $0) (result i32 i64)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (loop $label$1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:    (tuple.make 2
@@ -550,8 +550,8 @@
  )
 
  ;; CHECK:      (func $mv-switch (type $0) (result i32 i64)
- ;; CHECK-NEXT:  (local $0 (i32 i64))
- ;; CHECK-NEXT:  (local $1 (i32 i64))
+ ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
+ ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (block $label$1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:    (local.set $0

diff --git a/test/lit/passes/translate-eh-old-to-new.wast b/test/lit/passes/translate-eh-old-to-new.wast
@@ -149,7 +149,7 @@
   ;; CHECK:      (func $try-none-tag-single-with-rethrow (type $1)
   ;; CHECK-NEXT:  (local $0 exnref)
   ;; CHECK-NEXT:  (local $1 i32)
-  ;; CHECK-NEXT:  (local $2 (i32 exnref))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 exnref))
   ;; CHECK-NEXT:  (block $outer0
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -205,7 +205,7 @@
   )
 
   ;; CHECK:      (func $try-none-tag-tuple (type $1)
-  ;; CHECK-NEXT:  (local $0 (i32 i64))
+  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
   ;; CHECK-NEXT:  (block $outer0
   ;; CHECK-NEXT:   (block $catch_all2
   ;; CHECK-NEXT:    (local.set $0
@@ -243,8 +243,8 @@
 
   ;; CHECK:      (func $try-none-tag-tuple-with-rethrow (type $1)
   ;; CHECK-NEXT:  (local $0 exnref)
-  ;; CHECK-NEXT:  (local $1 (i32 i64))
-  ;; CHECK-NEXT:  (local $2 (i32 i64 exnref))
+  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 exnref))
   ;; CHECK-NEXT:  (block $outer0
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -419,7 +419,7 @@
   ;; CHECK:      (func $try-single-tag-single-with-rethrow (type $2) (result i32)
   ;; CHECK-NEXT:  (local $0 exnref)
   ;; CHECK-NEXT:  (local $1 i32)
-  ;; CHECK-NEXT:  (local $2 (i32 exnref))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 exnref))
   ;; CHECK-NEXT:  (block $outer0 (result i32)
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -481,7 +481,7 @@
   )
 
   ;; CHECK:      (func $try-single-tag-tuple (type $2) (result i32)
-  ;; CHECK-NEXT:  (local $0 (i32 i64))
+  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
   ;; CHECK-NEXT:  (block $outer0 (result i32)
   ;; CHECK-NEXT:   (block $catch_all2
   ;; CHECK-NEXT:    (local.set $0
@@ -527,8 +527,8 @@
 
   ;; CHECK:      (func $try-single-tag-tuple-with-rethrow (type $2) (result i32)
   ;; CHECK-NEXT:  (local $0 exnref)
-  ;; CHECK-NEXT:  (local $1 (i32 i64))
-  ;; CHECK-NEXT:  (local $2 (i32 i64 exnref))
+  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 exnref))
   ;; CHECK-NEXT:  (block $outer0 (result i32)
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -751,7 +751,7 @@
   ;; CHECK:      (func $try-tuple-tag-single-with-rethrow (type $0) (result i32 i64)
   ;; CHECK-NEXT:  (local $0 exnref)
   ;; CHECK-NEXT:  (local $1 i32)
-  ;; CHECK-NEXT:  (local $2 (i32 exnref))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 exnref))
   ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -819,7 +819,7 @@
   )
 
   ;; CHECK:      (func $try-tuple-tag-tuple (type $0) (result i32 i64)
-  ;; CHECK-NEXT:  (local $0 (i32 i64))
+  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
   ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
   ;; CHECK-NEXT:   (block $catch_all2
   ;; CHECK-NEXT:    (local.set $0
@@ -869,8 +869,8 @@
 
   ;; CHECK:      (func $try-tuple-tag-tuple-with-rethrow (type $0) (result i32 i64)
   ;; CHECK-NEXT:  (local $0 exnref)
-  ;; CHECK-NEXT:  (local $1 (i32 i64))
-  ;; CHECK-NEXT:  (local $2 (i32 i64 exnref))
+  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 exnref))
   ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all2 (result exnref)
@@ -961,9 +961,9 @@
   ;; CHECK:      (func $multiple-catches-and-catch_all (type $1)
   ;; CHECK-NEXT:  (local $0 exnref)
   ;; CHECK-NEXT:  (local $1 i32)
-  ;; CHECK-NEXT:  (local $2 (i32 i64))
-  ;; CHECK-NEXT:  (local $3 (i32 exnref))
-  ;; CHECK-NEXT:  (local $4 (i32 i64 exnref))
+  ;; CHECK-NEXT:  (local $2 (tuple i32 i64))
+  ;; CHECK-NEXT:  (local $3 (tuple i32 exnref))
+  ;; CHECK-NEXT:  (local $4 (tuple i32 i64 exnref))
   ;; CHECK-NEXT:  (block $outer0
   ;; CHECK-NEXT:   (local.set $0
   ;; CHECK-NEXT:    (block $catch_all4 (result exnref)

diff --git a/test/lit/validation/bad-non-nullable-locals.wast b/test/lit/validation/bad-non-nullable-locals.wast
@@ -68,7 +68,7 @@
   (func $tuple
     ;; Since this tuple local has a non-nullable element, it is subject to the
     ;; non-nullability rules.
-    (local $x (i32 (ref any) i64))
+    (local $x (tuple i32 (ref any) i64))
     (tuple.drop 3
       (local.get $x)
     )

diff --git a/test/lit/validation/nn-locals-bad-call_ref.wast b/test/lit/validation/nn-locals-bad-call_ref.wast
@@ -17,7 +17,7 @@
       )
       (catch $tag
         (drop
-          (pop (i32))
+          (pop i32)
         )
         ;; The path to here is from a possible exception thrown in the call_ref.
         ;; This is a regression test for call_ref not being seen as possibly

diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
@@ -964,7 +964,7 @@
 
  ;; CHECK:      (func $block-mix (type $void)
  ;; CHECK-NEXT:  (local $scratch i32)
- ;; CHECK-NEXT:  (local $scratch_1 (i32 i32))
+ ;; CHECK-NEXT:  (local $scratch_1 (tuple i32 i32))
  ;; CHECK-NEXT:  (local $scratch_2 i32)
  ;; CHECK-NEXT:  (block $0
  ;; CHECK-NEXT:   (drop
@@ -1019,7 +1019,7 @@
 
 
  ;; CHECK:      (func $multivalue-nested (type $ret2) (result i32 i32)
- ;; CHECK-NEXT:  (local $scratch (i32 i32))
+ ;; CHECK-NEXT:  (local $scratch (tuple i32 i32))
  ;; CHECK-NEXT:  (nop)
  ;; CHECK-NEXT:  (local.set $scratch
  ;; CHECK-NEXT:   (block (type $ret2) (result i32 i32)
@@ -3754,9 +3754,9 @@
  ;; CHECK-NEXT:  (local $0 (ref null $void))
  ;; CHECK-NEXT:  (local $1 (ref null $ret2))
  ;; CHECK-NEXT:  (local $2 (ref null $many))
- ;; CHECK-NEXT:  (local $scratch (i32 i32))
+ ;; CHECK-NEXT:  (local $scratch (tuple i32 i32))
  ;; CHECK-NEXT:  (local $scratch_4 i32)
- ;; CHECK-NEXT:  (local $scratch_5 (anyref (ref func)))
+ ;; CHECK-NEXT:  (local $scratch_5 (tuple anyref (ref func)))
  ;; CHECK-NEXT:  (local $scratch_6 anyref)
  ;; CHECK-NEXT:  (call_ref $void
  ;; CHECK-NEXT:   (local.get $0)

diff --git a/test/unit/test_poppy_validation.py b/test/unit/test_poppy_validation.py
@@ -59,7 +59,7 @@ def test_incompatible_type(self):
         )
         '''
         self.check_invalid(module, "block element has incompatible type")
-        self.check_invalid(module, "required: (i32 i32), available: (f32 i32)")
+        self.check_invalid(module, "required: (tuple i32 i32), available: (tuple f32 i32)")
 
     def test_incorrect_pop_type(self):
         module = '''