Replace I31New with RefI31 everywhere (#5930)

tlively · web-flow · commit 3ca8c21b89c2 · 2023-09-13T15:13:33.000Z
Globally replace the source string "I31New" with "RefI31" in preparation for renaming the instruction from "i31.new" to "ref.i31", as implemented in the spec in WebAssembly/gc#422. This would be NFC, except that it also changes the string in the external-facing C APIs. A follow-up PR will make the corresponding behavioral change.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,6 +15,8 @@ full changeset diff at the end of each section.
 Current Trunk
 -------------
 
+ - "I31New" changed to "RefI31" everywhere it appears in the C API.
+
 v115
 ----
 
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
@@ -564,7 +564,7 @@
     ("call_ref",             "makeCallRef(s, /*isReturn=*/false)"),
     ("return_call_ref",      "makeCallRef(s, /*isReturn=*/true)"),
     # GC
-    ("i31.new",              "makeI31New(s)"),
+    ("i31.new",              "makeRefI31(s)"),
     ("i31.get_s",            "makeI31Get(s, true)"),
     ("i31.get_u",            "makeI31Get(s, false)"),
     ("ref.test",             "makeRefTest(s)"),
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
@@ -1732,10 +1732,10 @@ BinaryenExpressionRef BinaryenRethrow(BinaryenModuleRef module,
     Builder(*(Module*)module).makeRethrow(target));
 }
 
