[NFC] Internally rename `ArrayInit` to `ArrayNewFixed` (#5526)

To match the standard instruction name, rename the expression class without
changing any parsing or printing behavior. A follow-on PR will take care of the
functional side of this change while keeping support for parsing the old name.

This change will allow `ArrayInit` to be used as the expression class for the
upcoming `array.init_data` and `array.init_elem` instructions.

35 files changed, 116 insertions, 109 deletions

diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index 1bcbae46a..53853b7f3 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -593,7 +593,7 @@ instructions = [
     ("array.new_default",    "makeArrayNew(s, true)"),
     ("array.new_data",       "makeArrayNewSeg(s, NewData)"),
     ("array.new_elem",       "makeArrayNewSeg(s, NewElem)"),
-    ("array.init_static",    "makeArrayInitStatic(s)"),
+    ("array.init_static",    "makeArrayNewFixedStatic(s)"),
     ("array.get",            "makeArrayGet(s)"),
     ("array.get_s",          "makeArrayGet(s, true)"),
     ("array.get_u",          "makeArrayGet(s, false)"),
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 72b0e26ca..6beb2b97c 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1825,16 +1825,16 @@ BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
     Builder(*(Module*)module)
       .makeArrayNew(HeapType(type), (Expression*)size, (Expression*)init));
 }
