Rename external conversion instructions (#6716)

Rename instructions `extern.internalize` into `any.convert_extern` and
`extern.externalize` into `extern.convert_any` to follow more closely
the spec. This was changed in
https://github.com/WebAssembly/gc/issues/432.

The legacy name is still accepted in text inputs and in the C and JS
APIs.

37 files changed, 161 insertions, 122 deletions

diff --git a/scripts/clang-tidy-diff.sh b/scripts/clang-tidy-diff.sh
index 632968a38..17a6a4687 100755
--- a/scripts/clang-tidy-diff.sh
+++ b/scripts/clang-tidy-diff.sh
@@ -24,7 +24,7 @@ function realpath() {
 
 CLANG_DIR=$(dirname $(dirname $(realpath $CLANG_TIDY)))
 CLANG_TIDY_DIFF=$CLANG_DIR/share/clang/clang-tidy-diff.py
-ARG="-quiet -p1 -iregex=src/.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm|inc)"
+ARG="-quiet -p1 -iregex=src/.*\.(cpp|cc|c\+\+|cxx|c|cl|h|hpp|m|mm)"
 if [ ! -e "$CLANG_TIDY_DIFF" ]; then
   echo "Failed to find clang-tidy-diff.py ($CLANG_TIDY_DIFF)"
   exit 1
diff --git a/scripts/gen-s-parser.py b/scripts/gen-s-parser.py
index 2aa158c59..43a85c636 100755
--- a/scripts/gen-s-parser.py
+++ b/scripts/gen-s-parser.py
@@ -603,8 +603,10 @@ instructions = [
     ("array.init_data",      "makeArrayInitData()"),
     ("array.init_elem",      "makeArrayInitElem()"),
     ("ref.as_non_null",      "makeRefAs(RefAsNonNull)"),
-    ("extern.internalize",   "makeRefAs(ExternInternalize)"),
-    ("extern.externalize",   "makeRefAs(ExternExternalize)"),
+    ("extern.internalize",   "makeRefAs(AnyConvertExtern)"),  # Deprecated
+    ("extern.externalize",   "makeRefAs(ExternConvertAny)"),  # Deprecated
+    ("any.convert_extern",   "makeRefAs(AnyConvertExtern)"),
+    ("extern.convert_any",   "makeRefAs(ExternConvertAny)"),
     ("string.new_lossy_utf8_array",  "makeStringNew(StringNewLossyUTF8Array)"),
     ("string.new_wtf16_array", "makeStringNew(StringNewWTF16Array)"),
     ("string.from_code_point", "makeStringNew(StringNewFromCodePoint)"),
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 841fa61ee..9c9a1c54f 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -1012,8 +1012,10 @@ BinaryenOp BinaryenDotI8x16I7x16SToVecI16x8(void) {
   return DotI8x16I7x16SToVecI16x8;
 }
 BinaryenOp BinaryenRefAsNonNull(void) { return RefAsNonNull; }
-BinaryenOp BinaryenRefAsExternInternalize(void) { return ExternInternalize; }
-BinaryenOp BinaryenRefAsExternExternalize(void) { return ExternExternalize; }
+BinaryenOp BinaryenRefAsExternInternalize(void) { return AnyConvertExtern; }
+BinaryenOp BinaryenRefAsExternExternalize(void) { return ExternConvertAny; }
+BinaryenOp BinaryenRefAsAnyConvertExtern(void) { return AnyConvertExtern; }
+BinaryenOp BinaryenRefAsExternConvertAny(void) { return ExternConvertAny; }
 BinaryenOp BinaryenBrOnNull(void) { return BrOnNull; }
 BinaryenOp BinaryenBrOnNonNull(void) { return BrOnNonNull; }
 BinaryenOp BinaryenBrOnCast(void) { return BrOnCast; }
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 3f2cab20c..45230a117 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -678,6 +678,8 @@ BINARYEN_API BinaryenOp BinaryenDotI8x16I7x16SToVecI16x8(void);
 BINARYEN_API BinaryenOp BinaryenRefAsNonNull(void);
 BINARYEN_API BinaryenOp BinaryenRefAsExternInternalize(void);
 BINARYEN_API BinaryenOp BinaryenRefAsExternExternalize(void);
+BINARYEN_API BinaryenOp BinaryenRefAsAnyConvertExtern(void);
+BINARYEN_API BinaryenOp BinaryenRefAsExternConvertAny(void);
 BINARYEN_API BinaryenOp BinaryenBrOnNull(void);
 BINARYEN_API BinaryenOp BinaryenBrOnNonNull(void);
 BINARYEN_API BinaryenOp BinaryenBrOnCast(void);
diff --git a/src/gen-s-parser.inc b/src/gen-s-parser.inc
index 03b346113..8a3dcba0b 100644
--- a/src/gen-s-parser.inc
+++ b/src/gen-s-parser.inc
@@ -14,6 +14,12 @@ memcpy(buf, op.data(), op.size());
 switch (buf[0]) {
   case 'a': {
     switch (buf[1]) {
+      case 'n':
+        if (op == "any.convert_extern"sv) {
+          CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern));
+          return Ok{};
+        }
+        goto parse_error;
       case 'r': {
         switch (buf[6]) {
           case 'c':
@@ -278,15 +284,21 @@ switch (buf[0]) {
   }
   case 'e': {
     switch (buf[7]) {
+      case 'c':
+        if (op == "extern.convert_any"sv) {
+          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
+          return Ok{};
+        }
+        goto parse_error;
       case 'e':
         if (op == "extern.externalize"sv) {
-          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternExternalize));
+          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternConvertAny));
           return Ok{};
         }
         goto parse_error;
       case 'i':
         if (op == "extern.internalize"sv) {
-          CHECK_ERR(makeRefAs(ctx, pos, annotations, ExternInternalize));
+          CHECK_ERR(makeRefAs(ctx, pos, annotations, AnyConvertExtern));
           return Ok{};
         }
         goto parse_error;
diff --git a/src/ir/child-typer.h b/src/ir/child-typer.h
index 7c09dddb0..5e2dc237d 100644
--- a/src/ir/child-typer.h
+++ b/src/ir/child-typer.h
@@ -949,10 +949,10 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
       case RefAsNonNull:
         noteAnyReference(&curr->value);
         return;
-      case ExternInternalize:
+      case AnyConvertExtern:
         note(&curr->value, Type(HeapType::ext, Nullable));
         return;
-      case ExternExternalize:
+      case ExternConvertAny:
         note(&curr->value, Type(HeapType::any, Nullable));
         return;
     }
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 46138d03c..be949a8bf 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -926,7 +926,7 @@ private:
     void visitArrayInitData(ArrayInitData* curr) { visitArrayInit(curr); }
     void visitArrayInitElem(ArrayInitElem* curr) { visitArrayInit(curr); }
     void visitRefAs(RefAs* curr) {
-      if (curr->op == ExternInternalize || curr->op == ExternExternalize) {
+      if (curr->op == AnyConvertExtern || curr->op == ExternConvertAny) {
         // These conversions are infallible.
         return;
       }
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index ac320c419..38fa3e5f6 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -697,7 +697,7 @@ struct InfoCollector
     receiveChildValue(curr->ref, curr);
   }
   void visitRefAs(RefAs* curr) {
-    if (curr->op == ExternExternalize || curr->op == ExternInternalize) {
+    if (curr->op == ExternConvertAny || curr->op == AnyConvertExtern) {
       // The external conversion ops emit something of a completely different
       // type, which we must mark as a root.
       addRoot(curr);
diff --git a/src/ir/properties.cpp b/src/ir/properties.cpp
index dd9a10a8e..d04771885 100644
--- a/src/ir/properties.cpp
+++ b/src/ir/properties.cpp
@@ -65,7 +65,7 @@ static bool isValidInConstantExpression(Module& wasm, Expression* expr) {
   }
 
   if (auto* refAs = expr->dynCast<RefAs>()) {
-    if (refAs->op == ExternExternalize || refAs->op == ExternInternalize) {
+    if (refAs->op == ExternConvertAny || refAs->op == AnyConvertExtern) {
       return true;
     }
   }
diff --git a/src/ir/properties.h b/src/ir/properties.h
index 4b73b7211..ccb2392b0 100644
--- a/src/ir/properties.h
+++ b/src/ir/properties.h
@@ -83,7 +83,7 @@ inline bool isNamedControlFlow(Expression* curr) {
 // isValidInConstantExpression or find better names(#4845)
 inline bool isSingleConstantExpression(const Expression* curr) {
   if (auto* refAs = curr->dynCast<RefAs>()) {
-    if (refAs->op == ExternExternalize || refAs->op == ExternInternalize) {
+    if (refAs->op == ExternConvertAny || refAs->op == AnyConvertExtern) {
       return isSingleConstantExpression(refAs->value);
     }
   }
@@ -124,9 +124,9 @@ inline Literal getLiteral(const Expression* curr) {
   } else if (auto* s = curr->dynCast<StringConst>()) {
     return Literal(s->string.toString());
   } else if (auto* r = curr->dynCast<RefAs>()) {
-    if (r->op == ExternExternalize) {
+    if (r->op == ExternConvertAny) {
       return getLiteral(r->value).externalize();
-    } else if (r->op == ExternInternalize) {
+    } else if (r->op == AnyConvertExtern) {
       return getLiteral(r->value).internalize();
     }
   }
@@ -329,7 +329,7 @@ inline Expression** getImmediateFallthroughPtr(
     // Extern conversions are not casts and actually produce new values.
     // Treating them as fallthroughs would lead to misoptimizations of
     // subsequent casts.
-    if (as->op != ExternInternalize && as->op != ExternExternalize) {
+    if (as->op != AnyConvertExtern && as->op != ExternConvertAny) {
       return &as->value;
     }
   } else if (auto* br = curr->dynCast<BrOn>()) {
diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index 8d7bd6d7f..097c28bc7 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -564,6 +564,8 @@ function initializeConstants() {
     'RefAsNonNull',
     'RefAsExternInternalize',
     'RefAsExternExternalize',
+    'RefAsAnyConvertExtern',
+    'RefAsExternConvertAny',
     'BrOnNull',
     'BrOnNonNull',
     'BrOnCast',
@@ -2380,8 +2382,8 @@ function wrapModule(module, self = {}) {
     }
   };
 
-  // TODO: extern.internalize
-  // TODO: extern.externalize
+  // TODO: any.convert_extern
+  // TODO: extern.convert_any
   // TODO: ref.test
   // TODO: ref.cast
   // TODO: br_on_*
diff --git a/src/passes/OptimizeCasts.cpp b/src/passes/OptimizeCasts.cpp
index 5edde4d2f..efa00948b 100644
--- a/src/passes/OptimizeCasts.cpp
+++ b/src/passes/OptimizeCasts.cpp
@@ -90,7 +90,7 @@
 //  )
 //
 // Note that right now, we only consider RefAs with op RefAsNonNull as a cast.
-// RefAs with ExternInternalize and ExternExternalize are not considered casts
+// RefAs with AnyConvertExtern and ExternConvertAny are not considered casts
 // when obtaining fallthroughs, and so are ignored.
 //
 // TODO: Look past individual basic blocks? This may be worth considering
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index 10c1aac9e..c470fa060 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -2440,7 +2440,7 @@ struct OptimizeInstructions
       return;
     }
 
-    if (curr->op == ExternExternalize || curr->op == ExternInternalize) {
+    if (curr->op == ExternConvertAny || curr->op == AnyConvertExtern) {
       // We can't optimize these. Even removing a non-null cast is not valid as
       // they allow nulls to filter through, unlike other RefAs*.
       return;
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 4ca5f722b..1d07b7f3c 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -2236,11 +2236,11 @@ struct PrintExpressionContents
       case RefAsNonNull:
         printMedium(o, "ref.as_non_null");
         break;
-      case ExternInternalize:
-        printMedium(o, "extern.internalize");
+      case AnyConvertExtern:
+        printMedium(o, "any.convert_extern");
         break;
-      case ExternExternalize:
-        printMedium(o, "extern.externalize");
+      case ExternConvertAny:
+        printMedium(o, "extern.convert_any");
         break;
       default:
         WASM_UNREACHABLE("invalid ref.is_*");
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
index 720830400..faf01f173 100644
--- a/src/passes/TypeGeneralizing.cpp
+++ b/src/passes/TypeGeneralizing.cpp
@@ -850,10 +850,10 @@ struct TransferFn : OverriddenVisitor<TransferFn> {
       case RefAsNonNull:
         push(Type(type.getHeapType(), Nullable));
         return;
-      case ExternInternalize:
+      case AnyConvertExtern:
         push(Type(HeapType::ext, type.getNullability()));
         return;
-      case ExternExternalize:
+      case ExternConvertAny:
         push(Type(HeapType::any, type.getNullability()));
         return;
     }
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp
index c025764e7..df4e7a9bf 100644
--- a/src/tools/wasm-ctor-eval.cpp
+++ b/src/tools/wasm-ctor-eval.cpp
@@ -916,7 +916,7 @@ public:
     if (original != value) {
       // The original is externalized.
       assert(original.type.getHeapType() == HeapType::ext);
-      ret = builder.makeRefAs(ExternExternalize, ret);
+      ret = builder.makeRefAs(ExternConvertAny, ret);
     }
     return ret;
   }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index 9ce9bf181..0b9615c7e 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -1120,8 +1120,8 @@ enum ASTNodes {
   RefCastNull = 0x17,
   BrOnCast = 0x18,
   BrOnCastFail = 0x19,
-  ExternInternalize = 0x1a,
-  ExternExternalize = 0x1b,
+  AnyConvertExtern = 0x1a,
+  ExternConvertAny = 0x1b,
   RefI31 = 0x1c,
   I31GetS = 0x1d,
   I31GetU = 0x1e,
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index f37e45240..a20ba46a6 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -1233,7 +1233,7 @@ public:
       return makeStringConst(wtf16.str());
     }
     if (type.isRef() && type.getHeapType() == HeapType::ext) {
-      return makeRefAs(ExternExternalize,
+      return makeRefAs(ExternConvertAny,
                        makeConstantExpression(value.internalize()));
     }
     TODO_SINGLE_COMPOUND(type);
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index c12f9cc33..93739d1c9 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -1858,9 +1858,9 @@ public:
           trap("null ref");
         }
         return value;
-      case ExternInternalize:
+      case AnyConvertExtern:
         return value.internalize();
-      case ExternExternalize:
+      case ExternConvertAny:
         return value.externalize();
     }
     WASM_UNREACHABLE("unimplemented ref.as_*");
@@ -2436,7 +2436,7 @@ public:
   }
   Flow visitRefAs(RefAs* curr) {
     // TODO: Remove this once interpretation is implemented.
-    if (curr->op == ExternInternalize || curr->op == ExternExternalize) {
+    if (curr->op == AnyConvertExtern || curr->op == ExternConvertAny) {
       return Flow(NONCONSTANT_FLOW);
     }
     return ExpressionRunner<SubType>::visitRefAs(curr);
diff --git a/src/wasm.h b/src/wasm.h
index ebb5a04f6..4a4ed561f 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -561,8 +561,8 @@ enum SIMDTernaryOp {
 
 enum RefAsOp {
   RefAsNonNull,
-  ExternInternalize,
-  ExternExternalize,
+  AnyConvertExtern,
+  ExternConvertAny,
 };
 
 enum BrOnOp {
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index c4aaec5e9..78470324c 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -4329,8 +4329,8 @@ BinaryConsts::ASTNodes WasmBinaryReader::readExpression(Expression*& curr) {
       if (maybeVisitStringSliceWTF(curr, opcode)) {
         break;
       }
-      if (opcode == BinaryConsts::ExternInternalize ||
-          opcode == BinaryConsts::ExternExternalize) {
+      if (opcode == BinaryConsts::AnyConvertExtern ||
+          opcode == BinaryConsts::ExternConvertAny) {
         visitRefAs((curr = allocator.alloc<RefAs>())->cast<RefAs>(), opcode);
         break;
       }
@@ -7730,11 +7730,11 @@ void WasmBinaryReader::visitRefAs(RefAs* curr, uint8_t code) {
     case BinaryConsts::RefAsNonNull:
       curr->op = RefAsNonNull;
       break;
-    case BinaryConsts::ExternInternalize:
-      curr->op = ExternInternalize;
+    case BinaryConsts::AnyConvertExtern:
+      curr->op = AnyConvertExtern;
       break;
-    case BinaryConsts::ExternExternalize:
-      curr->op = ExternExternalize;
+    case BinaryConsts::ExternConvertAny:
+      curr->op = ExternConvertAny;
       break;
     default:
       WASM_UNREACHABLE("invalid code for ref.as_*");
diff --git a/src/wasm/wasm-stack.cpp b/src/wasm/wasm-stack.cpp
index ac117e2e0..40a50706a 100644
--- a/src/wasm/wasm-stack.cpp
+++ b/src/wasm/wasm-stack.cpp
@@ -2334,13 +2334,13 @@ void BinaryInstWriter::visitRefAs(RefAs* curr) {
     case RefAsNonNull:
       o << int8_t(BinaryConsts::RefAsNonNull);
       break;
-    case ExternInternalize:
+    case AnyConvertExtern:
       o << int8_t(BinaryConsts::GCPrefix)
-        << U32LEB(BinaryConsts::ExternInternalize);
+        << U32LEB(BinaryConsts::AnyConvertExtern);
       break;
-    case ExternExternalize:
+    case ExternConvertAny:
       o << int8_t(BinaryConsts::GCPrefix)
-        << U32LEB(BinaryConsts::ExternExternalize);
+        << U32LEB(BinaryConsts::ExternConvertAny);
       break;
     default:
       WASM_UNREACHABLE("invalid ref.as_*");
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index a491fb951..9732f54a9 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -2215,30 +2215,30 @@ void FunctionValidator::visitRefAs(RefAs* curr) {
     default:
       // TODO: validate all the other ref.as_*
       break;
-    case ExternInternalize: {
+    case AnyConvertExtern: {
       shouldBeTrue(getModule()->features.hasGC(),
                    curr,
-                   "extern.internalize requries GC [--enable-gc]");
+                   "any.convert_extern requries GC [--enable-gc]");
       if (curr->type == Type::unreachable) {
         return;
       }
       shouldBeSubType(curr->value->type,
                       Type(HeapType::ext, Nullable),
                       curr->value,
-                      "extern.internalize value should be an externref");
+                      "any.convert_extern value should be an externref");
       break;
     }
-    case ExternExternalize: {
+    case ExternConvertAny: {
       shouldBeTrue(getModule()->features.hasGC(),
                    curr,
-                   "extern.externalize requries GC [--enable-gc]");
+                   "extern.convert_any requries GC [--enable-gc]");
       if (curr->type == Type::unreachable) {
         return;
       }
       shouldBeSubType(curr->value->type,
                       Type(HeapType::any, Nullable),
                       curr->value,
-                      "extern.externalize value should be an anyref");
+                      "extern.convert_any value should be an anyref");
       break;
     }
   }
diff --git a/src/wasm/wasm.cpp b/src/wasm/wasm.cpp
index ed05e9b47..58699ad8b 100644
--- a/src/wasm/wasm.cpp
+++ b/src/wasm/wasm.cpp
@@ -1231,10 +1231,10 @@ void RefAs::finalize() {
     case RefAsNonNull:
       type = Type(value->type.getHeapType(), NonNullable);
       break;
-    case ExternInternalize:
+    case AnyConvertExtern:
       type = Type(HeapType::any, value->type.getNullability());
       break;
-    case ExternExternalize:
+    case ExternConvertAny:
       type = Type(HeapType::ext, value->type.getNullability());
       break;
     default:
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
index 16e8e8c4e..bd8ec6793 100644
--- a/test/binaryen.js/expressions.js
+++ b/test/binaryen.js/expressions.js
@@ -1451,7 +1451,7 @@ console.log("# RefAs");
   assert(theRefAs.value === value);
   assert(theRefAs.type !== binaryen.i32); // TODO: === (ref any)
 
-  theRefAs.op = op = binaryen.Operations.RefAsExternExternalize;
+  theRefAs.op = op = binaryen.Operations.RefAsExternConvertAny;
   assert(theRefAs.op === op);
   theRefAs.op = op = binaryen.Operations.RefAsNonNull;
   theRefAs.value = value = module.local.get(2, binaryen.anyref);
@@ -1467,7 +1467,7 @@ console.log("# RefAs");
     "(ref.as_non_null\n (local.get $2)\n)\n"
   );
 
-  // TODO: extern.externalize and extern.internalize
+  // TODO: extern.convert_any and any.convert_extern
 
   module.dispose();
 })();
diff --git a/test/example/c-api-kitchen-sink.c b/test/example/c-api-kitchen-sink.c
index efd343be9..cd305c69b 100644
--- a/test/example/c-api-kitchen-sink.c
+++ b/test/example/c-api-kitchen-sink.c
@@ -1050,10 +1050,10 @@ void test_core() {
                   BinaryenRefAsNonNull(),
                   BinaryenRefNull(module, BinaryenTypeNullref())),
     BinaryenRefAs(module,
-                  BinaryenRefAsExternInternalize(),
+                  BinaryenRefAsAnyConvertExtern(),
                   BinaryenRefNull(module, BinaryenTypeNullExternref())),
     BinaryenRefAs(module,
-                  BinaryenRefAsExternExternalize(),
+                  BinaryenRefAsExternConvertAny(),
                   BinaryenRefNull(module, BinaryenTypeNullref())),
     // Exception handling
     BinaryenTry(module, NULL, tryBody, catchTags, 1, catchBodies, 2, NULL),
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index 5ba35fb0e..140d8e948 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -2137,12 +2137,12 @@ BinaryenFeatureAll: 262143
        )
       )
       (drop
-       (extern.internalize
+       (any.convert_extern
         (ref.null noextern)
        )
       )
       (drop
-       (extern.externalize
+       (extern.convert_any
         (ref.null none)
        )
       )
diff --git a/test/lit/ctor-eval/extern.wast b/test/lit/ctor-eval/extern.wast
index 9a8779abf..9591f9034 100644
--- a/test/lit/ctor-eval/extern.wast
+++ b/test/lit/ctor-eval/extern.wast
@@ -16,7 +16,7 @@
   ;; This will remain almost the same, even though we eval it, since the
   ;; serialization of an externalized i31 is what is written here. But the add
   ;; will be evalled out.
-  (extern.externalize
+  (extern.convert_any
    (ref.i31
     (i32.add
      (i32.const 41)
@@ -28,7 +28,7 @@
 
  (func $test2 (result externref)
   ;; This will be evalled into an externalization of a global.get.
-  (extern.externalize
+  (extern.convert_any
    (array.new_fixed $array 3
     (i32.const 1)
     (i32.const 2)
@@ -40,7 +40,7 @@
  (func $test3 (result anyref)
   ;; This will add a global that contains an externalization operation.
   (struct.new $struct
-   (extern.externalize
+   (extern.convert_any
     (ref.i31
      (i32.const 1)
     )
@@ -60,7 +60,7 @@
 ;; CHECK-NEXT: ))
 
 ;; CHECK:      (global $ctor-eval$global_1 (ref $struct) (struct.new $struct
-;; CHECK-NEXT:  (extern.externalize
+;; CHECK-NEXT:  (extern.convert_any
 ;; CHECK-NEXT:   (ref.i31
 ;; CHECK-NEXT:    (i32.const 1)
 ;; CHECK-NEXT:   )
@@ -74,7 +74,7 @@
 ;; CHECK:      (export "test3" (func $test3_5))
 
 ;; CHECK:      (func $test1_3 (type $2) (result externref)
-;; CHECK-NEXT:  (extern.externalize
+;; CHECK-NEXT:  (extern.convert_any
 ;; CHECK-NEXT:   (ref.i31
 ;; CHECK-NEXT:    (i32.const 42)
 ;; CHECK-NEXT:   )
@@ -82,7 +82,7 @@
 ;; CHECK-NEXT: )
 
 ;; CHECK:      (func $test2_4 (type $2) (result externref)
-;; CHECK-NEXT:  (extern.externalize
+;; CHECK-NEXT:  (extern.convert_any
 ;; CHECK-NEXT:   (global.get $ctor-eval$global)
 ;; CHECK-NEXT:  )
 ;; CHECK-NEXT: )
diff --git a/test/lit/exec/i31.wast b/test/lit/exec/i31.wast
index 0833d490d..807641d24 100644
--- a/test/lit/exec/i31.wast
+++ b/test/lit/exec/i31.wast
@@ -91,7 +91,7 @@
   ;; CHECK-NEXT: [fuzz-exec] note result: return-exted-i31 => i31ref(42)
   (func $return-exted-i31 (export "return-exted-i31") (result externref)
     ;; Even an externalized i31 is logged out using its integer value.
-    (extern.externalize
+    (extern.convert_any
       (ref.i31
         (i32.const 42)
       )
diff --git a/test/lit/extern-conversions.wast b/test/lit/extern-conversions.wast
index a3e18a2ac..f84097557 100644
--- a/test/lit/extern-conversions.wast
+++ b/test/lit/extern-conversions.wast
@@ -11,29 +11,48 @@
 
  ;; CHECK:      (type $1 (func (param externref) (result anyref)))
 
- ;; CHECK:      (export "ext" (func $extern.externalize))
+ ;; CHECK:      (type $2 (func (param externref) (result externref)))
 
- ;; CHECK:      (export "int" (func $extern.internalize))
+ ;; CHECK:      (export "ext" (func $extern.convert_any))
 
- ;; CHECK:      (func $extern.externalize (type $0) (param $0 (ref any)) (result (ref extern))
- ;; CHECK-NEXT:  (extern.externalize
+ ;; CHECK:      (export "int" (func $any.convert_extern))
+
+ ;; CHECK:      (export "legacy" (func $legacy_notation))
+
+ ;; CHECK:      (func $extern.convert_any (type $0) (param $0 (ref any)) (result (ref extern))
+ ;; CHECK-NEXT:  (extern.convert_any
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- (func $extern.externalize (export "ext") (param $x (ref any)) (result (ref extern))
-  (extern.externalize
+ (func $extern.convert_any (export "ext") (param $x (ref any)) (result (ref extern))
+  (extern.convert_any
    (local.get $x)
   )
  )
 
- ;; CHECK:      (func $extern.internalize (type $1) (param $0 externref) (result anyref)
- ;; CHECK-NEXT:  (extern.internalize
+ ;; CHECK:      (func $any.convert_extern (type $1) (param $0 externref) (result anyref)
+ ;; CHECK-NEXT:  (any.convert_extern
  ;; CHECK-NEXT:   (local.get $0)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
- (func $extern.internalize (export "int") (param $x (ref null extern)) (result (ref null any))
-  (extern.internalize
+ (func $any.convert_extern (export "int") (param $x (ref null extern)) (result (ref null any))
+  (any.convert_extern
    (local.get $x)
   )
  )
+
+ ;; CHECK:      (func $legacy_notation (type $2) (param $0 externref) (result externref)
+ ;; CHECK-NEXT:  (extern.convert_any
+ ;; CHECK-NEXT:   (any.convert_extern
+ ;; CHECK-NEXT:    (local.get $0)
+ ;; CHECK-NEXT:   )
+ ;; CHECK-NEXT:  )
+ ;; CHECK-NEXT: )
+ (func $legacy_notation (export "legacy") (param $x (ref null extern)) (result (ref null extern))
+  (extern.externalize
+   (extern.internalize
+    (local.get $x)
+   )
+  )
+ )
 )
diff --git a/test/lit/passes/gufa-extern.wast b/test/lit/passes/gufa-extern.wast
index 7cc604c76..ebb97cc59 100644
--- a/test/lit/passes/gufa-extern.wast
+++ b/test/lit/passes/gufa-extern.wast
@@ -9,13 +9,13 @@
   ;; CHECK:      (func $externals (type $0) (param $ext externref) (param $any anyref)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast (ref struct)
-  ;; CHECK-NEXT:    (extern.internalize
+  ;; CHECK-NEXT:    (any.convert_extern
   ;; CHECK-NEXT:     (local.get $ext)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.externalize
+  ;; CHECK-NEXT:   (extern.convert_any
   ;; CHECK-NEXT:    (local.get $any)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
@@ -25,13 +25,13 @@
     ;; exported.
     (drop
       (ref.cast (ref struct)
-        (extern.internalize
+        (any.convert_extern
           (local.get $ext)
         )
       )
     )
     (drop
-      (extern.externalize
+      (extern.convert_any
         (local.get $any)
       )
     )
@@ -41,7 +41,7 @@
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block ;; (replaces unreachable RefCast we can't emit)
   ;; CHECK-NEXT:    (drop
-  ;; CHECK-NEXT:     (extern.internalize
+  ;; CHECK-NEXT:     (any.convert_extern
   ;; CHECK-NEXT:      (unreachable)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )
@@ -49,7 +49,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.externalize
+  ;; CHECK-NEXT:   (extern.convert_any
   ;; CHECK-NEXT:    (unreachable)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
@@ -59,13 +59,13 @@
     ;; unreachable.
     (drop
       (ref.cast (ref struct)
-        (extern.internalize
+        (any.convert_extern
           (local.get $ext)
         )
       )
     )
     (drop
-      (extern.externalize
+      (extern.convert_any
         (local.get $any)
       )
     )
diff --git a/test/lit/passes/optimize-instructions-gc-extern.wast b/test/lit/passes/optimize-instructions-gc-extern.wast
index 558665171..658b2b115 100644
--- a/test/lit/passes/optimize-instructions-gc-extern.wast
+++ b/test/lit/passes/optimize-instructions-gc-extern.wast
@@ -3,53 +3,53 @@
 ;; RUN:   | filecheck %s
 
 (module
-  ;; CHECK:      (func $extern.externalize (type $0) (param $x anyref) (param $y externref)
+  ;; CHECK:      (func $extern.convert_any (type $0) (param $x anyref) (param $y externref)
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.externalize
+  ;; CHECK-NEXT:   (extern.convert_any
   ;; CHECK-NEXT:    (local.get $x)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.externalize
+  ;; CHECK-NEXT:   (extern.convert_any
   ;; CHECK-NEXT:    (ref.as_non_null
   ;; CHECK-NEXT:     (local.get $x)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.internalize
+  ;; CHECK-NEXT:   (any.convert_extern
   ;; CHECK-NEXT:    (local.get $y)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (extern.internalize
+  ;; CHECK-NEXT:   (any.convert_extern
   ;; CHECK-NEXT:    (ref.as_non_null
   ;; CHECK-NEXT:     (local.get $y)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
-  (func $extern.externalize (export "ext") (param $x (ref null any)) (param $y (ref null extern))
+  (func $extern.convert_any (export "ext") (param $x (ref null any)) (param $y (ref null extern))
     ;; We should not change anything here, and also not hit an internal error.
     (drop
-      (extern.externalize
+      (extern.convert_any
         (local.get $x)
       )
     )
     (drop
-      (extern.externalize
+      (extern.convert_any
         (ref.as_non_null
           (local.get $x)
         )
       )
     )
     (drop
-      (extern.internalize
+      (any.convert_extern
         (local.get $y)
       )
     )
     (drop
-      (extern.internalize
+      (any.convert_extern
         (ref.as_non_null
           (local.get $y)
         )
diff --git a/test/lit/passes/optimize-instructions-gc.wast b/test/lit/passes/optimize-instructions-gc.wast
index 14db70f3b..60fca14fc 100644
--- a/test/lit/passes/optimize-instructions-gc.wast
+++ b/test/lit/passes/optimize-instructions-gc.wast
@@ -2756,7 +2756,7 @@
   ;; CHECK:      (func $cast-internalized-extern (type $43) (param $externref externref)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (ref.cast (ref $A)
-  ;; CHECK-NEXT:    (extern.internalize
+  ;; CHECK-NEXT:    (any.convert_extern
   ;; CHECK-NEXT:     (local.get $externref)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
@@ -2768,7 +2768,7 @@
     ;; the cast cannot succeed.
     (drop
       (ref.cast (ref $A)
-        (extern.internalize
+        (any.convert_extern
           (local.get $externref)
         )
       )
diff --git a/test/lit/passes/type-generalizing.wast b/test/lit/passes/type-generalizing.wast
index 8278549d0..344509794 100644
--- a/test/lit/passes/type-generalizing.wast
+++ b/test/lit/passes/type-generalizing.wast
@@ -770,7 +770,7 @@
  ;; CHECK-NEXT:  (local.set $var
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (extern.internalize
+ ;; CHECK-NEXT:  (any.convert_extern
  ;; CHECK-NEXT:   (local.get $var)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -780,7 +780,7 @@
    (local.get $x)
   )
   ;; Require that typeof($var) <: externref.
-  (extern.internalize
+  (any.convert_extern
    (local.get $var)
   )
  )
@@ -790,7 +790,7 @@
  ;; CHECK-NEXT:  (local.set $var
  ;; CHECK-NEXT:   (local.get $x)
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (extern.internalize
+ ;; CHECK-NEXT:  (any.convert_extern
  ;; CHECK-NEXT:   (local.get $var)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -800,7 +800,7 @@
    (local.get $x)
   )
   ;; Require that typeof($var) <: (ref extern).
-  (extern.internalize
+  (any.convert_extern
    (local.get $var)
   )
  )
@@ -812,7 +812,7 @@
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (extern.externalize
+ ;; CHECK-NEXT:  (extern.convert_any
  ;; CHECK-NEXT:   (local.get $var)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -824,7 +824,7 @@
    )
   )
   ;; Require that typeof($var) <: anyref.
-  (extern.externalize
+  (extern.convert_any
    (local.get $var)
   )
  )
@@ -836,7 +836,7 @@
  ;; CHECK-NEXT:    (i32.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
- ;; CHECK-NEXT:  (extern.externalize
+ ;; CHECK-NEXT:  (extern.convert_any
  ;; CHECK-NEXT:   (local.get $var)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
@@ -848,7 +848,7 @@
    )
   )
   ;; Require that typeof($var) <: anyref.
-  (extern.externalize
+  (extern.convert_any
    (local.get $var)
   )
  )
diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast
index 771b4b9ae..277e2a2ff 100644
--- a/test/lit/passes/type-ssa.wast
+++ b/test/lit/passes/type-ssa.wast
@@ -382,15 +382,15 @@
   ;; CHECK:      (func $0 (type $2) (param $param anyref)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (struct.new $struct
-  ;; CHECK-NEXT:    (extern.externalize
+  ;; CHECK-NEXT:    (extern.convert_any
   ;; CHECK-NEXT:     (global.get $g)
   ;; CHECK-NEXT:    )
-  ;; CHECK-NEXT:    (extern.internalize
-  ;; CHECK-NEXT:     (extern.externalize
+  ;; CHECK-NEXT:    (any.convert_extern
+  ;; CHECK-NEXT:     (extern.convert_any
   ;; CHECK-NEXT:      (global.get $g)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )
-  ;; CHECK-NEXT:    (extern.externalize
+  ;; CHECK-NEXT:    (extern.convert_any
   ;; CHECK-NEXT:     (local.get $param)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
@@ -400,17 +400,17 @@
     (drop
       (struct.new $struct
         ;; An externalized global.
-        (extern.externalize
+        (extern.convert_any
           (global.get $g)
         )
         ;; An externalized and then internalized global.
-        (extern.internalize
-          (extern.externalize
+        (any.convert_extern
+          (extern.convert_any
             (global.get $g)
           )
         )
         ;; An externalized parameter.
-        (extern.externalize
+        (extern.convert_any
           (local.get $param)
         )
       )
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 71484977a..730d9773e 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -4416,27 +4416,27 @@
 
  ;; CHECK:      (func $any-convert-extern (type $71) (param $0 externref)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (extern.internalize
+ ;; CHECK-NEXT:   (any.convert_extern
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $any-convert-extern (param externref)
   local.get 0
-  extern.internalize
+  any.convert_extern
   drop
  )
 
  ;; CHECK:      (func $extern-convert-any (type $9) (param $0 anyref)
  ;; CHECK-NEXT:  (drop
- ;; CHECK-NEXT:   (extern.externalize
+ ;; CHECK-NEXT:   (extern.convert_any
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  (func $extern-convert-any (param anyref)
   local.get 0
-  extern.externalize
+  extern.convert_any
   drop
  )
 
diff --git a/test/spec/ref_test.wast b/test/spec/ref_test.wast
index 13bc34878..d02836106 100644
--- a/test/spec/ref_test.wast
+++ b/test/spec/ref_test.wast
@@ -19,8 +19,8 @@
     (table.set $ta (i32.const 3) (ref.i31 (i32.const 7)))
     (table.set $ta (i32.const 4) (struct.new_default $st))
     (table.set $ta (i32.const 5) (array.new_default $at (i32.const 0)))
-    (table.set $ta (i32.const 6) (extern.internalize (extern.externalize (ref.i31 (i32.const 0)))))
-    (table.set $ta (i32.const 7) (extern.internalize (ref.null extern)))
+    (table.set $ta (i32.const 6) (any.convert_extern (extern.convert_any (ref.i31 (i32.const 0)))))
+    (table.set $ta (i32.const 7) (any.convert_extern (ref.null extern)))
 
     (table.set $tf (i32.const 0) (ref.null nofunc))
     (table.set $tf (i32.const 1) (ref.null func))
@@ -28,10 +28,10 @@
 
     (table.set $te (i32.const 0) (ref.null noextern))
     (table.set $te (i32.const 1) (ref.null extern))
-    (table.set $te (i32.const 2) (extern.externalize (ref.i31 (i32.const 0))))
-    (table.set $te (i32.const 3) (extern.externalize (ref.i31 (i32.const 8))))
-    (table.set $te (i32.const 4) (extern.externalize (struct.new_default $st)))
-    (table.set $te (i32.const 5) (extern.externalize (ref.null any)))
+    (table.set $te (i32.const 2) (extern.convert_any (ref.i31 (i32.const 0))))
+    (table.set $te (i32.const 3) (extern.convert_any (ref.i31 (i32.const 8))))
+    (table.set $te (i32.const 4) (extern.convert_any (struct.new_default $st)))
+    (table.set $te (i32.const 5) (extern.convert_any (ref.null any)))
   )
 
   (func (export "ref_test_null_data") (param $i i32) (result i32)