Add support for (either ...) in wast (#8421)

* Adds support for (either ...) in assert_return in WAST
* Also allows customizing the error type in Result, which we use to keep
track of the failing lane in assertions.

Example failure:

```wast
(module
  (func (export "f") (result i32)
    (i32.const 1)
  )
)

(assert_return (invoke "f") (either (i32.const 2) (i32.const 3)))
```

```
Expected one of (2 | 3) but got 1
```

Example failure with SIMD from `relaxed_min_max.wast`:

```
Expected one of (canonical f32 | canonical f32 | 0 | 0x00000000) at lane 0 but got i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000
```

Part of #8261 and #8315. Fixes `i16x8_relaxed_q15mulr_s.wast`,
`i8x16_relaxed_swizzle.wast`, `relaxed_madd_nmadd.wast` spec tests, and
partially fixes `relaxed_dot_product.wast`, `relaxed_laneselect.wast`,
`relaxed_min_max.wast`, and `threads/thread.wast`.

Author: stevenfontanella

scripts/test/shared.py

@@ -396,7 +396,7 @@ def get_tests(test_dir, extensions=[], recursive=False):
     # Test invalid
     'elem.wast',
 
-    # Requires wast `either` support
+    # Requires scoping of `register` statements within `thread` blocks
     'threads/thread.wast',
 
     # Requires better support for multi-threaded tests
@@ -453,12 +453,9 @@ def get_tests(test_dir, extensions=[], recursive=False):
     'type-subtyping.wast',  # ShellExternalInterface::callTable does not handle subtyping
     'memory64.wast',        # Requires validations on the max memory size
     'imports3.wast',  # Requires better checking of exports from the special "spectest" module
-    'i16x8_relaxed_q15mulr_s.wast',  # Requires wast `either` support
-    'i8x16_relaxed_swizzle.wast',    # Requires wast `either` support
-    'relaxed_dot_product.wast',   # Requires wast `either` support
-    'relaxed_laneselect.wast',    # Requires wast `either` support
-    'relaxed_madd_nmadd.wast',    # Requires wast `either` support
-    'relaxed_min_max.wast',       # Requires wast `either` support
+    'relaxed_dot_product.wast',   # i16x8.relaxed_dot_i8x16_i7x16_s instruction not supported
+    'relaxed_laneselect.wast',    # i8x16.relaxed_laneselect instruction not supported
+    'relaxed_min_max.wast',       # Non-canonical NaN from f32x4.relaxed_min
     'simd_const.wast',            # Hex float constant not recognized as out of range
     'simd_conversions.wast',      # Promoted NaN should be canonical
     'simd_f32x4.wast',            # Min of 0 and NaN should give a canonical NaN

src/parser/wast-parser.cpp

@@ -342,12 +342,30 @@ Result<ExpectedResult> result(Lexer& in) {
   return in.err("unrecognized result");
 }
 
+Result<ResultAlternatives> eitherResult(Lexer& in) {
+  if (in.takeSExprStart("either"sv)) {
+    ResultAlternatives alternatives;
+    do {
+      auto r = result(in);
+      CHECK_ERR(r);
+
+      alternatives.push_back(*std::move(r));
+    } while (!in.takeRParen());
+
+    return alternatives;
+  }
+
+  auto r = result(in);
+  CHECK_ERR(r);
+  return ResultAlternatives{*std::move(r)};
+}
+
 Result<ExpectedResults> results(Lexer& in) {
   ExpectedResults res;
   while (!in.peekRParen()) {
-    auto r = result(in);
+    auto r = eitherResult(in);
     CHECK_ERR(r);
-    res.emplace_back(std::move(*r));
+    res.emplace_back(*std::move(r));
   }
   return res;
 }
@@ -666,7 +684,7 @@ Result<WASTScript> wast(Lexer& in) {
       return cmds;
     }
     CHECK_ERR(cmd);
-    cmds.push_back(ScriptEntry{std::move(*cmd), line});
+    cmds.push_back(ScriptEntry{*std::move(cmd), line});
   }
   return cmds;
 }

src/parser/wat-parser.h

