Update stringref text format (#5891)

* Allow new syntax for some stringref opcodes

Fixes #5607

* Update stringref text output

* Update tests with new syntax for stringref opcodes

Except in test/lit/strings.wat, to check that the legacy syntax still works.

3 files changed, 262 insertions, 90 deletions

diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index ce7baadd5..14386334e 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -3089,29 +3089,56 @@ switch (buf[0]) {
                   case 'e': {
                     switch (buf[8]) {
                       case 'n': {
-                        switch (buf[17]) {
-                          case '1': {
-                            switch (buf[19]) {
+                        switch (buf[14]) {
+                          case 'l': {
+                            switch (buf[24]) {
                               case '\0':
-                                if (op == "string.encode_wtf16"sv) { return makeStringEncode(s, StringEncodeWTF16); }
+                                if (op == "string.encode_lossy_utf8"sv) { return makeStringEncode(s, StringEncodeLossyUTF8); }
                                 goto parse_error;
                               case '_':
-                                if (op == "string.encode_wtf16_array"sv) { return makeStringEncode(s, StringEncodeWTF16Array); }
+                                if (op == "string.encode_lossy_utf8_array"sv) { return makeStringEncode(s, StringEncodeLossyUTF8Array); }
                                 goto parse_error;
                               default: goto parse_error;
                             }
                           }
-                          case '8': {
+                          case 'u': {
                             switch (buf[18]) {
                               case '\0':
-                                if (op == "string.encode_wtf8"sv) { return makeStringEncode(s, StringEncodeWTF8); }
+                                if (op == "string.encode_utf8"sv) { return makeStringEncode(s, StringEncodeUTF8); }
                                 goto parse_error;
                               case '_':
-                                if (op == "string.encode_wtf8_array"sv) { return makeStringEncode(s, StringEncodeWTF8Array); }
+                                if (op == "string.encode_utf8_array"sv) { return makeStringEncode(s, StringEncodeUTF8Array); }
                                 goto parse_error;
                               default: goto parse_error;
                             }
                           }
+                          case 'w': {
+                            switch (buf[17]) {
+                              case '1': {
+                                switch (buf[19]) {
+                                  case '\0':
+                                    if (op == "string.encode_wtf16"sv) { return makeStringEncode(s, StringEncodeWTF16); }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.encode_wtf16_array"sv) { return makeStringEncode(s, StringEncodeWTF16Array); }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              case '8': {
+                                switch (buf[18]) {
+                                  case '\0':
+                                    if (op == "string.encode_wtf8"sv) { return makeStringEncode(s, StringEncodeWTF8); }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.encode_wtf8_array"sv) { return makeStringEncode(s, StringEncodeWTF8Array); }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              default: goto parse_error;
+                            }
+                          }
                           default: goto parse_error;
                         }
                       }
@@ -3131,29 +3158,64 @@ switch (buf[0]) {
                     if (op == "string.is_usv_sequence"sv) { return makeStringMeasure(s, StringMeasureIsUSV); }
                     goto parse_error;
                   case 'm': {
-                    switch (buf[18]) {
-                      case '1':
-                        if (op == "string.measure_wtf16"sv) { return makeStringMeasure(s, StringMeasureWTF16); }
-                        goto parse_error;
-                      case '8':
-                        if (op == "string.measure_wtf8"sv) { return makeStringMeasure(s, StringMeasureWTF8); }
+                    switch (buf[15]) {
+                      case 'u':
+                        if (op == "string.measure_utf8"sv) { return makeStringMeasure(s, StringMeasureUTF8); }
                         goto parse_error;
+                      case 'w': {
+                        switch (buf[18]) {
+                          case '1':
+                            if (op == "string.measure_wtf16"sv) { return makeStringMeasure(s, StringMeasureWTF16); }
+                            goto parse_error;
+                          case '8':
+                            if (op == "string.measure_wtf8"sv) { return makeStringMeasure(s, StringMeasureWTF8); }
+                            goto parse_error;
+                          default: goto parse_error;
+                        }
+                      }
                       default: goto parse_error;
                     }
                   }
                   case 'n': {
                     switch (buf[11]) {
-                      case 'u': {
-                        switch (buf[16]) {
-                          case 'a':
-                            if (op == "string.new_utf8_array_try"sv) { return makeStringNew(s, StringNewUTF8Array, true); }
+                      case 'l': {
+                        switch (buf[21]) {
+                          case '\0':
+                            if (op == "string.new_lossy_utf8"sv) { return makeStringNew(s, StringNewLossyUTF8, false); }
                             goto parse_error;
-                          case 't':
-                            if (op == "string.new_utf8_try"sv) { return makeStringNew(s, StringNewUTF8, true); }
+                          case '_':
+                            if (op == "string.new_lossy_utf8_array"sv) { return makeStringNew(s, StringNewLossyUTF8Array, false); }
                             goto parse_error;
                           default: goto parse_error;
                         }
                       }
+                      case 'u': {
+                        switch (buf[15]) {
+                          case '\0':
+                            if (op == "string.new_utf8"sv) { return makeStringNew(s, StringNewUTF8, false); }
+                            goto parse_error;
+                          case '_': {
+                            switch (buf[16]) {
+                              case 'a': {
+                                switch (buf[21]) {
+                                  case '\0':
+                                    if (op == "string.new_utf8_array"sv) { return makeStringNew(s, StringNewUTF8Array, false); }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.new_utf8_array_try"sv) { return makeStringNew(s, StringNewUTF8Array, true); }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              case 't':
+                                if (op == "string.new_utf8_try"sv) { return makeStringNew(s, StringNewUTF8, true); }
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
                       case 'w': {
                         switch (buf[14]) {
                           case '1': {
@@ -8695,19 +8757,19 @@ switch (buf[0]) {
                   case 'e': {
                     switch (buf[8]) {
                       case 'n': {
-                        switch (buf[17]) {
-                          case '1': {
-                            switch (buf[19]) {
+                        switch (buf[14]) {
+                          case 'l': {
+                            switch (buf[24]) {
                               case '\0':
-                                if (op == "string.encode_wtf16"sv) {
-                                  auto ret = makeStringEncode(ctx, pos, StringEncodeWTF16);
+                                if (op == "string.encode_lossy_utf8"sv) {
+                                  auto ret = makeStringEncode(ctx, pos, StringEncodeLossyUTF8);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
                                 goto parse_error;
                               case '_':
-                                if (op == "string.encode_wtf16_array"sv) {
-                                  auto ret = makeStringEncode(ctx, pos, StringEncodeWTF16Array);
+                                if (op == "string.encode_lossy_utf8_array"sv) {
+                                  auto ret = makeStringEncode(ctx, pos, StringEncodeLossyUTF8Array);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
@@ -8715,18 +8777,18 @@ switch (buf[0]) {
                               default: goto parse_error;
                             }
                           }
-                          case '8': {
+                          case 'u': {
                             switch (buf[18]) {
                               case '\0':
-                                if (op == "string.encode_wtf8"sv) {
-                                  auto ret = makeStringEncode(ctx, pos, StringEncodeWTF8);
+                                if (op == "string.encode_utf8"sv) {
+                                  auto ret = makeStringEncode(ctx, pos, StringEncodeUTF8);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
                                 goto parse_error;
                               case '_':
-                                if (op == "string.encode_wtf8_array"sv) {
-                                  auto ret = makeStringEncode(ctx, pos, StringEncodeWTF8Array);
+                                if (op == "string.encode_utf8_array"sv) {
+                                  auto ret = makeStringEncode(ctx, pos, StringEncodeUTF8Array);
                                   CHECK_ERR(ret);
                                   return *ret;
                                 }
@@ -8734,6 +8796,49 @@ switch (buf[0]) {
                               default: goto parse_error;
                             }
                           }
+                          case 'w': {
+                            switch (buf[17]) {
+                              case '1': {
+                                switch (buf[19]) {
+                                  case '\0':
+                                    if (op == "string.encode_wtf16"sv) {
+                                      auto ret = makeStringEncode(ctx, pos, StringEncodeWTF16);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.encode_wtf16_array"sv) {
+                                      auto ret = makeStringEncode(ctx, pos, StringEncodeWTF16Array);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              case '8': {
+                                switch (buf[18]) {
+                                  case '\0':
+                                    if (op == "string.encode_wtf8"sv) {
+                                      auto ret = makeStringEncode(ctx, pos, StringEncodeWTF8);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.encode_wtf8_array"sv) {
+                                      auto ret = makeStringEncode(ctx, pos, StringEncodeWTF8Array);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              default: goto parse_error;
+                            }
+                          }
                           default: goto parse_error;
                         }
                       }
@@ -8769,38 +8874,50 @@ switch (buf[0]) {
                     }
                     goto parse_error;
                   case 'm': {
-                    switch (buf[18]) {
-                      case '1':
-                        if (op == "string.measure_wtf16"sv) {
-                          auto ret = makeStringMeasure(ctx, pos, StringMeasureWTF16);
+                    switch (buf[15]) {
+                      case 'u':
+                        if (op == "string.measure_utf8"sv) {
+                          auto ret = makeStringMeasure(ctx, pos, StringMeasureUTF8);
                           CHECK_ERR(ret);
                           return *ret;
                         }
                         goto parse_error;
-                      case '8':
-                        if (op == "string.measure_wtf8"sv) {
-                          auto ret = makeStringMeasure(ctx, pos, StringMeasureWTF8);
-                          CHECK_ERR(ret);
-                          return *ret;
+                      case 'w': {
+                        switch (buf[18]) {
+                          case '1':
+                            if (op == "string.measure_wtf16"sv) {
+                              auto ret = makeStringMeasure(ctx, pos, StringMeasureWTF16);
+                              CHECK_ERR(ret);
+                              return *ret;
+                            }
+                            goto parse_error;
+                          case '8':
+                            if (op == "string.measure_wtf8"sv) {
+                              auto ret = makeStringMeasure(ctx, pos, StringMeasureWTF8);
+                              CHECK_ERR(ret);
+                              return *ret;
+                            }
+                            goto parse_error;
+                          default: goto parse_error;
                         }
-                        goto parse_error;
+                      }
                       default: goto parse_error;
                     }
                   }
                   case 'n': {
                     switch (buf[11]) {
-                      case 'u': {
-                        switch (buf[16]) {
-                          case 'a':
-                            if (op == "string.new_utf8_array_try"sv) {
-                              auto ret = makeStringNew(ctx, pos, StringNewUTF8Array, true);
+                      case 'l': {
+                        switch (buf[21]) {
+                          case '\0':
+                            if (op == "string.new_lossy_utf8"sv) {
+                              auto ret = makeStringNew(ctx, pos, StringNewLossyUTF8, false);
                               CHECK_ERR(ret);
                               return *ret;
                             }
                             goto parse_error;
-                          case 't':
-                            if (op == "string.new_utf8_try"sv) {
-                              auto ret = makeStringNew(ctx, pos, StringNewUTF8, true);
+                          case '_':
+                            if (op == "string.new_lossy_utf8_array"sv) {
+                              auto ret = makeStringNew(ctx, pos, StringNewLossyUTF8Array, false);
                               CHECK_ERR(ret);
                               return *ret;
                             }
@@ -8808,6 +8925,49 @@ switch (buf[0]) {
                           default: goto parse_error;
                         }
                       }
+                      case 'u': {
+                        switch (buf[15]) {
+                          case '\0':
+                            if (op == "string.new_utf8"sv) {
+                              auto ret = makeStringNew(ctx, pos, StringNewUTF8, false);
+                              CHECK_ERR(ret);
+                              return *ret;
+                            }
+                            goto parse_error;
+                          case '_': {
+                            switch (buf[16]) {
+                              case 'a': {
+                                switch (buf[21]) {
+                                  case '\0':
+                                    if (op == "string.new_utf8_array"sv) {
+                                      auto ret = makeStringNew(ctx, pos, StringNewUTF8Array, false);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  case '_':
+                                    if (op == "string.new_utf8_array_try"sv) {
+                                      auto ret = makeStringNew(ctx, pos, StringNewUTF8Array, true);
+                                      CHECK_ERR(ret);
+                                      return *ret;
+                                    }
+                                    goto parse_error;
+                                  default: goto parse_error;
+                                }
+                              }
+                              case 't':
+                                if (op == "string.new_utf8_try"sv) {
+                                  auto ret = makeStringNew(ctx, pos, StringNewUTF8, true);
+                                  CHECK_ERR(ret);
+                                  return *ret;
+                                }
+                                goto parse_error;
+                              default: goto parse_error;
+                            }
+                          }
+                          default: goto parse_error;
+                        }
+                      }
                       case 'w': {
                         switch (buf[14]) {
                           case '1': {
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index dee23d67d..4e7ae3730 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2301,32 +2301,32 @@ struct PrintExpressionContents
     switch (curr->op) {
       case StringNewUTF8:
         if (!curr->try_) {
-          printMedium(o, "string.new_wtf8 utf8");
+          printMedium(o, "string.new_utf8");
         } else {
           printMedium(o, "string.new_utf8_try");
         }
         break;
       case StringNewWTF8:
-        printMedium(o, "string.new_wtf8 wtf8");
+        printMedium(o, "string.new_wtf8");
         break;
       case StringNewLossyUTF8:
-        printMedium(o, "string.new_wtf8 replace");
+        printMedium(o, "string.new_lossy_utf8");
         break;
       case StringNewWTF16:
         printMedium(o, "string.new_wtf16");
         break;
       case StringNewUTF8Array:
         if (!curr->try_) {
-          printMedium(o, "string.new_wtf8_array utf8");
+          printMedium(o, "string.new_utf8_array");
         } else {
           printMedium(o, "string.new_utf8_array_try");
         }
         break;
       case StringNewWTF8Array:
-        printMedium(o, "string.new_wtf8_array wtf8");
+        printMedium(o, "string.new_wtf8_array");
         break;
       case StringNewLossyUTF8Array:
-        printMedium(o, "string.new_wtf8_array replace");
+        printMedium(o, "string.new_lossy_utf8_array");
         break;
       case StringNewWTF16Array:
         printMedium(o, "string.new_wtf16_array");
@@ -2345,10 +2345,10 @@ struct PrintExpressionContents
   void visitStringMeasure(StringMeasure* curr) {
     switch (curr->op) {
       case StringMeasureUTF8:
-        printMedium(o, "string.measure_wtf8 utf8");
+        printMedium(o, "string.measure_utf8");
         break;
       case StringMeasureWTF8:
-        printMedium(o, "string.measure_wtf8 wtf8");
+        printMedium(o, "string.measure_wtf8");
         break;
       case StringMeasureWTF16:
         printMedium(o, "string.measure_wtf16");
@@ -2369,25 +2369,25 @@ struct PrintExpressionContents
   void visitStringEncode(StringEncode* curr) {
     switch (curr->op) {
       case StringEncodeUTF8:
-        printMedium(o, "string.encode_wtf8 utf8");
+        printMedium(o, "string.encode_utf8");
         break;
       case StringEncodeLossyUTF8:
-        printMedium(o, "string.encode_wtf8 replace");
+        printMedium(o, "string.encode_lossy_utf8");
         break;
       case StringEncodeWTF8:
-        printMedium(o, "string.encode_wtf8 wtf8");
+        printMedium(o, "string.encode_wtf8");
         break;
       case StringEncodeWTF16:
         printMedium(o, "string.encode_wtf16");
         break;
       case StringEncodeUTF8Array:
-        printMedium(o, "string.encode_wtf8_array utf8");
+        printMedium(o, "string.encode_utf8_array");
         break;
       case StringEncodeLossyUTF8Array:
-        printMedium(o, "string.encode_wtf8_array replace");
+        printMedium(o, "string.encode_lossy_utf8_array");
         break;
       case StringEncodeWTF8Array:
-        printMedium(o, "string.encode_wtf8_array wtf8");
+        printMedium(o, "string.encode_wtf8_array");
         break;
       case StringEncodeWTF16Array:
         printMedium(o, "string.encode_wtf16_array");
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 1f215135e..b6b9a40fb 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -3111,8 +3111,9 @@ Expression*
 SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
   size_t i = 1;
   Expression* length = nullptr;
-  if (op == StringNewWTF8 || op == StringNewUTF8) {
-    if (!try_) {
+  if (op == StringNewWTF8) {
+    if (s[i]->isStr()) {
+      // legacy syntax
       std::string_view str = s[i++]->str().str;
       if (str == "utf8") {
         op = StringNewUTF8;
@@ -3126,11 +3127,13 @@ SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
     }
     length = parseExpression(s[i + 1]);
     return Builder(wasm).makeStringNew(op, parseExpression(s[i]), length, try_);
-  } else if (op == StringNewWTF16) {
+  } else if (op == StringNewUTF8 || op == StringNewLossyUTF8 ||
+             op == StringNewWTF16) {
     length = parseExpression(s[i + 1]);
     return Builder(wasm).makeStringNew(op, parseExpression(s[i]), length, try_);
-  } else if (op == StringNewWTF8Array || op == StringNewUTF8Array) {
-    if (!try_) {
+  } else if (op == StringNewWTF8Array) {
+    if (s[i]->isStr()) {
+      // legacy syntax
       std::string_view str = s[i++]->str().str;
       if (str == "utf8") {
         op = StringNewUTF8Array;
@@ -3146,7 +3149,8 @@ SExpressionWasmBuilder::makeStringNew(Element& s, StringNewOp op, bool try_) {
     auto* end = parseExpression(s[i + 2]);
     return Builder(wasm).makeStringNew(
       op, parseExpression(s[i]), start, end, try_);
-  } else if (op == StringNewWTF16Array) {
+  } else if (op == StringNewUTF8Array || op == StringNewLossyUTF8Array ||
+             op == StringNewWTF16Array) {
     auto* start = parseExpression(s[i + 1]);
     auto* end = parseExpression(s[i + 2]);
     return Builder(wasm).makeStringNew(
@@ -3169,7 +3173,8 @@ Expression* SExpressionWasmBuilder::makeStringConst(Element& s) {
 Expression* SExpressionWasmBuilder::makeStringMeasure(Element& s,
                                                       StringMeasureOp op) {
   size_t i = 1;
-  if (op == StringMeasureWTF8) {
+  if (op == StringMeasureWTF8 && s[i]->isStr()) {
+    // legacy syntax
     std::string_view str = s[i++]->str().str;
     if (str == "utf8") {
       op = StringMeasureUTF8;
@@ -3187,29 +3192,36 @@ Expression* SExpressionWasmBuilder::makeStringEncode(Element& s,
   size_t i = 1;
   Expression* start = nullptr;
   if (op == StringEncodeWTF8) {
-    std::string_view str = s[i++]->str().str;
-    if (str == "utf8") {
-      op = StringEncodeUTF8;
-    } else if (str == "replace") {
-      op = StringEncodeLossyUTF8;
-    } else if (str == "wtf8") {
-      op = StringEncodeWTF8;
-    } else {
-      throw ParseException("bad string.new op", s.line, s.col);
+    if (s[i]->isStr()) {
+      // legacy syntax
+      std::string_view str = s[i++]->str().str;
+      if (str == "utf8") {
+        op = StringEncodeUTF8;
+      } else if (str == "replace") {
+        op = StringEncodeLossyUTF8;
+      } else if (str == "wtf8") {
+        op = StringEncodeWTF8;
+      } else {
+        throw ParseException("bad string.new op", s.line, s.col);
+      }
     }
   } else if (op == StringEncodeWTF8Array) {
-    std::string_view str = s[i++]->str().str;
-    if (str == "utf8") {
-      op = StringEncodeUTF8Array;
-    } else if (str == "replace") {
-      op = StringEncodeLossyUTF8Array;
-    } else if (str == "wtf8") {
-      op = StringEncodeWTF8Array;
-    } else {
-      throw ParseException("bad string.new op", s.line, s.col);
+    if (s[i]->isStr()) {
+      // legacy syntax
+      std::string_view str = s[i++]->str().str;
+      if (str == "utf8") {
+        op = StringEncodeUTF8Array;
+      } else if (str == "replace") {
+        op = StringEncodeLossyUTF8Array;
+      } else if (str == "wtf8") {
+        op = StringEncodeWTF8Array;
+      } else {
+        throw ParseException("bad string.new op", s.line, s.col);
+      }
     }
     start = parseExpression(s[i + 2]);
-  } else if (op == StringEncodeWTF16Array) {
+  } else if (op == StringEncodeUTF8Array || op == StringEncodeLossyUTF8Array ||
+             op == StringEncodeWTF16Array) {
     start = parseExpression(s[i + 2]);
   }
   return Builder(wasm).makeStringEncode(