-BinaryenExpressionRef BinaryenArrayInit(BinaryenModuleRef module,
-                                        BinaryenHeapType type,
-                                        BinaryenExpressionRef* values,
-                                        BinaryenIndex numValues) {
+BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module,
+                                            BinaryenHeapType type,
+                                            BinaryenExpressionRef* values,
+                                            BinaryenIndex numValues) {
   std::vector<Expression*> vals;
   for (BinaryenIndex i = 0; i < numValues; i++) {
     vals.push_back((Expression*)values[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeArrayInit(HeapType(type), vals));
+    Builder(*(Module*)module).makeArrayNewFixed(HeapType(type), vals));
 }
 BinaryenExpressionRef BinaryenArrayGet(BinaryenModuleRef module,
                                        BinaryenExpressionRef ref,
@@ -4293,52 +4293,56 @@ void BinaryenArrayNewSetSize(BinaryenExpressionRef expr,
   assert(sizeExpr);
   static_cast<ArrayNew*>(expression)->size = (Expression*)sizeExpr;
 }
-// ArrayInit
-BinaryenIndex BinaryenArrayInitGetNumValues(BinaryenExpressionRef expr) {
+// ArrayNewFixed
+BinaryenIndex BinaryenArrayNewFixedGetNumValues(BinaryenExpressionRef expr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
-  return static_cast<ArrayInit*>(expression)->values.size();
+  assert(expression->is<ArrayNewFixed>());
+  return static_cast<ArrayNewFixed*>(expression)->values.size();
 }
-BinaryenExpressionRef BinaryenArrayInitGetValueAt(BinaryenExpressionRef expr,
-                                                  BinaryenIndex index) {
+BinaryenExpressionRef
+BinaryenArrayNewFixedGetValueAt(BinaryenExpressionRef expr,
+                                BinaryenIndex index) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
-  assert(index < static_cast<ArrayInit*>(expression)->values.size());
-  return static_cast<ArrayInit*>(expression)->values[index];
+  assert(expression->is<ArrayNewFixed>());
+  assert(index < static_cast<ArrayNewFixed*>(expression)->values.size());
+  return static_cast<ArrayNewFixed*>(expression)->values[index];
 }
-void BinaryenArrayInitSetValueAt(BinaryenExpressionRef expr,
-                                 BinaryenIndex index,
-                                 BinaryenExpressionRef valueExpr) {
+void BinaryenArrayNewFixedSetValueAt(BinaryenExpressionRef expr,
+                                     BinaryenIndex index,
+                                     BinaryenExpressionRef valueExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
-  assert(index < static_cast<ArrayInit*>(expression)->values.size());
+  assert(expression->is<ArrayNewFixed>());
+  assert(index < static_cast<ArrayNewFixed*>(expression)->values.size());
   assert(valueExpr);
-  static_cast<ArrayInit*>(expression)->values[index] = (Expression*)valueExpr;
+  static_cast<ArrayNewFixed*>(expression)->values[index] =
+    (Expression*)valueExpr;
 }
-BinaryenIndex BinaryenArrayInitAppendValue(BinaryenExpressionRef expr,
-                                           BinaryenExpressionRef valueExpr) {
+BinaryenIndex
+BinaryenArrayNewFixedAppendValue(BinaryenExpressionRef expr,
+                                 BinaryenExpressionRef valueExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
+  assert(expression->is<ArrayNewFixed>());
   assert(valueExpr);
-  auto& list = static_cast<ArrayInit*>(expression)->values;
+  auto& list = static_cast<ArrayNewFixed*>(expression)->values;
   auto index = list.size();
   list.push_back((Expression*)valueExpr);
   return index;
 }
-void BinaryenArrayInitInsertValueAt(BinaryenExpressionRef expr,
-                                    BinaryenIndex index,
-                                    BinaryenExpressionRef valueExpr) {
+void BinaryenArrayNewFixedInsertValueAt(BinaryenExpressionRef expr,
+                                        BinaryenIndex index,
+                                        BinaryenExpressionRef valueExpr) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
+  assert(expression->is<ArrayNewFixed>());
   assert(valueExpr);
-  static_cast<ArrayInit*>(expression)
+  static_cast<ArrayNewFixed*>(expression)
     ->values.insertAt(index, (Expression*)valueExpr);
 }
-BinaryenExpressionRef BinaryenArrayInitRemoveValueAt(BinaryenExpressionRef expr,
-                                                     BinaryenIndex index) {
+BinaryenExpressionRef
+BinaryenArrayNewFixedRemoveValueAt(BinaryenExpressionRef expr,
+                                   BinaryenIndex index) {
   auto* expression = (Expression*)expr;
-  assert(expression->is<ArrayInit>());
-  return static_cast<ArrayInit*>(expression)->values.removeAt(index);
+  assert(expression->is<ArrayNewFixed>());
+  return static_cast<ArrayNewFixed*>(expression)->values.removeAt(index);
 }
 // ArrayGet
 BinaryenExpressionRef BinaryenArrayGetGetRef(BinaryenExpressionRef expr) {
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 94743d259..1a54e311c 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -1081,10 +1081,10 @@ BINARYEN_API BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
 // TODO: BinaryenArrayNewSeg
 
 BINARYEN_API BinaryenExpressionRef
-BinaryenArrayInit(BinaryenModuleRef module,
-                  BinaryenHeapType type,
-                  BinaryenExpressionRef* values,
-                  BinaryenIndex numValues);
+BinaryenArrayNewFixed(BinaryenModuleRef module,
+                      BinaryenHeapType type,
+                      BinaryenExpressionRef* values,
+                      BinaryenIndex numValues);
 BINARYEN_API BinaryenExpressionRef BinaryenArrayGet(BinaryenModuleRef module,
                                                     BinaryenExpressionRef ref,
                                                     BinaryenExpressionRef index,
@@ -2453,23 +2453,24 @@ BinaryenArrayNewGetSize(BinaryenExpressionRef expr);
 BINARYEN_API void BinaryenArrayNewSetSize(BinaryenExpressionRef expr,
                                           BinaryenExpressionRef sizeExpr);
 
-// ArrayInit
+// ArrayNewFixed
 
 BINARYEN_API BinaryenIndex
-BinaryenArrayInitGetNumValues(BinaryenExpressionRef expr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenArrayInitGetValueAt(BinaryenExpressionRef expr, BinaryenIndex index);
-BINARYEN_API void BinaryenArrayInitSetValueAt(BinaryenExpressionRef expr,
-                                              BinaryenIndex index,
-                                              BinaryenExpressionRef valueExpr);
-BINARYEN_API BinaryenIndex BinaryenArrayInitAppendValue(
+BinaryenArrayNewFixedGetNumValues(BinaryenExpressionRef expr);
+BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixedGetValueAt(
+  BinaryenExpressionRef expr, BinaryenIndex index);
+BINARYEN_API void
+BinaryenArrayNewFixedSetValueAt(BinaryenExpressionRef expr,
+                                BinaryenIndex index,
+                                BinaryenExpressionRef valueExpr);
+BINARYEN_API BinaryenIndex BinaryenArrayNewFixedAppendValue(
   BinaryenExpressionRef expr, BinaryenExpressionRef valueExpr);
 BINARYEN_API void
-BinaryenArrayInitInsertValueAt(BinaryenExpressionRef expr,
-                               BinaryenIndex index,
-                               BinaryenExpressionRef valueExpr);
-BINARYEN_API BinaryenExpressionRef
-BinaryenArrayInitRemoveValueAt(BinaryenExpressionRef expr, BinaryenIndex index);
+BinaryenArrayNewFixedInsertValueAt(BinaryenExpressionRef expr,
+                                   BinaryenIndex index,
+                                   BinaryenExpressionRef valueExpr);
+BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixedRemoveValueAt(
+  BinaryenExpressionRef expr, BinaryenIndex index);
 
 // ArrayGet
 
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 6bb1ed7dd..0022296a4 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 makeArrayInitStatic(s); }
+            if (op == "array.init_static"sv) { return makeArrayNewFixedStatic(s); }
             goto parse_error;
           case 'l':
             if (op == "array.len"sv) { return makeArrayLen(s); }
@@ -3637,7 +3637,7 @@ switch (buf[0]) {
           }
           case 'i':
             if (op == "array.init_static"sv) {
-              auto ret = makeArrayInitStatic(ctx, pos);
+              auto ret = makeArrayNewFixedStatic(ctx, pos);
               CHECK_ERR(ret);
               return *ret;
             }
diff --git a/src/ir/ReFinalize.cpp b/src/ir/ReFinalize.cpp
index a5651c6b6..9c4946342 100644
--- a/src/ir/ReFinalize.cpp
+++ b/src/ir/ReFinalize.cpp
@@ -165,7 +165,7 @@ void ReFinalize::visitStructGet(StructGet* curr) { curr->finalize(); }
 void ReFinalize::visitStructSet(StructSet* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNew(ArrayNew* curr) { curr->finalize(); }
 void ReFinalize::visitArrayNewSeg(ArrayNewSeg* curr) { curr->finalize(); }
-void ReFinalize::visitArrayInit(ArrayInit* curr) { curr->finalize(); }
+void ReFinalize::visitArrayNewFixed(ArrayNewFixed* curr) { curr->finalize(); }
 void ReFinalize::visitArrayGet(ArrayGet* curr) { curr->finalize(); }
 void ReFinalize::visitArraySet(ArraySet* curr) { curr->finalize(); }
 void ReFinalize::visitArrayLen(ArrayLen* curr) { curr->finalize(); }
diff --git a/src/ir/cost.h b/src/ir/cost.h
index 11c179d40..3e12318b6 100644
--- a/src/ir/cost.h
+++ b/src/ir/cost.h
@@ -639,7 +639,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   CostType visitArrayNewSeg(ArrayNewSeg* curr) {
     return 4 + visit(curr->offset) + visit(curr->size);
   }
-  CostType visitArrayInit(ArrayInit* curr) {
+  CostType visitArrayNewFixed(ArrayNewFixed* curr) {
     CostType ret = 4;
     for (auto* child : curr->values) {
       ret += visit(child);
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 4ea577f7a..59ef8bace 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -760,7 +760,7 @@ private:
       // segments.
       parent.implicitTrap = true;
     }
-    void visitArrayInit(ArrayInit* curr) {}
+    void visitArrayNewFixed(ArrayNewFixed* curr) {}
     void visitArrayGet(ArrayGet* curr) {
       if (curr->ref->type.isNull()) {
         parent.trap = true;
diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp
index 9dfc5f123..a6d2633ff 100644
--- a/src/ir/module-utils.cpp
+++ b/src/ir/module-utils.cpp
@@ -69,7 +69,7 @@ struct CodeScanner
       counts.note(curr->type);
     } else if (curr->is<ArrayNewSeg>()) {
       counts.note(curr->type);
-    } else if (curr->is<ArrayInit>()) {
+    } else if (curr->is<ArrayNewFixed>()) {
       counts.note(curr->type);
     } else if (auto* cast = curr->dynCast<RefCast>()) {
       counts.note(cast->type);
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index cf30cd917..d292529dc 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -910,7 +910,7 @@ struct InfoCollector
     }
     WASM_UNREACHABLE("unexpected op");
   }
-  void visitArrayInit(ArrayInit* curr) {
+  void visitArrayNewFixed(ArrayNewFixed* curr) {
     if (curr->type == Type::unreachable) {
       return;
     }
diff --git a/src/ir/properties.cpp b/src/ir/properties.cpp
index b5d2df952..8aef0baaa 100644
--- a/src/ir/properties.cpp
+++ b/src/ir/properties.cpp
@@ -30,7 +30,7 @@ bool isGenerative(Expression* curr, FeatureSet features) {
     bool generative = false;
     void visitStructNew(StructNew* curr) { generative = true; }
     void visitArrayNew(ArrayNew* curr) { generative = true; }
-    void visitArrayInit(ArrayInit* curr) { generative = true; }
+    void visitArrayNewFixed(ArrayNewFixed* curr) { generative = true; }
   } scanner;
   scanner.walk(curr);
   return scanner.generative;
diff --git a/src/ir/properties.h b/src/ir/properties.h
index fb0065948..43f74ceb8 100644
--- a/src/ir/properties.h
+++ b/src/ir/properties.h
@@ -455,8 +455,9 @@ bool isGenerative(Expression* curr, FeatureSet features);
 
 inline bool isValidInConstantExpression(Expression* expr, FeatureSet features) {
   if (isSingleConstantExpression(expr) || expr->is<GlobalGet>() ||
-      expr->is<StructNew>() || expr->is<ArrayNew>() || expr->is<ArrayInit>() ||
-      expr->is<I31New>() || expr->is<StringConst>()) {
+      expr->is<StructNew>() || expr->is<ArrayNew>() ||
+      expr->is<ArrayNewFixed>() || expr->is<I31New>() ||
+      expr->is<StringConst>()) {
     return true;
   }
 
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 3fe73f179..8c0b7873c 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -115,7 +115,7 @@ function initializeConstants() {
     'StructGet',
     'StructSet',
     'ArrayNew',
-    'ArrayInit',
+    'ArrayNewFixed',
     'ArrayGet',
     'ArraySet',
     'ArrayLen',
diff --git a/src/passes/Precompute.cpp b/src/passes/Precompute.cpp
index 5fff7710b..18139de3f 100644
--- a/src/passes/Precompute.cpp
+++ b/src/passes/Precompute.cpp
@@ -155,8 +155,8 @@ public:
     }
     return getHeapCreationFlow(flow, curr);
   }
-  Flow visitArrayInit(ArrayInit* curr) {
-    auto flow = Super::visitArrayInit(curr);
+  Flow visitArrayNewFixed(ArrayNewFixed* curr) {
+    auto flow = Super::visitArrayNewFixed(curr);
     if (flow.breaking()) {
       return flow;
     }
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index f7cfb7746..85fd2c21a 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2285,7 +2285,7 @@ struct PrintExpressionContents
     TypeNamePrinter(o, wasm).print(curr->type.getHeapType());
     o << ' ' << curr->segment;
   }
-  void visitArrayInit(ArrayInit* curr) {
+  void visitArrayNewFixed(ArrayNewFixed* curr) {
     if (printUnreachableReplacement(curr)) {
       return;
     }
@@ -2895,7 +2895,7 @@ struct PrintSExpression : public UnifiedExpressionVisitor<PrintSExpression> {
   void visitArrayNewSeg(ArrayNewSeg* curr) {
     maybePrintUnreachableReplacement(curr, curr->type);
   }
-  void visitArrayInit(ArrayInit* curr) {
+  void visitArrayNewFixed(ArrayNewFixed* curr) {
     maybePrintUnreachableReplacement(curr, curr->type);
   }
   void visitArraySet(ArraySet* curr) {
diff --git a/src/passes/TypeSSA.cpp b/src/passes/TypeSSA.cpp
index 17f166a9e..9e3a57815 100644
--- a/src/passes/TypeSSA.cpp
+++ b/src/passes/TypeSSA.cpp
@@ -68,7 +68,7 @@ struct NewFinder : public PostWalker<NewFinder> {
   void visitStructNew(StructNew* curr) { news.push_back(curr); }
   void visitArrayNew(ArrayNew* curr) { news.push_back(curr); }
   void visitArrayNewSeg(ArrayNewSeg* curr) { news.push_back(curr); }
-  void visitArrayInit(ArrayInit* curr) { news.push_back(curr); }
+  void visitArrayNewFixed(ArrayNewFixed* curr) { news.push_back(curr); }
 };
 
 struct TypeSSA : public Pass {
@@ -289,7 +289,7 @@ struct TypeSSA : public Pass {
     } else if (curr->is<ArrayNewSeg>()) {
       // TODO: If the element segment is immutable perhaps we could inspect it.
       return true;
-    } else if (auto* arrayInit = curr->dynCast<ArrayInit>()) {
+    } else if (auto* arrayInit = curr->dynCast<ArrayNewFixed>()) {
       // All the items must be interesting for us to consider this interesting,
       // as we only track a single value for all indexes in the array, so one
       // boring value means it is all boring.
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index bb3a76766..6e728d3a6 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -2099,7 +2099,7 @@ Expression* TranslateToFuzzReader::makeConstBasicRef(Type type) {
       // --nominal mode.
       static HeapType trivialArray =
         HeapType(Array(Field(Field::PackedType::i8, Immutable)));
-      return builder.makeArrayInit(trivialArray, {});
+      return builder.makeArrayNewFixed(trivialArray, {});
     }
     case HeapType::string:
       return builder.makeStringConst(std::to_string(upTo(1024)));
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp
index 13e2d5767..00bceac8f 100644
--- a/src/tools/wasm-ctor-eval.cpp
+++ b/src/tools/wasm-ctor-eval.cpp
@@ -613,7 +613,7 @@ public:
         init = builder.makeStructNew(heapType, args);
       } else if (heapType.isArray()) {
         // TODO: for repeated identical values, can use ArrayNew
-        init = builder.makeArrayInit(heapType, args);
+        init = builder.makeArrayNewFixed(heapType, args);
       } else {
         WASM_UNREACHABLE("bad gc type");
       }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index a5b4202a0..1e86252a1 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1110,7 +1110,7 @@ enum ASTNodes {
   ArrayLenAnnotated = 0x17,
   ArrayCopy = 0x18,
   ArrayLen = 0x19,
-  ArrayInitStatic = 0x1a,
+  ArrayNewFixedStatic = 0x1a,
   ArrayNew = 0x1b,
   ArrayNewDefault = 0x1c,
   ArrayNewData = 0x1d,
@@ -1718,7 +1718,7 @@ public:
   bool maybeVisitStructSet(Expression*& out, uint32_t code);
   bool maybeVisitArrayNew(Expression*& out, uint32_t code);
   bool maybeVisitArrayNewSeg(Expression*& out, uint32_t code);
-  bool maybeVisitArrayInit(Expression*& out, uint32_t code);
+  bool maybeVisitArrayNewFixed(Expression*& out, uint32_t code);
   bool maybeVisitArrayGet(Expression*& out, uint32_t code);
   bool maybeVisitArraySet(Expression*& out, uint32_t code);
   bool maybeVisitArrayLen(Expression*& out, uint32_t code);
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 5592273da..8d4235357 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -948,9 +948,9 @@ public:
     ret->finalize();
     return ret;
   }
-  ArrayInit* makeArrayInit(HeapType type,
-                           const std::vector<Expression*>& values) {
-    auto* ret = wasm.allocator.alloc<ArrayInit>();
+  ArrayNewFixed* makeArrayNewFixed(HeapType type,
+                                   const std::vector<Expression*>& values) {
+    auto* ret = wasm.allocator.alloc<ArrayNewFixed>();
     ret->values.set(values);
     ret->type = Type(type, NonNullable);
     ret->finalize();
diff --git a/src/wasm-delegations-fields.def b/src/wasm-delegations-fields.def
index e3ec30a40..92ab4c9d3 100644
--- a/src/wasm-delegations-fields.def
+++ b/src/wasm-delegations-fields.def
@@ -672,10 +672,10 @@ switch (DELEGATE_ID) {
     DELEGATE_END(ArrayNewSeg);
     break;
   }
-  case Expression::Id::ArrayInitId: {
-    DELEGATE_START(ArrayInit);
-    DELEGATE_FIELD_CHILD_VECTOR(ArrayInit, values);
-    DELEGATE_END(ArrayInit);
+  case Expression::Id::ArrayNewFixedId: {
+    DELEGATE_START(ArrayNewFixed);
+    DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values);
+    DELEGATE_END(ArrayNewFixed);
     break;
   }
   case Expression::Id::ArrayGetId: {
diff --git a/src/wasm-delegations.def b/src/wasm-delegations.def
index d2b5dfa2e..922bb7c87 100644
--- a/src/wasm-delegations.def
+++ b/src/wasm-delegations.def
@@ -78,7 +78,7 @@ DELEGATE(StructGet);
 DELEGATE(StructSet);
 DELEGATE(ArrayNew);
 DELEGATE(ArrayNewSeg);
-DELEGATE(ArrayInit);
+DELEGATE(ArrayNewFixed);
 DELEGATE(ArrayGet);
 DELEGATE(ArraySet);
 DELEGATE(ArrayLen);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index 4615e8625..8e82bdf80 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1635,8 +1635,8 @@ public:
                    curr->type.getHeapType());
   }
   Flow visitArrayNewSeg(ArrayNewSeg* curr) { WASM_UNREACHABLE("unimp"); }
-  Flow visitArrayInit(ArrayInit* curr) {
-    NOTE_ENTER("ArrayInit");
+  Flow visitArrayNewFixed(ArrayNewFixed* curr) {
+    NOTE_ENTER("ArrayNewFixed");
     Index num = curr->values.size();
     if (num >= ArrayLimit) {
       hostLimit("allocation failure");
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index d6a9c86d6..a52915441 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* makeArrayInitStatic(Element& s);
+  Expression* makeArrayNewFixedStatic(Element& s);
   Expression* makeArrayGet(Element& s, bool signed_ = false);
   Expression* makeArraySet(Element& s);
   Expression* makeArrayLen(Element& s);
diff --git a/src/wasm.h b/src/wasm.h
index eec68ebd5..0f188f7b0 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -717,7 +717,7 @@ public:
     StructSetId,
     ArrayNewId,
     ArrayNewSegId,
-    ArrayInitId,
+    ArrayNewFixedId,
     ArrayGetId,
     ArraySetId,
     ArrayLenId,
@@ -1615,9 +1615,9 @@ public:
   void finalize();
 };
 
-class ArrayInit : public SpecificExpression<Expression::ArrayInitId> {
+class ArrayNewFixed : public SpecificExpression<Expression::ArrayNewFixedId> {
 public:
-  ArrayInit(MixedArena& allocator) : values(allocator) {}
+  ArrayNewFixed(MixedArena& allocator) : values(allocator) {}
 
   ExpressionList values;
 
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index bb6f082f8..e5e05bacc 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -3987,7 +3987,7 @@ BinaryConsts::ASTNodes WasmBinaryBuilder::readExpression(Expression*& curr) {
       if (maybeVisitArrayNewSeg(curr, opcode)) {
         break;
       }
-      if (maybeVisitArrayInit(curr, opcode)) {
+      if (maybeVisitArrayNewFixed(curr, opcode)) {
         break;
       }
       if (maybeVisitArrayGet(curr, opcode)) {
@@ -7109,15 +7109,16 @@ bool WasmBinaryBuilder::maybeVisitArrayNewSeg(Expression*& out, uint32_t code) {
   return false;
 }
 
-bool WasmBinaryBuilder::maybeVisitArrayInit(Expression*& out, uint32_t code) {
-  if (code == BinaryConsts::ArrayInitStatic) {
+bool WasmBinaryBuilder::maybeVisitArrayNewFixed(Expression*& out,
+                                                uint32_t code) {
+  if (code == BinaryConsts::ArrayNewFixedStatic) {
     auto heapType = getIndexedHeapType();
     auto size = getU32LEB();
     std::vector<Expression*> values(size);
     for (size_t i = 0; i < size; i++) {
       values[size - i - 1] = popNonVoidExpression();
     }
-    out = Builder(wasm).makeArrayInit(heapType, values);
+    out = Builder(wasm).makeArrayNewFixed(heapType, values);
     return true;
   }
   return false;
diff --git a/src/wasm/wasm-s-parser.cpp b/src/wasm/wasm-s-parser.cpp
index 6bbd82476..4f4b28754 100644
--- a/src/wasm/wasm-s-parser.cpp
+++ b/src/wasm/wasm-s-parser.cpp
@@ -2925,14 +2925,14 @@ Expression* SExpressionWasmBuilder::makeArrayNewSeg(Element& s,
   return Builder(wasm).makeArrayNewSeg(op, heapType, seg, offset, size);
 }
 
-Expression* SExpressionWasmBuilder::makeArrayInitStatic(Element& s) {
+Expression* SExpressionWasmBuilder::makeArrayNewFixedStatic(Element& s) {
   auto heapType = parseHeapType(*s[1]);
   size_t i = 2;
   std::vector<Expression*> values;
   while (i < s.size()) {
     values.push_back(parseExpression(*s[i++]));
   }
-  return Builder(wasm).makeArrayInit(heapType, values);
+  return Builder(wasm).makeArrayNewFixed(heapType, values);
 }
 
 Expression* SExpressionWasmBuilder::makeArrayGet(Element& s, bool signed_) {
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index 1c12718ce..3f53e3dde 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2193,9 +2193,9 @@ void BinaryInstWriter::visitArrayNewSeg(ArrayNewSeg* curr) {
   o << U32LEB(curr->segment);
 }
 
-void BinaryInstWriter::visitArrayInit(ArrayInit* curr) {
+void BinaryInstWriter::visitArrayNewFixed(ArrayNewFixed* curr) {
   o << int8_t(BinaryConsts::GCPrefix);
-  o << U32LEB(BinaryConsts::ArrayInitStatic);
+  o << U32LEB(BinaryConsts::ArrayNewFixedStatic);
   parent.writeIndexedHeapType(curr->type.getHeapType());
   o << U32LEB(curr->values.size());
 }
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index a56f26be3..33e737ae1 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -456,7 +456,7 @@ public:
   void visitStructSet(StructSet* curr);
   void visitArrayNew(ArrayNew* curr);
   void visitArrayNewSeg(ArrayNewSeg* curr);
-  void visitArrayInit(ArrayInit* curr);
+  void visitArrayNewFixed(ArrayNewFixed* curr);
   void visitArrayGet(ArrayGet* curr);
   void visitArraySet(ArraySet* curr);
   void visitArrayLen(ArrayLen* curr);
@@ -2774,7 +2774,7 @@ void FunctionValidator::visitArrayNewSeg(ArrayNewSeg* curr) {
   }
 }
 
-void FunctionValidator::visitArrayInit(ArrayInit* curr) {
+void FunctionValidator::visitArrayNewFixed(ArrayNewFixed* curr) {
   shouldBeTrue(getModule()->features.hasGC(),
                curr,
                "array.init requires gc [--enable-gc]");
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index f58aaf0da..54e9dd142 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -1063,7 +1063,7 @@ void ArrayNewSeg::finalize() {
   }
 }
 
-void ArrayInit::finalize() {
+void ArrayNewFixed::finalize() {
   for (auto* value : values) {
     if (value->type == Type::unreachable) {
       type = Type::unreachable;
diff --git a/src/wasm/wat-parser.cpp b/src/wasm/wat-parser.cpp
index 1408ffe0d..ee48d7262 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> makeArrayInitStatic(Ctx&, Index);
+Result<typename Ctx::InstrT> makeArrayNewFixedStatic(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> makeArrayInitStatic(Ctx& ctx, Index pos) {
+Result<typename Ctx::InstrT> makeArrayNewFixedStatic(Ctx& ctx, Index pos) {
   return ctx.in.err("unimplemented instruction");
 }
 
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 45721bd75..03cde4347 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -2303,7 +2303,7 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m,
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
-    Ref visitArrayInit(ArrayInit* curr) {
+    Ref visitArrayNewFixed(ArrayNewFixed* curr) {
       unimplemented(curr);
       WASM_UNREACHABLE("unimp");
     }
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index 1a4b2452d..3522ea5da 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -167,7 +167,7 @@ function test_ids() {
   console.log("StructGetId: " + binaryen.StructGetId);
   console.log("StructSetId: " + binaryen.StructSetId);
   console.log("ArrayNewId: " + binaryen.ArrayNewId);
-  console.log("ArrayInitId: " + binaryen.ArrayInitId);
+  console.log("ArrayNewFixedId: " + binaryen.ArrayNewFixedId);
   console.log("ArrayGetId: " + binaryen.ArrayGetId);
   console.log("ArraySetId: " + binaryen.ArraySetId);
   console.log("ArrayLenId: " + binaryen.ArrayLenId);
diff --git a/test/binaryen.js/kitchen-sink.js.txt b/test/binaryen.js/kitchen-sink.js.txt
index 0605ef4cc..aed5849e2 100644
--- a/test/binaryen.js/kitchen-sink.js.txt
+++ b/test/binaryen.js/kitchen-sink.js.txt
@@ -97,7 +97,7 @@ StructNewId: 60
 StructGetId: 61
 StructSetId: 62
 ArrayNewId: 63
-ArrayInitId: 65
+ArrayNewFixedId: 65
 ArrayGetId: 66
 ArraySetId: 67
 ArrayLenId: 68
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index a8d07d717..cb6d760a6 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -1128,12 +1128,12 @@ void test_core() {
                      BinaryenTypeGetHeapType(i8Array),
                      makeInt32(module, 3),
                      makeInt32(module, 42)),
-    BinaryenArrayInit(module,
-                      BinaryenTypeGetHeapType(i8Array),
-                      (BinaryenExpressionRef[]){makeInt32(module, 1),
-                                                makeInt32(module, 2),
-                                                makeInt32(module, 3)},
-                      3),
+    BinaryenArrayNewFixed(module,
+                          BinaryenTypeGetHeapType(i8Array),
+                          (BinaryenExpressionRef[]){makeInt32(module, 1),
+                                                    makeInt32(module, 2),
+                                                    makeInt32(module, 3)},
+                          3),
     BinaryenArrayGet(module,
                      BinaryenGlobalGet(module, "i8Array-global", i8Array),
                      makeInt32(module, 0),
diff --git a/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt b/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
index 29bccd185..4fa1549f3 100644
--- a/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
+++ b/test/passes/translate-to-fuzz_all-features_metrics_noprint.txt
@@ -10,7 +10,7 @@ total
  [tags]         : 1       
  [total]        : 877     
  [vars]         : 40      
- ArrayInit      : 11      
+ ArrayNewFixed  : 11      
  AtomicFence    : 1       
  Binary         : 85      
  Block          : 139