[Parser] Parse the remaining array operations

src/parser/contexts.h

@@ -104,6 +104,10 @@ struct NullTypeParserCtx {
   HeapTypeT makeI31() { return Ok{}; }
   HeapTypeT makeStructType() { return Ok{}; }
   HeapTypeT makeArrayType() { return Ok{}; }
+  HeapTypeT makeStringType() { return Ok{}; }
+  HeapTypeT makeStringViewWTF8Type() { return Ok{}; }
+  HeapTypeT makeStringViewWTF16Type() { return Ok{}; }
+  HeapTypeT makeStringViewIterType() { return Ok{}; }
 
   TypeT makeI32() { return Ok{}; }
   TypeT makeI64() { return Ok{}; }
@@ -190,6 +194,10 @@ template<typename Ctx> struct TypeParserCtx {
   HeapTypeT makeI31() { return HeapType::i31; }
   HeapTypeT makeStructType() { return HeapType::struct_; }
   HeapTypeT makeArrayType() { return HeapType::array; }
+  HeapTypeT makeStringType() { return HeapType::string; }
+  HeapTypeT makeStringViewWTF8Type() { return HeapType::stringview_wtf8; }
+  HeapTypeT makeStringViewWTF16Type() { return HeapType::stringview_wtf16; }
+  HeapTypeT makeStringViewIterType() { return HeapType::stringview_iter; }
 
   TypeT makeI32() { return Type::i32; }
   TypeT makeI64() { return Type::i64; }
@@ -284,8 +292,9 @@ struct NullInstrParserCtx {
   using FuncIdxT = Ok;
   using LocalIdxT = Ok;
   using TableIdxT = Ok;
-  using GlobalIdxT = Ok;
   using MemoryIdxT = Ok;
+  using GlobalIdxT = Ok;
+  using ElemIdxT = Ok;
   using DataIdxT = Ok;
   using LabelIdxT = Ok;
   using TagIdxT = Ok;
@@ -310,6 +319,8 @@ struct NullInstrParserCtx {
   TableIdxT getTableFromName(Name) { return Ok{}; }
   MemoryIdxT getMemoryFromIdx(uint32_t) { return Ok{}; }
   MemoryIdxT getMemoryFromName(Name) { return Ok{}; }
+  ElemIdxT getElemFromIdx(uint32_t) { return Ok{}; }
+  ElemIdxT getElemFromName(Name) { return Ok{}; }
   DataIdxT getDataFromIdx(uint32_t) { return Ok{}; }
   DataIdxT getDataFromName(Name) { return Ok{}; }
   LabelIdxT getLabelFromIdx(uint32_t, bool) { return Ok{}; }
@@ -458,7 +469,7 @@ struct NullInstrParserCtx {
     return Ok{};
   }
   template<typename HeapTypeT>
-  Result<> makeArrayNewElem(Index, HeapTypeT, DataIdxT) {
+  Result<> makeArrayNewElem(Index, HeapTypeT, ElemIdxT) {
     return Ok{};
   }
   template<typename HeapTypeT>
@@ -479,7 +490,28 @@ struct NullInstrParserCtx {
   template<typename HeapTypeT> Result<> makeArrayFill(Index, HeapTypeT) {
     return Ok{};
   }
+  template<typename HeapTypeT>
+  Result<> makeArrayInitData(Index, HeapTypeT, DataIdxT) {
+    return Ok{};
+  }
+  template<typename HeapTypeT>
+  Result<> makeArrayInitElem(Index, HeapTypeT, ElemIdxT) {
+    return Ok{};
+  }
   Result<> makeRefAs(Index, RefAsOp) { return Ok{}; }
+  Result<> makeStringNew(Index, StringNewOp, bool, MemoryIdxT*) { return Ok{}; }
+  Result<> makeStringConst(Index, std::string_view) { return Ok{}; }
+  Result<> makeStringMeasure(Index, StringMeasureOp) { return Ok{}; }
+  Result<> makeStringEncode(Index, StringEncodeOp, MemoryIdxT*) { return Ok{}; }
+  Result<> makeStringConcat(Index) { return Ok{}; }
+  Result<> makeStringEq(Index, StringEqOp) { return Ok{}; }
+  Result<> makeStringAs(Index, StringAsOp) { return Ok{}; }
+  Result<> makeStringWTF8Advance(Index) { return Ok{}; }
+  Result<> makeStringWTF16Get(Index) { return Ok{}; }
+  Result<> makeStringIterNext(Index) { return Ok{}; }
+  Result<> makeStringIterMove(Index, StringIterMoveOp) { return Ok{}; }
+  Result<> makeStringSliceWTF(Index, StringSliceWTFOp) { return Ok{}; }
+  Result<> makeStringSliceIter(Index) { return Ok{}; }
 };
 
 // Phase 1: Parse definition spans for top-level module elements and determine
@@ -968,6 +1000,7 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
   using GlobalIdxT = Name;
   using TableIdxT = Name;
   using MemoryIdxT = Name;
+  using ElemIdxT = Name;
   using DataIdxT = Name;
   using TagIdxT = Name;
 
@@ -1141,6 +1174,20 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return name;
   }
 
+  Result<Name> getElemFromIdx(uint32_t idx) {
+    if (idx >= wasm.elementSegments.size()) {
+      return in.err("elem index out of bounds");
+    }
+    return wasm.elementSegments[idx]->name;
+  }
+
+  Result<Name> getElemFromName(Name name) {
+    if (!wasm.getElementSegmentOrNull(name)) {
+      return in.err("elem $" + name.toString() + " does not exist");
+    }
+    return name;
+  }
+
   Result<Name> getDataFromIdx(uint32_t idx) {
     if (idx >= wasm.dataSegments.size()) {
       return in.err("data index out of bounds");
@@ -1658,9 +1705,73 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeArrayFill(type));
   }
 
+  Result<> makeArrayInitData(Index pos, HeapType type, Name data) {
+    return withLoc(pos, irBuilder.makeArrayInitData(type, data));
+  }
+
+  Result<> makeArrayInitElem(Index pos, HeapType type, Name elem) {
+    return withLoc(pos, irBuilder.makeArrayInitElem(type, elem));
+  }
+
   Result<> makeRefAs(Index pos, RefAsOp op) {
     return withLoc(pos, irBuilder.makeRefAs(op));
   }
+
+  Result<> makeStringNew(Index pos, StringNewOp op, bool try_, Name* mem) {
+    auto m = getMemory(pos, mem);
+    CHECK_ERR(m);
+    return withLoc(pos, irBuilder.makeStringNew(op, try_, *m));
+  }
+
+  Result<> makeStringConst(Index pos, std::string_view str) {
+    return withLoc(pos, irBuilder.makeStringConst(Name(str)));
+  }
+
+  Result<> makeStringMeasure(Index pos, StringMeasureOp op) {
+    return withLoc(pos, irBuilder.makeStringMeasure(op));
+  }
+
+  Result<> makeStringEncode(Index pos, StringEncodeOp op, Name* mem) {
+    auto m = getMemory(pos, mem);
+    CHECK_ERR(m);
+    return withLoc(pos, irBuilder.makeStringEncode(op, *m));
+  }
+
+  Result<> makeStringConcat(Index pos) {
+    return withLoc(pos, irBuilder.makeStringConcat());
+  }
+
+  Result<> makeStringEq(Index pos, StringEqOp op) {
+    return withLoc(pos, irBuilder.makeStringEq(op));
+  }
+
+  Result<> makeStringAs(Index pos, StringAsOp op) {
+    return withLoc(pos, irBuilder.makeStringAs(op));
+  }
+
+  Result<> makeStringWTF8Advance(Index pos) {
+    return withLoc(pos, irBuilder.makeStringWTF8Advance());
+  }
+
+  Result<> makeStringWTF16Get(Index pos) {
+    return withLoc(pos, irBuilder.makeStringWTF16Get());
+  }
+
+  Result<> makeStringIterNext(Index pos) {
+    return withLoc(pos, irBuilder.makeStringIterNext());
+  }
+
+  Result<> makeStringIterMove(Index pos, StringIterMoveOp op) {
+    return withLoc(pos, irBuilder.makeStringIterMove(op));
+  }
+
+  Result<> makeStringSliceWTF(Index pos, StringSliceWTFOp op) {
+    return withLoc(pos, irBuilder.makeStringSliceWTF(op));
+  }
+
+  Result<> makeStringSliceIter(Index pos) {
+    return withLoc(pos, irBuilder.makeStringSliceIter());
+  }
 };
 
 } // namespace wasm::WATParser

src/parser/input-impl.h

@@ -226,11 +226,11 @@ inline std::optional<float> ParseInput::takeF32() {
   return std::nullopt;
 }
 
-inline std::optional<std::string_view> ParseInput::takeString() {
+inline std::optional<std::string> ParseInput::takeString() {
   if (auto t = peek()) {
     if (auto s = t->getString()) {
       ++lexer;
-      return s;
+      return std::string(*s);
     }
   }
   return {};

src/parser/input.h

@@ -59,7 +59,7 @@ struct ParseInput {
   std::optional<uint8_t> takeU8();
   std::optional<double> takeF64();
   std::optional<float> takeF32();
-  std::optional<std::string_view> takeString();
+  std::optional<std::string> takeString();
   std::optional<Name> takeName();
   bool takeSExprStart(std::string_view expected);
   bool peekSExprStart(std::string_view expected);

src/parser/parsers.h

@@ -176,6 +176,8 @@ template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::MemoryIdxT> memidx(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::MemoryIdxT> maybeMemuse(Ctx&);
 template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx&);
+template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx&);
 template<typename Ctx> Result<typename Ctx::LocalIdxT> localidx(Ctx&);
 template<typename Ctx>
 Result<typename Ctx::LabelIdxT> labelidx(Ctx&, bool inDelegate = false);
@@ -249,6 +251,18 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
   if (ctx.in.takeKeyword("array"sv)) {
     return ctx.makeArrayType();
   }
+  if (ctx.in.takeKeyword("string"sv)) {
+    return ctx.makeStringType();
+  }
+  if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+    return ctx.makeStringViewWTF8Type();
+  }
+  if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+    return ctx.makeStringViewWTF16Type();
+  }
+  if (ctx.in.takeKeyword("stringview_iter"sv)) {
+    return ctx.makeStringViewIterType();
+  }
   auto type = typeidx(ctx);
   CHECK_ERR(type);
   return *type;
@@ -282,7 +296,19 @@ template<typename Ctx> MaybeResult<typename Ctx::TypeT> reftype(Ctx& ctx) {
     return ctx.makeRefType(ctx.makeStructType(), Nullable);
   }
   if (ctx.in.takeKeyword("arrayref"sv)) {
-    return ctx.in.err("arrayref not yet supported");
+    return ctx.makeRefType(ctx.makeArrayType(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringref"sv)) {
+    return ctx.makeRefType(ctx.makeStringType(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_wtf8"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewWTF8Type(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_wtf16"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewWTF16Type(), Nullable);
+  }
+  if (ctx.in.takeKeyword("stringview_iter"sv)) {
+    return ctx.makeRefType(ctx.makeStringViewIterType(), Nullable);
   }
 
   if (!ctx.in.takeSExprStart("ref"sv)) {
@@ -1584,7 +1610,11 @@ template<typename Ctx> Result<> makeArrayNewData(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeArrayNewElem(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto elem = elemidx(ctx);
+  CHECK_ERR(elem);
+  return ctx.makeArrayNewElem(pos, *type, *elem);
 }
 
 template<typename Ctx> Result<> makeArrayNewFixed(Ctx& ctx, Index pos) {
@@ -1629,11 +1659,18 @@ template<typename Ctx> Result<> makeArrayFill(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeArrayInitData(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto data = dataidx(ctx);
+  CHECK_ERR(data);
+  return ctx.makeArrayInitData(pos, *type, *data);
 }
 
 template<typename Ctx> Result<> makeArrayInitElem(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto type = typeidx(ctx);
+  CHECK_ERR(type);
+  auto elem = elemidx(ctx);
+  return ctx.makeArrayInitElem(pos, *type, *elem);
 }
 
 template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
@@ -1642,61 +1679,69 @@ template<typename Ctx> Result<> makeRefAs(Ctx& ctx, Index pos, RefAsOp op) {
 
 template<typename Ctx>
 Result<> makeStringNew(Ctx& ctx, Index pos, StringNewOp op, bool try_) {
-  return ctx.in.err("unimplemented instruction");
+  auto mem = maybeMemidx(ctx);
+  CHECK_ERR(mem);
+  return ctx.makeStringNew(pos, op, try_, mem.getPtr());
 }
 
 template<typename Ctx> Result<> makeStringConst(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  auto str = ctx.in.takeString();
+  if (!str) {
+    return ctx.in.err("expected string");
+  }
+  return ctx.makeStringConst(pos, *str);
 }
 
 template<typename Ctx>
 Result<> makeStringMeasure(Ctx& ctx, Index pos, StringMeasureOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringMeasure(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringEncode(Ctx& ctx, Index pos, StringEncodeOp op) {
-  return ctx.in.err("unimplemented instruction");
+  auto mem = maybeMemidx(ctx);
+  CHECK_ERR(mem);
+  return ctx.makeStringEncode(pos, op, mem.getPtr());
 }
 
 template<typename Ctx> Result<> makeStringConcat(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringConcat(pos);
 }
 
 template<typename Ctx>
 Result<> makeStringEq(Ctx& ctx, Index pos, StringEqOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringEq(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringAs(Ctx& ctx, Index pos, StringAsOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringAs(pos, op);
 }
 
 template<typename Ctx> Result<> makeStringWTF8Advance(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringWTF8Advance(pos);
 }
 
 template<typename Ctx> Result<> makeStringWTF16Get(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringWTF16Get(pos);
 }
 
 template<typename Ctx> Result<> makeStringIterNext(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringIterNext(pos);
 }
 
 template<typename Ctx>
 Result<> makeStringIterMove(Ctx& ctx, Index pos, StringIterMoveOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringIterMove(pos, op);
 }
 
 template<typename Ctx>
 Result<> makeStringSliceWTF(Ctx& ctx, Index pos, StringSliceWTFOp op) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringSliceWTF(pos, op);
 }
 
 template<typename Ctx> Result<> makeStringSliceIter(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeStringSliceIter(pos);
 }
 
 // =======
@@ -1843,8 +1888,20 @@ template<typename Ctx> Result<typename Ctx::GlobalIdxT> globalidx(Ctx& ctx) {
   return ctx.in.err("expected global index or identifier");
 }
 
+// elemidx ::= x:u32 => x
+//           | v:id => x (if elems[x] = v)
+template<typename Ctx> Result<typename Ctx::ElemIdxT> elemidx(Ctx& ctx) {
+  if (auto x = ctx.in.takeU32()) {
+    return ctx.getElemFromIdx(*x);
+  }
+  if (auto id = ctx.in.takeID()) {
+    return ctx.getElemFromName(*id);
+  }
+  return ctx.in.err("expected elem index or identifier");
+}
+
 // dataidx ::= x:u32 => x
-//           | v:id => x (if data[x] = v)
+//           | v:id => x (if datas[x] = v)
 template<typename Ctx> Result<typename Ctx::DataIdxT> dataidx(Ctx& ctx) {
   if (auto x = ctx.in.takeU32()) {
     return ctx.getDataFromIdx(*x);