Parse and print `array.new_fixed` (#5527)

This is a (more) standard name for `array.init_static`. (The full upstream name
in the spec repo is `array.new_canon_fixed`, but I'm still hoping we can drop
`canon` from all the instruction names and it doesn't appear elsewhere in
Binaryen).

Update all the existing tests to use the new name and add a test specifically to
ensure the old name continues parsing.

8 files changed, 20 insertions, 10 deletions

diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 0022296a4..cbd2c027c 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -36,7 +36,7 @@ switch (buf[0]) {
             }
           }
           case 'i':
-            if (op == "array.init_static"sv) { return makeArrayNewFixedStatic(s); }
+            if (op == "array.init_static"sv) { return makeArrayNewFixed(s); }
             goto parse_error;
           case 'l':
             if (op == "array.len"sv) { return makeArrayLen(s); }
@@ -62,6 +62,9 @@ switch (buf[0]) {
                   case 'e':
                     if (op == "array.new_elem"sv) { return makeArrayNewSeg(s, NewElem); }
                     goto parse_error;
+                  case 'f':
+                    if (op == "array.new_fixed"sv) { return makeArrayNewFixed(s); }
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
@@ -3637,7 +3640,7 @@ switch (buf[0]) {
           }
           case 'i':
             if (op == "array.init_static"sv) {
-              auto ret = makeArrayNewFixedStatic(ctx, pos);
+              auto ret = makeArrayNewFixed(ctx, pos);
               CHECK_ERR(ret);
               return *ret;
             }
@@ -3686,6 +3689,13 @@ switch (buf[0]) {
                       return *ret;
                     }
                     goto parse_error;
+                  case 'f':
+                    if (op == "array.new_fixed"sv) {
+                      auto ret = makeArrayNewFixed(ctx, pos);
+                      CHECK_ERR(ret);
+                      return *ret;
+                    }
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 85fd2c21a..4a4fe60c7 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2289,7 +2289,7 @@ struct PrintExpressionContents
     if (printUnreachableReplacement(curr)) {
       return;
     }
-    printMedium(o, "array.init_static");
+    printMedium(o, "array.new_fixed");
     o << ' ';
     TypeNamePrinter(o, wasm).print(curr->type.getHeapType());
   }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 1e86252a1..f09094c9d 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1110,7 +1110,7 @@ enum ASTNodes {
   ArrayLenAnnotated = 0x17,
   ArrayCopy = 0x18,
   ArrayLen = 0x19,
-  ArrayNewFixedStatic = 0x1a,
+  ArrayNewFixed = 0x1a,
   ArrayNew = 0x1b,
   ArrayNewDefault = 0x1c,
   ArrayNewData = 0x1d,
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index a52915441..5692df03d 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -297,7 +297,7 @@ private:
   Expression* makeStructSet(Element& s);
   Expression* makeArrayNew(Element& s, bool default_);
   Expression* makeArrayNewSeg(Element& s, ArrayNewSegOp op);
-  Expression* makeArrayNewFixedStatic(Element& s);
+  Expression* makeArrayNewFixed(Element& s);
   Expression* makeArrayGet(Element& s, bool signed_ = false);
   Expression* makeArraySet(Element& s);
   Expression* makeArrayLen(Element& s);
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index e5e05bacc..72f99c033 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -7111,7 +7111,7 @@ bool WasmBinaryBuilder::maybeVisitArrayNewSeg(Expression*& out, uint32_t code) {
 
 bool WasmBinaryBuilder::maybeVisitArrayNewFixed(Expression*& out,
                                                 uint32_t code) {
-  if (code == BinaryConsts::ArrayNewFixedStatic) {
+  if (code == BinaryConsts::ArrayNewFixed) {
     auto heapType = getIndexedHeapType();
     auto size = getU32LEB();
     std::vector<Expression*> values(size);
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 4f4b28754..522c3f3c6 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -2925,7 +2925,7 @@ Expression* SExpressionWasmBuilder::makeArrayNewSeg(Element& s,
   return Builder(wasm).makeArrayNewSeg(op, heapType, seg, offset, size);
 }
 
-Expression* SExpressionWasmBuilder::makeArrayNewFixedStatic(Element& s) {
+Expression* SExpressionWasmBuilder::makeArrayNewFixed(Element& s) {
   auto heapType = parseHeapType(*s[1]);
   size_t i = 2;
   std::vector<Expression*> values;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 3f53e3dde..b0e78c22e 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2195,7 +2195,7 @@ void BinaryInstWriter::visitArrayNewSeg(ArrayNewSeg* curr) {
 
 void BinaryInstWriter::visitArrayNewFixed(ArrayNewFixed* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
-  o << U32LEB(BinaryConsts::ArrayNewFixedStatic);
+  o << U32LEB(BinaryConsts::ArrayNewFixed);
   parent.writeIndexedHeapType(curr->type.getHeapType());
   o << U32LEB(curr->values.size());
 }
diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp
index ee48d7262..89e913ab5 100644
--- a/src/wasm/wat-parser.cpp
+++ b/src/wasm/wat-parser.cpp
@@ -2365,7 +2365,7 @@ Result<typename Ctx::InstrT> makeArrayNew(Ctx&, Index, bool default_);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeArrayNewSeg(Ctx&, Index, ArrayNewSegOp op);
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeArrayNewFixedStatic(Ctx&, Index);
+Result<typename Ctx::InstrT> makeArrayNewFixed(Ctx&, Index);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeArrayGet(Ctx&, Index, bool signed_ = false);
 template<typename Ctx> Result<typename Ctx::InstrT> makeArraySet(Ctx&, Index);
@@ -3525,7 +3525,7 @@ makeArrayNewSeg(Ctx& ctx, Index pos, ArrayNewSegOp op) {
 }
 
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeArrayNewFixedStatic(Ctx& ctx, Index pos) {
+Result<typename Ctx::InstrT> makeArrayNewFixed(Ctx& ctx, Index pos) {
   return ctx.in.err("unimplemented instruction");
 }