Add standard versions of WasmGC casts (#5331)

We previously supported only the non-standard cast instructions introduced when
we were experimenting with nominal types. Parse the names and opcodes of their
standard counterparts and switch to emitting the standard names and opcodes.
Port all of the tests to use the standard instructions, but add additional tests
showing that the non-standard versions are still parsed correctly.

9 files changed, 158 insertions, 136 deletions

diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 929634c6c..dc5dae035 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -45,7 +45,7 @@ switch (op[0]) {
           case 'n': {
             switch (op[9]) {
               case '\0':
-                if (op == "array.new"sv) { return makeArrayNewStatic(s, false); }
+                if (op == "array.new"sv) { return makeArrayNew(s, false); }
                 goto parse_error;
               case '_': {
                 switch (op[10]) {
@@ -55,7 +55,7 @@ switch (op[0]) {
                         if (op == "array.new_data"sv) { return makeArrayNewSeg(s, NewData); }
                         goto parse_error;
                       case 'e':
-                        if (op == "array.new_default"sv) { return makeArrayNewStatic(s, true); }
+                        if (op == "array.new_default"sv) { return makeArrayNew(s, true); }
                         goto parse_error;
                       default: goto parse_error;
                     }
@@ -111,10 +111,10 @@ switch (op[0]) {
                           case 's': {
                             switch (op[17]) {
                               case '\0':
-                                if (op == "br_on_cast_static"sv) { return makeBrOnStatic(s, BrOnCast); }
+                                if (op == "br_on_cast_static"sv) { return makeBrOn(s, BrOnCast); }
                                 goto parse_error;
                               case '_':
-                                if (op == "br_on_cast_static_fail"sv) { return makeBrOnStatic(s, BrOnCastFail); }
+                                if (op == "br_on_cast_static_fail"sv) { return makeBrOn(s, BrOnCastFail); }
                                 goto parse_error;
                               default: goto parse_error;
                             }
@@ -3016,13 +3016,29 @@ switch (op[0]) {
             }
           }
           case 'c': {
-            switch (op[9]) {
-              case 'n':
-                if (op == "ref.cast_nop_static"sv) { return makeRefCastNopStatic(s); }
-                goto parse_error;
-              case 's':
-                if (op == "ref.cast_static"sv) { return makeRefCastStatic(s); }
+            switch (op[8]) {
+              case '\0':
+                if (op == "ref.cast"sv) { return makeRefCast(s); }
                 goto parse_error;
+              case '_': {
+                switch (op[9]) {
+                  case 'n': {
+                    switch (op[12]) {
+                      case '\0':
+                        if (op == "ref.cast_nop"sv) { return makeRefCastNop(s); }
+                        goto parse_error;
+                      case '_':
+                        if (op == "ref.cast_nop_static"sv) { return makeRefCastNop(s); }
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case 's':
+                    if (op == "ref.cast_static"sv) { return makeRefCast(s); }
+                    goto parse_error;
+                  default: goto parse_error;
+                }
+              }
               default: goto parse_error;
             }
           }
@@ -3052,9 +3068,17 @@ switch (op[0]) {
           case 'n':
             if (op == "ref.null"sv) { return makeRefNull(s); }
             goto parse_error;
-          case 't':
-            if (op == "ref.test_static"sv) { return makeRefTestStatic(s); }
-            goto parse_error;
+          case 't': {
+            switch (op[8]) {
+              case '\0':
+                if (op == "ref.test"sv) { return makeRefTest(s); }
+                goto parse_error;
+              case '_':
+                if (op == "ref.test_static"sv) { return makeRefTest(s); }
+                goto parse_error;
+              default: goto parse_error;
+            }
+          }
           default: goto parse_error;
         }
       }
@@ -3295,10 +3319,10 @@ switch (op[0]) {
               case 'n': {
                 switch (op[10]) {
                   case '\0':
-                    if (op == "struct.new"sv) { return makeStructNewStatic(s, false); }
+                    if (op == "struct.new"sv) { return makeStructNew(s, false); }
                     goto parse_error;
                   case '_':
-                    if (op == "struct.new_default"sv) { return makeStructNewStatic(s, true); }
+                    if (op == "struct.new_default"sv) { return makeStructNew(s, true); }
                     goto parse_error;
                   default: goto parse_error;
                 }
@@ -3613,7 +3637,7 @@ switch (op[0]) {
             switch (op[9]) {
               case '\0':
                 if (op == "array.new"sv) {
-                  auto ret = makeArrayNewStatic(ctx, pos, false);
+                  auto ret = makeArrayNew(ctx, pos, false);
                   CHECK_ERR(ret);
                   return *ret;
                 }
@@ -3631,7 +3655,7 @@ switch (op[0]) {
                         goto parse_error;
                       case 'e':
                         if (op == "array.new_default"sv) {
-                          auto ret = makeArrayNewStatic(ctx, pos, true);
+                          auto ret = makeArrayNew(ctx, pos, true);
                           CHECK_ERR(ret);
                           return *ret;
                         }
@@ -3723,14 +3747,14 @@ switch (op[0]) {
                             switch (op[17]) {
                               case '\0':
                                 if (op == "br_on_cast_static"sv) {
-                                  auto ret = makeBrOnStatic(ctx, pos, BrOnCast);
+                                  auto ret = makeBrOn(ctx, pos, BrOnCast);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
                                 goto parse_error;
                               case '_':
                                 if (op == "br_on_cast_static_fail"sv) {
-                                  auto ret = makeBrOnStatic(ctx, pos, BrOnCastFail);
+                                  auto ret = makeBrOn(ctx, pos, BrOnCastFail);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
@@ -8607,21 +8631,45 @@ switch (op[0]) {
             }
           }
           case 'c': {
-            switch (op[9]) {
-              case 'n':
-                if (op == "ref.cast_nop_static"sv) {
-                  auto ret = makeRefCastNopStatic(ctx, pos);
+            switch (op[8]) {
+              case '\0':
+                if (op == "ref.cast"sv) {
+                  auto ret = makeRefCast(ctx, pos);
                   CHECK_ERR(ret);
                   return *ret;
                 }
                 goto parse_error;
-              case 's':
-                if (op == "ref.cast_static"sv) {
-                  auto ret = makeRefCastStatic(ctx, pos);
-                  CHECK_ERR(ret);
-                  return *ret;
+              case '_': {
+                switch (op[9]) {
+                  case 'n': {
+                    switch (op[12]) {
+                      case '\0':
+                        if (op == "ref.cast_nop"sv) {
+                          auto ret = makeRefCastNop(ctx, pos);
+                          CHECK_ERR(ret);
+                          return *ret;
+                        }
+                        goto parse_error;
+                      case '_':
+                        if (op == "ref.cast_nop_static"sv) {
+                          auto ret = makeRefCastNop(ctx, pos);
+                          CHECK_ERR(ret);
+                          return *ret;
+                        }
+                        goto parse_error;
+                      default: goto parse_error;
+                    }
+                  }
+                  case 's':
+                    if (op == "ref.cast_static"sv) {
+                      auto ret = makeRefCast(ctx, pos);
+                      CHECK_ERR(ret);
+                      return *ret;
+                    }
+                    goto parse_error;
+                  default: goto parse_error;
                 }
-                goto parse_error;
+              }
               default: goto parse_error;
             }
           }
@@ -8679,13 +8727,25 @@ switch (op[0]) {
               return *ret;
             }
             goto parse_error;
-          case 't':
-            if (op == "ref.test_static"sv) {
-              auto ret = makeRefTestStatic(ctx, pos);
-              CHECK_ERR(ret);
-              return *ret;
+          case 't': {
+            switch (op[8]) {
+              case '\0':
+                if (op == "ref.test"sv) {
+                  auto ret = makeRefTest(ctx, pos);
+                  CHECK_ERR(ret);
+                  return *ret;
+                }
+                goto parse_error;
+              case '_':
+                if (op == "ref.test_static"sv) {
+                  auto ret = makeRefTest(ctx, pos);
+                  CHECK_ERR(ret);
+                  return *ret;
+                }
+                goto parse_error;
+              default: goto parse_error;
             }
-            goto parse_error;
+          }
           default: goto parse_error;
         }
       }
@@ -9067,14 +9127,14 @@ switch (op[0]) {
                 switch (op[10]) {
                   case '\0':
                     if (op == "struct.new"sv) {
-                      auto ret = makeStructNewStatic(ctx, pos, false);
+                      auto ret = makeStructNew(ctx, pos, false);
                       CHECK_ERR(ret);
                       return *ret;
                     }
                     goto parse_error;
                   case '_':
                     if (op == "struct.new_default"sv) {
-                      auto ret = makeStructNewStatic(ctx, pos, true);
+                      auto ret = makeStructNew(ctx, pos, true);
                       CHECK_ERR(ret);
                       return *ret;
                     }
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 16b036693..d700f85f3 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2109,14 +2109,14 @@ struct PrintExpressionContents
     printHeapType(o, curr->target->type.getHeapType(), wasm);
   }
   void visitRefTest(RefTest* curr) {
-    printMedium(o, "ref.test_static ");
+    printMedium(o, "ref.test ");
     printHeapType(o, curr->intendedType, wasm);
   }
   void visitRefCast(RefCast* curr) {
     if (curr->safety == RefCast::Unsafe) {
-      printMedium(o, "ref.cast_nop_static ");
+      printMedium(o, "ref.cast_nop ");
     } else {
-      printMedium(o, "ref.cast_static ");
+      printMedium(o, "ref.cast null ");
     }
     printHeapType(o, curr->intendedType, wasm);
   }
@@ -2130,13 +2130,13 @@ struct PrintExpressionContents
         printMedium(o, "br_on_non_null ");
         break;
       case BrOnCast:
-        printMedium(o, "br_on_cast_static ");
+        printMedium(o, "br_on_cast ");
         printName(curr->name, o);
         o << ' ';
         printHeapType(o, curr->intendedType, wasm);
         return;
       case BrOnCastFail:
-        printMedium(o, "br_on_cast_static_fail ");
+        printMedium(o, "br_on_cast_fail ");
         printName(curr->name, o);
         o << ' ';
         printHeapType(o, curr->intendedType, wasm);
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 1ca136f07..55370da26 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1117,11 +1117,19 @@ enum ASTNodes {
   I31New = 0x20,
   I31GetS = 0x21,
   I31GetU = 0x22,
+  RefTest = 0x40,
+  // TODO: RefTestNull
+  RefCastNull = 0x49,
+  // TODO: RefCastNull
+  BrOnCast = 0x42,
+  // TODO: BrOnCastNull
+  BrOnCastFail = 0x43,
+  // TODO: BrOnCastFailNull
   RefTestStatic = 0x44,
   RefCastStatic = 0x45,
   BrOnCastStatic = 0x46,
   BrOnCastStaticFail = 0x47,
-  RefCastNopStatic = 0x48,
+  RefCastNop = 0x48,
   RefIsFunc = 0x50,
   RefIsData = 0x51,
   RefIsI31 = 0x52,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index a29867e55..ff834013d 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -1320,30 +1320,6 @@ public:
   }
 };
 
-// This class adds methods that first inspect the input. They may not have fully
-// comprehensive error checking, when that can be left to the validator; the
-// benefit of the validate* methods is that they can share code between the
-// text and binary format parsers, for handling certain situations in the
-// input which preclude even creating valid IR, which the validator depends
-// on.
-class ValidatingBuilder : public Builder {
-  size_t line = -1, col = -1;
-
-public:
-  ValidatingBuilder(Module& wasm, size_t line) : Builder(wasm), line(line) {}
-  ValidatingBuilder(Module& wasm, size_t line, size_t col)
-    : Builder(wasm), line(line), col(col) {}
-
-  Expression* validateAndMakeBrOn(BrOnOp op, Name name, Expression* ref) {
-    if (op == BrOnNull) {
-      if (!ref->type.isRef() && ref->type != Type::unreachable) {
-        throw ParseException("Invalid ref for br_on_null", line, col);
-      }
-    }
-    return makeBrOn(op, name, ref);
-  }
-};
-
 } // namespace wasm
 
 #endif // wasm_wasm_builder_h
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index 524bc5a3c..23eed7923 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -283,16 +283,15 @@ private:
   Expression* makeCallRef(Element& s, bool isReturn);
   Expression* makeI31New(Element& s);
   Expression* makeI31Get(Element& s, bool signed_);
-  Expression* makeRefTestStatic(Element& s);
-  Expression* makeRefCastStatic(Element& s);
-  Expression* makeRefCastNopStatic(Element& s);
+  Expression* makeRefTest(Element& s);
+  Expression* makeRefCast(Element& s);
+  Expression* makeRefCastNop(Element& s);
   Expression* makeBrOn(Element& s, BrOnOp op);
-  Expression* makeBrOnStatic(Element& s, BrOnOp op);
-  Expression* makeStructNewStatic(Element& s, bool default_);
+  Expression* makeStructNew(Element& s, bool default_);
   Index getStructIndex(Element& type, Element& field);
   Expression* makeStructGet(Element& s, bool signed_ = false);
   Expression* makeStructSet(Element& s);
-  Expression* makeArrayNewStatic(Element& s, bool default_);
+  Expression* makeArrayNew(Element& s, bool default_);
   Expression* makeArrayNewSeg(Element& s, ArrayNewSegOp op);
   Expression* makeArrayInitStatic(Element& s);
   Expression* makeArrayGet(Element& s, bool signed_ = false);
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index d7a424695..7b2922d3c 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -6893,7 +6893,7 @@ bool WasmBinaryBuilder::maybeVisitI31Get(Expression*& out, uint32_t code) {
 }
 
 bool WasmBinaryBuilder::maybeVisitRefTest(Expression*& out, uint32_t code) {
-  if (code == BinaryConsts::RefTestStatic) {
+  if (code == BinaryConsts::RefTestStatic || code == BinaryConsts::RefTest) {
     auto intendedType = getIndexedHeapType();
     auto* ref = popNonVoidExpression();
     out = Builder(wasm).makeRefTest(ref, intendedType);
@@ -6904,11 +6904,11 @@ bool WasmBinaryBuilder::maybeVisitRefTest(Expression*& out, uint32_t code) {
 
 bool WasmBinaryBuilder::maybeVisitRefCast(Expression*& out, uint32_t code) {
   if (code == BinaryConsts::RefCastStatic ||
-      code == BinaryConsts::RefCastNopStatic) {
+      code == BinaryConsts::RefCastNull || code == BinaryConsts::RefCastNop) {
     auto intendedType = getIndexedHeapType();
     auto* ref = popNonVoidExpression();
     auto safety =
-      code == BinaryConsts::RefCastNopStatic ? RefCast::Unsafe : RefCast::Safe;
+      code == BinaryConsts::RefCastNop ? RefCast::Unsafe : RefCast::Safe;
     out = Builder(wasm).makeRefCast(ref, intendedType, safety);
     return true;
   }
@@ -6925,9 +6925,11 @@ bool WasmBinaryBuilder::maybeVisitBrOn(Expression*& out, uint32_t code) {
       op = BrOnNonNull;
       break;
     case BinaryConsts::BrOnCastStatic:
+    case BinaryConsts::BrOnCast:
       op = BrOnCast;
       break;
     case BinaryConsts::BrOnCastStaticFail:
+    case BinaryConsts::BrOnCastFail:
       op = BrOnCastFail;
       break;
     case BinaryConsts::BrOnFunc:
@@ -6952,15 +6954,12 @@ bool WasmBinaryBuilder::maybeVisitBrOn(Expression*& out, uint32_t code) {
       return false;
   }
   auto name = getBreakTarget(getU32LEB()).name;
-  if (code == BinaryConsts::BrOnCastStatic ||
-      code == BinaryConsts::BrOnCastStaticFail) {
-    auto intendedType = getIndexedHeapType();
-    auto* ref = popNonVoidExpression();
-    out = Builder(wasm).makeBrOn(op, name, ref, intendedType);
-    return true;
+  HeapType intendedType;
+  if (op == BrOnCast || op == BrOnCastFail) {
+    intendedType = getIndexedHeapType();
   }
   auto* ref = popNonVoidExpression();
-  out = ValidatingBuilder(wasm, pos).validateAndMakeBrOn(op, name, ref);
+  out = Builder(wasm).makeBrOn(op, name, ref, intendedType);
   return true;
 }
 
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 7bdbc69c6..ee9fdde72 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -2775,40 +2775,42 @@ Expression* SExpressionWasmBuilder::makeI31Get(Element& s, bool signed_) {
   return ret;
 }
 
-Expression* SExpressionWasmBuilder::makeRefTestStatic(Element& s) {
+Expression* SExpressionWasmBuilder::makeRefTest(Element& s) {
   auto heapType = parseHeapType(*s[1]);
   auto* ref = parseExpression(*s[2]);
   return Builder(wasm).makeRefTest(ref, heapType);
 }
 
-Expression* SExpressionWasmBuilder::makeRefCastStatic(Element& s) {
-  auto heapType = parseHeapType(*s[1]);
-  auto* ref = parseExpression(*s[2]);
+Expression* SExpressionWasmBuilder::makeRefCast(Element& s) {
+  int i = 1;
+  if (s[0]->str().str != "ref.cast_static") {
+    if (s[i++]->str().str != "null") {
+      throw ParseException("ref.cast not yet supported. Use ref.cast null.");
+    }
+  }
+  auto heapType = parseHeapType(*s[i++]);
+  auto* ref = parseExpression(*s[i++]);
   return Builder(wasm).makeRefCast(ref, heapType, RefCast::Safe);
 }
 
-Expression* SExpressionWasmBuilder::makeRefCastNopStatic(Element& s) {
+Expression* SExpressionWasmBuilder::makeRefCastNop(Element& s) {
   auto heapType = parseHeapType(*s[1]);
   auto* ref = parseExpression(*s[2]);
   return Builder(wasm).makeRefCast(ref, heapType, RefCast::Unsafe);
 }
 
 Expression* SExpressionWasmBuilder::makeBrOn(Element& s, BrOnOp op) {
-  auto name = getLabel(*s[1]);
-  auto* ref = parseExpression(*s[2]);
-  return ValidatingBuilder(wasm, s.line, s.col)
-    .validateAndMakeBrOn(op, name, ref);
-}
-
-Expression* SExpressionWasmBuilder::makeBrOnStatic(Element& s, BrOnOp op) {
-  auto name = getLabel(*s[1]);
-  auto heapType = parseHeapType(*s[2]);
-  auto* ref = parseExpression(*s[3]);
+  int i = 1;
+  auto name = getLabel(*s[i++]);
+  HeapType heapType;
+  if (op == BrOnCast || op == BrOnCastFail) {
+    heapType = parseHeapType(*s[i++]);
+  }
+  auto* ref = parseExpression(*s[i]);
   return Builder(wasm).makeBrOn(op, name, ref, heapType);
 }
 
-Expression* SExpressionWasmBuilder::makeStructNewStatic(Element& s,
-                                                        bool default_) {
+Expression* SExpressionWasmBuilder::makeStructNew(Element& s, bool default_) {
   auto heapType = parseHeapType(*s[1]);
   auto numOperands = s.size() - 2;
   if (default_ && numOperands > 0) {
@@ -2865,8 +2867,7 @@ Expression* SExpressionWasmBuilder::makeStructSet(Element& s) {
   return Builder(wasm).makeStructSet(index, ref, value);
 }
 
-Expression* SExpressionWasmBuilder::makeArrayNewStatic(Element& s,
-                                                       bool default_) {
+Expression* SExpressionWasmBuilder::makeArrayNew(Element& s, bool default_) {
   auto heapType = parseHeapType(*s[1]);
   Expression* init = nullptr;
   size_t i = 2;
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index daeac60d6..1f477a10c 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2025,16 +2025,16 @@ void BinaryInstWriter::visitCallRef(CallRef* curr) {
 
 void BinaryInstWriter::visitRefTest(RefTest* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
-  o << U32LEB(BinaryConsts::RefTestStatic);
+  o << U32LEB(BinaryConsts::RefTest);
   parent.writeIndexedHeapType(curr->intendedType);
 }
 
 void BinaryInstWriter::visitRefCast(RefCast* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
   if (curr->safety == RefCast::Unsafe) {
-    o << U32LEB(BinaryConsts::RefCastNopStatic);
+    o << U32LEB(BinaryConsts::RefCastNop);
   } else {
-    o << U32LEB(BinaryConsts::RefCastStatic);
+    o << U32LEB(BinaryConsts::RefCastNull);
   }
   parent.writeIndexedHeapType(curr->intendedType);
 }
@@ -2049,11 +2049,11 @@ void BinaryInstWriter::visitBrOn(BrOn* curr) {
       break;
     case BrOnCast:
       o << int8_t(BinaryConsts::GCPrefix);
-      o << U32LEB(BinaryConsts::BrOnCastStatic);
+      o << U32LEB(BinaryConsts::BrOnCast);
       break;
     case BrOnCastFail:
       o << int8_t(BinaryConsts::GCPrefix);
-      o << U32LEB(BinaryConsts::BrOnCastStaticFail);
+      o << U32LEB(BinaryConsts::BrOnCastFail);
       break;
     case BrOnFunc:
       o << int8_t(BinaryConsts::GCPrefix) << U32LEB(BinaryConsts::BrOnFunc);
diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp
index 3f52e6fe6..c3fd2bc4b 100644
--- a/src/wasm/wat-parser.cpp
+++ b/src/wasm/wat-parser.cpp
@@ -2016,24 +2016,20 @@ template<typename Ctx> Result<typename Ctx::InstrT> makeI31New(Ctx&, Index);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeI31Get(Ctx&, Index, bool signed_);
 template<typename Ctx> Result<typename Ctx::InstrT> makeRefTest(Ctx&, Index);
-template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefTestStatic(Ctx&, Index);
+template<typename Ctx> Result<typename Ctx::InstrT> makeRefTest(Ctx&, Index);
 template<typename Ctx> Result<typename Ctx::InstrT> makeRefCast(Ctx&, Index);
-template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefCastStatic(Ctx&, Index);
-template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefCastNopStatic(Ctx&, Index);
+template<typename Ctx> Result<typename Ctx::InstrT> makeRefCastNop(Ctx&, Index);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeBrOn(Ctx&, Index, BrOnOp op);
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeBrOnStatic(Ctx&, Index, BrOnOp op);
+Result<typename Ctx::InstrT> makeBrOn(Ctx&, Index, BrOnOp op);
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeStructNewStatic(Ctx&, Index, bool default_);
+Result<typename Ctx::InstrT> makeStructNew(Ctx&, Index, bool default_);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeStructGet(Ctx&, Index, bool signed_ = false);
 template<typename Ctx> Result<typename Ctx::InstrT> makeStructSet(Ctx&, Index);
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeArrayNewStatic(Ctx&, Index, bool default_);
+Result<typename Ctx::InstrT> makeArrayNew(Ctx&, Index, bool default_);
 template<typename Ctx>
 Result<typename Ctx::InstrT> makeArrayNewSeg(Ctx&, Index, ArrayNewSegOp op);
 template<typename Ctx>
@@ -2972,22 +2968,12 @@ Result<typename Ctx::InstrT> makeRefTest(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefTestStatic(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
-}
-
-template<typename Ctx>
 Result<typename Ctx::InstrT> makeRefCast(Ctx& ctx, Index pos) {
   return ctx.in.err("unimplemented instruction");
 }
 
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefCastStatic(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
-}
-
-template<typename Ctx>
-Result<typename Ctx::InstrT> makeRefCastNopStatic(Ctx& ctx, Index pos) {
+Result<typename Ctx::InstrT> makeRefCastNop(Ctx& ctx, Index pos) {
   return ctx.in.err("unimplemented instruction");
 }
 
@@ -2997,13 +2983,7 @@ Result<typename Ctx::InstrT> makeBrOn(Ctx& ctx, Index pos, BrOnOp op) {
 }
 
 template<typename Ctx>
-Result<typename Ctx::InstrT> makeBrOnStatic(Ctx& ctx, Index pos, BrOnOp op) {
-  return ctx.in.err("unimplemented instruction");
-}
-
-template<typename Ctx>
-Result<typename Ctx::InstrT>
-makeStructNewStatic(Ctx& ctx, Index pos, bool default_) {
+Result<typename Ctx::InstrT> makeStructNew(Ctx& ctx, Index pos, bool default_) {
   auto type = typeidx(ctx);
   CHECK_ERR(type);
   if (default_) {
@@ -3031,8 +3011,7 @@ Result<typename Ctx::InstrT> makeStructSet(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx>
-Result<typename Ctx::InstrT>
-makeArrayNewStatic(Ctx& ctx, Index pos, bool default_) {
+Result<typename Ctx::InstrT> makeArrayNew(Ctx& ctx, Index pos, bool default_) {
   return ctx.in.err("unimplemented instruction");
 }