[Strings] Implement string.test (WebAssembly#7684)

osa1 · web-flow · commit 22f87dc1cb9e · 2025-07-02T11:59:53.000-07:00
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -678,6 +678,7 @@
     ("string.concat",        "makeStringConcat()"),
     ("string.eq",            "makeStringEq(StringEqEqual)"),
     ("string.compare",       "makeStringEq(StringEqCompare)"),
+    ("string.test",          "makeStringTest()"),
     ("stringview_wtf16.get_codeunit", "makeStringWTF16Get()"),
     ("stringview_wtf16.slice",        "makeStringSliceWTF()"),
     # Ignored in input
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -5139,6 +5139,12 @@ switch (buf[0]) {
                       default: goto parse_error;
                     }
                   }
+                  case 't':
+                    if (op == "string.test"sv) {
+                      CHECK_ERR(makeStringTest(ctx, pos, annotations));
+                      return Ok{};
+                    }
+                    goto parse_error;
                   default: goto parse_error;
                 }
               }
diff --git a/src/interpreter/interpreter.cpp b/src/interpreter/interpreter.cpp
@@ -273,6 +273,7 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitStringEncode(StringEncode* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStringConcat(StringConcat* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStringEq(StringEq* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitStringTest(StringTest* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStringWTF16Get(StringWTF16Get* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStringSliceWTF(StringSliceWTF* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitContNew(ContNew* curr) { WASM_UNREACHABLE("TODO"); }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -182,6 +182,7 @@ void ReFinalize::visitStringMeasure(StringMeasure* curr) { curr->finalize(); }
 void ReFinalize::visitStringEncode(StringEncode* curr) { curr->finalize(); }
 void ReFinalize::visitStringConcat(StringConcat* curr) { curr->finalize(); }
 void ReFinalize::visitStringEq(StringEq* curr) { curr->finalize(); }
+void ReFinalize::visitStringTest(StringTest* curr) { curr->finalize(); }
 void ReFinalize::visitStringWTF16Get(StringWTF16Get* curr) { curr->finalize(); }
 void ReFinalize::visitStringSliceWTF(StringSliceWTF* curr) { curr->finalize(); }
 void ReFinalize::visitContNew(ContNew* curr) { curr->finalize(); }
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
@@ -1226,6 +1226,11 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     note(&curr->right, stringref);
   }
 
+  void visitStringTest(StringTest* curr) {
+    auto stringref = Type(HeapType::ext, Nullable);
+    note(&curr->ref, stringref);
+  }
+
   void visitStringWTF16Get(StringWTF16Get* curr) {
     note(&curr->ref, Type(HeapType::string, Nullable));
     note(&curr->pos, Type::i32);
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -788,6 +788,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     // "3" is chosen since strings might or might not be interned in the engine.
     return 3 + visit(curr->left) + visit(curr->right);
   }
+  CostType visitStringTest(StringTest* curr) {
+    // "3" copied from `visitStringEq`.
+    return 3 + visit(curr->ref);
+  }
   CostType visitStringWTF16Get(StringWTF16Get* curr) {
     return 1 + visit(curr->ref) + visit(curr->pos);
   }
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -1081,6 +1081,7 @@ class EffectAnalyzer {
         }
       }
     }
+    void visitStringTest(StringTest* curr) {}
     void visitStringWTF16Get(StringWTF16Get* curr) {
       // traps when ref is null.
       parent.implicitTrap = true;
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -662,9 +662,7 @@ struct InfoCollector
       info.calledFromOutside.insert(curr->func);
     }
   }
-  void visitRefEq(RefEq* curr) {
-    addRoot(curr);
-  }
+  void visitRefEq(RefEq* curr) { addRoot(curr); }
   void visitTableGet(TableGet* curr) {
     // TODO: be more precise
     addRoot(curr);
@@ -1143,6 +1141,10 @@ struct InfoCollector
     // TODO: optimize when possible
     addRoot(curr);
   }
+  void visitStringTest(StringTest* curr) {
+    // TODO: optimize when possible
+    addRoot(curr);
+  }
   void visitStringWTF16Get(StringWTF16Get* curr) {
     // TODO: optimize when possible
     addRoot(curr);
diff --git a/src/ir/subtype-exprs.h b/src/ir/subtype-exprs.h
@@ -429,6 +429,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitStringEncode(StringEncode* curr) {}
   void visitStringConcat(StringConcat* curr) {}
   void visitStringEq(StringEq* curr) {}
+  void visitStringTest(StringTest* curr) {}
   void visitStringWTF16Get(StringWTF16Get* curr) {}
   void visitStringSliceWTF(StringSliceWTF* curr) {}
 
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
@@ -890,6 +890,9 @@ struct NullInstrParserCtx {
   Result<> makeStringEq(Index, const std::vector<Annotation>&, StringEqOp) {
     return Ok{};
   }
+  Result<> makeStringTest(Index, const std::vector<Annotation>&) {
+    return Ok{};
+  }
   Result<> makeStringWTF8Advance(Index, const std::vector<Annotation>&) {
     return Ok{};
   }
@@ -2823,6 +2826,11 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx>, AnnotationParserCtx {
     return withLoc(pos, irBuilder.makeStringEq(op));
   }
 
+  Result<> makeStringTest(Index pos,
+                          const std::vector<Annotation>& annotations) {
+    return withLoc(pos, irBuilder.makeStringTest());
+  }
+
   Result<> makeStringWTF16Get(Index pos,
                               const std::vector<Annotation>& annotations) {
     return withLoc(pos, irBuilder.makeStringWTF16Get());
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
@@ -319,6 +319,8 @@ Result<> makeStringConcat(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeStringEq(Ctx&, Index, const std::vector<Annotation>&, StringEqOp);
 template<typename Ctx>
+Result<> makeStringTest(Ctx&, Index, const std::vector<Annotation>&);
+template<typename Ctx>
 Result<> makeStringWTF16Get(Ctx&, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeStringSliceWTF(Ctx&, Index, const std::vector<Annotation>&);
@@ -2627,6 +2629,13 @@ Result<> makeStringEq(Ctx& ctx,
   return ctx.makeStringEq(pos, annotations, op);
 }
 
+template<typename Ctx>
+Result<> makeStringTest(Ctx& ctx,
+                        Index pos,
+                        const std::vector<Annotation>& annotations) {
+  return ctx.makeStringTest(pos, annotations);
+}
+
 template<typename Ctx>
 Result<> makeStringWTF16Get(Ctx& ctx,
                             Index pos,
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -2547,6 +2547,7 @@ struct PrintExpressionContents
         WASM_UNREACHABLE("invalid string.eq*");
     }
   }
+  void visitStringTest(StringTest* curr) { printMedium(o, "string.test"); }
   void visitStringWTF16Get(StringWTF16Get* curr) {
     printMedium(o, "stringview_wtf16.get_codeunit");
   }
diff --git a/src/passes/StringLifting.cpp b/src/passes/StringLifting.cpp
@@ -44,6 +44,7 @@ struct StringLifting : public Pass {
   Name fromCodePointImport;
   Name concatImport;
   Name equalsImport;
+  Name testImport;
   Name compareImport;
   Name lengthImport;
   Name charCodeAtImport;
@@ -163,6 +164,12 @@ struct StringLifting : public Pass {
         }
         equalsImport = func->name;
         found = true;
+      } else if (func->base == "test") {
+        if (sig != Signature({externref}, i32)) {
+          Fatal() << "StringLifting: bad signature for test: " << sig;
+        }
+        testImport = func->name;
+        found = true;
       } else if (func->base == "compare") {
         if (sig != Signature({externref, externref}, i32)) {
           Fatal() << "StringLifting: bad signature for compare: " << sig;
@@ -247,6 +254,9 @@ struct StringLifting : public Pass {
                            .makeStringEq(StringEqEqual,
                                          curr->operands[0],
                                          curr->operands[1]));
+        } else if (curr->target == parent.testImport) {
+          replaceCurrent(
+            Builder(*getModule()).makeStringTest(curr->operands[0]));
         } else if (curr->target == parent.compareImport) {
           replaceCurrent(Builder(*getModule())
                            .makeStringEq(StringEqCompare,
diff --git a/src/passes/StringLowering.cpp b/src/passes/StringLowering.cpp
@@ -362,6 +362,7 @@ struct StringLowering : public StringGathering {
   Name fromCodePointImport;
   Name concatImport;
   Name equalsImport;
+  Name testImport;
   Name compareImport;
   Name lengthImport;
   Name charCodeAtImport;
@@ -397,6 +398,8 @@ struct StringLowering : public StringGathering {
                                         Type::i32);
     // string.equals: string, string -> i32
     equalsImport = addImport(module, "equals", {nullExt, nullExt}, Type::i32);
+    // string.test: externref -> i32
+    testImport = addImport(module, "test", {nullExt}, Type::i32);
     // string.compare: string, string -> i32
     compareImport = addImport(module, "compare", {nullExt, nullExt}, Type::i32);
     // string.length: string -> i32
@@ -473,6 +476,12 @@ struct StringLowering : public StringGathering {
         }
       }
 
+      void visitStringTest(StringTest* curr) {
+        Builder builder(*getModule());
+        replaceCurrent(
+          builder.makeCall(lowering.testImport, {curr->ref}, Type::i32));
+      }
+
       void visitStringMeasure(StringMeasure* curr) {
         Builder builder(*getModule());
         replaceCurrent(
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
@@ -880,6 +880,7 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
   void visitStringEncode(StringEncode* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStringConcat(StringConcat* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStringEq(StringEq* curr) { WASM_UNREACHABLE("TODO"); }
+  void visitStringTest(StringTest* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStringWTF16Get(StringWTF16Get* curr) { WASM_UNREACHABLE("TODO"); }
   void visitStringSliceWTF(StringSliceWTF* curr) { WASM_UNREACHABLE("TODO"); }
 
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1222,6 +1222,7 @@ enum ASTNodes {
   StringConcat = 0x88,
   StringEq = 0x89,
   StringIsUSV = 0x8a,
+  StringTest = 0x8b,
   StringAsWTF16 = 0x98,
   StringViewWTF16GetCodePoint = 0x9a,
   StringViewWTF16Slice = 0x9c,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -1231,6 +1231,12 @@ class Builder {
     ret->finalize();
     return ret;
   }
+  StringTest* makeStringTest(Expression* ref) {
+    auto* ret = wasm.allocator.alloc<StringTest>();
+    ret->ref = ref;
+    ret->finalize();
+    return ret;
+  }
   StringWTF16Get* makeStringWTF16Get(Expression* ref, Expression* pos) {
     auto* ret = wasm.allocator.alloc<StringWTF16Get>();
     ret->ref = ref;
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -830,6 +830,10 @@ DELEGATE_FIELD_CHILD(StringEq, right)
 DELEGATE_FIELD_CHILD(StringEq, left)
 DELEGATE_FIELD_CASE_END(StringEq)
 
+DELEGATE_FIELD_CASE_START(StringTest)
+DELEGATE_FIELD_CHILD(StringTest, ref)
+DELEGATE_FIELD_CASE_END(StringTest)
+
 DELEGATE_FIELD_CASE_START(StringWTF16Get)
 DELEGATE_FIELD_CHILD(StringWTF16Get, pos)
 DELEGATE_FIELD_CHILD(StringWTF16Get, ref)
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -105,6 +105,7 @@ DELEGATE(StringMeasure);
 DELEGATE(StringEncode);
 DELEGATE(StringConcat);
 DELEGATE(StringEq);
+DELEGATE(StringTest);
 DELEGATE(StringWTF16Get);
 DELEGATE(StringSliceWTF);
 DELEGATE(ContNew);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -2448,6 +2448,14 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     }
     return Literal(result);
   }
+  Flow visitStringTest(StringTest* curr) {
+    Flow flow = visit(curr->ref);
+    if (flow.breaking()) {
+      return flow;
+    }
+    auto value = flow.getSingleValue();
+    return Literal((uint32_t)value.isString());
+  }
   Flow visitStringWTF16Get(StringWTF16Get* curr) {
     NOTE_ENTER("StringWTF16Get");
     Flow ref = visit(curr->ref);
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -257,6 +257,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   Result<> makeStringEncode(StringEncodeOp op);
   Result<> makeStringConcat();
   Result<> makeStringEq(StringEqOp op);
+  Result<> makeStringTest();
   Result<> makeStringWTF8Advance();
   Result<> makeStringWTF16Get();
   Result<> makeStringIterNext();
diff --git a/src/wasm.h b/src/wasm.h
@@ -748,6 +748,7 @@ class Expression {
     StringEncodeId,
     StringConcatId,
     StringEqId,
+    StringTestId,
     StringWTF16GetId,
     StringSliceWTFId,
     ContNewId,
@@ -2006,6 +2007,16 @@ class StringEq : public SpecificExpression<Expression::StringEqId> {
   void finalize();
 };
 
+class StringTest : public SpecificExpression<Expression::StringTestId> {
+public:
+  StringTest() = default;
+  StringTest(MixedArena& allocator) {}
+
+  Expression* ref;
+
+  void finalize();
+};
+
 class StringWTF16Get : public SpecificExpression<Expression::StringWTF16GetId> {
 public:
   StringWTF16Get() = default;
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -4663,6 +4663,8 @@ Result<> WasmBinaryReader::readInst() {
           return builder.makeStringConcat();
         case BinaryConsts::StringEq:
           return builder.makeStringEq(StringEqEqual);
+        case BinaryConsts::StringTest:
+          return builder.makeStringTest();
         case BinaryConsts::StringCompare:
           return builder.makeStringEq(StringEqCompare);
         case BinaryConsts::StringViewWTF16GetCodePoint:
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -2505,6 +2505,13 @@ Result<> IRBuilder::makeStringEq(StringEqOp op) {
   return Ok{};
 }
 
+Result<> IRBuilder::makeStringTest() {
+  StringTest curr;
+  CHECK_ERR(visitStringTest(&curr));
+  push(builder.makeStringTest(curr.ref));
+  return Ok{};
+}
+
 Result<> IRBuilder::makeStringWTF16Get() {
   StringWTF16Get curr;
   CHECK_ERR(visitStringWTF16Get(&curr));
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
@@ -2697,6 +2697,10 @@ void BinaryInstWriter::visitStringEq(StringEq* curr) {
   }
 }
 
+void BinaryInstWriter::visitStringTest(StringTest* curr) {
+  o << int8_t(BinaryConsts::GCPrefix) << U32LEB(BinaryConsts::StringTest);
+}
+
 void BinaryInstWriter::visitStringWTF16Get(StringWTF16Get* curr) {
   // We need to convert the ref operand to a stringview, but it is under the pos
   // operand. Put the i32 in a scratch local, emit the conversion, then get the
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
diff --git a/src/wasm2js.h b/src/wasm2js.h
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
diff --git a/test/lit/passes/string-gathering.wast b/test/lit/passes/string-gathering.wast
diff --git a/test/lit/passes/string-lifting-section.wast b/test/lit/passes/string-lifting-section.wast
diff --git a/test/lit/passes/string-lifting.wast b/test/lit/passes/string-lifting.wast
diff --git a/test/lit/passes/string-lowering-imports-custom-module.wast b/test/lit/passes/string-lowering-imports-custom-module.wast
diff --git a/test/lit/passes/string-lowering-instructions.wast b/test/lit/passes/string-lowering-instructions.wast
diff --git a/test/lit/passes/string-lowering_types.wast b/test/lit/passes/string-lowering_types.wast
diff --git a/test/lit/strings.wast b/test/lit/strings.wast

Original file line number	Diff line number	Diff line change
`@@ -5139,6 +5139,12 @@ switch (buf[0]) {`
`5139`	`5139`	`default: goto parse_error;`
`5140`	`5140`	`}`
`5141`	`5141`	`}`
	`5142`	`+ case 't':`
	`5143`	`+ if (op == "string.test"sv) {`
	`5144`	`+ CHECK_ERR(makeStringTest(ctx, pos, annotations));`
	`5145`	`+ return Ok{};`
	`5146`	`+ }`
	`5147`	`+ goto parse_error;`
`5142`	`5148`	`default: goto parse_error;`
`5143`	`5149`	`}`
`5144`	`5150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -788,6 +788,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {`
`788`	`788`	`// "3" is chosen since strings might or might not be interned in the engine.`
`789`	`789`	`return 3 + visit(curr->left) + visit(curr->right);`
`790`	`790`	`}`
	`791`	`+ CostType visitStringTest(StringTest* curr) {`
	`792`	+ // "3" copied from `visitStringEq`.
	`793`	`+ return 3 + visit(curr->ref);`
	`794`	`+ }`
`791`	`795`	`CostType visitStringWTF16Get(StringWTF16Get* curr) {`
`792`	`796`	`return 1 + visit(curr->ref) + visit(curr->pos);`
`793`	`797`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1081,6 +1081,7 @@ class EffectAnalyzer {`
`1081`	`1081`	`}`
`1082`	`1082`	`}`
`1083`	`1083`	`}`
	`1084`	`+ void visitStringTest(StringTest* curr) {}`
`1084`	`1085`	`void visitStringWTF16Get(StringWTF16Get* curr) {`
`1085`	`1086`	`// traps when ref is null.`
`1086`	`1087`	`parent.implicitTrap = true;`