Rename external conversion instructions (#6716)

vouillon · web-flow · commit 81f8f770a1b2 · 2024-07-08T20:23:00.000Z
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 WebAssembly/gc#432. The legacy name is still accepted in text inputs and in the C and JS APIs.
diff --git 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
@@ -603,8 +603,10 @@
     ("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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -926,7 +926,7 @@ class EffectAnalyzer {
     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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -916,7 +916,7 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
     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
@@ -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
@@ -1233,7 +1233,7 @@ class Builder {
       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
@@ -1858,9 +1858,9 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
           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 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
   }
   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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
diff --git a/test/lit/ctor-eval/extern.wast b/test/lit/ctor-eval/extern.wast
diff --git a/test/lit/exec/i31.wast b/test/lit/exec/i31.wast
diff --git a/test/lit/extern-conversions.wast b/test/lit/extern-conversions.wast
diff --git a/test/lit/passes/gufa-extern.wast b/test/lit/passes/gufa-extern.wast
diff --git a/test/lit/passes/optimize-instructions-gc-extern.wast b/test/lit/passes/optimize-instructions-gc-extern.wast
diff --git a/test/lit/passes/optimize-instructions-gc.wast b/test/lit/passes/optimize-instructions-gc.wast
diff --git a/test/lit/passes/type-generalizing.wast b/test/lit/passes/type-generalizing.wast
diff --git a/test/lit/passes/type-ssa.wast b/test/lit/passes/type-ssa.wast
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
diff --git a/test/spec/ref_test.wast b/test/spec/ref_test.wast

Original file line number	Diff line number	Diff line change
`@@ -926,7 +926,7 @@ class EffectAnalyzer {`
`926`	`926`	`void visitArrayInitData(ArrayInitData* curr) { visitArrayInit(curr); }`
`927`	`927`	`void visitArrayInitElem(ArrayInitElem* curr) { visitArrayInit(curr); }`
`928`	`928`	`void visitRefAs(RefAs* curr) {`
`929`		`- if (curr->op == ExternInternalize \|\| curr->op == ExternExternalize) {`
	`929`	`+ if (curr->op == AnyConvertExtern \|\| curr->op == ExternConvertAny) {`
`930`	`930`	`// These conversions are infallible.`
`931`	`931`	`return;`
`932`	`932`	`}`
Original file line number	Diff line number	Diff line change
`@@ -697,7 +697,7 @@ struct InfoCollector`
`697`	`697`	`receiveChildValue(curr->ref, curr);`
`698`	`698`	`}`
`699`	`699`	`void visitRefAs(RefAs* curr) {`
`700`		`- if (curr->op == ExternExternalize \|\| curr->op == ExternInternalize) {`
	`700`	`+ if (curr->op == ExternConvertAny \|\| curr->op == AnyConvertExtern) {`
`701`	`701`	`// The external conversion ops emit something of a completely different`
`702`	`702`	`// type, which we must mark as a root.`
`703`	`703`	`addRoot(curr);`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ static bool isValidInConstantExpression(Module& wasm, Expression* expr) {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`if (auto* refAs = expr->dynCast<RefAs>()) {`
`68`		`- if (refAs->op == ExternExternalize \|\| refAs->op == ExternInternalize) {`
	`68`	`+ if (refAs->op == ExternConvertAny \|\| refAs->op == AnyConvertExtern) {`
`69`	`69`	`return true;`
`70`	`70`	`}`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ inline bool isNamedControlFlow(Expression* curr) {`
`83`	`83`	`// isValidInConstantExpression or find better names(#4845)`
`84`	`84`	`inline bool isSingleConstantExpression(const Expression* curr) {`
`85`	`85`	`if (auto* refAs = curr->dynCast<RefAs>()) {`
`86`		`- if (refAs->op == ExternExternalize \|\| refAs->op == ExternInternalize) {`
	`86`	`+ if (refAs->op == ExternConvertAny \|\| refAs->op == AnyConvertExtern) {`
`87`	`87`	`return isSingleConstantExpression(refAs->value);`
`88`	`88`	`}`
`89`	`89`	`}`
`@@ -124,9 +124,9 @@ inline Literal getLiteral(const Expression* curr) {`
`124`	`124`	`} else if (auto* s = curr->dynCast<StringConst>()) {`
`125`	`125`	`return Literal(s->string.toString());`
`126`	`126`	`} else if (auto* r = curr->dynCast<RefAs>()) {`
`127`		`- if (r->op == ExternExternalize) {`
	`127`	`+ if (r->op == ExternConvertAny) {`
`128`	`128`	`return getLiteral(r->value).externalize();`
`129`		`- } else if (r->op == ExternInternalize) {`
	`129`	`+ } else if (r->op == AnyConvertExtern) {`
`130`	`130`	`return getLiteral(r->value).internalize();`
`131`	`131`	`}`
`132`	`132`	`}`
`@@ -329,7 +329,7 @@ inline Expression** getImmediateFallthroughPtr(`
`329`	`329`	`// Extern conversions are not casts and actually produce new values.`
`330`	`330`	`// Treating them as fallthroughs would lead to misoptimizations of`
`331`	`331`	`// subsequent casts.`
`332`		`- if (as->op != ExternInternalize && as->op != ExternExternalize) {`
	`332`	`+ if (as->op != AnyConvertExtern && as->op != ExternConvertAny) {`
`333`	`333`	`return &as->value;`
`334`	`334`	`}`
`335`	`335`	`} else if (auto* br = curr->dynCast<BrOn>()) {`