@@ -89,7 +89,13 @@ struct LaneResults {
 using ExpectedResult =
   std::variant<Literal, NullRefResult, RefResult, NaNResult, LaneResults>;
 
-using ExpectedResults = std::vector<ExpectedResult>;
+using ResultAlternatives = std::vector<ExpectedResult>;
+
+// The WAST spec states that `either`s maybe be nested arbitrarily e.g.
+// (either (either "a" "b") (either "a" "c"))
+// but we store this flattened since there's no way to tell the difference
+// anyway.
+using ExpectedResults = std::vector<ResultAlternatives>;
 
 struct AssertReturn {
   Action action;

src/support/result.h

@@ -36,28 +36,30 @@ struct Err {
 // Check a Result or MaybeResult for error and return the error if it exists.
 #define CHECK_ERR(val)                                                         \
   if (auto _val = (val); auto err = _val.getErr()) {                           \
-    return Err{*err};                                                          \
+    return (typename decltype(_val)::ErrorType)(*err);                         \
   }
 
 // Represent a result of type T or an error message.
-template<typename T = Ok> struct [[nodiscard]] Result {
-  std::variant<T, Err> val;
-
-  Result(Result<T>& other) = default;
-  Result(Result<T>&& other) = default;
-  Result(const Err& e) : val(std::in_place_type<Err>, e) {}
-  Result(Err&& e) : val(std::in_place_type<Err>, std::move(e)) {}
+template<typename T = Ok, typename E = Err> struct [[nodiscard]] Result {
+  using ErrorType = E;
+  std::variant<T, E> val;
+
+  Result(Result<T, E>& other) = default;
+  Result(Result<T, E>&& other) = default;
+  Result(const E& e) : val(std::in_place_type<E>, e) {}
+  Result(E&& e) : val(std::in_place_type<E>, std::move(e)) {}
   template<typename U = T>
   Result(U&& u) : val(std::in_place_type<T>, std::forward<U>(u)) {}
 
-  Err* getErr() { return std::get_if<Err>(&val); }
+  E* getErr() { return std::get_if<E>(&val); }
   T& operator*() { return *std::get_if<T>(&val); }
   T* operator->() { return std::get_if<T>(&val); }
 };
 
 // Represent an optional result of type T or an error message.
 template<typename T = Ok> struct [[nodiscard]] MaybeResult {
   std::variant<T, None, Err> val;
+  using ErrorType = Err;
 
   MaybeResult() : val(None{}) {}
   MaybeResult(MaybeResult<T>& other) = default;

src/tools/wasm-shell.cpp

@@ -319,31 +319,31 @@ struct Shell {
     switch (nan.kind) {
       case NaNKind::Canonical:
         if (val.type != nan.type || !val.isCanonicalNaN()) {
-          err << "expected canonical " << nan.type << " NaN, got " << val;
+          err << "canonical " << nan.type;
           return Err{err.str()};
         }
         break;
       case NaNKind::Arithmetic:
         if (val.type != nan.type || !val.isArithmeticNaN()) {
-          err << "expected arithmetic " << nan.type << " NaN, got " << val;
+          err << "arithmetic " << nan.type;
           return Err{err.str()};
         }
         break;
     }
     return Ok{};
   }
 
-  Result<> checkLane(Literal val, LaneResult expected, Index index) {
+  Result<> checkLane(Literal val, LaneResult expected) {
     std::stringstream err;
     if (auto* e = std::get_if<Literal>(&expected)) {
       if (*e != val) {
-        err << "expected " << *e << ", got " << val << " at lane " << index;
+        err << *e;
         return Err{err.str()};
       }
     } else if (auto* nan = std::get_if<NaNResult>(&expected)) {
       auto check = checkNaN(val, *nan);
       if (auto* e = check.getErr()) {
-        err << e->msg << " at lane " << index;
+        err << e->msg;
         return Err{err.str()};
       }
     } else {
@@ -352,6 +352,88 @@ struct Shell {
     return Ok{};
   }
 
+  struct AlternativeErr {
+    std::string expected;
+    int lane = -1;
+  };
+
+  Result<Ok, AlternativeErr> matchAlternative(const Literal& val,
+                                              const ExpectedResult& expected) {
+    std::stringstream err;
+
+    if (auto* v = std::get_if<Literal>(&expected)) {
+      if (val != *v) {
+        err << *v;
+        return AlternativeErr{err.str()};
+      }
+    } else if (auto* ref = std::get_if<RefResult>(&expected)) {
+      if (!val.type.isRef() ||
+          !HeapType::isSubType(val.type.getHeapType(), ref->type)) {
+        err << ref->type;
+        return AlternativeErr{err.str()};
+      }
+    } else if ([[maybe_unused]] auto* nullRef =
+                 std::get_if<NullRefResult>(&expected)) {
+      if (!val.isNull()) {
+        err << "ref.null";
+        return AlternativeErr{err.str()};
+      }
+    } else if (auto* nan = std::get_if<NaNResult>(&expected)) {
+      auto check = checkNaN(val, *nan);
+      if (auto* e = check.getErr()) {
+        err << e->msg;
+        return AlternativeErr{err.str()};
+      }
+    } else if (auto* laneResults = std::get_if<LaneResults>(&expected)) {
+      auto check = [&](const auto& vals) -> Result<Ok, AlternativeErr> {
+        for (size_t i = 0; i < vals.size(); ++i) {
+          auto check = checkLane(vals[i], laneResults->lanes[i]);
+          if (auto* e = check.getErr()) {
+            err << e->msg;
+
+            // The number of lanes is small
+            assert(i <= std::numeric_limits<int>::max());
+            return AlternativeErr{err.str(), static_cast<int>(i)};
+          }
+        }
+        return Ok{};
+      };
+
+      bool isFloat =
+        laneResults->type == WATParser::LaneResults::LaneType::Float;
+      switch (laneResults->lanes.size()) {
+        // Use unsigned values for the smaller types here to avoid sign
+        // extension when storing 8/16-bit values in 32-bit ints. This isn't
+        // needed for i32 and i64.
+        case 16: {
+          // There is no f8.
+          assert(!isFloat && "float8 does not exist");
+          CHECK_ERR(check(val.getLanesUI8x16()));
+          break;
+        }
+        case 8: {
+          CHECK_ERR(
+            check(isFloat ? val.getLanesF16x8() : val.getLanesUI16x8()));
+          break;
+        }
+        case 4: {
+          CHECK_ERR(check(isFloat ? val.getLanesF32x4() : val.getLanesI32x4()));
+          break;
+        }
+        case 2: {
+          CHECK_ERR(check(isFloat ? val.getLanesF64x2() : val.getLanesI64x2()));
+          break;
+        }
+        default:
+          WASM_UNREACHABLE("unexpected number of lanes");
+      }
+
+    } else {
+      WASM_UNREACHABLE("unexpected expectation");
+    }
+    return Ok{};
+  }
+
   Result<> assertReturn(AssertReturn& assn) {
     std::stringstream err;
     auto result = doAction(assn.action);
@@ -374,79 +456,53 @@ struct Shell {
         return ss.str();
       };
 
-      Literal val = (*values)[i];
-      auto& expected = assn.expected[i];
-      if (auto* v = std::get_if<Literal>(&expected)) {
-        if (val != *v) {
-          err << "expected " << *v << ", got " << val << atIndex();
-          return Err{err.str()};
-        }
-      } else if (auto* ref = std::get_if<RefResult>(&expected)) {
-        if (!val.type.isRef() ||
-            !HeapType::isSubType(val.type.getHeapType(), ref->type)) {
-          err << "expected " << ref->type << " reference, got " << val
-              << atIndex();
-          return Err{err.str()};
-        }
-      } else if ([[maybe_unused]] auto* nullRef =
-                   std::get_if<NullRefResult>(&expected)) {
-        if (!val.isNull()) {
-          err << "expected ref.null, got " << val << atIndex();
-          return Err{err.str()};
+      // non-either case
+      if (assn.expected[i].size() == 1) {
+        auto result = matchAlternative((*values)[i], assn.expected[i][0]);
+        if (auto* e = result.getErr()) {
+          std::stringstream ss;
+          ss << "expected " << e->expected << ", got " << (*values)[i];
+          if (e->lane != -1) {
+            ss << " at lane " << e->lane;
+          }
+          ss << atIndex();
+          return Err{ss.str()};
         }
-      } else if (auto* nan = std::get_if<NaNResult>(&expected)) {
-        auto check = checkNaN(val, *nan);
-        if (auto* e = check.getErr()) {
-          err << e->msg << atIndex();
-          return Err{err.str()};
+        continue;
+      }
+
+      // either case
+      bool success = false;
+      std::vector<std::string> expecteds;
+      int failedLane = -1;
+      for (const auto& alternative : assn.expected[i]) {
+        auto result = matchAlternative((*values)[i], alternative);
+        if (!result.getErr()) {
+          success = true;
+          break;
         }
-      } else if (auto* l = std::get_if<LaneResults>(&expected)) {
-        auto* lanes = &l->lanes;
-
-        auto check = [&](const auto& vals) -> Result<> {
-          for (size_t i = 0; i < vals.size(); ++i) {
-            auto check = checkLane(vals[i], (*lanes)[i], i);
-            if (auto* e = check.getErr()) {
-              err << e->msg << atIndex();
-              return Err{err.str()};
-            }
-          }
-          return Ok{};
-        };
-
-        bool isFloat = l->type == WATParser::LaneResults::LaneType::Float;
-        switch (lanes->size()) {
-          // Use unsigned values for the smaller types here to avoid sign
-          // extension when storing 8/16-bit values in 32-bit ints. This isn't
-          // needed for i32 and i64.
-          case 16: {
-            // There is no f8.
-            assert(!isFloat && "float8 does not exist");
-            CHECK_ERR(check(val.getLanesUI8x16()));
-            break;
-          }
-          case 8: {
-            CHECK_ERR(
-              check(isFloat ? val.getLanesF16x8() : val.getLanesUI16x8()));
-            break;
-          }
-          case 4: {
-            CHECK_ERR(
-              check(isFloat ? val.getLanesF32x4() : val.getLanesI32x4()));
-            break;
-          }
-          case 2: {
-            CHECK_ERR(
-              check(isFloat ? val.getLanesF64x2() : val.getLanesI64x2()));
-            break;
-          }
-          default:
-            WASM_UNREACHABLE("unexpected number of lanes");
+
+        auto* e = result.getErr();
+        expecteds.push_back(e->expected);
+        if (failedLane == -1 && e->lane != -1) {
+          failedLane = e->lane;
         }
-      } else {
-        WASM_UNREACHABLE("unexpected expectation");
       }
+      if (success) {
+        continue;
+      }
+      std::stringstream ss;
+      ss << "Expected one of (" << String::join(expecteds, " | ") << ")";
+      if (failedLane != -1) {
+        ss << " at lane " << failedLane;
+      }
+      ss << " but got " << (*values)[i];
+
+      ss << atIndex();
+
+      return Err{ss.str()};
     }
+
     return Ok{};
   }