-BinaryenExpressionRef BinaryenI31New(BinaryenModuleRef module,
+BinaryenExpressionRef BinaryenRefI31(BinaryenModuleRef module,
                                      BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeI31New((Expression*)value));
+    Builder(*(Module*)module).makeRefI31((Expression*)value));
 }
 
 BinaryenExpressionRef BinaryenI31Get(BinaryenModuleRef module,
@@ -3952,18 +3952,18 @@ void BinaryenTupleExtractSetIndex(BinaryenExpressionRef expr,
   assert(expression->is<TupleExtract>());
   static_cast<TupleExtract*>(expression)->index = index;
 }
-// I31New
-BinaryenExpressionRef BinaryenI31NewGetValue(BinaryenExpressionRef expr) {
+// RefI31
+BinaryenExpressionRef BinaryenRefI31GetValue(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<I31New>());
-  return static_cast<I31New*>(expression)->value;
+  assert(expression->is<RefI31>());
+  return static_cast<RefI31*>(expression)->value;
 }
-void BinaryenI31NewSetValue(BinaryenExpressionRef expr,
+void BinaryenRefI31SetValue(BinaryenExpressionRef expr,
                             BinaryenExpressionRef valueExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<I31New>());
+  assert(expression->is<RefI31>());
   assert(valueExpr);
-  static_cast<I31New*>(expression)->value = (Expression*)valueExpr;
+  static_cast<RefI31*>(expression)->value = (Expression*)valueExpr;
 }
 // I31Get
 BinaryenExpressionRef BinaryenI31GetGetI31(BinaryenExpressionRef expr) {
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
@@ -1028,7 +1028,7 @@ BINARYEN_API BinaryenExpressionRef BinaryenTupleExtract(
   BinaryenModuleRef module, BinaryenExpressionRef tuple, BinaryenIndex index);
 BINARYEN_API BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module,
                                                BinaryenType type);
-BINARYEN_API BinaryenExpressionRef BinaryenI31New(BinaryenModuleRef module,
+BINARYEN_API BinaryenExpressionRef BinaryenRefI31(BinaryenModuleRef module,
                                                   BinaryenExpressionRef value);
 BINARYEN_API BinaryenExpressionRef BinaryenI31Get(BinaryenModuleRef module,
                                                   BinaryenExpressionRef i31,
@@ -2306,13 +2306,13 @@ BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr);
 BINARYEN_API void BinaryenTupleExtractSetIndex(BinaryenExpressionRef expr,
                                                BinaryenIndex index);
 
-// I31New
+// RefI31
 
 // Gets the value expression of an `i31.new` expression.
 BINARYEN_API BinaryenExpressionRef
-BinaryenI31NewGetValue(BinaryenExpressionRef expr);
+BinaryenRefI31GetValue(BinaryenExpressionRef expr);
 // Sets the value expression of an `i31.new` expression.
-BINARYEN_API void BinaryenI31NewSetValue(BinaryenExpressionRef expr,
+BINARYEN_API void BinaryenRefI31SetValue(BinaryenExpressionRef expr,
                                          BinaryenExpressionRef valueExpr);
 
 // I31Get
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
@@ -1203,7 +1203,7 @@ switch (buf[0]) {
                 }
               }
               case 'n':
-                if (op == "i31.new"sv) { return makeI31New(s); }
+                if (op == "i31.new"sv) { return makeRefI31(s); }
                 goto parse_error;
               default: goto parse_error;
             }
@@ -5593,7 +5593,7 @@ switch (buf[0]) {
               }
               case 'n':
                 if (op == "i31.new"sv) {
-                  auto ret = makeI31New(ctx, pos);
+                  auto ret = makeRefI31(ctx, pos);
                   CHECK_ERR(ret);
                   return *ret;
                 }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
@@ -132,7 +132,7 @@ void ReFinalize::visitUnreachable(Unreachable* curr) { curr->finalize(); }
 void ReFinalize::visitPop(Pop* curr) { curr->finalize(); }
 void ReFinalize::visitTupleMake(TupleMake* curr) { curr->finalize(); }
 void ReFinalize::visitTupleExtract(TupleExtract* curr) { curr->finalize(); }
-void ReFinalize::visitI31New(I31New* curr) { curr->finalize(); }
+void ReFinalize::visitRefI31(RefI31* curr) { curr->finalize(); }
 void ReFinalize::visitI31Get(I31Get* curr) { curr->finalize(); }
 void ReFinalize::visitCallRef(CallRef* curr) { curr->finalize(); }
 void ReFinalize::visitRefTest(RefTest* curr) { curr->finalize(); }
diff --git a/src/ir/cost.h b/src/ir/cost.h
@@ -598,7 +598,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitNop(Nop* curr) { return 0; }
   CostType visitUnreachable(Unreachable* curr) { return 0; }
   CostType visitDataDrop(DataDrop* curr) { return 5; }
-  CostType visitI31New(I31New* curr) { return 3 + visit(curr->value); }
+  CostType visitRefI31(RefI31* curr) { return 3 + visit(curr->value); }
   CostType visitI31Get(I31Get* curr) { return 2 + visit(curr->i31); }
   CostType visitRefTest(RefTest* curr) {
     // Casts have a very high cost because in the VM they end up implemented as
diff --git a/src/ir/effects.h b/src/ir/effects.h
@@ -718,7 +718,7 @@ class EffectAnalyzer {
     }
     void visitTupleMake(TupleMake* curr) {}
     void visitTupleExtract(TupleExtract* curr) {}
-    void visitI31New(I31New* curr) {}
+    void visitRefI31(RefI31* curr) {}
     void visitI31Get(I31Get* curr) {
       // traps when the ref is null
       if (curr->i31->type.isNullable()) {
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
@@ -678,7 +678,7 @@ struct InfoCollector
     totalPops++;
 #endif
   }
-  void visitI31New(I31New* curr) {
+  void visitRefI31(RefI31* curr) {
     // TODO: optimize like struct references
     addRoot(curr);
   }
diff --git a/src/ir/properties.cpp b/src/ir/properties.cpp
@@ -40,7 +40,7 @@ bool isGenerative(Expression* curr, FeatureSet features) {
 // to whether it is valid in a wasm constant expression.
 static bool isValidInConstantExpression(Module& wasm, Expression* expr) {
   if (isSingleConstantExpression(expr) || expr->is<StructNew>() ||
-      expr->is<ArrayNew>() || expr->is<ArrayNewFixed>() || expr->is<I31New>() ||
+      expr->is<ArrayNew>() || expr->is<ArrayNewFixed>() || expr->is<RefI31>() ||
       expr->is<StringConst>()) {
     return true;
   }
diff --git a/src/ir/properties.h b/src/ir/properties.h
@@ -117,7 +117,7 @@ inline Literal getLiteral(const Expression* curr) {
     return Literal(n->type);
   } else if (auto* r = curr->dynCast<RefFunc>()) {
     return Literal(r->func, r->type.getHeapType());
-  } else if (auto* i = curr->dynCast<I31New>()) {
+  } else if (auto* i = curr->dynCast<RefI31>()) {
     if (auto* c = i->value->dynCast<Const>()) {
       return Literal::makeI31(c->value.geti32());
     }
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
@@ -105,7 +105,7 @@ function initializeConstants() {
     'TupleMake',
     'TupleExtract',
     'Pop',
-    'I31New',
+    'RefI31',
     'I31Get',
     'CallRef',
     'RefTest',
@@ -2419,7 +2419,7 @@ function wrapModule(module, self = {}) {
 
   self['i31'] = {
     'new'(value) {
-      return Module['_BinaryenI31New'](module, value);
+      return Module['_BinaryenRefI31'](module, value);
     },
     'get_s'(i31) {
       return Module['_BinaryenI31Get'](module, i31, 1);
@@ -3271,11 +3271,11 @@ Module['getExpressionInfo'] = function(expr) {
         'tuple': Module['_BinaryenTupleExtractGetTuple'](expr),
         'index': Module['_BinaryenTupleExtractGetIndex'](expr)
       };
-    case Module['I31NewId']:
+    case Module['RefI31Id']:
       return {
         'id': id,
         'type': type,
-        'value': Module['_BinaryenI31NewGetValue'](expr)
+        'value': Module['_BinaryenRefI31GetValue'](expr)
       };
     case Module['I31GetId']:
       return {
@@ -4837,12 +4837,12 @@ Module['TupleExtract'] = makeExpressionWrapper({
   }
 });
 
-Module['I31New'] = makeExpressionWrapper({
+Module['RefI31'] = makeExpressionWrapper({
   'getValue'(expr) {
-    return Module['_BinaryenI31NewGetValue'](expr);
+    return Module['_BinaryenRefI31GetValue'](expr);
   },
   'setValue'(expr, valueExpr) {
-    Module['_BinaryenI31NewSetValue'](expr, valueExpr);
+    Module['_BinaryenRefI31SetValue'](expr, valueExpr);
   }
 });
 
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
@@ -1959,7 +1959,7 @@ struct PrintExpressionContents
     printMedium(o, "tuple.extract ");
     o << curr->index;
   }
-  void visitI31New(I31New* curr) { printMedium(o, "i31.new"); }
+  void visitRefI31(RefI31* curr) { printMedium(o, "i31.new"); }
   void visitI31Get(I31Get* curr) {
     printMedium(o, curr->signed_ ? "i31.get_s" : "i31.get_u");
   }
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
@@ -2341,7 +2341,7 @@ Expression* TranslateToFuzzReader::makeBasicRef(Type type) {
       if (type.isNullable() && oneIn(4)) {
         return builder.makeRefNull(HeapType::none);
       }
-      return builder.makeI31New(makeConst(Type::i32));
+      return builder.makeRefI31(makeConst(Type::i32));
     }
     case HeapType::struct_: {
       assert(wasm.features.hasGC());
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
@@ -1188,7 +1188,7 @@ enum ASTNodes {
   BrOnCastFail = 0x19,
   ExternInternalize = 0x1a,
   ExternExternalize = 0x1b,
-  I31New = 0x1c,
+  RefI31 = 0x1c,
   I31GetS = 0x1d,
   I31GetU = 0x1e,
 #else
@@ -1209,7 +1209,7 @@ enum ASTNodes {
   ArrayNew = 0x1b,
   ArrayNewDefault = 0x1c,
   ArrayNewData = 0x1d,
-  I31New = 0x20,
+  RefI31 = 0x20,
   I31GetS = 0x21,
   I31GetU = 0x22,
   RefTest = 0x40,
@@ -1838,7 +1838,7 @@ class WasmBinaryReader {
   bool maybeVisitMemoryFill(Expression*& out, uint32_t code);
   bool maybeVisitTableSize(Expression*& out, uint32_t code);
   bool maybeVisitTableGrow(Expression*& out, uint32_t code);
-  bool maybeVisitI31New(Expression*& out, uint32_t code);
+  bool maybeVisitRefI31(Expression*& out, uint32_t code);
   bool maybeVisitI31Get(Expression*& out, uint32_t code);
   bool maybeVisitRefTest(Expression*& out, uint32_t code);
   bool maybeVisitRefCast(Expression*& out, uint32_t code);
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
@@ -856,8 +856,8 @@ class Builder {
     ret->finalize();
     return ret;
   }
-  I31New* makeI31New(Expression* value) {
-    auto* ret = wasm.allocator.alloc<I31New>();
+  RefI31* makeRefI31(Expression* value) {
+    auto* ret = wasm.allocator.alloc<RefI31>();
     ret->value = value;
     ret->finalize();
     return ret;
@@ -1209,7 +1209,7 @@ class Builder {
       return makeRefFunc(value.getFunc(), type.getHeapType());
     }
     if (type.isRef() && type.getHeapType() == HeapType::i31) {
-      return makeI31New(makeConst(value.geti31()));
+      return makeRefI31(makeConst(value.geti31()));
     }
     if (type.isString()) {
       // TODO: more than ascii support
@@ -1359,7 +1359,7 @@ class Builder {
       return ExpressionManipulator::refNull(curr, curr->type);
     }
     if (curr->type.isRef() && curr->type.getHeapType() == HeapType::i31) {
-      Expression* ret = makeI31New(makeConst(0));
+      Expression* ret = makeRefI31(makeConst(0));
       if (curr->type.isNullable()) {
         // To keep the type identical, wrap it in a block that adds nullability.
         ret = makeBlock({ret}, curr->type);
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
@@ -618,10 +618,10 @@ switch (DELEGATE_ID) {
     DELEGATE_END(TupleExtract);
     break;
   }
-  case Expression::Id::I31NewId: {
-    DELEGATE_START(I31New);
-    DELEGATE_FIELD_CHILD(I31New, value);
-    DELEGATE_END(I31New);
+  case Expression::Id::RefI31Id: {
+    DELEGATE_START(RefI31);
+    DELEGATE_FIELD_CHILD(RefI31, value);
+    DELEGATE_END(RefI31);
     break;
   }
   case Expression::Id::I31GetId: {
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
@@ -67,7 +67,7 @@ DELEGATE(Throw);
 DELEGATE(Rethrow);
 DELEGATE(TupleMake);
 DELEGATE(TupleExtract);
-DELEGATE(I31New);
+DELEGATE(RefI31);
 DELEGATE(I31Get);
 DELEGATE(CallRef);
 DELEGATE(RefTest);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
@@ -1409,8 +1409,8 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     WASM_UNREACHABLE("throw");
   }
   Flow visitRethrow(Rethrow* curr) { WASM_UNREACHABLE("unimp"); }
-  Flow visitI31New(I31New* curr) {
-    NOTE_ENTER("I31New");
+  Flow visitRefI31(RefI31* curr) {
+    NOTE_ENTER("RefI31");
     Flow flow = visit(curr->value);
     if (flow.breaking()) {
       return flow;
diff --git a/src/wasm-ir-builder.h b/src/wasm-ir-builder.h
@@ -130,7 +130,7 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   // [[nodiscard]] Result<> makeRethrow();
   // [[nodiscard]] Result<> makeTupleMake();
   // [[nodiscard]] Result<> makeTupleExtract();
-  [[nodiscard]] Result<> makeI31New();
+  [[nodiscard]] Result<> makeRefI31();
   [[nodiscard]] Result<> makeI31Get(bool signed_);
   // [[nodiscard]] Result<> makeCallRef();
   // [[nodiscard]] Result<> makeRefTest();
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
@@ -285,7 +285,7 @@ class SExpressionWasmBuilder {
   Expression* makeTupleMake(Element& s);
   Expression* makeTupleExtract(Element& s);
   Expression* makeCallRef(Element& s, bool isReturn);
-  Expression* makeI31New(Element& s);
+  Expression* makeRefI31(Element& s);
   Expression* makeI31Get(Element& s, bool signed_);
   Expression* makeRefTest(Element& s);
   Expression* makeRefCast(Element& s);
diff --git a/src/wasm.h b/src/wasm.h
@@ -703,7 +703,7 @@ class Expression {
     RethrowId,
     TupleMakeId,
     TupleExtractId,
-    I31NewId,
+    RefI31Id,
     I31GetId,
     CallRefId,
     RefTestId,
@@ -1478,10 +1478,10 @@ class TupleExtract : public SpecificExpression<Expression::TupleExtractId> {
   void finalize();
 };
 
-class I31New : public SpecificExpression<Expression::I31NewId> {
+class RefI31 : public SpecificExpression<Expression::RefI31Id> {
 public:
-  I31New() = default;
-  I31New(MixedArena& allocator) {}
+  RefI31() = default;
+  RefI31(MixedArena& allocator) {}
 
   Expression* value;
 
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
@@ -4055,7 +4055,7 @@ BinaryConsts::ASTNodes WasmBinaryReader::readExpression(Expression*& curr) {
     }
     case BinaryConsts::GCPrefix: {
       auto opcode = getU32LEB();
-      if (maybeVisitI31New(curr, opcode)) {
+      if (maybeVisitRefI31(curr, opcode)) {
         break;
       }
       if (maybeVisitI31Get(curr, opcode)) {
@@ -6959,11 +6959,11 @@ void WasmBinaryReader::visitCallRef(CallRef* curr) {
   curr->finalize();
 }
 
-bool WasmBinaryReader::maybeVisitI31New(Expression*& out, uint32_t code) {
-  if (code != BinaryConsts::I31New) {
+bool WasmBinaryReader::maybeVisitRefI31(Expression*& out, uint32_t code) {
+  if (code != BinaryConsts::RefI31) {
     return false;
   }
-  auto* curr = allocator.alloc<I31New>();
+  auto* curr = allocator.alloc<RefI31>();
   curr->value = popNonVoidExpression();
   curr->finalize();
   out = curr;
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
@@ -661,10 +661,10 @@ Result<> IRBuilder::makeRefEq() {
 
 // Result<> IRBuilder::makeTupleExtract() {}
 
-Result<> IRBuilder::makeI31New() {
-  I31New curr;
-  CHECK_ERR(visitI31New(&curr));
-  push(builder.makeI31New(curr.value));
+Result<> IRBuilder::makeRefI31() {
+  RefI31 curr;
+  CHECK_ERR(visitRefI31(&curr));
+  push(builder.makeRefI31(curr.value));
   return Ok{};
 }
 
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
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/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp
diff --git a/src/wasm2js.h b/src/wasm2js.h
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
diff --git a/test/binaryen.js/expressions.js.txt b/test/binaryen.js/expressions.js.txt
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
diff --git a/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt b/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt

Original file line number	Diff line number	Diff line change
`@@ -1203,7 +1203,7 @@ switch (buf[0]) {`
`1203`	`1203`	`}`
`1204`	`1204`	`}`
`1205`	`1205`	`case 'n':`
`1206`		`- if (op == "i31.new"sv) { return makeI31New(s); }`
	`1206`	`+ if (op == "i31.new"sv) { return makeRefI31(s); }`
`1207`	`1207`	`goto parse_error;`
`1208`	`1208`	`default: goto parse_error;`
`1209`	`1209`	`}`
`@@ -5593,7 +5593,7 @@ switch (buf[0]) {`
`5593`	`5593`	`}`
`5594`	`5594`	`case 'n':`
`5595`	`5595`	`if (op == "i31.new"sv) {`
`5596`		`- auto ret = makeI31New(ctx, pos);`
	`5596`	`+ auto ret = makeRefI31(ctx, pos);`
`5597`	`5597`	`CHECK_ERR(ret);`
`5598`	`5598`	`return *ret;`
`5599`	`5599`	`}`
Original file line number	Diff line number	Diff line change
`@@ -718,7 +718,7 @@ class EffectAnalyzer {`
`718`	`718`	`}`
`719`	`719`	`void visitTupleMake(TupleMake* curr) {}`
`720`	`720`	`void visitTupleExtract(TupleExtract* curr) {}`
`721`		`- void visitI31New(I31New* curr) {}`
	`721`	`+ void visitRefI31(RefI31* curr) {}`
`722`	`722`	`void visitI31Get(I31Get* curr) {`
`723`	`723`	`// traps when the ref is null`
`724`	`724`	`if (curr->i31->type.isNullable()) {`
Original file line number	Diff line number	Diff line change
`@@ -678,7 +678,7 @@ struct InfoCollector`
`678`	`678`	`totalPops++;`
`679`	`679`	`#endif`
`680`	`680`	`}`
`681`		`- void visitI31New(I31New* curr) {`
	`681`	`+ void visitRefI31(RefI31* curr) {`
`682`	`682`	`// TODO: optimize like struct references`
`683`	`683`	`addRoot(curr);`
`684`	`684`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ bool isGenerative(Expression* curr, FeatureSet features) {`
`40`	`40`	`// to whether it is valid in a wasm constant expression.`
`41`	`41`	`static bool isValidInConstantExpression(Module& wasm, Expression* expr) {`
`42`	`42`	`if (isSingleConstantExpression(expr) \|\| expr->is<StructNew>() \|\|`
`43`		`- expr->is<ArrayNew>() \|\| expr->is<ArrayNewFixed>() \|\| expr->is<I31New>() \|\|`
	`43`	`+ expr->is<ArrayNew>() \|\| expr->is<ArrayNewFixed>() \|\| expr->is<RefI31>() \|\|`
`44`	`44`	`expr->is<StringConst>()) {`
`45`	`45`	`return true;`
`46`	`46`	`}`