diff --git a/src/tint/cmd/fuzz/wgsl/dictionary.txt b/src/tint/cmd/fuzz/wgsl/dictionary.txt
index cc0d9d3..a8a1694 100644
--- a/src/tint/cmd/fuzz/wgsl/dictionary.txt
+++ b/src/tint/cmd/fuzz/wgsl/dictionary.txt
@@ -55,6 +55,9 @@
 "->"
 "."
 "/"
+"// AAAA"
+"// AAAB"
+"// BAAA"
 "/="
 ":"
 ";"
diff --git a/src/tint/cmd/fuzz/wgsl/dictionary.txt.tmpl b/src/tint/cmd/fuzz/wgsl/dictionary.txt.tmpl
index 5ffad37..e5605d7 100644
--- a/src/tint/cmd/fuzz/wgsl/dictionary.txt.tmpl
+++ b/src/tint/cmd/fuzz/wgsl/dictionary.txt.tmpl
@@ -17,7 +17,7 @@
 
 {{- $tokens := List}}
 
-{{- /* ============================== Operators ============================== */ -}}
+{{- /* ========================= Operators & Keywords ======================== */ -}}
 {{- $tokens = Append $tokens
     "!"
     "!="
@@ -105,6 +105,13 @@
     "true" "false"
 -}}
 
+{{- /* =========================== Base64 comments =========================== */ -}}
+{{- $tokens = Append $tokens
+    "// AAAA"
+    "// BAAA"
+    "// AAAB"
+-}}
+
 {{- /* ========================== Builtin functions ========================== */ -}}
 {{- range $W.Sem.Builtins}}{{$tokens = Append $tokens .Name}}{{end -}}
 
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index 281cb61..c31cad8 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -184,7 +184,7 @@
     Indent();
 
     SourceMarker sm(this);
-    out_ << "%b" << IdOf(blk) << " = block";
+    out_ << "$B" << IdOf(blk);
     if (auto* merge = blk->As<MultiInBlock>()) {
         if (!merge->Params().IsEmpty()) {
             out_ << " (";
@@ -201,7 +201,7 @@
     }
     sm.Store(blk);
 
-    out_ << " {";
+    out_ << ": {";
     if (!comment.empty()) {
         out_ << "  # " << comment;
     }
@@ -340,7 +340,7 @@
 
     EmitReturnAttributes(func);
 
-    out_ << " -> %b" << IdOf(func->Block()) << " {";
+    out_ << " {";
 
     {  // Add a comment if the function IDs or parameter IDs doesn't match their name
         Vector<std::string, 4> names;
@@ -621,9 +621,9 @@
 
     bool has_false = !if_->False()->IsEmpty();
 
-    out_ << " [t: %b" << IdOf(if_->True());
+    out_ << " [t: $B" << IdOf(if_->True());
     if (has_false) {
-        out_ << ", f: %b" << IdOf(if_->False());
+        out_ << ", f: $B" << IdOf(if_->False());
     }
     out_ << "]";
     sm.Store(if_);
@@ -657,12 +657,12 @@
 void Disassembler::EmitLoop(const Loop* l) {
     Vector<std::string, 3> parts;
     if (!l->Initializer()->IsEmpty()) {
-        parts.Push("i: %b" + std::to_string(IdOf(l->Initializer())));
+        parts.Push("i: $B" + std::to_string(IdOf(l->Initializer())));
     }
-    parts.Push("b: %b" + std::to_string(IdOf(l->Body())));
+    parts.Push("b: $B" + std::to_string(IdOf(l->Body())));
 
     if (!l->Continuing()->IsEmpty()) {
-        parts.Push("c: %b" + std::to_string(IdOf(l->Continuing())));
+        parts.Push("c: $B" + std::to_string(IdOf(l->Continuing())));
     }
     SourceMarker sm(this);
     if (auto results = l->Results(); !results.IsEmpty()) {
@@ -734,7 +734,7 @@
                 EmitValue(selector.val);
             }
         }
-        out_ << ", %b" << IdOf(c.block) << ")";
+        out_ << ", $B" << IdOf(c.block) << ")";
     }
     out_ << "]";
     sm.Store(s);
@@ -760,8 +760,8 @@
             out_ << "ret";
             args_offset = ir::Return::kArgsOperandOffset;
         },
-        [&](const ir::Continue* cont) {
-            out_ << "continue %b" << IdOf(cont->Loop()->Continuing());
+        [&](const ir::Continue*) {
+            out_ << "continue";
             args_offset = ir::Continue::kArgsOperandOffset;
         },
         [&](const ir::ExitIf*) {
@@ -776,15 +776,14 @@
             out_ << "exit_loop";
             args_offset = ir::ExitLoop::kArgsOperandOffset;
         },
-        [&](const ir::NextIteration* ni) {
-            out_ << "next_iteration %b" << IdOf(ni->Loop()->Body());
+        [&](const ir::NextIteration*) {
+            out_ << "next_iteration";
             args_offset = ir::NextIteration::kArgsOperandOffset;
         },
         [&](const ir::Unreachable*) { out_ << "unreachable"; },
         [&](const ir::BreakIf* bi) {
             out_ << "break_if ";
             EmitValue(bi->Condition());
-            out_ << " %b" << IdOf(bi->Loop()->Body());
             args_offset = ir::BreakIf::kArgsOperandOffset;
         },
         [&](const ir::TerminateInvocation*) { out_ << "terminate_invocation"; },
@@ -797,10 +796,16 @@
     sm.Store(b);
 
     tint::Switch(
-        b,                                                                        //
-        [&](const ir::ExitIf* e) { out_ << "  # " << NameOf(e->If()); },          //
-        [&](const ir::ExitSwitch* e) { out_ << "  # " << NameOf(e->Switch()); },  //
-        [&](const ir::ExitLoop* e) { out_ << "  # " << NameOf(e->Loop()); }       //
+        b,  //
+        [&](const ir::BreakIf* bi) {
+            out_ << "  # -> [t: exit_loop " << NameOf(bi->Loop()) << ", f: $B"
+                 << IdOf(bi->Loop()->Body()) << "]";
+        },                                                                                     //
+        [&](const ir::Continue* c) { out_ << "  # -> $B" << IdOf(c->Loop()->Continuing()); },  //
+        [&](const ir::ExitIf* e) { out_ << "  # " << NameOf(e->If()); },                       //
+        [&](const ir::ExitSwitch* e) { out_ << "  # " << NameOf(e->Switch()); },               //
+        [&](const ir::ExitLoop* e) { out_ << "  # " << NameOf(e->Loop()); },                   //
+        [&](const ir::NextIteration* ni) { out_ << "  # -> $B" << IdOf(ni->Loop()->Body()); }  //
     );
 }
 
diff --git a/src/tint/lang/core/ir/transform/add_empty_entry_point_test.cc b/src/tint/lang/core/ir/transform/add_empty_entry_point_test.cc
index 541b68e..6a449d7 100644
--- a/src/tint/lang/core/ir/transform/add_empty_entry_point_test.cc
+++ b/src/tint/lang/core/ir/transform/add_empty_entry_point_test.cc
@@ -38,8 +38,8 @@
 
 TEST_F(IR_AddEmptyEntryPointTest, EmptyModule) {
     auto* expect = R"(
-%unused_entry_point = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%unused_entry_point = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     ret
   }
 }
@@ -55,8 +55,8 @@
     ep->Block()->Append(b.Return(ep));
 
     auto* expect = R"(
-%main = @fragment func():void -> %b1 {
-  %b1 = block {
+%main = @fragment func():void {
+  $B1: {
     ret
   }
 }
diff --git a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
index 7028d4e..1e4b39e 100644
--- a/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/bgra8unorm_polyfill_test.cc
@@ -45,8 +45,8 @@
     func->Block()->Append(b.Return(func));
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     ret
   }
 }
@@ -78,12 +78,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void {
+  $B2: {
     %5:texture_storage_2d<rgba8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %value
     ret
@@ -115,8 +115,8 @@
     });
 
     auto* src = R"(
-%foo = func(%texture:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%texture:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {
+  $B1: {
     %5:void = textureStore %texture, %coords, %value
     ret
   }
@@ -151,12 +151,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void {
+  $B2: {
     %5:texture_storage_2d<bgra8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %value
     ret
@@ -164,12 +164,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void {
+  $B2: {
     %5:texture_storage_2d<rgba8unorm, write> = load %texture
     %6:vec4<f32> = swizzle %value, zyxw
     %7:void = textureStore %5, %coords, %6
@@ -201,16 +201,16 @@
     });
 
     auto* src = R"(
-%foo = func(%texture:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%texture:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {
+  $B1: {
     %5:void = textureStore %texture, %coords, %value
     ret
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%texture:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%texture:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {
+  $B1: {
     %5:vec4<f32> = swizzle %value, zyxw
     %6:void = textureStore %texture, %coords, %5
     ret
@@ -259,18 +259,18 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%bar = func(%texture_1:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%bar = func(%texture_1:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_1: 'texture'
+  $B2: {
     %6:void = textureStore %texture_1, %coords, %value
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %10:texture_storage_2d<bgra8unorm, write> = load %texture
     %11:void = call %bar, %10, %coords_1, %value_1
     ret
@@ -278,19 +278,19 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%bar = func(%texture_1:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%bar = func(%texture_1:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_1: 'texture'
+  $B2: {
     %6:vec4<f32> = swizzle %value, zyxw
     %7:void = textureStore %texture_1, %coords, %6
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %11:texture_storage_2d<rgba8unorm, write> = load %texture
     %12:void = call %bar, %11, %coords_1, %value_1
     ret
@@ -351,22 +351,22 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture_a:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 2)
   %texture_b:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 3)
   %texture_c:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 4)
 }
 
-%bar = func(%texture_a_1:texture_storage_2d<bgra8unorm, write>, %texture_b_1:texture_storage_2d<bgra8unorm, write>, %texture_b_2:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_a_1: 'texture_a', %texture_b_1: 'texture_b', %texture_b_2: 'texture_b'
-  %b2 = block {
+%bar = func(%texture_a_1:texture_storage_2d<bgra8unorm, write>, %texture_b_1:texture_storage_2d<bgra8unorm, write>, %texture_b_2:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_a_1: 'texture_a', %texture_b_1: 'texture_b', %texture_b_2: 'texture_b'
+  $B2: {
     %10:void = textureStore %texture_a_1, %coords, %value
     %11:void = textureStore %texture_b_1, %coords, %value
     %12:void = textureStore %texture_b_2, %coords, %value
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %16:texture_storage_2d<bgra8unorm, write> = load %texture_a
     %17:texture_storage_2d<bgra8unorm, write> = load %texture_b
     %18:texture_storage_2d<bgra8unorm, write> = load %texture_c
@@ -376,14 +376,14 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture_a:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
   %texture_b:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 3)
   %texture_c:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 4)
 }
 
-%bar = func(%texture_a_1:texture_storage_2d<rgba8unorm, write>, %texture_b_1:texture_storage_2d<rgba8unorm, write>, %texture_b_2:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_a_1: 'texture_a', %texture_b_1: 'texture_b', %texture_b_2: 'texture_b'
-  %b2 = block {
+%bar = func(%texture_a_1:texture_storage_2d<rgba8unorm, write>, %texture_b_1:texture_storage_2d<rgba8unorm, write>, %texture_b_2:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_a_1: 'texture_a', %texture_b_1: 'texture_b', %texture_b_2: 'texture_b'
+  $B2: {
     %10:vec4<f32> = swizzle %value, zyxw
     %11:void = textureStore %texture_a_1, %coords, %10
     %12:vec4<f32> = swizzle %value, zyxw
@@ -393,8 +393,8 @@
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %19:texture_storage_2d<rgba8unorm, write> = load %texture_a
     %20:texture_storage_2d<rgba8unorm, write> = load %texture_b
     %21:texture_storage_2d<rgba8unorm, write> = load %texture_c
@@ -451,20 +451,20 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%bar = func(%texture_1:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%bar = func(%texture_1:texture_storage_2d<bgra8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_1: 'texture'
+  $B2: {
     %6:void = textureStore %texture_1, %coords, %value
     %7:void = textureStore %texture_1, %coords, %value
     %8:void = textureStore %texture_1, %coords, %value
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %12:texture_storage_2d<bgra8unorm, write> = load %texture
     %13:void = textureStore %12, %coords_1, %value_1
     %14:texture_storage_2d<bgra8unorm, write> = load %texture
@@ -476,12 +476,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%bar = func(%texture_1:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%bar = func(%texture_1:texture_storage_2d<rgba8unorm, write>, %coords:vec2<u32>, %value:vec4<f32>):void {  # %texture_1: 'texture'
+  $B2: {
     %6:vec4<f32> = swizzle %value, zyxw
     %7:void = textureStore %texture_1, %coords, %6
     %8:vec4<f32> = swizzle %value, zyxw
@@ -491,8 +491,8 @@
     ret
   }
 }
-%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%foo = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %15:texture_storage_2d<rgba8unorm, write> = load %texture
     %16:vec4<f32> = swizzle %value_1, zyxw
     %17:void = textureStore %15, %coords_1, %16
@@ -533,12 +533,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<bgra8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void {
+  $B2: {
     %5:texture_storage_2d_array<bgra8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %index, %value
     ret
@@ -546,12 +546,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec4<f32>, %coords:vec2<u32>):void {
+  $B2: {
     %5:texture_storage_2d_array<rgba8unorm, write> = load %texture
     %6:vec4<f32> = swizzle %value, zyxw
     %7:void = textureStore %5, %coords, %index, %6
@@ -585,12 +585,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func():vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<u32> {
+  $B2: {
     %3:texture_storage_2d<bgra8unorm, write> = load %texture
     %dims:vec2<u32> = textureDimensions %3
     ret %dims
@@ -598,12 +598,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func():vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<u32> {
+  $B2: {
     %3:texture_storage_2d<rgba8unorm, write> = load %texture
     %dims:vec2<u32> = textureDimensions %3
     ret %dims
@@ -638,12 +638,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, read>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<u32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_2d<bgra8unorm, read> = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     ret %result
@@ -651,12 +651,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, read>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<u32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_2d<rgba8unorm, read> = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     %6:vec4<f32> = swizzle %result, zyxw
@@ -693,12 +693,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<bgra8unorm, read_write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):void {
+  $B2: {
     %4:texture_storage_2d<bgra8unorm, read_write> = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     %6:void = textureStore %4, %coords, %result
@@ -707,12 +707,12 @@
 }
 )";
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, read_write>, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):void {
+  $B2: {
     %4:texture_storage_2d<rgba8unorm, read_write> = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     %6:vec4<f32> = swizzle %result, zyxw
diff --git a/src/tint/lang/core/ir/transform/binary_polyfill_test.cc b/src/tint/lang/core/ir/transform/binary_polyfill_test.cc
index 314ac0c..1711351 100644
--- a/src/tint/lang/core/ir/transform/binary_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/binary_polyfill_test.cc
@@ -65,8 +65,8 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftLeft_NoPolyfill) {
     Build(BinaryOp::kShiftLeft, ty.i32(), ty.i32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %result:i32 = shl %lhs, %rhs
     ret %result
   }
@@ -85,8 +85,8 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftRight_NoPolyfill) {
     Build(BinaryOp::kShiftRight, ty.i32(), ty.i32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %result:i32 = shr %lhs, %rhs
     ret %result
   }
@@ -105,16 +105,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftLeft_I32) {
     Build(BinaryOp::kShiftLeft, ty.i32(), ty.i32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %result:i32 = shl %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %4:u32 = and %rhs, 31u
     %result:i32 = shl %lhs, %4
     ret %result
@@ -133,16 +133,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftLeft_U32) {
     Build(BinaryOp::kShiftLeft, ty.u32(), ty.u32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = shl %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %4:u32 = and %rhs, 31u
     %result:u32 = shl %lhs, %4
     ret %result
@@ -161,16 +161,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftLeft_Vec2I32) {
     Build(BinaryOp::kShiftLeft, ty.vec2<i32>(), ty.vec2<i32>(), ty.vec2<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = shl %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> {
+  $B1: {
     %4:vec2<u32> = and %rhs, vec2<u32>(31u)
     %result:vec2<i32> = shl %lhs, %4
     ret %result
@@ -189,16 +189,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftLeft_Vec3U32) {
     Build(BinaryOp::kShiftLeft, ty.vec3<u32>(), ty.vec3<u32>(), ty.vec3<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = shl %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %4:vec3<u32> = and %rhs, vec3<u32>(31u)
     %result:vec3<u32> = shl %lhs, %4
     ret %result
@@ -217,16 +217,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftRight_I32) {
     Build(BinaryOp::kShiftRight, ty.i32(), ty.i32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %result:i32 = shr %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:u32):i32 {
+  $B1: {
     %4:u32 = and %rhs, 31u
     %result:i32 = shr %lhs, %4
     ret %result
@@ -245,16 +245,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftRight_U32) {
     Build(BinaryOp::kShiftRight, ty.u32(), ty.u32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = shr %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %4:u32 = and %rhs, 31u
     %result:u32 = shr %lhs, %4
     ret %result
@@ -273,16 +273,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftRight_Vec2I32) {
     Build(BinaryOp::kShiftRight, ty.vec2<i32>(), ty.vec2<i32>(), ty.vec2<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = shr %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<u32>):vec2<i32> {
+  $B1: {
     %4:vec2<u32> = and %rhs, vec2<u32>(31u)
     %result:vec2<i32> = shr %lhs, %4
     ret %result
@@ -301,16 +301,16 @@
 TEST_F(IR_BinaryPolyfillTest, ShiftRight_Vec3U32) {
     Build(BinaryOp::kShiftRight, ty.vec3<u32>(), ty.vec3<u32>(), ty.vec3<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = shr %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %4:vec3<u32> = and %rhs, vec3<u32>(31u)
     %result:vec3<u32> = shr %lhs, %4
     ret %result
@@ -329,8 +329,8 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_NoPolyfill) {
     Build(BinaryOp::kDivide, ty.i32(), ty.i32(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = div %lhs, %rhs
     ret %result
   }
@@ -349,8 +349,8 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_NoPolyfill) {
     Build(BinaryOp::kModulo, ty.i32(), ty.i32(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = mod %lhs, %rhs
     ret %result
   }
@@ -369,22 +369,22 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_I32) {
     Build(BinaryOp::kDivide, ty.i32(), ty.i32(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = call %tint_div_i32, %lhs, %rhs
     ret %result
   }
 }
-%tint_div_i32 = func(%lhs_1:i32, %rhs_1:i32):i32 -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_i32 = func(%lhs_1:i32, %rhs_1:i32):i32 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:bool = eq %rhs_1, 0i
     %9:bool = eq %lhs_1, -2147483648i
     %10:bool = eq %rhs_1, -1i
@@ -408,22 +408,22 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_U32) {
     Build(BinaryOp::kDivide, ty.u32(), ty.u32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = call %tint_div_u32, %lhs, %rhs
     ret %result
   }
 }
-%tint_div_u32 = func(%lhs_1:u32, %rhs_1:u32):u32 -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_u32 = func(%lhs_1:u32, %rhs_1:u32):u32 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:bool = eq %rhs_1, 0u
     %9:u32 = select %rhs_1, 1u, %8
     %10:u32 = div %lhs_1, %9
@@ -443,22 +443,22 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_Vec2I32) {
     Build(BinaryOp::kDivide, ty.vec2<i32>(), ty.vec2<i32>(), ty.vec2<i32>());
     auto* src = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = call %tint_div_v2i32, %lhs, %rhs
     ret %result
   }
 }
-%tint_div_v2i32 = func(%lhs_1:vec2<i32>, %rhs_1:vec2<i32>):vec2<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_v2i32 = func(%lhs_1:vec2<i32>, %rhs_1:vec2<i32>):vec2<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:vec2<bool> = eq %rhs_1, vec2<i32>(0i)
     %9:vec2<bool> = eq %lhs_1, vec2<i32>(-2147483648i)
     %10:vec2<bool> = eq %rhs_1, vec2<i32>(-1i)
@@ -482,22 +482,22 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_Vec3U32) {
     Build(BinaryOp::kDivide, ty.vec3<u32>(), ty.vec3<u32>(), ty.vec3<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = call %tint_div_v3u32, %lhs, %rhs
     ret %result
   }
 }
-%tint_div_v3u32 = func(%lhs_1:vec3<u32>, %rhs_1:vec3<u32>):vec3<u32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_v3u32 = func(%lhs_1:vec3<u32>, %rhs_1:vec3<u32>):vec3<u32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:vec3<bool> = eq %rhs_1, vec3<u32>(0u)
     %9:vec3<u32> = select %rhs_1, vec3<u32>(1u), %8
     %10:vec3<u32> = div %lhs_1, %9
@@ -517,22 +517,22 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_I32) {
     Build(BinaryOp::kModulo, ty.i32(), ty.i32(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:i32):i32 {
+  $B1: {
     %result:i32 = call %tint_mod_i32, %lhs, %rhs
     ret %result
   }
 }
-%tint_mod_i32 = func(%lhs_1:i32, %rhs_1:i32):i32 -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_i32 = func(%lhs_1:i32, %rhs_1:i32):i32 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:bool = eq %rhs_1, 0i
     %9:bool = eq %lhs_1, -2147483648i
     %10:bool = eq %rhs_1, -1i
@@ -558,22 +558,22 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_U32) {
     Build(BinaryOp::kModulo, ty.u32(), ty.u32(), ty.u32());
     auto* src = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:u32, %rhs:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:u32, %rhs:u32):u32 {
+  $B1: {
     %result:u32 = call %tint_mod_u32, %lhs, %rhs
     ret %result
   }
 }
-%tint_mod_u32 = func(%lhs_1:u32, %rhs_1:u32):u32 -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_u32 = func(%lhs_1:u32, %rhs_1:u32):u32 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:bool = eq %rhs_1, 0u
     %9:u32 = select %rhs_1, 1u, %8
     %10:u32 = div %lhs_1, %9
@@ -595,22 +595,22 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_Vec2I32) {
     Build(BinaryOp::kModulo, ty.vec2<i32>(), ty.vec2<i32>(), ty.vec2<i32>());
     auto* src = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec2<i32>, %rhs:vec2<i32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = call %tint_mod_v2i32, %lhs, %rhs
     ret %result
   }
 }
-%tint_mod_v2i32 = func(%lhs_1:vec2<i32>, %rhs_1:vec2<i32>):vec2<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_v2i32 = func(%lhs_1:vec2<i32>, %rhs_1:vec2<i32>):vec2<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:vec2<bool> = eq %rhs_1, vec2<i32>(0i)
     %9:vec2<bool> = eq %lhs_1, vec2<i32>(-2147483648i)
     %10:vec2<bool> = eq %rhs_1, vec2<i32>(-1i)
@@ -636,22 +636,22 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_Vec3U32) {
     Build(BinaryOp::kModulo, ty.vec3<u32>(), ty.vec3<u32>(), ty.vec3<u32>());
     auto* src = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec3<u32>, %rhs:vec3<u32>):vec3<u32> {
+  $B1: {
     %result:vec3<u32> = call %tint_mod_v3u32, %lhs, %rhs
     ret %result
   }
 }
-%tint_mod_v3u32 = func(%lhs_1:vec3<u32>, %rhs_1:vec3<u32>):vec3<u32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_v3u32 = func(%lhs_1:vec3<u32>, %rhs_1:vec3<u32>):vec3<u32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %8:vec3<bool> = eq %rhs_1, vec3<u32>(0u)
     %9:vec3<u32> = select %rhs_1, vec3<u32>(1u), %8
     %10:vec3<u32> = div %lhs_1, %9
@@ -673,23 +673,23 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_Scalar_Vector) {
     Build(BinaryOp::kDivide, ty.vec4<i32>(), ty.i32(), ty.vec4<i32>());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %lhs
     %result:vec4<i32> = call %tint_div_v4i32, %4, %rhs
     ret %result
   }
 }
-%tint_div_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %9:vec4<bool> = eq %rhs_1, vec4<i32>(0i)
     %10:vec4<bool> = eq %lhs_1, vec4<i32>(-2147483648i)
     %11:vec4<bool> = eq %rhs_1, vec4<i32>(-1i)
@@ -713,23 +713,23 @@
 TEST_F(IR_BinaryPolyfillTest, Divide_Vector_Scalar) {
     Build(BinaryOp::kDivide, ty.vec4<i32>(), ty.vec4<i32>(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = div %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %rhs
     %result:vec4<i32> = call %tint_div_v4i32, %lhs, %4
     ret %result
   }
 }
-%tint_div_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_div_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %9:vec4<bool> = eq %rhs_1, vec4<i32>(0i)
     %10:vec4<bool> = eq %lhs_1, vec4<i32>(-2147483648i)
     %11:vec4<bool> = eq %rhs_1, vec4<i32>(-1i)
@@ -753,23 +753,23 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_Scalar_Vector) {
     Build(BinaryOp::kModulo, ty.vec4<i32>(), ty.i32(), ty.vec4<i32>());
     auto* src = R"(
-%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:i32, %rhs:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %lhs
     %result:vec4<i32> = call %tint_mod_v4i32, %4, %rhs
     ret %result
   }
 }
-%tint_mod_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %9:vec4<bool> = eq %rhs_1, vec4<i32>(0i)
     %10:vec4<bool> = eq %lhs_1, vec4<i32>(-2147483648i)
     %11:vec4<bool> = eq %rhs_1, vec4<i32>(-1i)
@@ -795,23 +795,23 @@
 TEST_F(IR_BinaryPolyfillTest, Modulo_Vector_Scalar) {
     Build(BinaryOp::kModulo, ty.vec4<i32>(), ty.vec4<i32>(), ty.i32());
     auto* src = R"(
-%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = mod %lhs, %rhs
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%lhs:vec4<i32>, %rhs:i32):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %rhs
     %result:vec4<i32> = call %tint_mod_v4i32, %lhs, %4
     ret %result
   }
 }
-%tint_mod_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%tint_mod_v4i32 = func(%lhs_1:vec4<i32>, %rhs_1:vec4<i32>):vec4<i32> {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %9:vec4<bool> = eq %rhs_1, vec4<i32>(0i)
     %10:vec4<bool> = eq %lhs_1, vec4<i32>(-2147483648i)
     %11:vec4<bool> = eq %rhs_1, vec4<i32>(-1i)
@@ -893,8 +893,8 @@
     }
 
     auto* src = R"(
-%foo_i32 = func(%lhs:i32, %rhs:i32):void -> %b1 {
-  %b1 = block {
+%foo_i32 = func(%lhs:i32, %rhs:i32):void {
+  $B1: {
     %4:i32 = div %lhs, %rhs
     %5:i32 = div %lhs, %rhs
     %6:i32 = mod %lhs, %rhs
@@ -902,8 +902,8 @@
     ret
   }
 }
-%foo_u32 = func(%lhs_1:u32, %rhs_1:u32):void -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%foo_u32 = func(%lhs_1:u32, %rhs_1:u32):void {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %11:u32 = div %lhs_1, %rhs_1
     %12:u32 = div %lhs_1, %rhs_1
     %13:u32 = mod %lhs_1, %rhs_1
@@ -911,8 +911,8 @@
     ret
   }
 }
-%foo_vec4i = func(%lhs_2:vec4<i32>, %rhs_2:vec4<i32>):void -> %b3 {  # %lhs_2: 'lhs', %rhs_2: 'rhs'
-  %b3 = block {
+%foo_vec4i = func(%lhs_2:vec4<i32>, %rhs_2:vec4<i32>):void {  # %lhs_2: 'lhs', %rhs_2: 'rhs'
+  $B3: {
     %18:vec4<i32> = div %lhs_2, %rhs_2
     %19:vec4<i32> = div %lhs_2, %rhs_2
     %20:vec4<i32> = mod %lhs_2, %rhs_2
@@ -920,8 +920,8 @@
     ret
   }
 }
-%foo_vec4u = func(%lhs_3:vec4<u32>, %rhs_3:vec4<u32>):void -> %b4 {  # %lhs_3: 'lhs', %rhs_3: 'rhs'
-  %b4 = block {
+%foo_vec4u = func(%lhs_3:vec4<u32>, %rhs_3:vec4<u32>):void {  # %lhs_3: 'lhs', %rhs_3: 'rhs'
+  $B4: {
     %25:vec4<u32> = div %lhs_3, %rhs_3
     %26:vec4<u32> = div %lhs_3, %rhs_3
     %27:vec4<u32> = mod %lhs_3, %rhs_3
@@ -931,8 +931,8 @@
 }
 )";
     auto* expect = R"(
-%foo_i32 = func(%lhs:i32, %rhs:i32):void -> %b1 {
-  %b1 = block {
+%foo_i32 = func(%lhs:i32, %rhs:i32):void {
+  $B1: {
     %4:i32 = call %tint_div_i32, %lhs, %rhs
     %6:i32 = call %tint_div_i32, %lhs, %rhs
     %7:i32 = call %tint_mod_i32, %lhs, %rhs
@@ -940,8 +940,8 @@
     ret
   }
 }
-%foo_u32 = func(%lhs_1:u32, %rhs_1:u32):void -> %b2 {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
-  %b2 = block {
+%foo_u32 = func(%lhs_1:u32, %rhs_1:u32):void {  # %lhs_1: 'lhs', %rhs_1: 'rhs'
+  $B2: {
     %13:u32 = call %tint_div_u32, %lhs_1, %rhs_1
     %15:u32 = call %tint_div_u32, %lhs_1, %rhs_1
     %16:u32 = call %tint_mod_u32, %lhs_1, %rhs_1
@@ -949,8 +949,8 @@
     ret
   }
 }
-%foo_vec4i = func(%lhs_2:vec4<i32>, %rhs_2:vec4<i32>):void -> %b3 {  # %lhs_2: 'lhs', %rhs_2: 'rhs'
-  %b3 = block {
+%foo_vec4i = func(%lhs_2:vec4<i32>, %rhs_2:vec4<i32>):void {  # %lhs_2: 'lhs', %rhs_2: 'rhs'
+  $B3: {
     %22:vec4<i32> = call %tint_div_v4i32, %lhs_2, %rhs_2
     %24:vec4<i32> = call %tint_div_v4i32, %lhs_2, %rhs_2
     %25:vec4<i32> = call %tint_mod_v4i32, %lhs_2, %rhs_2
@@ -958,8 +958,8 @@
     ret
   }
 }
-%foo_vec4u = func(%lhs_3:vec4<u32>, %rhs_3:vec4<u32>):void -> %b4 {  # %lhs_3: 'lhs', %rhs_3: 'rhs'
-  %b4 = block {
+%foo_vec4u = func(%lhs_3:vec4<u32>, %rhs_3:vec4<u32>):void {  # %lhs_3: 'lhs', %rhs_3: 'rhs'
+  $B4: {
     %31:vec4<u32> = call %tint_div_v4u32, %lhs_3, %rhs_3
     %33:vec4<u32> = call %tint_div_v4u32, %lhs_3, %rhs_3
     %34:vec4<u32> = call %tint_mod_v4u32, %lhs_3, %rhs_3
@@ -967,8 +967,8 @@
     ret
   }
 }
-%tint_div_i32 = func(%lhs_4:i32, %rhs_4:i32):i32 -> %b5 {  # %lhs_4: 'lhs', %rhs_4: 'rhs'
-  %b5 = block {
+%tint_div_i32 = func(%lhs_4:i32, %rhs_4:i32):i32 {  # %lhs_4: 'lhs', %rhs_4: 'rhs'
+  $B5: {
     %39:bool = eq %rhs_4, 0i
     %40:bool = eq %lhs_4, -2147483648i
     %41:bool = eq %rhs_4, -1i
@@ -979,8 +979,8 @@
     ret %45
   }
 }
-%tint_mod_i32 = func(%lhs_5:i32, %rhs_5:i32):i32 -> %b6 {  # %lhs_5: 'lhs', %rhs_5: 'rhs'
-  %b6 = block {
+%tint_mod_i32 = func(%lhs_5:i32, %rhs_5:i32):i32 {  # %lhs_5: 'lhs', %rhs_5: 'rhs'
+  $B6: {
     %48:bool = eq %rhs_5, 0i
     %49:bool = eq %lhs_5, -2147483648i
     %50:bool = eq %rhs_5, -1i
@@ -993,16 +993,16 @@
     ret %56
   }
 }
-%tint_div_u32 = func(%lhs_6:u32, %rhs_6:u32):u32 -> %b7 {  # %lhs_6: 'lhs', %rhs_6: 'rhs'
-  %b7 = block {
+%tint_div_u32 = func(%lhs_6:u32, %rhs_6:u32):u32 {  # %lhs_6: 'lhs', %rhs_6: 'rhs'
+  $B7: {
     %59:bool = eq %rhs_6, 0u
     %60:u32 = select %rhs_6, 1u, %59
     %61:u32 = div %lhs_6, %60
     ret %61
   }
 }
-%tint_mod_u32 = func(%lhs_7:u32, %rhs_7:u32):u32 -> %b8 {  # %lhs_7: 'lhs', %rhs_7: 'rhs'
-  %b8 = block {
+%tint_mod_u32 = func(%lhs_7:u32, %rhs_7:u32):u32 {  # %lhs_7: 'lhs', %rhs_7: 'rhs'
+  $B8: {
     %64:bool = eq %rhs_7, 0u
     %65:u32 = select %rhs_7, 1u, %64
     %66:u32 = div %lhs_7, %65
@@ -1011,8 +1011,8 @@
     ret %68
   }
 }
-%tint_div_v4i32 = func(%lhs_8:vec4<i32>, %rhs_8:vec4<i32>):vec4<i32> -> %b9 {  # %lhs_8: 'lhs', %rhs_8: 'rhs'
-  %b9 = block {
+%tint_div_v4i32 = func(%lhs_8:vec4<i32>, %rhs_8:vec4<i32>):vec4<i32> {  # %lhs_8: 'lhs', %rhs_8: 'rhs'
+  $B9: {
     %71:vec4<bool> = eq %rhs_8, vec4<i32>(0i)
     %72:vec4<bool> = eq %lhs_8, vec4<i32>(-2147483648i)
     %73:vec4<bool> = eq %rhs_8, vec4<i32>(-1i)
@@ -1023,8 +1023,8 @@
     ret %77
   }
 }
-%tint_mod_v4i32 = func(%lhs_9:vec4<i32>, %rhs_9:vec4<i32>):vec4<i32> -> %b10 {  # %lhs_9: 'lhs', %rhs_9: 'rhs'
-  %b10 = block {
+%tint_mod_v4i32 = func(%lhs_9:vec4<i32>, %rhs_9:vec4<i32>):vec4<i32> {  # %lhs_9: 'lhs', %rhs_9: 'rhs'
+  $B10: {
     %80:vec4<bool> = eq %rhs_9, vec4<i32>(0i)
     %81:vec4<bool> = eq %lhs_9, vec4<i32>(-2147483648i)
     %82:vec4<bool> = eq %rhs_9, vec4<i32>(-1i)
@@ -1037,16 +1037,16 @@
     ret %88
   }
 }
-%tint_div_v4u32 = func(%lhs_10:vec4<u32>, %rhs_10:vec4<u32>):vec4<u32> -> %b11 {  # %lhs_10: 'lhs', %rhs_10: 'rhs'
-  %b11 = block {
+%tint_div_v4u32 = func(%lhs_10:vec4<u32>, %rhs_10:vec4<u32>):vec4<u32> {  # %lhs_10: 'lhs', %rhs_10: 'rhs'
+  $B11: {
     %91:vec4<bool> = eq %rhs_10, vec4<u32>(0u)
     %92:vec4<u32> = select %rhs_10, vec4<u32>(1u), %91
     %93:vec4<u32> = div %lhs_10, %92
     ret %93
   }
 }
-%tint_mod_v4u32 = func(%lhs_11:vec4<u32>, %rhs_11:vec4<u32>):vec4<u32> -> %b12 {  # %lhs_11: 'lhs', %rhs_11: 'rhs'
-  %b12 = block {
+%tint_mod_v4u32 = func(%lhs_11:vec4<u32>, %rhs_11:vec4<u32>):vec4<u32> {  # %lhs_11: 'lhs', %rhs_11: 'rhs'
+  $B12: {
     %96:vec4<bool> = eq %rhs_11, vec4<u32>(0u)
     %97:vec4<u32> = select %rhs_11, vec4<u32>(1u), %96
     %98:vec4<u32> = div %lhs_11, %97
diff --git a/src/tint/lang/core/ir/transform/binding_remapper_test.cc b/src/tint/lang/core/ir/transform/binding_remapper_test.cc
index 11987b7..15eda22 100644
--- a/src/tint/lang/core/ir/transform/binding_remapper_test.cc
+++ b/src/tint/lang/core/ir/transform/binding_remapper_test.cc
@@ -45,7 +45,7 @@
     mod.root_block->Append(buffer);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(0, 0)
 }
 
@@ -66,7 +66,7 @@
     mod.root_block->Append(buffer);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(0, 0)
 }
 
@@ -88,7 +88,7 @@
     mod.root_block->Append(buffer);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(1, 2)
 }
 
@@ -96,7 +96,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(3, 2)
 }
 
@@ -115,7 +115,7 @@
     mod.root_block->Append(buffer);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(1, 2)
 }
 
@@ -123,7 +123,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(1, 3)
 }
 
@@ -142,7 +142,7 @@
     mod.root_block->Append(buffer);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(1, 2)
 }
 
@@ -150,7 +150,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, i32, read> = var @binding_point(3, 4)
 }
 
@@ -172,7 +172,7 @@
     mod.root_block->Append(buffer_b);
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer_a:ptr<uniform, i32, read> = var @binding_point(1, 2)
   %buffer_b:ptr<uniform, i32, read> = var @binding_point(3, 4)
 }
@@ -181,7 +181,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer_a:ptr<uniform, i32, read> = var @binding_point(3, 4)
   %buffer_b:ptr<uniform, i32, read> = var @binding_point(1, 2)
 }
@@ -212,13 +212,13 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer_a:ptr<uniform, i32, read> = var @binding_point(1, 2)
   %buffer_b:ptr<uniform, i32, read> = var @binding_point(3, 4)
 }
 
-%main = @fragment func():void -> %b2 {
-  %b2 = block {
+%main = @fragment func():void {
+  $B2: {
     %4:i32 = load %buffer_a
     %5:i32 = load %buffer_b
     ret
@@ -228,13 +228,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer_a:ptr<uniform, i32, read> = var @binding_point(0, 1)
   %buffer_b:ptr<uniform, i32, read> = var @binding_point(0, 1)
 }
 
-%main = @fragment func():void -> %b2 {
-  %b2 = block {
+%main = @fragment func():void {
+  $B2: {
     %4:i32 = load %buffer_a
     %5:i32 = load %buffer_b
     ret
diff --git a/src/tint/lang/core/ir/transform/block_decorated_structs_test.cc b/src/tint/lang/core/ir/transform/block_decorated_structs_test.cc
index 714e39c..f85e4dd 100644
--- a/src/tint/lang/core/ir/transform/block_decorated_structs_test.cc
+++ b/src/tint/lang/core/ir/transform/block_decorated_structs_test.cc
@@ -47,8 +47,8 @@
     func->Block()->Append(b.Return(func));
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     ret
   }
 }
@@ -75,12 +75,12 @@
   tint_symbol:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<uniform, tint_symbol_1, read> = var @binding_point(0, 0)
 }
 
-%foo = func():i32 -> %b2 {
-  %b2 = block {
+%foo = func():i32 {
+  $B2: {
     %3:ptr<uniform, i32, read> = access %1, 0u
     %4:i32 = load %3
     ret %4
@@ -107,12 +107,12 @@
   tint_symbol:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<storage, i32, read_write> = access %1, 0u
     store %3, 42i
     ret
@@ -139,12 +139,12 @@
   tint_symbol:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<push_constant, tint_symbol_1, read> = var
 }
 
-%foo = func():i32 -> %b2 {
-  %b2 = block {
+%foo = func():i32 {
+  $B2: {
     %3:ptr<push_constant, i32, read> = access %1, 0u
     %4:i32 = load %3
     ret %4
@@ -175,12 +175,12 @@
   tint_symbol:array<i32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<storage, array<i32>, read_write> = access %1, 0u
     %4:ptr<storage, i32, read_write> = access %3, 1u
     store %4, 42i
@@ -223,12 +223,12 @@
   arr:array<i32> @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<storage, i32, read_write> = access %1, 0u
     %4:i32 = load %3
     %5:ptr<storage, i32, read_write> = access %1, 1u, 3u
@@ -268,12 +268,12 @@
   arr:array<i32> @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %root:ptr<storage, MyStruct, read_write> = let %1
     %4:ptr<storage, array<i32>, read_write> = access %root, 1u
     %arr:ptr<storage, array<i32>, read_write> = let %4
@@ -316,13 +316,13 @@
   tint_symbol:MyStruct @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read_write> = var @binding_point(0, 0)
   %2:ptr<private, MyStruct, read_write> = var
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %4:MyStruct = load %2
     %5:ptr<storage, MyStruct, read_write> = access %1, 0u
     store %5, %4
@@ -369,14 +369,14 @@
   tint_symbol_4:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read_write> = var @binding_point(0, 0)
   %2:ptr<storage, tint_symbol_3, read_write> = var @binding_point(0, 1)
   %3:ptr<storage, tint_symbol_5, read_write> = var @binding_point(0, 2)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %5:ptr<storage, i32, read_write> = access %2, 0u
     %6:i32 = load %5
     %7:ptr<storage, i32, read_write> = access %3, 0u
diff --git a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
index 6c6f910..0e1dd0a 100644
--- a/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/builtin_polyfill_test.cc
@@ -64,8 +64,8 @@
 TEST_F(IR_BuiltinPolyfillTest, Saturate_NoPolyfill) {
     Build(core::BuiltinFn::kSaturate, ty.f32(), Vector{ty.f32()});
     auto* src = R"(
-%foo = func(%arg:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f32):f32 {
+  $B1: {
     %result:f32 = saturate %arg
     ret %result
   }
@@ -84,16 +84,16 @@
 TEST_F(IR_BuiltinPolyfillTest, Saturate_F32) {
     Build(core::BuiltinFn::kSaturate, ty.f32(), Vector{ty.f32()});
     auto* src = R"(
-%foo = func(%arg:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f32):f32 {
+  $B1: {
     %result:f32 = saturate %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f32):f32 {
+  $B1: {
     %result:f32 = clamp %arg, 0.0f, 1.0f
     ret %result
   }
@@ -111,16 +111,16 @@
 TEST_F(IR_BuiltinPolyfillTest, Saturate_F16) {
     Build(core::BuiltinFn::kSaturate, ty.f16(), Vector{ty.f16()});
     auto* src = R"(
-%foo = func(%arg:f16):f16 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f16):f16 {
+  $B1: {
     %result:f16 = saturate %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:f16):f16 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f16):f16 {
+  $B1: {
     %result:f16 = clamp %arg, 0.0h, 1.0h
     ret %result
   }
@@ -137,16 +137,16 @@
 TEST_F(IR_BuiltinPolyfillTest, Saturate_Vec2F32) {
     Build(core::BuiltinFn::kSaturate, ty.vec2<f32>(), Vector{ty.vec2<f32>()});
     auto* src = R"(
-%foo = func(%arg:vec2<f32>):vec2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<f32>):vec2<f32> {
+  $B1: {
     %result:vec2<f32> = saturate %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<f32>):vec2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<f32>):vec2<f32> {
+  $B1: {
     %result:vec2<f32> = clamp %arg, vec2<f32>(0.0f), vec2<f32>(1.0f)
     ret %result
   }
@@ -164,16 +164,16 @@
 TEST_F(IR_BuiltinPolyfillTest, Saturate_Vec4F16) {
     Build(core::BuiltinFn::kSaturate, ty.vec4<f16>(), Vector{ty.vec4<f16>()});
     auto* src = R"(
-%foo = func(%arg:vec4<f16>):vec4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<f16>):vec4<f16> {
+  $B1: {
     %result:vec4<f16> = saturate %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<f16>):vec4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<f16>):vec4<f16> {
+  $B1: {
     %result:vec4<f16> = clamp %arg, vec4<f16>(0.0h), vec4<f16>(1.0h)
     ret %result
   }
@@ -191,8 +191,8 @@
 TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_NoPolyfill) {
     Build(core::BuiltinFn::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = countLeadingZeros %arg
     ret %result
   }
@@ -211,16 +211,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_U32) {
     Build(core::BuiltinFn::kCountLeadingZeros, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = countLeadingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %3:bool = lte %arg, 65535u
     %4:u32 = select 0u, 16u, %3
     %5:u32 = shl %arg, %4
@@ -259,16 +259,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_I32) {
     Build(core::BuiltinFn::kCountLeadingZeros, ty.i32(), Vector{ty.i32()});
     auto* src = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %result:i32 = countLeadingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %3:u32 = bitcast %arg
     %4:bool = lte %3, 65535u
     %5:u32 = select 0u, 16u, %4
@@ -309,16 +309,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_Vec2U32) {
     Build(core::BuiltinFn::kCountLeadingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = countLeadingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %3:vec2<bool> = lte %arg, vec2<u32>(65535u)
     %4:vec2<u32> = select vec2<u32>(0u), vec2<u32>(16u), %3
     %5:vec2<u32> = shl %arg, %4
@@ -357,16 +357,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountLeadingZeros_Vec4I32) {
     Build(core::BuiltinFn::kCountLeadingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = countLeadingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %3:vec4<u32> = bitcast %arg
     %4:vec4<bool> = lte %3, vec4<u32>(65535u)
     %5:vec4<u32> = select vec4<u32>(0u), vec4<u32>(16u), %4
@@ -407,8 +407,8 @@
 TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_NoPolyfill) {
     Build(core::BuiltinFn::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = countTrailingZeros %arg
     ret %result
   }
@@ -427,16 +427,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_U32) {
     Build(core::BuiltinFn::kCountTrailingZeros, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = countTrailingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %3:u32 = and %arg, 65535u
     %4:bool = eq %3, 0u
     %5:u32 = select 0u, 16u, %4
@@ -479,16 +479,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_I32) {
     Build(core::BuiltinFn::kCountTrailingZeros, ty.i32(), Vector{ty.i32()});
     auto* src = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %result:i32 = countTrailingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %3:u32 = bitcast %arg
     %4:u32 = and %3, 65535u
     %5:bool = eq %4, 0u
@@ -533,16 +533,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_Vec2U32) {
     Build(core::BuiltinFn::kCountTrailingZeros, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = countTrailingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = and %arg, vec2<u32>(65535u)
     %4:vec2<bool> = eq %3, vec2<u32>(0u)
     %5:vec2<u32> = select vec2<u32>(0u), vec2<u32>(16u), %4
@@ -585,16 +585,16 @@
 TEST_F(IR_BuiltinPolyfillTest, CountTrailingZeros_Vec4I32) {
     Build(core::BuiltinFn::kCountTrailingZeros, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = countTrailingZeros %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = countTrailingZeros %arg
     ret %result
   }
@@ -612,8 +612,8 @@
 TEST_F(IR_BuiltinPolyfillTest, ExtractBits_NoPolyfill) {
     Build(core::BuiltinFn::kExtractBits, ty.u32(), Vector{ty.u32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:u32 = extractBits %arg, %arg_1, %arg_2
     ret %result
   }
@@ -632,16 +632,16 @@
 TEST_F(IR_BuiltinPolyfillTest, ExtractBits_ClampArgs_U32) {
     Build(core::BuiltinFn::kExtractBits, ty.u32(), Vector{ty.u32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:u32 = extractBits %arg, %arg_1, %arg_2
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %5:u32 = min %arg_1, 32u
     %6:u32 = sub 32u, %5
     %7:u32 = min %arg_2, %6
@@ -662,16 +662,16 @@
 TEST_F(IR_BuiltinPolyfillTest, ExtractBits_ClampArgs_I32) {
     Build(core::BuiltinFn::kExtractBits, ty.i32(), Vector{ty.i32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:i32, %arg_1:u32, %arg_2:u32):i32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:i32, %arg_1:u32, %arg_2:u32):i32 {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:i32 = extractBits %arg, %arg_1, %arg_2
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32, %arg_1:u32, %arg_2:u32):i32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:i32, %arg_1:u32, %arg_2:u32):i32 {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %5:u32 = min %arg_1, 32u
     %6:u32 = sub 32u, %5
     %7:u32 = min %arg_2, %6
@@ -693,16 +693,16 @@
     Build(core::BuiltinFn::kExtractBits, ty.vec2<u32>(),
           Vector{ty.vec2<u32>(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>, %arg_1:u32, %arg_2:u32):vec2<u32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec2<u32>, %arg_1:u32, %arg_2:u32):vec2<u32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:vec2<u32> = extractBits %arg, %arg_1, %arg_2
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>, %arg_1:u32, %arg_2:u32):vec2<u32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec2<u32>, %arg_1:u32, %arg_2:u32):vec2<u32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %5:u32 = min %arg_1, 32u
     %6:u32 = sub 32u, %5
     %7:u32 = min %arg_2, %6
@@ -724,16 +724,16 @@
     Build(core::BuiltinFn::kExtractBits, ty.vec4<i32>(),
           Vector{ty.vec4<i32>(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>, %arg_1:u32, %arg_2:u32):vec4<i32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec4<i32>, %arg_1:u32, %arg_2:u32):vec4<i32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:vec4<i32> = extractBits %arg, %arg_1, %arg_2
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>, %arg_1:u32, %arg_2:u32):vec4<i32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec4<i32>, %arg_1:u32, %arg_2:u32):vec4<i32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %5:u32 = min %arg_1, 32u
     %6:u32 = sub 32u, %5
     %7:u32 = min %arg_2, %6
@@ -754,8 +754,8 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_NoPolyfill) {
     Build(core::BuiltinFn::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = firstLeadingBit %arg
     ret %result
   }
@@ -774,16 +774,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_U32) {
     Build(core::BuiltinFn::kFirstLeadingBit, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = firstLeadingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %3:u32 = and %arg, 4294901760u
     %4:bool = eq %3, 0u
     %5:u32 = select 16u, 0u, %4
@@ -825,16 +825,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_I32) {
     Build(core::BuiltinFn::kFirstLeadingBit, ty.i32(), Vector{ty.i32()});
     auto* src = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %result:i32 = firstLeadingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %3:u32 = bitcast %arg
     %4:u32 = complement %3
     %5:bool = lt %3, 2147483648u
@@ -881,16 +881,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_Vec2U32) {
     Build(core::BuiltinFn::kFirstLeadingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = firstLeadingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = and %arg, vec2<u32>(4294901760u)
     %4:vec2<bool> = eq %3, vec2<u32>(0u)
     %5:vec2<u32> = select vec2<u32>(16u), vec2<u32>(0u), %4
@@ -932,16 +932,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstLeadingBit_Vec4I32) {
     Build(core::BuiltinFn::kFirstLeadingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = firstLeadingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %3:vec4<u32> = bitcast %arg
     %4:vec4<u32> = complement %3
     %5:vec4<bool> = lt %3, vec4<u32>(2147483648u)
@@ -988,8 +988,8 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_NoPolyfill) {
     Build(core::BuiltinFn::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = firstTrailingBit %arg
     ret %result
   }
@@ -1008,16 +1008,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_U32) {
     Build(core::BuiltinFn::kFirstTrailingBit, ty.u32(), Vector{ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %result:u32 = firstTrailingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):u32 {
+  $B1: {
     %3:u32 = and %arg, 65535u
     %4:bool = eq %3, 0u
     %5:u32 = select 0u, 16u, %4
@@ -1059,16 +1059,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_I32) {
     Build(core::BuiltinFn::kFirstTrailingBit, ty.i32(), Vector{ty.i32()});
     auto* src = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %result:i32 = firstTrailingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:i32):i32 {
+  $B1: {
     %3:u32 = bitcast %arg
     %4:u32 = and %3, 65535u
     %5:bool = eq %4, 0u
@@ -1112,16 +1112,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_Vec2U32) {
     Build(core::BuiltinFn::kFirstTrailingBit, ty.vec2<u32>(), Vector{ty.vec2<u32>()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = firstTrailingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec2<u32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = and %arg, vec2<u32>(65535u)
     %4:vec2<bool> = eq %3, vec2<u32>(0u)
     %5:vec2<u32> = select vec2<u32>(0u), vec2<u32>(16u), %4
@@ -1163,16 +1163,16 @@
 TEST_F(IR_BuiltinPolyfillTest, FirstTrailingBit_Vec4I32) {
     Build(core::BuiltinFn::kFirstTrailingBit, ty.vec4<i32>(), Vector{ty.vec4<i32>()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = firstTrailingBit %arg
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):vec4<i32> {
+  $B1: {
     %3:vec4<u32> = bitcast %arg
     %4:vec4<u32> = and %3, vec4<u32>(65535u)
     %5:vec4<bool> = eq %4, vec4<u32>(0u)
@@ -1216,8 +1216,8 @@
 TEST_F(IR_BuiltinPolyfillTest, InsertBits_NoPolyfill) {
     Build(core::BuiltinFn::kInsertBits, ty.u32(), Vector{ty.u32(), ty.u32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %result:u32 = insertBits %arg, %arg_1, %arg_2, %arg_3
     ret %result
   }
@@ -1236,16 +1236,16 @@
 TEST_F(IR_BuiltinPolyfillTest, InsertBits_ClampArgs_U32) {
     Build(core::BuiltinFn::kInsertBits, ty.u32(), Vector{ty.u32(), ty.u32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %result:u32 = insertBits %arg, %arg_1, %arg_2, %arg_3
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32, %arg_2:u32, %arg_3:u32):u32 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %6:u32 = min %arg_2, 32u
     %7:u32 = sub 32u, %6
     %8:u32 = min %arg_3, %7
@@ -1266,16 +1266,16 @@
 TEST_F(IR_BuiltinPolyfillTest, InsertBits_ClampArgs_I32) {
     Build(core::BuiltinFn::kInsertBits, ty.i32(), Vector{ty.i32(), ty.i32(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:i32, %arg_1:i32, %arg_2:u32, %arg_3:u32):i32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:i32, %arg_1:i32, %arg_2:u32, %arg_3:u32):i32 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %result:i32 = insertBits %arg, %arg_1, %arg_2, %arg_3
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:i32, %arg_1:i32, %arg_2:u32, %arg_3:u32):i32 -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:i32, %arg_1:i32, %arg_2:u32, %arg_3:u32):i32 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %6:u32 = min %arg_2, 32u
     %7:u32 = sub 32u, %6
     %8:u32 = min %arg_3, %7
@@ -1297,16 +1297,16 @@
     Build(core::BuiltinFn::kInsertBits, ty.vec2<u32>(),
           Vector{ty.vec2<u32>(), ty.vec2<u32>(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:vec2<u32>, %arg_1:vec2<u32>, %arg_2:u32, %arg_3:u32):vec2<u32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec2<u32>, %arg_1:vec2<u32>, %arg_2:u32, %arg_3:u32):vec2<u32> {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %result:vec2<u32> = insertBits %arg, %arg_1, %arg_2, %arg_3
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec2<u32>, %arg_1:vec2<u32>, %arg_2:u32, %arg_3:u32):vec2<u32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec2<u32>, %arg_1:vec2<u32>, %arg_2:u32, %arg_3:u32):vec2<u32> {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %6:u32 = min %arg_2, 32u
     %7:u32 = sub 32u, %6
     %8:u32 = min %arg_3, %7
@@ -1328,16 +1328,16 @@
     Build(core::BuiltinFn::kInsertBits, ty.vec4<i32>(),
           Vector{ty.vec4<i32>(), ty.vec4<i32>(), ty.u32(), ty.u32()});
     auto* src = R"(
-%foo = func(%arg:vec4<i32>, %arg_1:vec4<i32>, %arg_2:u32, %arg_3:u32):vec4<i32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec4<i32>, %arg_1:vec4<i32>, %arg_2:u32, %arg_3:u32):vec4<i32> {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %result:vec4<i32> = insertBits %arg, %arg_1, %arg_2, %arg_3
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>, %arg_1:vec4<i32>, %arg_2:u32, %arg_3:u32):vec4<i32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
-  %b1 = block {
+%foo = func(%arg:vec4<i32>, %arg_1:vec4<i32>, %arg_2:u32, %arg_3:u32):vec4<i32> {  # %arg_1: 'arg', %arg_2: 'arg', %arg_3: 'arg'
+  $B1: {
     %6:u32 = min %arg_2, 32u
     %7:u32 = sub 32u, %6
     %8:u32 = min %arg_3, %7
@@ -1361,8 +1361,8 @@
     Build(core::BuiltinFn::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
           Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
     auto* src = R"(
-%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:vec4<f32> = textureSampleBaseClampToEdge %arg, %arg_1, %arg_2
     ret %result
   }
@@ -1384,16 +1384,16 @@
     Build(core::BuiltinFn::kTextureSampleBaseClampToEdge, ty.vec4<f32>(),
           Vector{texture_ty, ty.sampler(), ty.vec2<f32>()});
     auto* src = R"(
-%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %result:vec4<f32> = textureSampleBaseClampToEdge %arg, %arg_1, %arg_2
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> -> %b1 {  # %arg_1: 'arg', %arg_2: 'arg'
-  %b1 = block {
+%foo = func(%arg:texture_2d<f32>, %arg_1:sampler, %arg_2:vec2<f32>):vec4<f32> {  # %arg_1: 'arg', %arg_2: 'arg'
+  $B1: {
     %5:vec2<u32> = textureDimensions %arg
     %6:vec2<f32> = convert %5
     %7:vec2<f32> = div vec2<f32>(0.5f), %6
@@ -1417,8 +1417,8 @@
     Build(core::BuiltinFn::kPack4XI8, ty.u32(), Vector{ty.vec4<i32>()});
 
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):u32 {
+  $B1: {
     %result:u32 = pack4xI8 %arg
     ret %result
   }
@@ -1427,8 +1427,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):u32 {
+  $B1: {
     %3:vec4<u32> = construct 0u, 8u, 16u, 24u
     %4:vec4<u32> = bitcast %arg
     %5:vec4<u32> = construct 255u
@@ -1452,8 +1452,8 @@
     Build(core::BuiltinFn::kPack4XU8, ty.u32(), Vector{ty.vec4<u32>()});
 
     auto* src = R"(
-%foo = func(%arg:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<u32>):u32 {
+  $B1: {
     %result:u32 = pack4xU8 %arg
     ret %result
   }
@@ -1462,8 +1462,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<u32>):u32 {
+  $B1: {
     %3:vec4<u32> = construct 0u, 8u, 16u, 24u
     %4:vec4<u32> = construct 255u
     %5:vec4<u32> = and %arg, %4
@@ -1486,8 +1486,8 @@
     Build(core::BuiltinFn::kPack4XI8Clamp, ty.u32(), Vector{ty.vec4<i32>()});
 
     auto* src = R"(
-%foo = func(%arg:vec4<i32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):u32 {
+  $B1: {
     %result:u32 = pack4xI8Clamp %arg
     ret %result
   }
@@ -1496,8 +1496,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:vec4<i32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<i32>):u32 {
+  $B1: {
     %3:vec4<u32> = construct 0u, 8u, 16u, 24u
     %4:vec4<i32> = construct -128i
     %5:vec4<i32> = construct 127i
@@ -1524,8 +1524,8 @@
     Build(core::BuiltinFn::kPack4XU8Clamp, ty.u32(), Vector{ty.vec4<u32>()});
 
     auto* src = R"(
-%foo = func(%arg:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<u32>):u32 {
+  $B1: {
     %result:u32 = pack4xU8Clamp %arg
     ret %result
   }
@@ -1534,8 +1534,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<u32>):u32 {
+  $B1: {
     %3:vec4<u32> = construct 0u, 8u, 16u, 24u
     %4:vec4<u32> = construct 0u
     %5:vec4<u32> = construct 255u
@@ -1559,8 +1559,8 @@
     Build(core::BuiltinFn::kUnpack4XI8, ty.vec4<i32>(), Vector{ty.u32()});
 
     auto* src = R"(
-%foo = func(%arg:u32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):vec4<i32> {
+  $B1: {
     %result:vec4<i32> = unpack4xI8 %arg
     ret %result
   }
@@ -1569,8 +1569,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:u32):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):vec4<i32> {
+  $B1: {
     %3:vec4<u32> = construct 24u, 16u, 8u, 0u
     %4:vec4<u32> = construct %arg
     %5:vec4<u32> = shl %4, %3
@@ -1593,8 +1593,8 @@
     Build(core::BuiltinFn::kUnpack4XU8, ty.vec4<u32>(), Vector{ty.u32()});
 
     auto* src = R"(
-%foo = func(%arg:u32):vec4<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):vec4<u32> {
+  $B1: {
     %result:vec4<u32> = unpack4xU8 %arg
     ret %result
   }
@@ -1603,8 +1603,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:u32):vec4<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:u32):vec4<u32> {
+  $B1: {
     %3:vec4<u32> = construct 0u, 8u, 16u, 24u
     %4:vec4<u32> = construct %arg
     %5:vec4<u32> = shr %4, %3
@@ -1626,8 +1626,8 @@
     Build(core::BuiltinFn::kDot4I8Packed, ty.i32(), Vector{ty.u32(), ty.u32()});
 
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32):i32 -> %b1 {  # %arg_1: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32):i32 {  # %arg_1: 'arg'
+  $B1: {
     %result:i32 = dot4I8Packed %arg, %arg_1
     ret %result
   }
@@ -1636,8 +1636,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:u32, %arg_1:u32):i32 -> %b1 {  # %arg_1: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32):i32 {  # %arg_1: 'arg'
+  $B1: {
     %4:vec4<u32> = construct 24u, 16u, 8u, 0u
     %5:vec4<u32> = construct %arg
     %6:vec4<u32> = shl %5, %4
@@ -1667,8 +1667,8 @@
     Build(core::BuiltinFn::kDot4U8Packed, ty.u32(), Vector{ty.u32(), ty.u32()});
 
     auto* src = R"(
-%foo = func(%arg:u32, %arg_1:u32):u32 -> %b1 {  # %arg_1: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32):u32 {  # %arg_1: 'arg'
+  $B1: {
     %result:u32 = dot4U8Packed %arg, %arg_1
     ret %result
   }
@@ -1677,8 +1677,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:u32, %arg_1:u32):u32 -> %b1 {  # %arg_1: 'arg'
-  %b1 = block {
+%foo = func(%arg:u32, %arg_1:u32):u32 {  # %arg_1: 'arg'
+  $B1: {
     %4:vec4<u32> = construct 0u, 8u, 16u, 24u
     %5:vec4<u32> = construct %arg
     %6:vec4<u32> = shr %5, %4
diff --git a/src/tint/lang/core/ir/transform/combine_access_instructions_test.cc b/src/tint/lang/core/ir/transform/combine_access_instructions_test.cc
index 8fd46fd..2d07019 100644
--- a/src/tint/lang/core/ir/transform/combine_access_instructions_test.cc
+++ b/src/tint/lang/core/ir/transform/combine_access_instructions_test.cc
@@ -73,12 +73,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, MyStruct, read> = access %buffer
     %4:MyStruct = load %3
     %5:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
@@ -127,12 +127,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
     %5:ptr<uniform, vec3<f32>, read> = access %4, 2u
@@ -148,12 +148,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 2u
     %4:vec3<f32> = load %3
     ret
@@ -191,12 +191,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, MyStruct, read> = access %buffer
     %4:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %3, 0u
     %5:array<mat3x3<f32>, 4> = load %4
@@ -211,12 +211,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:array<mat3x3<f32>, 4> = load %3
     ret
@@ -255,12 +255,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %3
     %5:ptr<uniform, mat3x3<f32>, read> = access %4, 1u
@@ -276,12 +276,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 1u
     %4:mat3x3<f32> = load %3
     ret
@@ -320,12 +320,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
     %5:ptr<uniform, mat3x3<f32>, read> = access %4
@@ -341,12 +341,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 1u
     %4:mat3x3<f32> = load %3
     ret
@@ -399,12 +399,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
     %5:ptr<uniform, vec3<f32>, read> = access %4, 2u
@@ -426,12 +426,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 2u
     %4:vec3<f32> = load %3
     %5:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 2u, 0u
@@ -486,12 +486,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
     %5:ptr<uniform, vec3<f32>, read> = access %4, 2u
@@ -511,12 +511,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 2u
     %4:vec3<f32> = load %3
     %5:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 0u
@@ -561,12 +561,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:array<mat3x3<f32>, 4> = load %3
     %5:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
@@ -583,12 +583,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:array<mat3x3<f32>, 4> = load %3
     %5:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 2u
@@ -631,12 +631,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
     %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
     %5:mat3x3<f32> = load %4
@@ -653,12 +653,12 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 1u
     %4:mat3x3<f32> = load %3
     %5:ptr<uniform, vec3<f32>, read> = access %buffer, 0u, 1u, 2u
@@ -684,8 +684,8 @@
     });
 
     auto* src = R"(
-%foo = func():f32 -> %b1 {
-  %b1 = block {
+%foo = func():f32 {
+  $B1: {
     %2:u32 = access %indices, 1u
     %4:f32 = access %values, %2
     ret %4
@@ -734,20 +734,20 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
-    if true [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    if true [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         %4:ptr<uniform, mat3x3<f32>, read> = access %3, 1u
         %5:mat3x3<f32> = load %4
         exit_if  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         %6:ptr<uniform, mat3x3<f32>, read> = access %3, 2u
         %7:mat3x3<f32> = load %6
         exit_if  # if_1
@@ -764,19 +764,19 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    if true [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func():void {
+  $B2: {
+    if true [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         %3:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 1u
         %4:mat3x3<f32> = load %3
         exit_if  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         %5:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 2u
         %6:mat3x3<f32> = load %5
         exit_if  # if_1
@@ -825,23 +825,23 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<mat3x3<f32>, 4>, read> = access %buffer, 0u
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
         %4:ptr<uniform, mat3x3<f32>, read> = access %3, 2u
         %5:mat3x3<f32> = load %4
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %6:ptr<uniform, mat3x3<f32>, read> = access %3, 3u
         %7:mat3x3<f32> = load %6
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
@@ -855,22 +855,22 @@
   a:array<mat3x3<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
+%foo = func():void {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
         %3:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 2u
         %4:mat3x3<f32> = load %3
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %5:ptr<uniform, mat3x3<f32>, read> = access %buffer, 0u, 3u
         %6:mat3x3<f32> = load %5
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
diff --git a/src/tint/lang/core/ir/transform/conversion_polyfill_test.cc b/src/tint/lang/core/ir/transform/conversion_polyfill_test.cc
index 214ca29..cdb2db9 100644
--- a/src/tint/lang/core/ir/transform/conversion_polyfill_test.cc
+++ b/src/tint/lang/core/ir/transform/conversion_polyfill_test.cc
@@ -58,8 +58,8 @@
 TEST_F(IR_ConversionPolyfillTest, I32_to_F32) {
     Build(ty.i32(), ty.f32());
     auto* src = R"(
-%foo = func(%src:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:i32):f32 {
+  $B1: {
     %result:f32 = convert %src
     ret %result
   }
@@ -79,8 +79,8 @@
 TEST_F(IR_ConversionPolyfillTest, U32_to_F32) {
     Build(ty.u32(), ty.f32());
     auto* src = R"(
-%foo = func(%src:u32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:u32):f32 {
+  $B1: {
     %result:f32 = convert %src
     ret %result
   }
@@ -99,8 +99,8 @@
 TEST_F(IR_ConversionPolyfillTest, F32_to_I32_NoPolyfill) {
     Build(ty.f32(), ty.i32());
     auto* src = R"(
-%foo = func(%src:f32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f32):i32 {
+  $B1: {
     %result:i32 = convert %src
     ret %result
   }
@@ -119,22 +119,22 @@
 TEST_F(IR_ConversionPolyfillTest, F32_to_I32) {
     Build(ty.f32(), ty.i32());
     auto* src = R"(
-%foo = func(%src:f32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f32):i32 {
+  $B1: {
     %result:i32 = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:f32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f32):i32 {
+  $B1: {
     %result:i32 = call %tint_f32_to_i32, %src
     ret %result
   }
 }
-%tint_f32_to_i32 = func(%value:f32):i32 -> %b2 {
-  %b2 = block {
+%tint_f32_to_i32 = func(%value:f32):i32 {
+  $B2: {
     %6:i32 = convert %value
     %7:bool = gte %value, -2147483648.0f
     %8:i32 = select -2147483648i, %6, %7
@@ -156,22 +156,22 @@
 TEST_F(IR_ConversionPolyfillTest, F32_to_U32) {
     Build(ty.f32(), ty.u32());
     auto* src = R"(
-%foo = func(%src:f32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f32):u32 {
+  $B1: {
     %result:u32 = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:f32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f32):u32 {
+  $B1: {
     %result:u32 = call %tint_f32_to_u32, %src
     ret %result
   }
 }
-%tint_f32_to_u32 = func(%value:f32):u32 -> %b2 {
-  %b2 = block {
+%tint_f32_to_u32 = func(%value:f32):u32 {
+  $B2: {
     %6:u32 = convert %value
     %7:bool = gte %value, 0.0f
     %8:u32 = select 0u, %6, %7
@@ -193,22 +193,22 @@
 TEST_F(IR_ConversionPolyfillTest, F32_to_I32_Vec2) {
     Build(ty.vec2<f32>(), ty.vec2<i32>());
     auto* src = R"(
-%foo = func(%src:vec2<f32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:vec2<f32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f32>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = call %tint_v2f32_to_v2i32, %src
     ret %result
   }
 }
-%tint_v2f32_to_v2i32 = func(%value:vec2<f32>):vec2<i32> -> %b2 {
-  %b2 = block {
+%tint_v2f32_to_v2i32 = func(%value:vec2<f32>):vec2<i32> {
+  $B2: {
     %6:vec2<i32> = convert %value
     %7:vec2<bool> = gte %value, vec2<f32>(-2147483648.0f)
     %8:vec2<i32> = select vec2<i32>(-2147483648i), %6, %7
@@ -230,22 +230,22 @@
 TEST_F(IR_ConversionPolyfillTest, F32_to_U32_Vec3) {
     Build(ty.vec2<f32>(), ty.vec2<u32>());
     auto* src = R"(
-%foo = func(%src:vec2<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:vec2<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f32>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = call %tint_v2f32_to_v2u32, %src
     ret %result
   }
 }
-%tint_v2f32_to_v2u32 = func(%value:vec2<f32>):vec2<u32> -> %b2 {
-  %b2 = block {
+%tint_v2f32_to_v2u32 = func(%value:vec2<f32>):vec2<u32> {
+  $B2: {
     %6:vec2<u32> = convert %value
     %7:vec2<bool> = gte %value, vec2<f32>(0.0f)
     %8:vec2<u32> = select vec2<u32>(0u), %6, %7
@@ -267,22 +267,22 @@
 TEST_F(IR_ConversionPolyfillTest, F16_to_I32) {
     Build(ty.f16(), ty.i32());
     auto* src = R"(
-%foo = func(%src:f16):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f16):i32 {
+  $B1: {
     %result:i32 = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:f16):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f16):i32 {
+  $B1: {
     %result:i32 = call %tint_f16_to_i32, %src
     ret %result
   }
 }
-%tint_f16_to_i32 = func(%value:f16):i32 -> %b2 {
-  %b2 = block {
+%tint_f16_to_i32 = func(%value:f16):i32 {
+  $B2: {
     %6:i32 = convert %value
     %7:bool = gte %value, -65504.0h
     %8:i32 = select -2147483648i, %6, %7
@@ -304,22 +304,22 @@
 TEST_F(IR_ConversionPolyfillTest, F16_to_U32) {
     Build(ty.f16(), ty.u32());
     auto* src = R"(
-%foo = func(%src:f16):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f16):u32 {
+  $B1: {
     %result:u32 = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:f16):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%src:f16):u32 {
+  $B1: {
     %result:u32 = call %tint_f16_to_u32, %src
     ret %result
   }
 }
-%tint_f16_to_u32 = func(%value:f16):u32 -> %b2 {
-  %b2 = block {
+%tint_f16_to_u32 = func(%value:f16):u32 {
+  $B2: {
     %6:u32 = convert %value
     %7:bool = gte %value, 0.0h
     %8:u32 = select 0u, %6, %7
@@ -341,22 +341,22 @@
 TEST_F(IR_ConversionPolyfillTest, F16_to_I32_Vec2) {
     Build(ty.vec2<f16>(), ty.vec2<i32>());
     auto* src = R"(
-%foo = func(%src:vec2<f16>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f16>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:vec2<f16>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f16>):vec2<i32> {
+  $B1: {
     %result:vec2<i32> = call %tint_v2f16_to_v2i32, %src
     ret %result
   }
 }
-%tint_v2f16_to_v2i32 = func(%value:vec2<f16>):vec2<i32> -> %b2 {
-  %b2 = block {
+%tint_v2f16_to_v2i32 = func(%value:vec2<f16>):vec2<i32> {
+  $B2: {
     %6:vec2<i32> = convert %value
     %7:vec2<bool> = gte %value, vec2<f16>(-65504.0h)
     %8:vec2<i32> = select vec2<i32>(-2147483648i), %6, %7
@@ -378,22 +378,22 @@
 TEST_F(IR_ConversionPolyfillTest, F16_to_U32_Vec3) {
     Build(ty.vec2<f16>(), ty.vec2<u32>());
     auto* src = R"(
-%foo = func(%src:vec2<f16>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f16>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = convert %src
     ret %result
   }
 }
 )";
     auto* expect = R"(
-%foo = func(%src:vec2<f16>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%src:vec2<f16>):vec2<u32> {
+  $B1: {
     %result:vec2<u32> = call %tint_v2f16_to_v2u32, %src
     ret %result
   }
 }
-%tint_v2f16_to_v2u32 = func(%value:vec2<f16>):vec2<u32> -> %b2 {
-  %b2 = block {
+%tint_v2f16_to_v2u32 = func(%value:vec2<f16>):vec2<u32> {
+  $B2: {
     %6:vec2<u32> = convert %value
     %7:vec2<bool> = gte %value, vec2<f16>(0.0h)
     %8:vec2<u32> = select vec2<u32>(0u), %6, %7
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
index e997e41..e26ff8d 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper_test.cc
@@ -56,12 +56,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func():f32 [@location(0)] -> %b2 {
-  %b2 = block {
+%ep = @fragment func():f32 [@location(0)] {
+  $B2: {
     store %buffer, 42i
     ret 0.5f
   }
@@ -98,14 +98,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -118,30 +118,30 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         store %buffer, 42i
         exit_if  # if_2
       }
     }
     %6:bool = load %continue_execution
     %7:bool = eq %6, false
-    if %7 [t: %b5] {  # if_3
-      %b5 = block {  # true
+    if %7 [t: $B5] {  # if_3
+      $B5: {  # true
         terminate_invocation
       }
     }
@@ -183,20 +183,20 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     store %buffer, 42i
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b3 {
-  %b3 = block {
-    if %front_facing [t: %b4] {  # if_1
-      %b4 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B3: {
+    if %front_facing [t: $B4] {  # if_1
+      $B4: {  # true
         discard
         exit_if  # if_1
       }
@@ -209,16 +209,16 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %4:bool = load %continue_execution
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %buffer, 42i
         exit_if  # if_1
       }
@@ -226,10 +226,10 @@
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b4 {
-  %b4 = block {
-    if %front_facing [t: %b5] {  # if_2
-      %b5 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B4: {
+    if %front_facing [t: $B5] {  # if_2
+      $B5: {  # true
         store %continue_execution, false
         exit_if  # if_2
       }
@@ -237,8 +237,8 @@
     %7:void = call %foo
     %8:bool = load %continue_execution
     %9:bool = eq %8, false
-    if %9 [t: %b6] {  # if_3
-      %b6 = block {  # true
+    if %9 [t: $B6] {  # if_3
+      $B6: {  # true
         terminate_invocation
       }
     }
@@ -282,14 +282,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%cond:bool):void -> %b2 {
-  %b2 = block {
-    if %cond [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo = func(%cond:bool):void {
+  $B2: {
+    if %cond [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -297,8 +297,8 @@
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b4 {
-  %b4 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B4: {
     %6:void = call %foo, %front_facing
     store %buffer, 42i
     ret 0.5f
@@ -308,15 +308,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%foo = func(%cond:bool):void -> %b2 {
-  %b2 = block {
-    if %cond [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo = func(%cond:bool):void {
+  $B2: {
+    if %cond [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
@@ -324,20 +324,20 @@
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b4 {
-  %b4 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B4: {
     %7:void = call %foo, %front_facing
     %8:bool = load %continue_execution
-    if %8 [t: %b5] {  # if_2
-      %b5 = block {  # true
+    if %8 [t: $B5] {  # if_2
+      $B5: {  # true
         store %buffer, 42i
         exit_if  # if_2
       }
     }
     %9:bool = load %continue_execution
     %10:bool = eq %9, false
-    if %10 [t: %b6] {  # if_3
-      %b6 = block {  # true
+    if %10 [t: $B6] {  # if_3
+      $B6: {  # true
         terminate_invocation
       }
     }
@@ -381,14 +381,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%cond:bool):void -> %b2 {
-  %b2 = block {
-    if %cond [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo = func(%cond:bool):void {
+  $B2: {
+    if %cond [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -397,8 +397,8 @@
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b4 {
-  %b4 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B4: {
     %6:void = call %foo, %front_facing
     ret 0.5f
   }
@@ -407,22 +407,22 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, i32, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%foo = func(%cond:bool):void -> %b2 {
-  %b2 = block {
-    if %cond [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo = func(%cond:bool):void {
+  $B2: {
+    if %cond [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         store %buffer, 42i
         exit_if  # if_2
       }
@@ -430,13 +430,13 @@
     ret
   }
 }
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b5 {
-  %b5 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B5: {
     %8:void = call %foo, %front_facing
     %9:bool = load %continue_execution
     %10:bool = eq %9, false
-    if %10 [t: %b6] {  # if_3
-      %b6 = block {  # true
+    if %10 [t: $B6] {  # if_3
+      $B6: {  # true
         terminate_invocation
       }
     }
@@ -471,15 +471,15 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %priv:ptr<private, i32, read_write> = var
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
     %func:ptr<function, i32, read_write> = var
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -493,16 +493,16 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %priv:ptr<private, i32, read_write> = var
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
     %func:ptr<function, i32, read_write> = var
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
@@ -511,8 +511,8 @@
     store %func, 42i
     %6:bool = load %continue_execution
     %7:bool = eq %6, false
-    if %7 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %7 [t: $B4] {  # if_2
+      $B4: {  # true
         terminate_invocation
       }
     }
@@ -555,14 +555,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<r32float, write>, read> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing], %coord:vec2<i32>):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing], %coord:vec2<i32>):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -576,31 +576,31 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<r32float, write>, read> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing], %coord:vec2<i32>):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing], %coord:vec2<i32>):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %6:texture_storage_2d<r32float, write> = load %texture
     %7:bool = load %continue_execution
-    if %7 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %7 [t: $B4] {  # if_2
+      $B4: {  # true
         %8:void = textureStore %6, %coord, vec4<f32>(0.5f)
         exit_if  # if_2
       }
     }
     %9:bool = load %continue_execution
     %10:bool = eq %9, false
-    if %10 [t: %b5] {  # if_3
-      %b5 = block {  # true
+    if %10 [t: $B5] {  # if_3
+      $B5: {  # true
         terminate_invocation
       }
     }
@@ -636,14 +636,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -656,30 +656,30 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         %6:void = atomicStore %buffer, 42i
         exit_if  # if_2
       }
     }
     %7:bool = load %continue_execution
     %8:bool = eq %7, false
-    if %8 [t: %b5] {  # if_3
-      %b5 = block {  # true
+    if %8 [t: $B5] {  # if_3
+      $B5: {  # true
         terminate_invocation
       }
     }
@@ -716,14 +716,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -737,22 +737,22 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    %6:i32 = if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    %6:i32 = if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         %7:i32 = atomicAdd %buffer, 42i
         exit_if %7  # if_2
       }
@@ -761,8 +761,8 @@
     %8:i32 = add %6, 1i
     %9:bool = load %continue_execution
     %10:bool = eq %9, false
-    if %10 [t: %b5] {  # if_3
-      %b5 = block {  # true
+    if %10 [t: $B5] {  # if_3
+      $B5: {  # true
         terminate_invocation
       }
     }
@@ -806,14 +806,14 @@
   exchanged:bool @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         discard
         exit_if  # if_1
       }
@@ -833,22 +833,22 @@
   exchanged:bool @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%ep = @fragment func(%front_facing:bool [@front_facing]):f32 [@location(0)] {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    %6:__atomic_compare_exchange_result_i32 = if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    %6:__atomic_compare_exchange_result_i32 = if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         %7:__atomic_compare_exchange_result_i32 = atomicCompareExchangeWeak %buffer, 0i, 42i
         exit_if %7  # if_2
       }
@@ -858,8 +858,8 @@
     %9:i32 = add %8, 1i
     %10:bool = load %continue_execution
     %11:bool = eq %10, false
-    if %11 [t: %b5] {  # if_3
-      %b5 = block {  # true
+    if %11 [t: $B5] {  # if_3
+      $B5: {  # true
         terminate_invocation
       }
     }
@@ -882,8 +882,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     discard
     ret
   }
@@ -892,12 +892,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %continue_execution:ptr<private, bool, read_write> = var, true
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     store %continue_execution, false
     ret
   }
diff --git a/src/tint/lang/core/ir/transform/direct_variable_access_test.cc b/src/tint/lang/core/ir/transform/direct_variable_access_test.cc
index 4919a26..cf464d3 100644
--- a/src/tint/lang/core/ir/transform/direct_variable_access_test.cc
+++ b/src/tint/lang/core/ir/transform/direct_variable_access_test.cc
@@ -75,12 +75,12 @@
     b.Append(u->Block(), [&] { b.Return(u, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%u = func(%pre:i32, %p:ptr<uniform, i32, read>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%u = func(%pre:i32, %p:ptr<uniform, i32, read>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -90,7 +90,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
@@ -114,12 +114,12 @@
     b.Append(s->Block(), [&] { b.Return(s, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%s = func(%pre:i32, %p:ptr<storage, i32, read>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%s = func(%pre:i32, %p:ptr<storage, i32, read>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -129,7 +129,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
@@ -153,12 +153,12 @@
     b.Append(w->Block(), [&] { b.Return(w, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%w = func(%pre:i32, %p:ptr<workgroup, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%w = func(%pre:i32, %p:ptr<workgroup, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -168,7 +168,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
@@ -192,12 +192,12 @@
     b.Append(f->Block(), [&] { b.Return(f, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%f = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%f = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -226,12 +226,12 @@
     b.Append(f->Block(), [&] { b.Return(f, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%f = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%f = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -241,7 +241,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
@@ -264,12 +264,12 @@
     b.Append(f->Block(), [&] { b.Return(f, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%f = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%f = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -298,12 +298,12 @@
     b.Append(f->Block(), [&] { b.Return(f, b.Load(p)); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
-%f = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%f = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
@@ -312,7 +312,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %keep_me:ptr<private, i32, read_write> = var, 42i
 }
 
@@ -384,18 +384,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> {
+  $B2: {
     %6:vec4<i32> = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %p0:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = let %U
     %p1:ptr<uniform, array<array<vec4<i32>, 8>, 8>, read> = access %p0, 1i
     %p2:ptr<uniform, array<vec4<i32>, 8>, read> = access %p1, 2i
@@ -404,8 +404,8 @@
     ret
   }
 }
-%c = func(%p_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read>):void -> %b4 {  # %p_1: 'p'
-  %b4 = block {
+%c = func(%p_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read>):void {  # %p_1: 'p'
+  $B4: {
     %p0_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = let %p_1  # %p0_1: 'p0'
     %p1_1:ptr<uniform, array<array<vec4<i32>, 8>, 8>, read> = access %p0_1, 1i  # %p1_1: 'p1'
     %p2_1:ptr<uniform, array<vec4<i32>, 8>, read> = access %p1_1, 2i  # %p2_1: 'p2'
@@ -414,8 +414,8 @@
     ret
   }
 }
-%d = func():void -> %b5 {
-  %b5 = block {
+%d = func():void {
+  $B5: {
     %21:void = call %c, %U
     ret
   }
@@ -426,12 +426,12 @@
 
     auto* expect =
         R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p_indices:array<u32, 3>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 3>, %post:i32):vec4<i32> {
+  $B2: {
     %6:u32 = access %p_indices, 0u
     %7:u32 = access %p_indices, 1u
     %8:u32 = access %p_indices, 2u
@@ -440,8 +440,8 @@
     ret %10
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %12:u32 = convert 3i
     %13:u32 = convert 2i
     %14:u32 = convert 1i
@@ -450,8 +450,8 @@
     ret
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %18:u32 = convert 3i
     %19:u32 = convert 2i
     %20:u32 = convert 1i
@@ -460,8 +460,8 @@
     ret
   }
 }
-%d = func():void -> %b5 {
-  %b5 = block {
+%d = func():void {
+  $B5: {
     %24:void = call %c
     ret
   }
@@ -539,13 +539,13 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = var @binding_point(0, 0)
   %i:ptr<private, i32, read_write> = var
 }
 
-%first = func():i32 -> %b2 {
-  %b2 = block {
+%first = func():i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, 1i
     store %i, %5
@@ -553,8 +553,8 @@
     ret %6
   }
 }
-%second = func():i32 -> %b3 {
-  %b3 = block {
+%second = func():i32 {
+  $B3: {
     %8:i32 = load %i
     %9:i32 = add %8, 1i
     store %i, %9
@@ -562,8 +562,8 @@
     ret %10
   }
 }
-%third = func():i32 -> %b4 {
-  %b4 = block {
+%third = func():i32 {
+  $B4: {
     %12:i32 = load %i
     %13:i32 = add %12, 1i
     store %i, %13
@@ -571,14 +571,14 @@
     ret %14
   }
 }
-%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> -> %b5 {
-  %b5 = block {
+%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> {
+  $B5: {
     %19:vec4<i32> = load %p
     ret %19
   }
 }
-%b = func():void -> %b6 {
-  %b6 = block {
+%b = func():void {
+  $B6: {
     %p0:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = let %U
     %22:i32 = call %first
     %p1:ptr<uniform, array<array<vec4<i32>, 8>, 8>, read> = access %p0, %22
@@ -589,8 +589,8 @@
     ret
   }
 }
-%c = func(%p_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read>):void -> %b7 {  # %p_1: 'p'
-  %b7 = block {
+%c = func(%p_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read>):void {  # %p_1: 'p'
+  $B7: {
     %p0_1:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = let %p_1  # %p0_1: 'p0'
     %31:i32 = call %first
     %p1_1:ptr<uniform, array<array<vec4<i32>, 8>, 8>, read> = access %p0_1, %31  # %p1_1: 'p1'
@@ -601,8 +601,8 @@
     ret
   }
 }
-%d = func():void -> %b8 {
-  %b8 = block {
+%d = func():void {
+  $B8: {
     %38:void = call %c, %U
     ret
   }
@@ -612,13 +612,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 8>, 8>, 8>, read> = var @binding_point(0, 0)
   %i:ptr<private, i32, read_write> = var
 }
 
-%first = func():i32 -> %b2 {
-  %b2 = block {
+%first = func():i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, 1i
     store %i, %5
@@ -626,8 +626,8 @@
     ret %6
   }
 }
-%second = func():i32 -> %b3 {
-  %b3 = block {
+%second = func():i32 {
+  $B3: {
     %8:i32 = load %i
     %9:i32 = add %8, 1i
     store %i, %9
@@ -635,8 +635,8 @@
     ret %10
   }
 }
-%third = func():i32 -> %b4 {
-  %b4 = block {
+%third = func():i32 {
+  $B4: {
     %12:i32 = load %i
     %13:i32 = add %12, 1i
     store %i, %13
@@ -644,8 +644,8 @@
     ret %14
   }
 }
-%a = func(%pre:i32, %p_indices:array<u32, 3>, %post:i32):vec4<i32> -> %b5 {
-  %b5 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 3>, %post:i32):vec4<i32> {
+  $B5: {
     %19:u32 = access %p_indices, 0u
     %20:u32 = access %p_indices, 1u
     %21:u32 = access %p_indices, 2u
@@ -654,8 +654,8 @@
     ret %23
   }
 }
-%b = func():void -> %b6 {
-  %b6 = block {
+%b = func():void {
+  $B6: {
     %25:i32 = call %first
     %26:i32 = call %second
     %27:i32 = call %third
@@ -667,8 +667,8 @@
     ret
   }
 }
-%c = func():void -> %b7 {
-  %b7 = block {
+%c = func():void {
+  $B7: {
     %34:i32 = call %first
     %35:i32 = call %second
     %36:i32 = call %third
@@ -680,8 +680,8 @@
     ret
   }
 }
-%d = func():void -> %b8 {
-  %b8 = block {
+%d = func():void {
+  $B8: {
     %43:void = call %c
     ret
   }
@@ -726,18 +726,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, i32, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<uniform, i32, read>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<uniform, i32, read>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, %U, 20i
     ret
   }
@@ -747,19 +747,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, i32, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):i32 {
+  $B2: {
     %5:ptr<uniform, i32, read> = access %U
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, 20i
     ret
   }
@@ -797,18 +797,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<vec4<i32>, 8>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<uniform, vec4<i32>, read>, %post:i32):vec4<i32> {
+  $B2: {
     %6:vec4<i32> = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %I:i32 = let 3i
     %9:ptr<uniform, vec4<i32>, read> = access %U, %I
     %10:vec4<i32> = call %a, 10i, %9, 20i
@@ -820,20 +820,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<vec4<i32>, 8>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):vec4<i32> {
+  $B2: {
     %6:u32 = access %p_indices, 0u
     %7:ptr<uniform, vec4<i32>, read> = access %U, %6
     %8:vec4<i32> = load %7
     ret %8
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %I:i32 = let 3i
     %11:u32 = convert %I
     %12:array<u32, 1> = construct %11
@@ -952,18 +952,18 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%f0 = func(%p:ptr<uniform, vec4<f32>, read>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p:ptr<uniform, vec4<f32>, read>):f32 {
+  $B2: {
     %4:f32 = load_vector_element %p, 0u
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<uniform, mat3x4<f32>, read>):f32 -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<uniform, mat3x4<f32>, read>):f32 {  # %p_1: 'p'
+  $B3: {
     %res:ptr<function, f32, read_write> = var
     %8:ptr<uniform, vec4<f32>, read> = access %p_1, 1i
     %9:f32 = call %f0, %8
@@ -989,15 +989,15 @@
     ret %24
   }
 }
-%f2 = func(%p_2:ptr<uniform, Inner, read>):f32 -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f2 = func(%p_2:ptr<uniform, Inner, read>):f32 {  # %p_2: 'p'
+  $B4: {
     %p_mat:ptr<uniform, mat3x4<f32>, read> = access %p_2, 0u
     %28:f32 = call %f1, %p_mat
     ret %28
   }
 }
-%f3 = func(%p0:ptr<uniform, array<Inner, 4>, read>, %p1:ptr<uniform, mat3x4<f32>, read>):f32 -> %b5 {
-  %b5 = block {
+%f3 = func(%p0:ptr<uniform, array<Inner, 4>, read>, %p1:ptr<uniform, mat3x4<f32>, read>):f32 {
+  $B5: {
     %p0_inner:ptr<uniform, Inner, read> = access %p0, 3i
     %33:f32 = call %f2, %p0_inner
     %34:f32 = call %f1, %p1
@@ -1005,16 +1005,16 @@
     ret %35
   }
 }
-%f4 = func(%p_3:ptr<uniform, Outer, read>):f32 -> %b6 {  # %p_3: 'p'
-  %b6 = block {
+%f4 = func(%p_3:ptr<uniform, Outer, read>):f32 {  # %p_3: 'p'
+  $B6: {
     %38:ptr<uniform, array<Inner, 4>, read> = access %p_3, 0u
     %39:ptr<uniform, mat3x4<f32>, read> = access %U, 1u
     %40:f32 = call %f3, %38, %39
     ret %40
   }
 }
-%b = func():void -> %b7 {
-  %b7 = block {
+%b = func():void {
+  $B7: {
     %42:f32 = call %f4, %U
     ret
   }
@@ -1033,20 +1033,20 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%f0 = func(%p_indices:array<u32, 1>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p_indices:array<u32, 1>):f32 {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:ptr<uniform, vec4<f32>, read> = access %U, 1u, %4
     %6:f32 = load_vector_element %5, 0u
     ret %6
   }
 }
-%f0_1 = func(%p_indices_1:array<u32, 2>):f32 -> %b3 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
-  %b3 = block {
+%f0_1 = func(%p_indices_1:array<u32, 2>):f32 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
+  $B3: {
     %9:u32 = access %p_indices_1, 0u
     %10:u32 = access %p_indices_1, 1u
     %11:ptr<uniform, vec4<f32>, read> = access %U, 0u, %9, 0u, %10
@@ -1054,8 +1054,8 @@
     ret %12
   }
 }
-%f1 = func():f32 -> %b4 {
-  %b4 = block {
+%f1 = func():f32 {
+  $B4: {
     %res:ptr<function, f32, read_write> = var
     %15:u32 = convert 1i
     %16:array<u32, 1> = construct %15
@@ -1087,8 +1087,8 @@
     ret %37
   }
 }
-%f1_1 = func(%p_indices_2:array<u32, 1>):f32 -> %b5 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
-  %b5 = block {
+%f1_1 = func(%p_indices_2:array<u32, 1>):f32 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
+  $B5: {
     %40:u32 = access %p_indices_2, 0u
     %res_1:ptr<function, f32, read_write> = var  # %res_1: 'res'
     %42:u32 = convert 1i
@@ -1121,16 +1121,16 @@
     ret %64
   }
 }
-%f2 = func(%p_indices_3:array<u32, 1>):f32 -> %b6 {  # %p_indices_3: 'p_indices'
-  %b6 = block {
+%f2 = func(%p_indices_3:array<u32, 1>):f32 {  # %p_indices_3: 'p_indices'
+  $B6: {
     %67:u32 = access %p_indices_3, 0u
     %68:array<u32, 1> = construct %67
     %69:f32 = call %f1_1, %68
     ret %69
   }
 }
-%f3 = func():f32 -> %b7 {
-  %b7 = block {
+%f3 = func():f32 {
+  $B7: {
     %71:u32 = convert 3i
     %72:array<u32, 1> = construct %71
     %73:f32 = call %f2, %72
@@ -1139,14 +1139,14 @@
     ret %75
   }
 }
-%f4 = func():f32 -> %b8 {
-  %b8 = block {
+%f4 = func():f32 {
+  $B8: {
     %77:f32 = call %f3
     ret %77
   }
 }
-%b = func():void -> %b9 {
-  %b9 = block {
+%b = func():void {
+  $B9: {
     %79:f32 = call %f4
     ret
   }
@@ -1202,33 +1202,33 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 5>, 5>, 5>, read> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p:ptr<uniform, array<vec4<i32>, 5>, read>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p:ptr<uniform, array<vec4<i32>, 5>, read>):vec4<i32> {
+  $B2: {
     %4:ptr<uniform, vec4<i32>, read> = access %p, 3u
     %5:vec4<i32> = load %4
     ret %5
   }
 }
-%f1 = func(%p_1:ptr<uniform, array<array<vec4<i32>, 5>, 5>, read>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<uniform, array<array<vec4<i32>, 5>, 5>, read>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %8:ptr<uniform, array<vec4<i32>, 5>, read> = access %p_1, 2u
     %9:vec4<i32> = call %f2, %8
     ret %9
   }
 }
-%f0 = func(%p_2:ptr<uniform, array<array<array<vec4<i32>, 5>, 5>, 5>, read>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f0 = func(%p_2:ptr<uniform, array<array<array<vec4<i32>, 5>, 5>, 5>, read>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %12:ptr<uniform, array<array<vec4<i32>, 5>, 5>, read> = access %p_2, 1u
     %13:vec4<i32> = call %f1, %12
     ret %13
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %15:vec4<i32> = call %f0, %U
     ret
   }
@@ -1238,12 +1238,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, array<array<array<vec4<i32>, 5>, 5>, 5>, read> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p_indices:array<u32, 2>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p_indices:array<u32, 2>):vec4<i32> {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<uniform, array<vec4<i32>, 5>, read> = access %U, %4, %5
@@ -1252,23 +1252,23 @@
     ret %8
   }
 }
-%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> -> %b3 {  # %p_indices_1: 'p_indices'
-  %b3 = block {
+%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> {  # %p_indices_1: 'p_indices'
+  $B3: {
     %11:u32 = access %p_indices_1, 0u
     %12:array<u32, 2> = construct %11, 2u
     %13:vec4<i32> = call %f2, %12
     ret %13
   }
 }
-%f0 = func():vec4<i32> -> %b4 {
-  %b4 = block {
+%f0 = func():vec4<i32> {
+  $B4: {
     %15:array<u32, 1> = construct 1u
     %16:vec4<i32> = call %f1, %15
     ret %16
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %18:vec4<i32> = call %f0
     ret
   }
@@ -1322,18 +1322,18 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, str, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<storage, i32, read>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<storage, i32, read>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:ptr<storage, i32, read> = access %S, 0u
     %9:i32 = call %a, 10i, %8, 20i
     ret
@@ -1348,19 +1348,19 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, str, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):i32 {
+  $B2: {
     %5:ptr<storage, i32, read> = access %S, 0u
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, 20i
     ret
   }
@@ -1409,18 +1409,18 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, str, read_write> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<storage, array<i32, 4>, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<storage, array<i32, 4>, read_write>, %post:i32):void {
+  $B2: {
     store %p, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:ptr<storage, array<i32, 4>, read_write> = access %S, 0u
     %8:void = call %a, 10i, %7, 20i
     ret
@@ -1435,19 +1435,19 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, str, read_write> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):void {
+  $B2: {
     %5:ptr<storage, array<i32, 4>, read_write> = access %S, 0u
     store %5, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:void = call %a, 10i, 20i
     ret
   }
@@ -1488,18 +1488,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<vec4<i32>, 8>, read_write> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p:ptr<storage, vec4<i32>, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<storage, vec4<i32>, read_write>, %post:i32):void {
+  $B2: {
     store %p, vec4<i32>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %I:i32 = let 3i
     %8:ptr<storage, vec4<i32>, read_write> = access %S, %I
     %9:void = call %a, 10i, %8, 20i
@@ -1511,20 +1511,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<vec4<i32>, 8>, read_write> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):void {
+  $B2: {
     %6:u32 = access %p_indices, 0u
     %7:ptr<storage, vec4<i32>, read_write> = access %S, %6
     store %7, vec4<i32>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %I:i32 = let 3i
     %10:u32 = convert %I
     %11:array<u32, 1> = construct %10
@@ -1643,18 +1643,18 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, Outer, read> = var @binding_point(0, 0)
 }
 
-%f0 = func(%p:ptr<storage, vec4<f32>, read>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p:ptr<storage, vec4<f32>, read>):f32 {
+  $B2: {
     %4:f32 = load_vector_element %p, 0u
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<storage, mat3x4<f32>, read>):f32 -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<storage, mat3x4<f32>, read>):f32 {  # %p_1: 'p'
+  $B3: {
     %res:ptr<function, f32, read_write> = var
     %8:ptr<storage, vec4<f32>, read> = access %p_1, 1i
     %9:f32 = call %f0, %8
@@ -1680,15 +1680,15 @@
     ret %24
   }
 }
-%f2 = func(%p_2:ptr<storage, Inner, read>):f32 -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f2 = func(%p_2:ptr<storage, Inner, read>):f32 {  # %p_2: 'p'
+  $B4: {
     %p_mat:ptr<storage, mat3x4<f32>, read> = access %p_2, 0u
     %28:f32 = call %f1, %p_mat
     ret %28
   }
 }
-%f3 = func(%p0:ptr<storage, array<Inner, 4>, read>, %p1:ptr<storage, mat3x4<f32>, read>):f32 -> %b5 {
-  %b5 = block {
+%f3 = func(%p0:ptr<storage, array<Inner, 4>, read>, %p1:ptr<storage, mat3x4<f32>, read>):f32 {
+  $B5: {
     %p0_inner:ptr<storage, Inner, read> = access %p0, 3i
     %33:f32 = call %f2, %p0_inner
     %34:f32 = call %f1, %p1
@@ -1696,16 +1696,16 @@
     ret %35
   }
 }
-%f4 = func(%p_3:ptr<storage, Outer, read>):f32 -> %b6 {  # %p_3: 'p'
-  %b6 = block {
+%f4 = func(%p_3:ptr<storage, Outer, read>):f32 {  # %p_3: 'p'
+  $B6: {
     %38:ptr<storage, array<Inner, 4>, read> = access %p_3, 0u
     %39:ptr<storage, mat3x4<f32>, read> = access %S, 1u
     %40:f32 = call %f3, %38, %39
     ret %40
   }
 }
-%b = func():void -> %b7 {
-  %b7 = block {
+%b = func():void {
+  $B7: {
     %42:f32 = call %f4, %S
     ret
   }
@@ -1724,20 +1724,20 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, Outer, read> = var @binding_point(0, 0)
 }
 
-%f0 = func(%p_indices:array<u32, 1>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p_indices:array<u32, 1>):f32 {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:ptr<storage, vec4<f32>, read> = access %S, 1u, %4
     %6:f32 = load_vector_element %5, 0u
     ret %6
   }
 }
-%f0_1 = func(%p_indices_1:array<u32, 2>):f32 -> %b3 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
-  %b3 = block {
+%f0_1 = func(%p_indices_1:array<u32, 2>):f32 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
+  $B3: {
     %9:u32 = access %p_indices_1, 0u
     %10:u32 = access %p_indices_1, 1u
     %11:ptr<storage, vec4<f32>, read> = access %S, 0u, %9, 0u, %10
@@ -1745,8 +1745,8 @@
     ret %12
   }
 }
-%f1 = func():f32 -> %b4 {
-  %b4 = block {
+%f1 = func():f32 {
+  $B4: {
     %res:ptr<function, f32, read_write> = var
     %15:u32 = convert 1i
     %16:array<u32, 1> = construct %15
@@ -1778,8 +1778,8 @@
     ret %37
   }
 }
-%f1_1 = func(%p_indices_2:array<u32, 1>):f32 -> %b5 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
-  %b5 = block {
+%f1_1 = func(%p_indices_2:array<u32, 1>):f32 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
+  $B5: {
     %40:u32 = access %p_indices_2, 0u
     %res_1:ptr<function, f32, read_write> = var  # %res_1: 'res'
     %42:u32 = convert 1i
@@ -1812,16 +1812,16 @@
     ret %64
   }
 }
-%f2 = func(%p_indices_3:array<u32, 1>):f32 -> %b6 {  # %p_indices_3: 'p_indices'
-  %b6 = block {
+%f2 = func(%p_indices_3:array<u32, 1>):f32 {  # %p_indices_3: 'p_indices'
+  $B6: {
     %67:u32 = access %p_indices_3, 0u
     %68:array<u32, 1> = construct %67
     %69:f32 = call %f1_1, %68
     ret %69
   }
 }
-%f3 = func():f32 -> %b7 {
-  %b7 = block {
+%f3 = func():f32 {
+  $B7: {
     %71:u32 = convert 3i
     %72:array<u32, 1> = construct %71
     %73:f32 = call %f2, %72
@@ -1830,14 +1830,14 @@
     ret %75
   }
 }
-%f4 = func():f32 -> %b8 {
-  %b8 = block {
+%f4 = func():f32 {
+  $B8: {
     %77:f32 = call %f3
     ret %77
   }
 }
-%b = func():void -> %b9 {
-  %b9 = block {
+%b = func():void {
+  $B9: {
     %79:f32 = call %f4
     ret
   }
@@ -1893,33 +1893,33 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<storage, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p:ptr<storage, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p:ptr<storage, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B2: {
     %4:ptr<storage, vec4<i32>, read_write> = access %p, 3u
     %5:vec4<i32> = load %4
     ret %5
   }
 }
-%f1 = func(%p_1:ptr<storage, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<storage, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %8:ptr<storage, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %9:vec4<i32> = call %f2, %8
     ret %9
   }
 }
-%f0 = func(%p_2:ptr<storage, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f0 = func(%p_2:ptr<storage, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %12:ptr<storage, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %13:vec4<i32> = call %f1, %12
     ret %13
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %15:vec4<i32> = call %f0, %U
     ret
   }
@@ -1929,12 +1929,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<storage, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p_indices:array<u32, 2>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p_indices:array<u32, 2>):vec4<i32> {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<storage, array<vec4<i32>, 5>, read_write> = access %U, %4, %5
@@ -1943,23 +1943,23 @@
     ret %8
   }
 }
-%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> -> %b3 {  # %p_indices_1: 'p_indices'
-  %b3 = block {
+%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> {  # %p_indices_1: 'p_indices'
+  $B3: {
     %11:u32 = access %p_indices_1, 0u
     %12:array<u32, 2> = construct %11, 2u
     %13:vec4<i32> = call %f2, %12
     ret %13
   }
 }
-%f0 = func():vec4<i32> -> %b4 {
-  %b4 = block {
+%f0 = func():vec4<i32> {
+  $B4: {
     %15:array<u32, 1> = construct 1u
     %16:vec4<i32> = call %f1, %15
     ret %16
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %18:vec4<i32> = call %f0
     ret
   }
@@ -2004,18 +2004,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, array<vec4<i32>, 8>, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<workgroup, vec4<i32>, read_write>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<workgroup, vec4<i32>, read_write>, %post:i32):vec4<i32> {
+  $B2: {
     %6:vec4<i32> = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:ptr<workgroup, vec4<i32>, read_write> = access %W, 3i
     %9:vec4<i32> = call %a, 10i, %8, 20i
     ret
@@ -2026,20 +2026,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, array<vec4<i32>, 8>, read_write> = var
 }
 
-%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):vec4<i32> -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):vec4<i32> {
+  $B2: {
     %6:u32 = access %p_indices, 0u
     %7:ptr<workgroup, vec4<i32>, read_write> = access %W, %6
     %8:vec4<i32> = load %7
     ret %8
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %10:u32 = convert 3i
     %11:array<u32, 1> = construct %10
     %12:vec4<i32> = call %a, 10i, %11, 20i
@@ -2080,18 +2080,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, array<vec4<i32>, 8>, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<workgroup, vec4<i32>, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<workgroup, vec4<i32>, read_write>, %post:i32):void {
+  $B2: {
     store %p, vec4<i32>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:ptr<workgroup, vec4<i32>, read_write> = access %W, 3i
     %8:void = call %a, 10i, %7, 20i
     ret
@@ -2102,20 +2102,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, array<vec4<i32>, 8>, read_write> = var
 }
 
-%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p_indices:array<u32, 1>, %post:i32):void {
+  $B2: {
     %6:u32 = access %p_indices, 0u
     %7:ptr<workgroup, vec4<i32>, read_write> = access %W, %6
     store %7, vec4<i32>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %9:u32 = convert 3i
     %10:array<u32, 1> = construct %9
     %11:void = call %a, 10i, %10, 20i
@@ -2232,18 +2232,18 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, Outer, read_write> = var
 }
 
-%f0 = func(%p:ptr<workgroup, vec4<f32>, read_write>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p:ptr<workgroup, vec4<f32>, read_write>):f32 {
+  $B2: {
     %4:f32 = load_vector_element %p, 0u
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<workgroup, mat3x4<f32>, read_write>):f32 -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<workgroup, mat3x4<f32>, read_write>):f32 {  # %p_1: 'p'
+  $B3: {
     %res:ptr<function, f32, read_write> = var
     %8:ptr<workgroup, vec4<f32>, read_write> = access %p_1, 1i
     %9:f32 = call %f0, %8
@@ -2269,15 +2269,15 @@
     ret %24
   }
 }
-%f2 = func(%p_2:ptr<workgroup, Inner, read_write>):f32 -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f2 = func(%p_2:ptr<workgroup, Inner, read_write>):f32 {  # %p_2: 'p'
+  $B4: {
     %p_mat:ptr<workgroup, mat3x4<f32>, read_write> = access %p_2, 0u
     %28:f32 = call %f1, %p_mat
     ret %28
   }
 }
-%f3 = func(%p0:ptr<workgroup, array<Inner, 4>, read_write>, %p1:ptr<workgroup, mat3x4<f32>, read_write>):f32 -> %b5 {
-  %b5 = block {
+%f3 = func(%p0:ptr<workgroup, array<Inner, 4>, read_write>, %p1:ptr<workgroup, mat3x4<f32>, read_write>):f32 {
+  $B5: {
     %p0_inner:ptr<workgroup, Inner, read_write> = access %p0, 3i
     %33:f32 = call %f2, %p0_inner
     %34:f32 = call %f1, %p1
@@ -2285,16 +2285,16 @@
     ret %35
   }
 }
-%f4 = func(%p_3:ptr<workgroup, Outer, read_write>):f32 -> %b6 {  # %p_3: 'p'
-  %b6 = block {
+%f4 = func(%p_3:ptr<workgroup, Outer, read_write>):f32 {  # %p_3: 'p'
+  $B6: {
     %38:ptr<workgroup, array<Inner, 4>, read_write> = access %p_3, 0u
     %39:ptr<workgroup, mat3x4<f32>, read_write> = access %W, 1u
     %40:f32 = call %f3, %38, %39
     ret %40
   }
 }
-%b = func():void -> %b7 {
-  %b7 = block {
+%b = func():void {
+  $B7: {
     %42:f32 = call %f4, %W
     ret
   }
@@ -2313,20 +2313,20 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, Outer, read_write> = var
 }
 
-%f0 = func(%p_indices:array<u32, 1>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p_indices:array<u32, 1>):f32 {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:ptr<workgroup, vec4<f32>, read_write> = access %W, 1u, %4
     %6:f32 = load_vector_element %5, 0u
     ret %6
   }
 }
-%f0_1 = func(%p_indices_1:array<u32, 2>):f32 -> %b3 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
-  %b3 = block {
+%f0_1 = func(%p_indices_1:array<u32, 2>):f32 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
+  $B3: {
     %9:u32 = access %p_indices_1, 0u
     %10:u32 = access %p_indices_1, 1u
     %11:ptr<workgroup, vec4<f32>, read_write> = access %W, 0u, %9, 0u, %10
@@ -2334,8 +2334,8 @@
     ret %12
   }
 }
-%f1 = func():f32 -> %b4 {
-  %b4 = block {
+%f1 = func():f32 {
+  $B4: {
     %res:ptr<function, f32, read_write> = var
     %15:u32 = convert 1i
     %16:array<u32, 1> = construct %15
@@ -2367,8 +2367,8 @@
     ret %37
   }
 }
-%f1_1 = func(%p_indices_2:array<u32, 1>):f32 -> %b5 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
-  %b5 = block {
+%f1_1 = func(%p_indices_2:array<u32, 1>):f32 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
+  $B5: {
     %40:u32 = access %p_indices_2, 0u
     %res_1:ptr<function, f32, read_write> = var  # %res_1: 'res'
     %42:u32 = convert 1i
@@ -2401,16 +2401,16 @@
     ret %64
   }
 }
-%f2 = func(%p_indices_3:array<u32, 1>):f32 -> %b6 {  # %p_indices_3: 'p_indices'
-  %b6 = block {
+%f2 = func(%p_indices_3:array<u32, 1>):f32 {  # %p_indices_3: 'p_indices'
+  $B6: {
     %67:u32 = access %p_indices_3, 0u
     %68:array<u32, 1> = construct %67
     %69:f32 = call %f1_1, %68
     ret %69
   }
 }
-%f3 = func():f32 -> %b7 {
-  %b7 = block {
+%f3 = func():f32 {
+  $B7: {
     %71:u32 = convert 3i
     %72:array<u32, 1> = construct %71
     %73:f32 = call %f2, %72
@@ -2419,14 +2419,14 @@
     ret %75
   }
 }
-%f4 = func():f32 -> %b8 {
-  %b8 = block {
+%f4 = func():f32 {
+  $B8: {
     %77:f32 = call %f3
     ret %77
   }
 }
-%b = func():void -> %b9 {
-  %b9 = block {
+%b = func():void {
+  $B9: {
     %79:f32 = call %f4
     ret
   }
@@ -2482,33 +2482,33 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<workgroup, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p:ptr<workgroup, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p:ptr<workgroup, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B2: {
     %4:ptr<workgroup, vec4<i32>, read_write> = access %p, 3u
     %5:vec4<i32> = load %4
     ret %5
   }
 }
-%f1 = func(%p_1:ptr<workgroup, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<workgroup, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %8:ptr<workgroup, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %9:vec4<i32> = call %f2, %8
     ret %9
   }
 }
-%f0 = func(%p_2:ptr<workgroup, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f0 = func(%p_2:ptr<workgroup, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %12:ptr<workgroup, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %13:vec4<i32> = call %f1, %12
     ret %13
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %15:vec4<i32> = call %f0, %U
     ret
   }
@@ -2518,12 +2518,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<workgroup, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var @binding_point(0, 0)
 }
 
-%f2 = func(%p_indices:array<u32, 2>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p_indices:array<u32, 2>):vec4<i32> {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<workgroup, array<vec4<i32>, 5>, read_write> = access %U, %4, %5
@@ -2532,23 +2532,23 @@
     ret %8
   }
 }
-%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> -> %b3 {  # %p_indices_1: 'p_indices'
-  %b3 = block {
+%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> {  # %p_indices_1: 'p_indices'
+  $B3: {
     %11:u32 = access %p_indices_1, 0u
     %12:array<u32, 2> = construct %11, 2u
     %13:vec4<i32> = call %f2, %12
     ret %13
   }
 }
-%f0 = func():vec4<i32> -> %b4 {
-  %b4 = block {
+%f0 = func():vec4<i32> {
+  $B4: {
     %15:array<u32, 1> = construct 1u
     %16:vec4<i32> = call %f1, %15
     ret %16
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %18:vec4<i32> = call %f0
     ret
   }
@@ -2592,18 +2592,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, i32, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, %P, 20i
     ret
   }
@@ -2613,19 +2613,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, i32, read_write> = var
 }
 
-%a = func(%pre:i32, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):i32 {
+  $B2: {
     %5:ptr<private, i32, read_write> = access %P
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, 20i
     ret
   }
@@ -2663,18 +2663,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, i32, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):void {
+  $B2: {
     store %p, 42i
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:void = call %a, 10i, %P, 20i
     ret
   }
@@ -2684,19 +2684,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, i32, read_write> = var
 }
 
-%a = func(%pre:i32, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):void {
+  $B2: {
     %5:ptr<private, i32, read_write> = access %P
     store %5, 42i
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:void = call %a, 10i, 20i
     ret
   }
@@ -2740,18 +2740,18 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:ptr<private, i32, read_write> = access %P, 0u
     %9:i32 = call %a, 10i, %8, 20i
     ret
@@ -2766,19 +2766,19 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):i32 {
+  $B2: {
     %5:ptr<private, i32, read_write> = access %P, 0u
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:i32 = call %a, 10i, 20i
     ret
   }
@@ -2822,18 +2822,18 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %p
     ret %6
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %8:ptr<private, i32, read_write> = access %P, 0u
     %9:i32 = call %a, 10i, %8, 20i
     ret
@@ -2886,18 +2886,18 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, array<i32, 4>, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, array<i32, 4>, read_write>, %post:i32):void {
+  $B2: {
     store %p, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:ptr<private, array<i32, 4>, read_write> = access %P, 0u
     %8:void = call %a, 10i, %7, 20i
     ret
@@ -2912,19 +2912,19 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):void {
+  $B2: {
     %5:ptr<private, array<i32, 4>, read_write> = access %P, 0u
     store %5, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:void = call %a, 10i, 20i
     ret
   }
@@ -2972,18 +2972,18 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, str, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, array<i32, 4>, read_write>, %post:i32):void -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, array<i32, 4>, read_write>, %post:i32):void {
+  $B2: {
     store %p, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %7:ptr<private, array<i32, 4>, read_write> = access %P, 0u
     %8:void = call %a, 10i, %7, 20i
     ret
@@ -3045,20 +3045,20 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %Pi:ptr<private, i32, read_write> = var
   %Ps:ptr<private, str, read_write> = var
   %Pa:ptr<private, array<i32, 4>, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %8:i32 = load %p
     ret %8
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %10:i32 = call %a, 10i, %Pi, 20i
     %11:ptr<private, i32, read_write> = access %Ps, 0u
     %12:i32 = call %a, 30i, %11, 40i
@@ -3076,36 +3076,36 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %Pi:ptr<private, i32, read_write> = var
   %Ps:ptr<private, str, read_write> = var
   %Pa:ptr<private, array<i32, 4>, read_write> = var
 }
 
-%a = func(%pre:i32, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %post:i32):i32 {
+  $B2: {
     %7:ptr<private, i32, read_write> = access %Pi
     %8:i32 = load %7
     ret %8
   }
 }
-%a_1 = func(%pre_1:i32, %post_1:i32):i32 -> %b3 {  # %a_1: 'a', %pre_1: 'pre', %post_1: 'post'
-  %b3 = block {
+%a_1 = func(%pre_1:i32, %post_1:i32):i32 {  # %a_1: 'a', %pre_1: 'pre', %post_1: 'post'
+  $B3: {
     %12:ptr<private, i32, read_write> = access %Ps, 0u
     %13:i32 = load %12
     ret %13
   }
 }
-%a_2 = func(%pre_2:i32, %p_indices:array<u32, 1>, %post_2:i32):i32 -> %b4 {  # %a_2: 'a', %pre_2: 'pre', %post_2: 'post'
-  %b4 = block {
+%a_2 = func(%pre_2:i32, %p_indices:array<u32, 1>, %post_2:i32):i32 {  # %a_2: 'a', %pre_2: 'pre', %post_2: 'post'
+  $B4: {
     %18:u32 = access %p_indices, 0u
     %19:ptr<private, i32, read_write> = access %Pa, %18
     %20:i32 = load %19
     ret %20
   }
 }
-%b = func():void -> %b5 {
-  %b5 = block {
+%b = func():void {
+  $B5: {
     %22:i32 = call %a, 10i, 20i
     %23:i32 = call %a_1, 30i, 40i
     %24:u32 = convert 2i
@@ -3166,20 +3166,20 @@
   i:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %Pi:ptr<private, i32, read_write> = var
   %Ps:ptr<private, str, read_write> = var
   %Pa:ptr<private, array<i32, 4>, read_write> = var
 }
 
-%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %p:ptr<private, i32, read_write>, %post:i32):i32 {
+  $B2: {
     %8:i32 = load %p
     ret %8
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %10:i32 = call %a, 10i, %Pi, 20i
     %11:ptr<private, i32, read_write> = access %Ps, 0u
     %12:i32 = call %a, 30i, %11, 40i
@@ -3302,18 +3302,18 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, Outer, read_write> = var
 }
 
-%f0 = func(%p:ptr<private, vec4<f32>, read_write>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p:ptr<private, vec4<f32>, read_write>):f32 {
+  $B2: {
     %4:f32 = load_vector_element %p, 0u
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<private, mat3x4<f32>, read_write>):f32 -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<private, mat3x4<f32>, read_write>):f32 {  # %p_1: 'p'
+  $B3: {
     %res:ptr<function, f32, read_write> = var
     %8:ptr<private, vec4<f32>, read_write> = access %p_1, 1i
     %9:f32 = call %f0, %8
@@ -3339,15 +3339,15 @@
     ret %24
   }
 }
-%f2 = func(%p_2:ptr<private, Inner, read_write>):f32 -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f2 = func(%p_2:ptr<private, Inner, read_write>):f32 {  # %p_2: 'p'
+  $B4: {
     %p_mat:ptr<private, mat3x4<f32>, read_write> = access %p_2, 0u
     %28:f32 = call %f1, %p_mat
     ret %28
   }
 }
-%f3 = func(%p0:ptr<private, array<Inner, 4>, read_write>, %p1:ptr<private, mat3x4<f32>, read_write>):f32 -> %b5 {
-  %b5 = block {
+%f3 = func(%p0:ptr<private, array<Inner, 4>, read_write>, %p1:ptr<private, mat3x4<f32>, read_write>):f32 {
+  $B5: {
     %p0_inner:ptr<private, Inner, read_write> = access %p0, 3i
     %33:f32 = call %f2, %p0_inner
     %34:f32 = call %f1, %p1
@@ -3355,16 +3355,16 @@
     ret %35
   }
 }
-%f4 = func(%p_3:ptr<private, Outer, read_write>):f32 -> %b6 {  # %p_3: 'p'
-  %b6 = block {
+%f4 = func(%p_3:ptr<private, Outer, read_write>):f32 {  # %p_3: 'p'
+  $B6: {
     %38:ptr<private, array<Inner, 4>, read_write> = access %p_3, 0u
     %39:ptr<private, mat3x4<f32>, read_write> = access %P, 1u
     %40:f32 = call %f3, %38, %39
     ret %40
   }
 }
-%b = func():void -> %b7 {
-  %b7 = block {
+%b = func():void {
+  $B7: {
     %42:f32 = call %f4, %P
     ret
   }
@@ -3383,20 +3383,20 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, Outer, read_write> = var
 }
 
-%f0 = func(%p_indices:array<u32, 1>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p_indices:array<u32, 1>):f32 {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:ptr<private, vec4<f32>, read_write> = access %P, 1u, %4
     %6:f32 = load_vector_element %5, 0u
     ret %6
   }
 }
-%f0_1 = func(%p_indices_1:array<u32, 2>):f32 -> %b3 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
-  %b3 = block {
+%f0_1 = func(%p_indices_1:array<u32, 2>):f32 {  # %f0_1: 'f0', %p_indices_1: 'p_indices'
+  $B3: {
     %9:u32 = access %p_indices_1, 0u
     %10:u32 = access %p_indices_1, 1u
     %11:ptr<private, vec4<f32>, read_write> = access %P, 0u, %9, 0u, %10
@@ -3404,8 +3404,8 @@
     ret %12
   }
 }
-%f1 = func():f32 -> %b4 {
-  %b4 = block {
+%f1 = func():f32 {
+  $B4: {
     %res:ptr<function, f32, read_write> = var
     %15:u32 = convert 1i
     %16:array<u32, 1> = construct %15
@@ -3437,8 +3437,8 @@
     ret %37
   }
 }
-%f1_1 = func(%p_indices_2:array<u32, 1>):f32 -> %b5 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
-  %b5 = block {
+%f1_1 = func(%p_indices_2:array<u32, 1>):f32 {  # %f1_1: 'f1', %p_indices_2: 'p_indices'
+  $B5: {
     %40:u32 = access %p_indices_2, 0u
     %res_1:ptr<function, f32, read_write> = var  # %res_1: 'res'
     %42:u32 = convert 1i
@@ -3471,16 +3471,16 @@
     ret %64
   }
 }
-%f2 = func(%p_indices_3:array<u32, 1>):f32 -> %b6 {  # %p_indices_3: 'p_indices'
-  %b6 = block {
+%f2 = func(%p_indices_3:array<u32, 1>):f32 {  # %p_indices_3: 'p_indices'
+  $B6: {
     %67:u32 = access %p_indices_3, 0u
     %68:array<u32, 1> = construct %67
     %69:f32 = call %f1_1, %68
     ret %69
   }
 }
-%f3 = func():f32 -> %b7 {
-  %b7 = block {
+%f3 = func():f32 {
+  $B7: {
     %71:u32 = convert 3i
     %72:array<u32, 1> = construct %71
     %73:f32 = call %f2, %72
@@ -3489,14 +3489,14 @@
     ret %75
   }
 }
-%f4 = func():f32 -> %b8 {
-  %b8 = block {
+%f4 = func():f32 {
+  $B8: {
     %77:f32 = call %f3
     ret %77
   }
 }
-%b = func():void -> %b9 {
-  %b9 = block {
+%b = func():void {
+  $B9: {
     %79:f32 = call %f4
     ret
   }
@@ -3611,18 +3611,18 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, Outer, read_write> = var
 }
 
-%f0 = func(%p:ptr<private, vec4<f32>, read_write>):f32 -> %b2 {
-  %b2 = block {
+%f0 = func(%p:ptr<private, vec4<f32>, read_write>):f32 {
+  $B2: {
     %4:f32 = load_vector_element %p, 0u
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<private, mat3x4<f32>, read_write>):f32 -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<private, mat3x4<f32>, read_write>):f32 {  # %p_1: 'p'
+  $B3: {
     %res:ptr<function, f32, read_write> = var
     %8:ptr<private, vec4<f32>, read_write> = access %p_1, 1i
     %9:f32 = call %f0, %8
@@ -3648,15 +3648,15 @@
     ret %24
   }
 }
-%f2 = func(%p_2:ptr<private, Inner, read_write>):f32 -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f2 = func(%p_2:ptr<private, Inner, read_write>):f32 {  # %p_2: 'p'
+  $B4: {
     %p_mat:ptr<private, mat3x4<f32>, read_write> = access %p_2, 0u
     %28:f32 = call %f1, %p_mat
     ret %28
   }
 }
-%f3 = func(%p0:ptr<private, array<Inner, 4>, read_write>, %p1:ptr<private, mat3x4<f32>, read_write>):f32 -> %b5 {
-  %b5 = block {
+%f3 = func(%p0:ptr<private, array<Inner, 4>, read_write>, %p1:ptr<private, mat3x4<f32>, read_write>):f32 {
+  $B5: {
     %p0_inner:ptr<private, Inner, read_write> = access %p0, 3i
     %33:f32 = call %f2, %p0_inner
     %34:f32 = call %f1, %p1
@@ -3664,16 +3664,16 @@
     ret %35
   }
 }
-%f4 = func(%p_3:ptr<private, Outer, read_write>):f32 -> %b6 {  # %p_3: 'p'
-  %b6 = block {
+%f4 = func(%p_3:ptr<private, Outer, read_write>):f32 {  # %p_3: 'p'
+  $B6: {
     %38:ptr<private, array<Inner, 4>, read_write> = access %p_3, 0u
     %39:ptr<private, mat3x4<f32>, read_write> = access %P, 1u
     %40:f32 = call %f3, %38, %39
     ret %40
   }
 }
-%b = func():void -> %b7 {
-  %b7 = block {
+%b = func():void {
+  $B7: {
     %42:f32 = call %f4, %P
     ret
   }
@@ -3733,33 +3733,33 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
 }
 
-%f2 = func(%p:ptr<private, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p:ptr<private, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B2: {
     %4:ptr<private, vec4<i32>, read_write> = access %p, 3u
     %5:vec4<i32> = load %4
     ret %5
   }
 }
-%f1 = func(%p_1:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %8:ptr<private, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %9:vec4<i32> = call %f2, %8
     ret %9
   }
 }
-%f0 = func(%p_2:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f0 = func(%p_2:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %12:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %13:vec4<i32> = call %f1, %12
     ret %13
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %15:vec4<i32> = call %f0, %P
     ret
   }
@@ -3769,12 +3769,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
 }
 
-%f2 = func(%p_indices:array<u32, 2>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p_indices:array<u32, 2>):vec4<i32> {
+  $B2: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<private, array<vec4<i32>, 5>, read_write> = access %P, %4, %5
@@ -3783,23 +3783,23 @@
     ret %8
   }
 }
-%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> -> %b3 {  # %p_indices_1: 'p_indices'
-  %b3 = block {
+%f1 = func(%p_indices_1:array<u32, 1>):vec4<i32> {  # %p_indices_1: 'p_indices'
+  $B3: {
     %11:u32 = access %p_indices_1, 0u
     %12:array<u32, 2> = construct %11, 2u
     %13:vec4<i32> = call %f2, %12
     ret %13
   }
 }
-%f0 = func():vec4<i32> -> %b4 {
-  %b4 = block {
+%f0 = func():vec4<i32> {
+  $B4: {
     %15:array<u32, 1> = construct 1u
     %16:vec4<i32> = call %f1, %15
     ret %16
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %18:vec4<i32> = call %f0
     ret
   }
@@ -3855,33 +3855,33 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %P:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
 }
 
-%f2 = func(%p:ptr<private, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b2 {
-  %b2 = block {
+%f2 = func(%p:ptr<private, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B2: {
     %4:ptr<private, vec4<i32>, read_write> = access %p, 3u
     %5:vec4<i32> = load %4
     ret %5
   }
 }
-%f1 = func(%p_1:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%f1 = func(%p_1:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %8:ptr<private, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %9:vec4<i32> = call %f2, %8
     ret %9
   }
 }
-%f0 = func(%p_2:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%f0 = func(%p_2:ptr<private, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %12:ptr<private, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %13:vec4<i32> = call %f1, %12
     ret %13
   }
 }
-%main = func():void -> %b5 {
-  %b5 = block {
+%main = func():void {
+  $B5: {
     %15:vec4<i32> = call %f0, %P
     ret
   }
@@ -3916,8 +3916,8 @@
     });
 
     auto* src = R"(
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %p:ptr<function, i32, read_write> = let %v
     %4:i32 = load %p
@@ -3954,14 +3954,14 @@
     });
 
     auto* src = R"(
-%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:i32 = load %p
     ret %5
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, i32, read_write> = var
     %8:i32 = call %a, 10i, %F, 20i
     ret
@@ -3972,15 +3972,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:ptr<function, i32, read_write> = access %p_root
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, i32, read_write> = var
     %9:i32 = call %a, 10i, %F, 20i
     ret
@@ -4014,14 +4014,14 @@
     });
 
     auto* src = R"(
-%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):void -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):void {
+  $B1: {
     store %p, 42i
     ret
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, i32, read_write> = var
     %7:void = call %a, 10i, %F, 20i
     ret
@@ -4032,15 +4032,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):void -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):void {
+  $B1: {
     %5:ptr<function, i32, read_write> = access %p_root
     store %5, 42i
     ret
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, i32, read_write> = var
     %8:void = call %a, 10i, %F, 20i
     ret
@@ -4080,14 +4080,14 @@
   i:i32 @offset(0)
 }
 
-%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:i32 = load %p
     ret %5
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %8:ptr<function, i32, read_write> = access %F, 0u
     %9:i32 = call %a, 10i, %8, 20i
@@ -4103,15 +4103,15 @@
   i:i32 @offset(0)
 }
 
-%a = func(%pre:i32, %p_root:ptr<function, str, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p_root:ptr<function, str, read_write>, %post:i32):i32 {
+  $B1: {
     %5:ptr<function, i32, read_write> = access %p_root, 0u
     %6:i32 = load %5
     ret %6
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %9:i32 = call %a, 10i, %F, 20i
     ret
@@ -4155,14 +4155,14 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%a = func(%pre:i32, %p:ptr<function, array<i32, 4>, read_write>, %post:i32):void -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, array<i32, 4>, read_write>, %post:i32):void {
+  $B1: {
     store %p, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %7:ptr<function, array<i32, 4>, read_write> = access %F, 0u
     %8:void = call %a, 10i, %7, 20i
@@ -4178,15 +4178,15 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%a = func(%pre:i32, %p_root:ptr<function, str, read_write>, %post:i32):void -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p_root:ptr<function, str, read_write>, %post:i32):void {
+  $B1: {
     %5:ptr<function, array<i32, 4>, read_write> = access %p_root, 0u
     store %5, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %8:void = call %a, 10i, %F, 20i
     ret
@@ -4237,14 +4237,14 @@
   i:i32 @offset(0)
 }
 
-%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:i32 = load %p
     ret %5
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %Fi:ptr<function, i32, read_write> = var
     %Fs:ptr<function, str, read_write> = var
     %Fa:ptr<function, array<i32, 4>, read_write> = var
@@ -4265,30 +4265,30 @@
   i:i32 @offset(0)
 }
 
-%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p_root:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:ptr<function, i32, read_write> = access %p_root
     %6:i32 = load %5
     ret %6
   }
 }
-%a_1 = func(%pre_1:i32, %p_root_1:ptr<function, str, read_write>, %post_1:i32):i32 -> %b2 {  # %a_1: 'a', %pre_1: 'pre', %p_root_1: 'p_root', %post_1: 'post'
-  %b2 = block {
+%a_1 = func(%pre_1:i32, %p_root_1:ptr<function, str, read_write>, %post_1:i32):i32 {  # %a_1: 'a', %pre_1: 'pre', %p_root_1: 'p_root', %post_1: 'post'
+  $B2: {
     %11:ptr<function, i32, read_write> = access %p_root_1, 0u
     %12:i32 = load %11
     ret %12
   }
 }
-%a_2 = func(%pre_2:i32, %p_root_2:ptr<function, array<i32, 4>, read_write>, %p_indices:array<u32, 1>, %post_2:i32):i32 -> %b3 {  # %a_2: 'a', %pre_2: 'pre', %p_root_2: 'p_root', %post_2: 'post'
-  %b3 = block {
+%a_2 = func(%pre_2:i32, %p_root_2:ptr<function, array<i32, 4>, read_write>, %p_indices:array<u32, 1>, %post_2:i32):i32 {  # %a_2: 'a', %pre_2: 'pre', %p_root_2: 'p_root', %post_2: 'post'
+  $B3: {
     %18:u32 = access %p_indices, 0u
     %19:ptr<function, i32, read_write> = access %p_root_2, %18
     %20:i32 = load %19
     ret %20
   }
 }
-%b = func():void -> %b4 {
-  %b4 = block {
+%b = func():void {
+  $B4: {
     %Fi:ptr<function, i32, read_write> = var
     %Fs:ptr<function, str, read_write> = var
     %Fa:ptr<function, array<i32, 4>, read_write> = var
@@ -4334,14 +4334,14 @@
   i:i32 @offset(0)
 }
 
-%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, i32, read_write>, %post:i32):i32 {
+  $B1: {
     %5:i32 = load %p
     ret %5
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %8:ptr<function, i32, read_write> = access %F, 0u
     %9:i32 = call %a, 10i, %8, 20i
@@ -4390,14 +4390,14 @@
   arr:array<i32, 4> @offset(0)
 }
 
-%a = func(%pre:i32, %p:ptr<function, array<i32, 4>, read_write>, %post:i32):void -> %b1 {
-  %b1 = block {
+%a = func(%pre:i32, %p:ptr<function, array<i32, 4>, read_write>, %post:i32):void {
+  $B1: {
     store %p, array<i32, 4>(0i)
     ret
   }
 }
-%b = func():void -> %b2 {
-  %b2 = block {
+%b = func():void {
+  $B2: {
     %F:ptr<function, str, read_write> = var
     %7:ptr<function, array<i32, 4>, read_write> = access %F, 0u
     %8:void = call %a, 10i, %7, 20i
@@ -4505,14 +4505,14 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%f0 = func(%p:ptr<function, vec4<f32>, read_write>):f32 -> %b1 {
-  %b1 = block {
+%f0 = func(%p:ptr<function, vec4<f32>, read_write>):f32 {
+  $B1: {
     %3:f32 = load_vector_element %p, 0u
     ret %3
   }
 }
-%f1 = func(%p_1:ptr<function, mat3x4<f32>, read_write>):f32 -> %b2 {  # %p_1: 'p'
-  %b2 = block {
+%f1 = func(%p_1:ptr<function, mat3x4<f32>, read_write>):f32 {  # %p_1: 'p'
+  $B2: {
     %res:ptr<function, f32, read_write> = var
     %7:ptr<function, vec4<f32>, read_write> = access %p_1, 1i
     %8:f32 = call %f0, %7
@@ -4528,29 +4528,29 @@
     ret %15
   }
 }
-%f2 = func(%p_2:ptr<function, Inner, read_write>):f32 -> %b3 {  # %p_2: 'p'
-  %b3 = block {
+%f2 = func(%p_2:ptr<function, Inner, read_write>):f32 {  # %p_2: 'p'
+  $B3: {
     %p_mat:ptr<function, mat3x4<f32>, read_write> = access %p_2, 0u
     %19:f32 = call %f1, %p_mat
     ret %19
   }
 }
-%f3 = func(%p_3:ptr<function, array<Inner, 4>, read_write>):f32 -> %b4 {  # %p_3: 'p'
-  %b4 = block {
+%f3 = func(%p_3:ptr<function, array<Inner, 4>, read_write>):f32 {  # %p_3: 'p'
+  $B4: {
     %p_inner:ptr<function, Inner, read_write> = access %p_3, 3i
     %23:f32 = call %f2, %p_inner
     ret %23
   }
 }
-%f4 = func(%p_4:ptr<function, Outer, read_write>):f32 -> %b5 {  # %p_4: 'p'
-  %b5 = block {
+%f4 = func(%p_4:ptr<function, Outer, read_write>):f32 {  # %p_4: 'p'
+  $B5: {
     %26:ptr<function, array<Inner, 4>, read_write> = access %p_4, 0u
     %27:f32 = call %f3, %26
     ret %27
   }
 }
-%b = func():void -> %b6 {
-  %b6 = block {
+%b = func():void {
+  $B6: {
     %F:ptr<function, Outer, read_write> = var
     %30:f32 = call %f4, %F
     ret
@@ -4570,8 +4570,8 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%f0 = func(%p_root:ptr<function, Outer, read_write>, %p_indices:array<u32, 2>):f32 -> %b1 {
-  %b1 = block {
+%f0 = func(%p_root:ptr<function, Outer, read_write>, %p_indices:array<u32, 2>):f32 {
+  $B1: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<function, vec4<f32>, read_write> = access %p_root, 0u, %4, 0u, %5
@@ -4579,8 +4579,8 @@
     ret %7
   }
 }
-%f1 = func(%p_root_1:ptr<function, Outer, read_write>, %p_indices_1:array<u32, 1>):f32 -> %b2 {  # %p_root_1: 'p_root', %p_indices_1: 'p_indices'
-  %b2 = block {
+%f1 = func(%p_root_1:ptr<function, Outer, read_write>, %p_indices_1:array<u32, 1>):f32 {  # %p_root_1: 'p_root', %p_indices_1: 'p_indices'
+  $B2: {
     %11:u32 = access %p_indices_1, 0u
     %res:ptr<function, f32, read_write> = var
     %13:u32 = convert 1i
@@ -4599,30 +4599,30 @@
     ret %23
   }
 }
-%f2 = func(%p_root_2:ptr<function, Outer, read_write>, %p_indices_2:array<u32, 1>):f32 -> %b3 {  # %p_root_2: 'p_root', %p_indices_2: 'p_indices'
-  %b3 = block {
+%f2 = func(%p_root_2:ptr<function, Outer, read_write>, %p_indices_2:array<u32, 1>):f32 {  # %p_root_2: 'p_root', %p_indices_2: 'p_indices'
+  $B3: {
     %27:u32 = access %p_indices_2, 0u
     %28:array<u32, 1> = construct %27
     %29:f32 = call %f1, %p_root_2, %28
     ret %29
   }
 }
-%f3 = func(%p_root_3:ptr<function, Outer, read_write>):f32 -> %b4 {  # %p_root_3: 'p_root'
-  %b4 = block {
+%f3 = func(%p_root_3:ptr<function, Outer, read_write>):f32 {  # %p_root_3: 'p_root'
+  $B4: {
     %32:u32 = convert 3i
     %33:array<u32, 1> = construct %32
     %34:f32 = call %f2, %p_root_3, %33
     ret %34
   }
 }
-%f4 = func(%p_root_4:ptr<function, Outer, read_write>):f32 -> %b5 {  # %p_root_4: 'p_root'
-  %b5 = block {
+%f4 = func(%p_root_4:ptr<function, Outer, read_write>):f32 {  # %p_root_4: 'p_root'
+  $B5: {
     %37:f32 = call %f3, %p_root_4
     ret %37
   }
 }
-%b = func():void -> %b6 {
-  %b6 = block {
+%b = func():void {
+  $B6: {
     %F:ptr<function, Outer, read_write> = var
     %40:f32 = call %f4, %F
     ret
@@ -4725,14 +4725,14 @@
   mat:mat3x4<f32> @offset(192)
 }
 
-%f0 = func(%p:ptr<function, vec4<f32>, read_write>):f32 -> %b1 {
-  %b1 = block {
+%f0 = func(%p:ptr<function, vec4<f32>, read_write>):f32 {
+  $B1: {
     %3:f32 = load_vector_element %p, 0u
     ret %3
   }
 }
-%f1 = func(%p_1:ptr<function, mat3x4<f32>, read_write>):f32 -> %b2 {  # %p_1: 'p'
-  %b2 = block {
+%f1 = func(%p_1:ptr<function, mat3x4<f32>, read_write>):f32 {  # %p_1: 'p'
+  $B2: {
     %res:ptr<function, f32, read_write> = var
     %7:ptr<function, vec4<f32>, read_write> = access %p_1, 1i
     %8:f32 = call %f0, %7
@@ -4748,29 +4748,29 @@
     ret %15
   }
 }
-%f2 = func(%p_2:ptr<function, Inner, read_write>):f32 -> %b3 {  # %p_2: 'p'
-  %b3 = block {
+%f2 = func(%p_2:ptr<function, Inner, read_write>):f32 {  # %p_2: 'p'
+  $B3: {
     %p_mat:ptr<function, mat3x4<f32>, read_write> = access %p_2, 0u
     %19:f32 = call %f1, %p_mat
     ret %19
   }
 }
-%f3 = func(%p_3:ptr<function, array<Inner, 4>, read_write>):f32 -> %b4 {  # %p_3: 'p'
-  %b4 = block {
+%f3 = func(%p_3:ptr<function, array<Inner, 4>, read_write>):f32 {  # %p_3: 'p'
+  $B4: {
     %p_inner:ptr<function, Inner, read_write> = access %p_3, 3i
     %23:f32 = call %f2, %p_inner
     ret %23
   }
 }
-%f4 = func(%p_4:ptr<function, Outer, read_write>):f32 -> %b5 {  # %p_4: 'p'
-  %b5 = block {
+%f4 = func(%p_4:ptr<function, Outer, read_write>):f32 {  # %p_4: 'p'
+  $B5: {
     %26:ptr<function, array<Inner, 4>, read_write> = access %p_4, 0u
     %27:f32 = call %f3, %26
     ret %27
   }
 }
-%b = func():void -> %b6 {
-  %b6 = block {
+%b = func():void {
+  $B6: {
     %F:ptr<function, Outer, read_write> = var
     %30:f32 = call %f4, %F
     ret
@@ -4826,29 +4826,29 @@
     });
 
     auto* src = R"(
-%f2 = func(%p:ptr<function, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b1 {
-  %b1 = block {
+%f2 = func(%p:ptr<function, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B1: {
     %3:ptr<function, vec4<i32>, read_write> = access %p, 3u
     %4:vec4<i32> = load %3
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b2 {  # %p_1: 'p'
-  %b2 = block {
+%f1 = func(%p_1:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B2: {
     %7:ptr<function, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %8:vec4<i32> = call %f2, %7
     ret %8
   }
 }
-%f0 = func(%p_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_2: 'p'
-  %b3 = block {
+%f0 = func(%p_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B3: {
     %11:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %12:vec4<i32> = call %f1, %11
     ret %12
   }
 }
-%main = func():void -> %b4 {
-  %b4 = block {
+%main = func():void {
+  $B4: {
     %F:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
     %15:vec4<i32> = call %f0, %F
     ret
@@ -4859,8 +4859,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f2 = func(%p_root:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>, %p_indices:array<u32, 2>):vec4<i32> -> %b1 {
-  %b1 = block {
+%f2 = func(%p_root:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>, %p_indices:array<u32, 2>):vec4<i32> {
+  $B1: {
     %4:u32 = access %p_indices, 0u
     %5:u32 = access %p_indices, 1u
     %6:ptr<function, array<vec4<i32>, 5>, read_write> = access %p_root, %4, %5
@@ -4869,23 +4869,23 @@
     ret %8
   }
 }
-%f1 = func(%p_root_1:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>, %p_indices_1:array<u32, 1>):vec4<i32> -> %b2 {  # %p_root_1: 'p_root', %p_indices_1: 'p_indices'
-  %b2 = block {
+%f1 = func(%p_root_1:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>, %p_indices_1:array<u32, 1>):vec4<i32> {  # %p_root_1: 'p_root', %p_indices_1: 'p_indices'
+  $B2: {
     %12:u32 = access %p_indices_1, 0u
     %13:array<u32, 2> = construct %12, 2u
     %14:vec4<i32> = call %f2, %p_root_1, %13
     ret %14
   }
 }
-%f0 = func(%p_root_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_root_2: 'p_root'
-  %b3 = block {
+%f0 = func(%p_root_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_root_2: 'p_root'
+  $B3: {
     %17:array<u32, 1> = construct 1u
     %18:vec4<i32> = call %f1, %p_root_2, %17
     ret %18
   }
 }
-%main = func():void -> %b4 {
-  %b4 = block {
+%main = func():void {
+  $B4: {
     %F:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
     %21:vec4<i32> = call %f0, %F
     ret
@@ -4937,29 +4937,29 @@
     });
 
     auto* src = R"(
-%f2 = func(%p:ptr<function, array<vec4<i32>, 5>, read_write>):vec4<i32> -> %b1 {
-  %b1 = block {
+%f2 = func(%p:ptr<function, array<vec4<i32>, 5>, read_write>):vec4<i32> {
+  $B1: {
     %3:ptr<function, vec4<i32>, read_write> = access %p, 3u
     %4:vec4<i32> = load %3
     ret %4
   }
 }
-%f1 = func(%p_1:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> -> %b2 {  # %p_1: 'p'
-  %b2 = block {
+%f1 = func(%p_1:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write>):vec4<i32> {  # %p_1: 'p'
+  $B2: {
     %7:ptr<function, array<vec4<i32>, 5>, read_write> = access %p_1, 2u
     %8:vec4<i32> = call %f2, %7
     ret %8
   }
 }
-%f0 = func(%p_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> -> %b3 {  # %p_2: 'p'
-  %b3 = block {
+%f0 = func(%p_2:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B3: {
     %11:ptr<function, array<array<vec4<i32>, 5>, 5>, read_write> = access %p_2, 1u
     %12:vec4<i32> = call %f1, %11
     ret %12
   }
 }
-%main = func():void -> %b4 {
-  %b4 = block {
+%main = func():void {
+  $B4: {
     %F:ptr<function, array<array<array<vec4<i32>, 5>, 5>, 5>, read_write> = var
     %15:vec4<i32> = call %f0, %F
     ret
@@ -5008,18 +5008,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%len = func(%p:ptr<storage, array<f32>, read_write>):u32 -> %b2 {
-  %b2 = block {
+%len = func(%p:ptr<storage, array<f32>, read_write>):u32 {
+  $B2: {
     %4:u32 = arrayLength %p
     ret %4
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %6:u32 = call %len, %S
     ret
   }
@@ -5029,19 +5029,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%len = func():u32 -> %b2 {
-  %b2 = block {
+%len = func():u32 {
+  $B2: {
     %3:ptr<storage, array<f32>, read_write> = access %S
     %4:u32 = arrayLength %3
     ret %4
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %6:u32 = call %len
     ret
   }
@@ -5075,18 +5075,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%load = func(%p:ptr<workgroup, atomic<i32>, read_write>):i32 -> %b2 {
-  %b2 = block {
+%load = func(%p:ptr<workgroup, atomic<i32>, read_write>):i32 {
+  $B2: {
     %4:i32 = atomicLoad %p
     ret %4
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %6:i32 = call %load, %W
     ret
   }
@@ -5096,19 +5096,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%load = func():i32 -> %b2 {
-  %b2 = block {
+%load = func():i32 {
+  $B2: {
     %3:ptr<workgroup, atomic<i32>, read_write> = access %W
     %4:i32 = atomicLoad %3
     ret %4
   }
 }
-%b = func():void -> %b3 {
-  %b3 = block {
+%b = func():void {
+  $B3: {
     %6:i32 = call %load
     ret
   }
@@ -5265,7 +5265,7 @@
   i:vec4<i32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, vec4<i32>, read> = var @binding_point(0, 0)
   %U_str:ptr<uniform, str, read> = var @binding_point(0, 1)
   %U_arr:ptr<uniform, array<vec4<i32>, 8>, read> = var @binding_point(0, 2)
@@ -5280,26 +5280,26 @@
   %W_arr_arr:ptr<workgroup, array<array<vec4<i32>, 8>, 4>, read_write> = var
 }
 
-%fn_u = func(%p:ptr<uniform, vec4<i32>, read>):vec4<i32> -> %b2 {
-  %b2 = block {
+%fn_u = func(%p:ptr<uniform, vec4<i32>, read>):vec4<i32> {
+  $B2: {
     %15:vec4<i32> = load %p
     ret %15
   }
 }
-%fn_s = func(%p_1:ptr<storage, vec4<i32>, read>):vec4<i32> -> %b3 {  # %p_1: 'p'
-  %b3 = block {
+%fn_s = func(%p_1:ptr<storage, vec4<i32>, read>):vec4<i32> {  # %p_1: 'p'
+  $B3: {
     %18:vec4<i32> = load %p_1
     ret %18
   }
 }
-%fn_w = func(%p_2:ptr<workgroup, vec4<i32>, read_write>):vec4<i32> -> %b4 {  # %p_2: 'p'
-  %b4 = block {
+%fn_w = func(%p_2:ptr<workgroup, vec4<i32>, read_write>):vec4<i32> {  # %p_2: 'p'
+  $B4: {
     %21:vec4<i32> = load %p_2
     ret %21
   }
 }
-%b = func():void -> %b5 {
-  %b5 = block {
+%b = func():void {
+  $B5: {
     %I:i32 = let 3i
     %J:i32 = let 4i
     %u:vec4<i32> = call %fn_u, %U
@@ -5365,7 +5365,7 @@
   i:vec4<i32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %U:ptr<uniform, vec4<i32>, read> = var @binding_point(0, 0)
   %U_str:ptr<uniform, str, read> = var @binding_point(0, 1)
   %U_arr:ptr<uniform, array<vec4<i32>, 8>, read> = var @binding_point(0, 2)
@@ -5380,30 +5380,30 @@
   %W_arr_arr:ptr<workgroup, array<array<vec4<i32>, 8>, 4>, read_write> = var
 }
 
-%fn_u = func():vec4<i32> -> %b2 {
-  %b2 = block {
+%fn_u = func():vec4<i32> {
+  $B2: {
     %14:ptr<uniform, vec4<i32>, read> = access %U
     %15:vec4<i32> = load %14
     ret %15
   }
 }
-%fn_u_1 = func():vec4<i32> -> %b3 {  # %fn_u_1: 'fn_u'
-  %b3 = block {
+%fn_u_1 = func():vec4<i32> {  # %fn_u_1: 'fn_u'
+  $B3: {
     %17:ptr<uniform, vec4<i32>, read> = access %U_str, 0u
     %18:vec4<i32> = load %17
     ret %18
   }
 }
-%fn_u_2 = func(%p_indices:array<u32, 1>):vec4<i32> -> %b4 {  # %fn_u_2: 'fn_u'
-  %b4 = block {
+%fn_u_2 = func(%p_indices:array<u32, 1>):vec4<i32> {  # %fn_u_2: 'fn_u'
+  $B4: {
     %21:u32 = access %p_indices, 0u
     %22:ptr<uniform, vec4<i32>, read> = access %U_arr, %21
     %23:vec4<i32> = load %22
     ret %23
   }
 }
-%fn_u_3 = func(%p_indices_1:array<u32, 2>):vec4<i32> -> %b5 {  # %fn_u_3: 'fn_u', %p_indices_1: 'p_indices'
-  %b5 = block {
+%fn_u_3 = func(%p_indices_1:array<u32, 2>):vec4<i32> {  # %fn_u_3: 'fn_u', %p_indices_1: 'p_indices'
+  $B5: {
     %26:u32 = access %p_indices_1, 0u
     %27:u32 = access %p_indices_1, 1u
     %28:ptr<uniform, vec4<i32>, read> = access %U_arr_arr, %26, %27
@@ -5411,30 +5411,30 @@
     ret %29
   }
 }
-%fn_s = func():vec4<i32> -> %b6 {
-  %b6 = block {
+%fn_s = func():vec4<i32> {
+  $B6: {
     %31:ptr<storage, vec4<i32>, read> = access %S
     %32:vec4<i32> = load %31
     ret %32
   }
 }
-%fn_s_1 = func():vec4<i32> -> %b7 {  # %fn_s_1: 'fn_s'
-  %b7 = block {
+%fn_s_1 = func():vec4<i32> {  # %fn_s_1: 'fn_s'
+  $B7: {
     %34:ptr<storage, vec4<i32>, read> = access %S_str, 0u
     %35:vec4<i32> = load %34
     ret %35
   }
 }
-%fn_s_2 = func(%p_indices_2:array<u32, 1>):vec4<i32> -> %b8 {  # %fn_s_2: 'fn_s', %p_indices_2: 'p_indices'
-  %b8 = block {
+%fn_s_2 = func(%p_indices_2:array<u32, 1>):vec4<i32> {  # %fn_s_2: 'fn_s', %p_indices_2: 'p_indices'
+  $B8: {
     %38:u32 = access %p_indices_2, 0u
     %39:ptr<storage, vec4<i32>, read> = access %S_arr, %38
     %40:vec4<i32> = load %39
     ret %40
   }
 }
-%fn_s_3 = func(%p_indices_3:array<u32, 2>):vec4<i32> -> %b9 {  # %fn_s_3: 'fn_s', %p_indices_3: 'p_indices'
-  %b9 = block {
+%fn_s_3 = func(%p_indices_3:array<u32, 2>):vec4<i32> {  # %fn_s_3: 'fn_s', %p_indices_3: 'p_indices'
+  $B9: {
     %43:u32 = access %p_indices_3, 0u
     %44:u32 = access %p_indices_3, 1u
     %45:ptr<storage, vec4<i32>, read> = access %S_arr_arr, %43, %44
@@ -5442,30 +5442,30 @@
     ret %46
   }
 }
-%fn_w = func():vec4<i32> -> %b10 {
-  %b10 = block {
+%fn_w = func():vec4<i32> {
+  $B10: {
     %48:ptr<workgroup, vec4<i32>, read_write> = access %W
     %49:vec4<i32> = load %48
     ret %49
   }
 }
-%fn_w_1 = func():vec4<i32> -> %b11 {  # %fn_w_1: 'fn_w'
-  %b11 = block {
+%fn_w_1 = func():vec4<i32> {  # %fn_w_1: 'fn_w'
+  $B11: {
     %51:ptr<workgroup, vec4<i32>, read_write> = access %W_str, 0u
     %52:vec4<i32> = load %51
     ret %52
   }
 }
-%fn_w_2 = func(%p_indices_4:array<u32, 1>):vec4<i32> -> %b12 {  # %fn_w_2: 'fn_w', %p_indices_4: 'p_indices'
-  %b12 = block {
+%fn_w_2 = func(%p_indices_4:array<u32, 1>):vec4<i32> {  # %fn_w_2: 'fn_w', %p_indices_4: 'p_indices'
+  $B12: {
     %55:u32 = access %p_indices_4, 0u
     %56:ptr<workgroup, vec4<i32>, read_write> = access %W_arr, %55
     %57:vec4<i32> = load %56
     ret %57
   }
 }
-%fn_w_3 = func(%p_indices_5:array<u32, 2>):vec4<i32> -> %b13 {  # %fn_w_3: 'fn_w', %p_indices_5: 'p_indices'
-  %b13 = block {
+%fn_w_3 = func(%p_indices_5:array<u32, 2>):vec4<i32> {  # %fn_w_3: 'fn_w', %p_indices_5: 'p_indices'
+  $B13: {
     %60:u32 = access %p_indices_5, 0u
     %61:u32 = access %p_indices_5, 1u
     %62:ptr<workgroup, vec4<i32>, read_write> = access %W_arr_arr, %60, %61
@@ -5473,8 +5473,8 @@
     ret %63
   }
 }
-%b = func():void -> %b14 {
-  %b14 = block {
+%b = func():void {
+  $B14: {
     %I:i32 = let 3i
     %J:i32 = let 4i
     %u:vec4<i32> = call %fn_u
@@ -5609,17 +5609,17 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<array<i32, 9>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%i:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%i:i32):i32 {
+  $B2: {
     ret %i
   }
 }
-%b = func(%p:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%p:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read>):i32 {
+  $B3: {
     %6:ptr<storage, i32, read> = access %p, 0i, 1i, 2i
     %7:i32 = load %6
     %8:i32 = call %a, %7
@@ -5636,8 +5636,8 @@
     ret %18
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %20:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read> = access %S, 42i
     %v:i32 = call %b, %20
     ret
@@ -5648,17 +5648,17 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<array<i32, 9>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%i:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%i:i32):i32 {
+  $B2: {
     ret %i
   }
 }
-%b = func(%p_indices:array<u32, 1>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%p_indices:array<u32, 1>):i32 {
+  $B3: {
     %6:u32 = access %p_indices, 0u
     %7:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read> = access %S, %6
     %8:ptr<storage, i32, read> = access %7, 0i, 1i, 2i
@@ -5677,8 +5677,8 @@
     ret %20
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %22:u32 = convert 42i
     %23:array<u32, 1> = construct %22
     %v:i32 = call %b, %23
@@ -5738,18 +5738,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<array<i32, 9>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %i:ptr<storage, i32, read>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %i:ptr<storage, i32, read>, %post:i32):i32 {
+  $B2: {
     %6:i32 = load %i
     ret %6
   }
 }
-%b = func(%p:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%p:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read>):i32 {
+  $B3: {
     %9:ptr<storage, i32, read> = access %p, 0i, 1i, 2i
     %10:i32 = call %a, 20i, %9, 30i
     %11:ptr<storage, i32, read> = access %p, 3i, 4i, 5i
@@ -5761,8 +5761,8 @@
     ret %16
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %18:ptr<storage, array<array<array<i32, 9>, 9>, 9>, read> = access %S, 42i
     %v:i32 = call %b, %18
     ret
@@ -5773,12 +5773,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<array<i32, 9>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%pre:i32, %i_indices:array<u32, 4>, %post:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%pre:i32, %i_indices:array<u32, 4>, %post:i32):i32 {
+  $B2: {
     %6:u32 = access %i_indices, 0u
     %7:u32 = access %i_indices, 1u
     %8:u32 = access %i_indices, 2u
@@ -5788,8 +5788,8 @@
     ret %11
   }
 }
-%b = func(%p_indices:array<u32, 1>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%p_indices:array<u32, 1>):i32 {
+  $B3: {
     %14:u32 = access %p_indices, 0u
     %15:u32 = convert 0i
     %16:u32 = convert 1i
@@ -5814,8 +5814,8 @@
     ret %34
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %36:u32 = convert 42i
     %37:array<u32, 1> = construct %36
     %v:i32 = call %b, %37
@@ -5872,18 +5872,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<i32, 9>, 9>, 50>, read> = var @binding_point(0, 0)
   %U:ptr<uniform, array<array<array<vec4<i32>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%i:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%i:i32):i32 {
+  $B2: {
     ret %i
   }
 }
-%b = func(%s:ptr<storage, array<array<i32, 9>, 9>, read>, %u:ptr<uniform, array<array<vec4<i32>, 9>, 9>, read>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%s:ptr<storage, array<array<i32, 9>, 9>, read>, %u:ptr<uniform, array<array<vec4<i32>, 9>, 9>, read>):i32 {
+  $B3: {
     %8:ptr<uniform, vec4<i32>, read> = access %u, 0i, 1i
     %9:i32 = load_vector_element %8, 0u
     %10:i32 = call %a, %9
@@ -5896,8 +5896,8 @@
     ret %16
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %18:ptr<storage, array<array<i32, 9>, 9>, read> = access %S, 42i
     %19:ptr<uniform, array<array<vec4<i32>, 9>, 9>, read> = access %U, 24i
     %v:i32 = call %b, %18, %19
@@ -5909,18 +5909,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %S:ptr<storage, array<array<array<i32, 9>, 9>, 50>, read> = var @binding_point(0, 0)
   %U:ptr<uniform, array<array<array<vec4<i32>, 9>, 9>, 50>, read> = var @binding_point(0, 0)
 }
 
-%a = func(%i:i32):i32 -> %b2 {
-  %b2 = block {
+%a = func(%i:i32):i32 {
+  $B2: {
     ret %i
   }
 }
-%b = func(%s_indices:array<u32, 1>, %u_indices:array<u32, 1>):i32 -> %b3 {
-  %b3 = block {
+%b = func(%s_indices:array<u32, 1>, %u_indices:array<u32, 1>):i32 {
+  $B3: {
     %8:u32 = access %s_indices, 0u
     %9:ptr<storage, array<array<i32, 9>, 9>, read> = access %S, %8
     %10:u32 = access %u_indices, 0u
@@ -5937,8 +5937,8 @@
     ret %20
   }
 }
-%c = func():void -> %b4 {
-  %b4 = block {
+%c = func():void {
+  $B4: {
     %22:u32 = convert 42i
     %23:array<u32, 1> = construct %22
     %24:u32 = convert 24i
diff --git a/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc b/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
index 8f4ea34..dadb543 100644
--- a/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
+++ b/src/tint/lang/core/ir/transform/multiplanar_external_texture_test.cc
@@ -45,8 +45,8 @@
     func->Block()->Append(b.Return(func));
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     ret
   }
 }
@@ -68,12 +68,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     ret
   }
 }
@@ -100,14 +100,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     ret
   }
 }
@@ -133,12 +133,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:texture_external = load %texture
     ret
   }
@@ -166,14 +166,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %5:texture_2d<f32> = load %texture_plane0
     %6:texture_2d<f32> = load %texture_plane1
     %7:tint_ExternalTextureParams = load %texture_params
@@ -204,12 +204,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func():vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<u32> {
+  $B2: {
     %3:texture_external = load %texture
     %result:vec2<u32> = textureDimensions %3
     ret %result
@@ -238,14 +238,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func():vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<u32> {
+  $B2: {
     %5:texture_2d<f32> = load %texture_plane0
     %6:texture_2d<f32> = load %texture_plane1
     %7:tint_ExternalTextureParams = load %texture_params
@@ -279,12 +279,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<u32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):vec4<f32> {
+  $B2: {
     %4:texture_external = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     ret %result
@@ -313,14 +313,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func(%coords:vec2<u32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):vec4<f32> {
+  $B2: {
     %6:texture_2d<f32> = load %texture_plane0
     %7:texture_2d<f32> = load %texture_plane1
     %8:tint_ExternalTextureParams = load %texture_params
@@ -328,20 +328,20 @@
     ret %9
   }
 }
-%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %15:u32 = access %params, 1u
     %16:mat3x4<f32> = access %params, 2u
     %17:u32 = access %params, 0u
     %18:bool = eq %17, 1u
-    %19:vec3<f32>, %20:f32 = if %18 [t: %b4, f: %b5] {  # if_1
-      %b4 = block {  # true
+    %19:vec3<f32>, %20:f32 = if %18 [t: $B4, f: $B5] {  # if_1
+      $B4: {  # true
         %21:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %22:vec3<f32> = swizzle %21, xyz
         %23:f32 = access %21, 3u
         exit_if %22, %23  # if_1
       }
-      %b5 = block {  # false
+      $B5: {  # false
         %24:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %25:f32 = access %24, 0u
         %26:vec2<u32> = shr %coords_1, vec2<u32>(1u)
@@ -353,8 +353,8 @@
       }
     }
     %31:bool = eq %15, 0u
-    %32:vec3<f32> = if %31 [t: %b6, f: %b7] {  # if_2
-      %b6 = block {  # true
+    %32:vec3<f32> = if %31 [t: $B6, f: $B7] {  # if_2
+      $B6: {  # true
         %33:tint_GammaTransferParams = access %params, 3u
         %34:tint_GammaTransferParams = access %params, 4u
         %35:mat3x3<f32> = access %params, 5u
@@ -363,7 +363,7 @@
         %39:vec3<f32> = call %tint_GammaCorrection, %38, %34
         exit_if %39  # if_2
       }
-      %b7 = block {  # false
+      $B7: {  # false
         exit_if %19  # if_2
       }
     }
@@ -371,8 +371,8 @@
     ret %40
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b8 {  # %params_1: 'params'
-  %b8 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B8: {
     %43:f32 = access %params_1, 0u
     %44:f32 = access %params_1, 1u
     %45:f32 = access %params_1, 2u
@@ -423,12 +423,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %4:texture_external = load %texture
     %result:vec4<f32> = textureLoad %4, %coords
     ret %result
@@ -457,14 +457,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %6:texture_2d<f32> = load %texture_plane0
     %7:texture_2d<f32> = load %texture_plane1
     %8:tint_ExternalTextureParams = load %texture_params
@@ -473,20 +473,20 @@
     ret %10
   }
 }
-%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %16:u32 = access %params, 1u
     %17:mat3x4<f32> = access %params, 2u
     %18:u32 = access %params, 0u
     %19:bool = eq %18, 1u
-    %20:vec3<f32>, %21:f32 = if %19 [t: %b4, f: %b5] {  # if_1
-      %b4 = block {  # true
+    %20:vec3<f32>, %21:f32 = if %19 [t: $B4, f: $B5] {  # if_1
+      $B4: {  # true
         %22:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %23:vec3<f32> = swizzle %22, xyz
         %24:f32 = access %22, 3u
         exit_if %23, %24  # if_1
       }
-      %b5 = block {  # false
+      $B5: {  # false
         %25:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %26:f32 = access %25, 0u
         %27:vec2<u32> = shr %coords_1, vec2<u32>(1u)
@@ -498,8 +498,8 @@
       }
     }
     %32:bool = eq %16, 0u
-    %33:vec3<f32> = if %32 [t: %b6, f: %b7] {  # if_2
-      %b6 = block {  # true
+    %33:vec3<f32> = if %32 [t: $B6, f: $B7] {  # if_2
+      $B6: {  # true
         %34:tint_GammaTransferParams = access %params, 3u
         %35:tint_GammaTransferParams = access %params, 4u
         %36:mat3x3<f32> = access %params, 5u
@@ -508,7 +508,7 @@
         %40:vec3<f32> = call %tint_GammaCorrection, %39, %35
         exit_if %40  # if_2
       }
-      %b7 = block {  # false
+      $B7: {  # false
         exit_if %20  # if_2
       }
     }
@@ -516,8 +516,8 @@
     ret %41
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b8 {  # %params_1: 'params'
-  %b8 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B8: {
     %44:f32 = access %params_1, 0u
     %45:f32 = access %params_1, 1u
     %46:f32 = access %params_1, 2u
@@ -570,12 +570,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%sampler:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B2: {
     %5:texture_external = load %texture
     %result:vec4<f32> = textureSampleBaseClampToEdge %5, %sampler, %coords
     ret %result
@@ -604,14 +604,14 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func(%sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%foo = func(%sampler:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B2: {
     %7:texture_2d<f32> = load %texture_plane0
     %8:texture_2d<f32> = load %texture_plane1
     %9:tint_ExternalTextureParams = load %texture_params
@@ -619,8 +619,8 @@
     ret %10
   }
 }
-%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> -> %b3 {  # %sampler_1: 'sampler', %coords_1: 'coords'
-  %b3 = block {
+%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> {  # %sampler_1: 'sampler', %coords_1: 'coords'
+  $B3: {
     %17:u32 = access %params, 1u
     %18:mat3x4<f32> = access %params, 2u
     %19:mat3x2<f32> = access %params, 6u
@@ -638,14 +638,14 @@
     %31:vec2<f32> = clamp %21, %29, %30
     %32:u32 = access %params, 0u
     %33:bool = eq %32, 1u
-    %34:vec3<f32>, %35:f32 = if %33 [t: %b4, f: %b5] {  # if_1
-      %b4 = block {  # true
+    %34:vec3<f32>, %35:f32 = if %33 [t: $B4, f: $B5] {  # if_1
+      $B4: {  # true
         %36:vec4<f32> = textureSampleLevel %plane_0, %sampler_1, %26, 0.0f
         %37:vec3<f32> = swizzle %36, xyz
         %38:f32 = access %36, 3u
         exit_if %37, %38  # if_1
       }
-      %b5 = block {  # false
+      $B5: {  # false
         %39:vec4<f32> = textureSampleLevel %plane_0, %sampler_1, %26, 0.0f
         %40:f32 = access %39, 0u
         %41:vec4<f32> = textureSampleLevel %plane_1, %sampler_1, %31, 0.0f
@@ -656,8 +656,8 @@
       }
     }
     %45:bool = eq %17, 0u
-    %46:vec3<f32> = if %45 [t: %b6, f: %b7] {  # if_2
-      %b6 = block {  # true
+    %46:vec3<f32> = if %45 [t: $B6, f: $B7] {  # if_2
+      $B6: {  # true
         %47:tint_GammaTransferParams = access %params, 3u
         %48:tint_GammaTransferParams = access %params, 4u
         %49:mat3x3<f32> = access %params, 5u
@@ -666,7 +666,7 @@
         %53:vec3<f32> = call %tint_GammaCorrection, %52, %48
         exit_if %53  # if_2
       }
-      %b7 = block {  # false
+      $B7: {  # false
         exit_if %34  # if_2
       }
     }
@@ -674,8 +674,8 @@
     ret %54
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b8 {  # %params_1: 'params'
-  %b8 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B8: {
     %57:f32 = access %params_1, 0u
     %58:f32 = access %params_1, 1u
     %59:f32 = access %params_1, 2u
@@ -743,18 +743,18 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%texture_1:texture_external, %sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%foo = func(%texture_1:texture_external, %sampler:sampler, %coords:vec2<f32>):vec4<f32> {  # %texture_1: 'texture'
+  $B2: {
     %result:vec4<f32> = textureSampleBaseClampToEdge %texture_1, %sampler, %coords
     ret %result
   }
 }
-%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> -> %b3 {  # %sampler_1: 'sampler', %coords_1: 'coords'
-  %b3 = block {
+%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> {  # %sampler_1: 'sampler', %coords_1: 'coords'
+  $B3: {
     %10:texture_external = load %texture
     %result_1:vec4<f32> = call %foo, %10, %sampler_1, %coords_1  # %result_1: 'result'
     ret %result_1
@@ -783,20 +783,20 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func(%texture_plane0_1:texture_2d<f32>, %texture_plane1_1:texture_2d<f32>, %texture_params_1:tint_ExternalTextureParams, %sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {  # %texture_plane0_1: 'texture_plane0', %texture_plane1_1: 'texture_plane1', %texture_params_1: 'texture_params'
-  %b2 = block {
+%foo = func(%texture_plane0_1:texture_2d<f32>, %texture_plane1_1:texture_2d<f32>, %texture_params_1:tint_ExternalTextureParams, %sampler:sampler, %coords:vec2<f32>):vec4<f32> {  # %texture_plane0_1: 'texture_plane0', %texture_plane1_1: 'texture_plane1', %texture_params_1: 'texture_params'
+  $B2: {
     %10:vec4<f32> = call %tint_TextureSampleExternal, %texture_plane0_1, %texture_plane1_1, %texture_params_1, %sampler, %coords
     ret %10
   }
 }
-%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> -> %b3 {  # %sampler_1: 'sampler', %coords_1: 'coords'
-  %b3 = block {
+%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> {  # %sampler_1: 'sampler', %coords_1: 'coords'
+  $B3: {
     %15:texture_2d<f32> = load %texture_plane0
     %16:texture_2d<f32> = load %texture_plane1
     %17:tint_ExternalTextureParams = load %texture_params
@@ -804,8 +804,8 @@
     ret %result
   }
 }
-%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_2:sampler, %coords_2:vec2<f32>):vec4<f32> -> %b4 {  # %sampler_2: 'sampler', %coords_2: 'coords'
-  %b4 = block {
+%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_2:sampler, %coords_2:vec2<f32>):vec4<f32> {  # %sampler_2: 'sampler', %coords_2: 'coords'
+  $B4: {
     %24:u32 = access %params, 1u
     %25:mat3x4<f32> = access %params, 2u
     %26:mat3x2<f32> = access %params, 6u
@@ -823,14 +823,14 @@
     %38:vec2<f32> = clamp %28, %36, %37
     %39:u32 = access %params, 0u
     %40:bool = eq %39, 1u
-    %41:vec3<f32>, %42:f32 = if %40 [t: %b5, f: %b6] {  # if_1
-      %b5 = block {  # true
+    %41:vec3<f32>, %42:f32 = if %40 [t: $B5, f: $B6] {  # if_1
+      $B5: {  # true
         %43:vec4<f32> = textureSampleLevel %plane_0, %sampler_2, %33, 0.0f
         %44:vec3<f32> = swizzle %43, xyz
         %45:f32 = access %43, 3u
         exit_if %44, %45  # if_1
       }
-      %b6 = block {  # false
+      $B6: {  # false
         %46:vec4<f32> = textureSampleLevel %plane_0, %sampler_2, %33, 0.0f
         %47:f32 = access %46, 0u
         %48:vec4<f32> = textureSampleLevel %plane_1, %sampler_2, %38, 0.0f
@@ -841,8 +841,8 @@
       }
     }
     %52:bool = eq %24, 0u
-    %53:vec3<f32> = if %52 [t: %b7, f: %b8] {  # if_2
-      %b7 = block {  # true
+    %53:vec3<f32> = if %52 [t: $B7, f: $B8] {  # if_2
+      $B7: {  # true
         %54:tint_GammaTransferParams = access %params, 3u
         %55:tint_GammaTransferParams = access %params, 4u
         %56:mat3x3<f32> = access %params, 5u
@@ -851,7 +851,7 @@
         %60:vec3<f32> = call %tint_GammaCorrection, %59, %55
         exit_if %60  # if_2
       }
-      %b8 = block {  # false
+      $B8: {  # false
         exit_if %41  # if_2
       }
     }
@@ -859,8 +859,8 @@
     ret %61
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b9 {  # %params_1: 'params'
-  %b9 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B9: {
     %64:f32 = access %params_1, 0u
     %65:f32 = access %params_1, 1u
     %66:f32 = access %params_1, 2u
@@ -938,18 +938,18 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(1, 2)
 }
 
-%foo = func(%texture_1:texture_external, %sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {  # %texture_1: 'texture'
-  %b2 = block {
+%foo = func(%texture_1:texture_external, %sampler:sampler, %coords:vec2<f32>):vec4<f32> {  # %texture_1: 'texture'
+  $B2: {
     %result:vec4<f32> = textureSampleBaseClampToEdge %texture_1, %sampler, %coords
     ret %result
   }
 }
-%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> -> %b3 {  # %sampler_1: 'sampler', %coords_1: 'coords'
-  %b3 = block {
+%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> {  # %sampler_1: 'sampler', %coords_1: 'coords'
+  $B3: {
     %10:texture_external = load %texture
     %11:vec2<u32> = textureDimensions %10
     %12:texture_external = load %texture
@@ -986,20 +986,20 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
 }
 
-%foo = func(%texture_plane0_1:texture_2d<f32>, %texture_plane1_1:texture_2d<f32>, %texture_params_1:tint_ExternalTextureParams, %sampler:sampler, %coords:vec2<f32>):vec4<f32> -> %b2 {  # %texture_plane0_1: 'texture_plane0', %texture_plane1_1: 'texture_plane1', %texture_params_1: 'texture_params'
-  %b2 = block {
+%foo = func(%texture_plane0_1:texture_2d<f32>, %texture_plane1_1:texture_2d<f32>, %texture_params_1:tint_ExternalTextureParams, %sampler:sampler, %coords:vec2<f32>):vec4<f32> {  # %texture_plane0_1: 'texture_plane0', %texture_plane1_1: 'texture_plane1', %texture_params_1: 'texture_params'
+  $B2: {
     %10:vec4<f32> = call %tint_TextureSampleExternal, %texture_plane0_1, %texture_plane1_1, %texture_params_1, %sampler, %coords
     ret %10
   }
 }
-%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> -> %b3 {  # %sampler_1: 'sampler', %coords_1: 'coords'
-  %b3 = block {
+%bar = func(%sampler_1:sampler, %coords_1:vec2<f32>):vec4<f32> {  # %sampler_1: 'sampler', %coords_1: 'coords'
+  $B3: {
     %15:texture_2d<f32> = load %texture_plane0
     %16:texture_2d<f32> = load %texture_plane1
     %17:tint_ExternalTextureParams = load %texture_params
@@ -1021,8 +1021,8 @@
     ret %32
   }
 }
-%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_2:sampler, %coords_2:vec2<f32>):vec4<f32> -> %b4 {  # %sampler_2: 'sampler', %coords_2: 'coords'
-  %b4 = block {
+%tint_TextureSampleExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %sampler_2:sampler, %coords_2:vec2<f32>):vec4<f32> {  # %sampler_2: 'sampler', %coords_2: 'coords'
+  $B4: {
     %38:u32 = access %params, 1u
     %39:mat3x4<f32> = access %params, 2u
     %40:mat3x2<f32> = access %params, 6u
@@ -1040,14 +1040,14 @@
     %52:vec2<f32> = clamp %42, %50, %51
     %53:u32 = access %params, 0u
     %54:bool = eq %53, 1u
-    %55:vec3<f32>, %56:f32 = if %54 [t: %b5, f: %b6] {  # if_1
-      %b5 = block {  # true
+    %55:vec3<f32>, %56:f32 = if %54 [t: $B5, f: $B6] {  # if_1
+      $B5: {  # true
         %57:vec4<f32> = textureSampleLevel %plane_0, %sampler_2, %47, 0.0f
         %58:vec3<f32> = swizzle %57, xyz
         %59:f32 = access %57, 3u
         exit_if %58, %59  # if_1
       }
-      %b6 = block {  # false
+      $B6: {  # false
         %60:vec4<f32> = textureSampleLevel %plane_0, %sampler_2, %47, 0.0f
         %61:f32 = access %60, 0u
         %62:vec4<f32> = textureSampleLevel %plane_1, %sampler_2, %52, 0.0f
@@ -1058,8 +1058,8 @@
       }
     }
     %66:bool = eq %38, 0u
-    %67:vec3<f32> = if %66 [t: %b7, f: %b8] {  # if_2
-      %b7 = block {  # true
+    %67:vec3<f32> = if %66 [t: $B7, f: $B8] {  # if_2
+      $B7: {  # true
         %68:tint_GammaTransferParams = access %params, 3u
         %69:tint_GammaTransferParams = access %params, 4u
         %70:mat3x3<f32> = access %params, 5u
@@ -1068,7 +1068,7 @@
         %74:vec3<f32> = call %tint_GammaCorrection, %73, %69
         exit_if %74  # if_2
       }
-      %b8 = block {  # false
+      $B8: {  # false
         exit_if %55  # if_2
       }
     }
@@ -1076,8 +1076,8 @@
     ret %75
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b9 {  # %params_1: 'params'
-  %b9 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B9: {
     %78:f32 = access %params_1, 0u
     %79:f32 = access %params_1, 1u
     %80:f32 = access %params_1, 2u
@@ -1139,14 +1139,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture_a:ptr<handle, texture_external, read> = var @binding_point(1, 2)
   %texture_b:ptr<handle, texture_external, read> = var @binding_point(2, 2)
   %texture_c:ptr<handle, texture_external, read> = var @binding_point(3, 2)
 }
 
-%foo = func(%coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):void {
+  $B2: {
     %6:texture_external = load %texture_a
     %7:vec4<f32> = textureLoad %6, %coords
     %8:texture_external = load %texture_b
@@ -1179,7 +1179,7 @@
   coordTransformationMatrix:mat3x2<f32> @offset(176)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %texture_a_plane0:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 2)
   %texture_a_plane1:ptr<handle, texture_2d<f32>, read> = var @binding_point(1, 3)
   %texture_a_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(1, 4)
@@ -1191,8 +1191,8 @@
   %texture_c_params:ptr<uniform, tint_ExternalTextureParams, read> = var @binding_point(3, 4)
 }
 
-%foo = func(%coords:vec2<u32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%coords:vec2<u32>):void {
+  $B2: {
     %12:texture_2d<f32> = load %texture_a_plane0
     %13:texture_2d<f32> = load %texture_a_plane1
     %14:tint_ExternalTextureParams = load %texture_a_params
@@ -1208,20 +1208,20 @@
     ret
   }
 }
-%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%tint_TextureLoadExternal = func(%plane_0:texture_2d<f32>, %plane_1:texture_2d<f32>, %params:tint_ExternalTextureParams, %coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %29:u32 = access %params, 1u
     %30:mat3x4<f32> = access %params, 2u
     %31:u32 = access %params, 0u
     %32:bool = eq %31, 1u
-    %33:vec3<f32>, %34:f32 = if %32 [t: %b4, f: %b5] {  # if_1
-      %b4 = block {  # true
+    %33:vec3<f32>, %34:f32 = if %32 [t: $B4, f: $B5] {  # if_1
+      $B4: {  # true
         %35:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %36:vec3<f32> = swizzle %35, xyz
         %37:f32 = access %35, 3u
         exit_if %36, %37  # if_1
       }
-      %b5 = block {  # false
+      $B5: {  # false
         %38:vec4<f32> = textureLoad %plane_0, %coords_1, 0u
         %39:f32 = access %38, 0u
         %40:vec2<u32> = shr %coords_1, vec2<u32>(1u)
@@ -1233,8 +1233,8 @@
       }
     }
     %45:bool = eq %29, 0u
-    %46:vec3<f32> = if %45 [t: %b6, f: %b7] {  # if_2
-      %b6 = block {  # true
+    %46:vec3<f32> = if %45 [t: $B6, f: $B7] {  # if_2
+      $B6: {  # true
         %47:tint_GammaTransferParams = access %params, 3u
         %48:tint_GammaTransferParams = access %params, 4u
         %49:mat3x3<f32> = access %params, 5u
@@ -1243,7 +1243,7 @@
         %53:vec3<f32> = call %tint_GammaCorrection, %52, %48
         exit_if %53  # if_2
       }
-      %b7 = block {  # false
+      $B7: {  # false
         exit_if %33  # if_2
       }
     }
@@ -1251,8 +1251,8 @@
     ret %54
   }
 }
-%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> -> %b8 {  # %params_1: 'params'
-  %b8 = block {
+%tint_GammaCorrection = func(%v:vec3<f32>, %params_1:tint_GammaTransferParams):vec3<f32> {  # %params_1: 'params'
+  $B8: {
     %57:f32 = access %params_1, 0u
     %58:f32 = access %params_1, 1u
     %59:f32 = access %params_1, 2u
diff --git a/src/tint/lang/core/ir/transform/preserve_padding_test.cc b/src/tint/lang/core/ir/transform/preserve_padding_test.cc
index 82a4ade..83f5942 100644
--- a/src/tint/lang/core/ir/transform/preserve_padding_test.cc
+++ b/src/tint/lang/core/ir/transform/preserve_padding_test.cc
@@ -92,12 +92,12 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<workgroup, MyStruct, read_write> = var
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -131,12 +131,12 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<private, MyStruct, read_write> = var
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -169,8 +169,8 @@
   b:u32 @offset(16)
 }
 
-%foo = func(%value:MyStruct):void -> %b1 {
-  %b1 = block {
+%foo = func(%value:MyStruct):void {
+  $B1: {
     %buffer:ptr<function, MyStruct, read_write> = var
     store %buffer, %value
     ret
@@ -207,12 +207,12 @@
   c:vec4<u32> @offset(32)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -242,12 +242,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, mat4x4<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:mat4x4<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:mat4x4<f32>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -277,12 +277,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<vec4<f32>>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<vec4<f32>>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<vec4<f32>>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -311,12 +311,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, vec3<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:vec3<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:vec3<f32>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -350,12 +350,12 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():MyStruct -> %b2 {
-  %b2 = block {
+%foo = func():MyStruct {
+  $B2: {
     %3:MyStruct = load %buffer
     ret %3
   }
@@ -391,12 +391,12 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -410,18 +410,18 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void {
+  $B3: {
     %8:ptr<storage, vec4<u32>, read_write> = access %target, 0u
     %9:vec4<u32> = access %value_param, 0u
     store %8, %9
@@ -460,12 +460,12 @@
   c:vec4<u32> @offset(32)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -480,18 +480,18 @@
   c:vec4<u32> @offset(32)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void {
+  $B3: {
     %8:ptr<storage, vec4<u32>, read_write> = access %target, 0u
     %9:vec4<u32> = access %value_param, 0u
     store %8, %9
@@ -540,12 +540,12 @@
   inner:MyStruct @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, Outer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:Outer):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:Outer):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -564,26 +564,26 @@
   inner:MyStruct @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, Outer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:Outer):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:Outer):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, Outer, read_write>, %value_param:Outer):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, Outer, read_write>, %value_param:Outer):void {
+  $B3: {
     %8:ptr<storage, MyStruct, read_write> = access %target, 0u
     %9:MyStruct = access %value_param, 0u
     %10:void = call %tint_store_and_preserve_padding_1, %8, %9
     ret
   }
 }
-%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, MyStruct, read_write>, %value_param_1:MyStruct):void -> %b4 {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
-  %b4 = block {
+%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, MyStruct, read_write>, %value_param_1:MyStruct):void {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
+  $B4: {
     %14:ptr<storage, vec4<u32>, read_write> = access %target_1, 0u
     %15:vec4<u32> = access %value_param_1, 0u
     store %14, %15
@@ -625,12 +625,12 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<MyStruct, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<MyStruct, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<MyStruct, 4>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -644,44 +644,44 @@
   b:u32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<MyStruct, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<MyStruct, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<MyStruct, 4>):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, array<MyStruct, 4>, read_write>, %value_param:array<MyStruct, 4>):void -> %b3 {
-  %b3 = block {
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 0u
+%tint_store_and_preserve_padding = func(%target:ptr<storage, array<MyStruct, 4>, read_write>, %value_param:array<MyStruct, 4>):void {
+  $B3: {
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration 0u  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %9:bool = gte %idx:u32, 4u
-        if %9 [t: %b7] {  # if_1
-          %b7 = block {  # true
+        if %9 [t: $B7] {  # if_1
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
         %10:ptr<storage, MyStruct, read_write> = access %target, %idx:u32
         %11:MyStruct = access %value_param, %idx:u32
         %12:void = call %tint_store_and_preserve_padding_1, %10, %11
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %14:u32 = add %idx:u32, 1u
-        next_iteration %b5 %14
+        next_iteration %14  # -> $B5
       }
     }
     ret
   }
 }
-%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, MyStruct, read_write>, %value_param_1:MyStruct):void -> %b8 {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
-  %b8 = block {
+%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, MyStruct, read_write>, %value_param_1:MyStruct):void {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
+  $B8: {
     %17:ptr<storage, vec4<u32>, read_write> = access %target_1, 0u
     %18:vec4<u32> = access %value_param_1, 0u
     store %17, %18
@@ -714,12 +714,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, mat3x3<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:mat3x3<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:mat3x3<f32>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -728,18 +728,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, mat3x3<f32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:mat3x3<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:mat3x3<f32>):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, mat3x3<f32>, read_write>, %value_param:mat3x3<f32>):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, mat3x3<f32>, read_write>, %value_param:mat3x3<f32>):void {
+  $B3: {
     %8:ptr<storage, vec3<f32>, read_write> = access %target, 0u
     %9:vec3<f32> = access %value_param, 0u
     store %8, %9
@@ -784,12 +784,12 @@
   b:mat3x3<f32> @offset(48)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -803,18 +803,18 @@
   b:mat3x3<f32> @offset(48)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:MyStruct):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:MyStruct):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, MyStruct, read_write>, %value_param:MyStruct):void {
+  $B3: {
     %8:ptr<storage, mat3x3<f32>, read_write> = access %target, 0u
     %9:mat3x3<f32> = access %value_param, 0u
     %10:void = call %tint_store_and_preserve_padding_1, %8, %9
@@ -824,8 +824,8 @@
     ret
   }
 }
-%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, mat3x3<f32>, read_write>, %value_param_1:mat3x3<f32>):void -> %b4 {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
-  %b4 = block {
+%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, mat3x3<f32>, read_write>, %value_param_1:mat3x3<f32>):void {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
+  $B4: {
     %17:ptr<storage, vec3<f32>, read_write> = access %target_1, 0u
     %18:vec3<f32> = access %value_param_1, 0u
     store %17, %18
@@ -862,12 +862,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<mat3x3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<mat3x3<f32>, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<mat3x3<f32>, 4>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -876,44 +876,44 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<mat3x3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<mat3x3<f32>, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<mat3x3<f32>, 4>):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, array<mat3x3<f32>, 4>, read_write>, %value_param:array<mat3x3<f32>, 4>):void -> %b3 {
-  %b3 = block {
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 0u
+%tint_store_and_preserve_padding = func(%target:ptr<storage, array<mat3x3<f32>, 4>, read_write>, %value_param:array<mat3x3<f32>, 4>):void {
+  $B3: {
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration 0u  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %9:bool = gte %idx:u32, 4u
-        if %9 [t: %b7] {  # if_1
-          %b7 = block {  # true
+        if %9 [t: $B7] {  # if_1
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
         %10:ptr<storage, mat3x3<f32>, read_write> = access %target, %idx:u32
         %11:mat3x3<f32> = access %value_param, %idx:u32
         %12:void = call %tint_store_and_preserve_padding_1, %10, %11
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %14:u32 = add %idx:u32, 1u
-        next_iteration %b5 %14
+        next_iteration %14  # -> $B5
       }
     }
     ret
   }
 }
-%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, mat3x3<f32>, read_write>, %value_param_1:mat3x3<f32>):void -> %b8 {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
-  %b8 = block {
+%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, mat3x3<f32>, read_write>, %value_param_1:mat3x3<f32>):void {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
+  $B8: {
     %17:ptr<storage, vec3<f32>, read_write> = access %target_1, 0u
     %18:vec3<f32> = access %value_param_1, 0u
     store %17, %18
@@ -949,12 +949,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<vec3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<vec3<f32>, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<vec3<f32>, 4>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -963,37 +963,37 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<vec3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<vec3<f32>, 4>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<vec3<f32>, 4>):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, array<vec3<f32>, 4>, read_write>, %value_param:array<vec3<f32>, 4>):void -> %b3 {
-  %b3 = block {
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 0u
+%tint_store_and_preserve_padding = func(%target:ptr<storage, array<vec3<f32>, 4>, read_write>, %value_param:array<vec3<f32>, 4>):void {
+  $B3: {
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration 0u  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %9:bool = gte %idx:u32, 4u
-        if %9 [t: %b7] {  # if_1
-          %b7 = block {  # true
+        if %9 [t: $B7] {  # if_1
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
         %10:ptr<storage, vec3<f32>, read_write> = access %target, %idx:u32
         %11:vec3<f32> = access %value_param, %idx:u32
         store %10, %11
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %12:u32 = add %idx:u32, 1u
-        next_iteration %b5 %12
+        next_iteration %12  # -> $B5
       }
     }
     ret
@@ -1050,12 +1050,12 @@
   b_1:u32 @offset(736)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<Outer, 3>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<Outer, 3>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<Outer, 3>):void {
+  $B2: {
     store %buffer, %value
     ret
   }
@@ -1078,44 +1078,44 @@
   b_1:u32 @offset(736)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<Outer, 3>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:array<Outer, 3>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:array<Outer, 3>):void {
+  $B2: {
     %4:void = call %tint_store_and_preserve_padding, %buffer, %value
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, array<Outer, 3>, read_write>, %value_param:array<Outer, 3>):void -> %b3 {
-  %b3 = block {
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 0u
+%tint_store_and_preserve_padding = func(%target:ptr<storage, array<Outer, 3>, read_write>, %value_param:array<Outer, 3>):void {
+  $B3: {
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration 0u  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %9:bool = gte %idx:u32, 3u
-        if %9 [t: %b7] {  # if_1
-          %b7 = block {  # true
+        if %9 [t: $B7] {  # if_1
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
         %10:ptr<storage, Outer, read_write> = access %target, %idx:u32
         %11:Outer = access %value_param, %idx:u32
         %12:void = call %tint_store_and_preserve_padding_1, %10, %11
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %14:u32 = add %idx:u32, 1u
-        next_iteration %b5 %14
+        next_iteration %14  # -> $B5
       }
     }
     ret
   }
 }
-%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, Outer, read_write>, %value_param_1:Outer):void -> %b8 {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
-  %b8 = block {
+%tint_store_and_preserve_padding_1 = func(%target_1:ptr<storage, Outer, read_write>, %value_param_1:Outer):void {  # %tint_store_and_preserve_padding_1: 'tint_store_and_preserve_padding', %target_1: 'target', %value_param_1: 'value_param'
+  $B8: {
     %17:ptr<storage, u32, read_write> = access %target_1, 0u
     %18:u32 = access %value_param_1, 0u
     store %17, %18
@@ -1131,8 +1131,8 @@
     ret
   }
 }
-%tint_store_and_preserve_padding_2 = func(%target_2:ptr<storage, Inner, read_write>, %value_param_2:Inner):void -> %b9 {  # %tint_store_and_preserve_padding_2: 'tint_store_and_preserve_padding', %target_2: 'target', %value_param_2: 'value_param'
-  %b9 = block {
+%tint_store_and_preserve_padding_2 = func(%target_2:ptr<storage, Inner, read_write>, %value_param_2:Inner):void {  # %tint_store_and_preserve_padding_2: 'tint_store_and_preserve_padding', %target_2: 'target', %value_param_2: 'value_param'
+  $B9: {
     %31:ptr<storage, u32, read_write> = access %target_2, 0u
     %32:u32 = access %value_param_2, 0u
     store %31, %32
@@ -1148,34 +1148,34 @@
     ret
   }
 }
-%tint_store_and_preserve_padding_4 = func(%target_3:ptr<storage, array<vec3<f32>, 4>, read_write>, %value_param_3:array<vec3<f32>, 4>):void -> %b10 {  # %tint_store_and_preserve_padding_4: 'tint_store_and_preserve_padding', %target_3: 'target', %value_param_3: 'value_param'
-  %b10 = block {
-    loop [i: %b11, b: %b12, c: %b13] {  # loop_2
-      %b11 = block {  # initializer
-        next_iteration %b12 0u
+%tint_store_and_preserve_padding_4 = func(%target_3:ptr<storage, array<vec3<f32>, 4>, read_write>, %value_param_3:array<vec3<f32>, 4>):void {  # %tint_store_and_preserve_padding_4: 'tint_store_and_preserve_padding', %target_3: 'target', %value_param_3: 'value_param'
+  $B10: {
+    loop [i: $B11, b: $B12, c: $B13] {  # loop_2
+      $B11: {  # initializer
+        next_iteration 0u  # -> $B12
       }
-      %b12 = block (%idx_1:u32) {  # body
+      $B12 (%idx_1:u32): {  # body
         %46:bool = gte %idx_1:u32, 4u
-        if %46 [t: %b14] {  # if_2
-          %b14 = block {  # true
+        if %46 [t: $B14] {  # if_2
+          $B14: {  # true
             exit_loop  # loop_2
           }
         }
         %47:ptr<storage, vec3<f32>, read_write> = access %target_3, %idx_1:u32
         %48:vec3<f32> = access %value_param_3, %idx_1:u32
         store %47, %48
-        continue %b13
+        continue  # -> $B13
       }
-      %b13 = block {  # continuing
+      $B13: {  # continuing
         %49:u32 = add %idx_1:u32, 1u
-        next_iteration %b12 %49
+        next_iteration %49  # -> $B12
       }
     }
     ret
   }
 }
-%tint_store_and_preserve_padding_5 = func(%target_4:ptr<storage, mat3x3<f32>, read_write>, %value_param_4:mat3x3<f32>):void -> %b15 {  # %tint_store_and_preserve_padding_5: 'tint_store_and_preserve_padding', %target_4: 'target', %value_param_4: 'value_param'
-  %b15 = block {
+%tint_store_and_preserve_padding_5 = func(%target_4:ptr<storage, mat3x3<f32>, read_write>, %value_param_4:mat3x3<f32>):void {  # %tint_store_and_preserve_padding_5: 'tint_store_and_preserve_padding', %target_4: 'target', %value_param_4: 'value_param'
+  $B15: {
     %52:ptr<storage, vec3<f32>, read_write> = access %target_4, 0u
     %53:vec3<f32> = access %value_param_4, 0u
     store %52, %53
@@ -1188,27 +1188,27 @@
     ret
   }
 }
-%tint_store_and_preserve_padding_3 = func(%target_5:ptr<storage, array<Inner, 4>, read_write>, %value_param_5:array<Inner, 4>):void -> %b16 {  # %tint_store_and_preserve_padding_3: 'tint_store_and_preserve_padding', %target_5: 'target', %value_param_5: 'value_param'
-  %b16 = block {
-    loop [i: %b17, b: %b18, c: %b19] {  # loop_3
-      %b17 = block {  # initializer
-        next_iteration %b18 0u
+%tint_store_and_preserve_padding_3 = func(%target_5:ptr<storage, array<Inner, 4>, read_write>, %value_param_5:array<Inner, 4>):void {  # %tint_store_and_preserve_padding_3: 'tint_store_and_preserve_padding', %target_5: 'target', %value_param_5: 'value_param'
+  $B16: {
+    loop [i: $B17, b: $B18, c: $B19] {  # loop_3
+      $B17: {  # initializer
+        next_iteration 0u  # -> $B18
       }
-      %b18 = block (%idx_2:u32) {  # body
+      $B18 (%idx_2:u32): {  # body
         %61:bool = gte %idx_2:u32, 4u
-        if %61 [t: %b20] {  # if_3
-          %b20 = block {  # true
+        if %61 [t: $B20] {  # if_3
+          $B20: {  # true
             exit_loop  # loop_3
           }
         }
         %62:ptr<storage, Inner, read_write> = access %target_5, %idx_2:u32
         %63:Inner = access %value_param_5, %idx_2:u32
         %64:void = call %tint_store_and_preserve_padding_2, %62, %63
-        continue %b19
+        continue  # -> $B19
       }
-      %b19 = block {  # continuing
+      $B19: {  # continuing
         %65:u32 = add %idx_2:u32, 1u
-        next_iteration %b18 %65
+        next_iteration %65  # -> $B18
       }
     }
     ret
@@ -1241,12 +1241,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<mat3x3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:mat3x3<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:mat3x3<f32>):void {
+  $B2: {
     %4:ptr<storage, mat3x3<f32>, read_write> = access %buffer, 0u
     store %4, %value
     %5:ptr<storage, mat3x3<f32>, read_write> = access %buffer, 1u
@@ -1262,12 +1262,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, array<mat3x3<f32>, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%value:mat3x3<f32>):void -> %b2 {
-  %b2 = block {
+%foo = func(%value:mat3x3<f32>):void {
+  $B2: {
     %4:ptr<storage, mat3x3<f32>, read_write> = access %buffer, 0u
     %5:void = call %tint_store_and_preserve_padding, %4, %value
     %7:ptr<storage, mat3x3<f32>, read_write> = access %buffer, 1u
@@ -1279,8 +1279,8 @@
     ret
   }
 }
-%tint_store_and_preserve_padding = func(%target:ptr<storage, mat3x3<f32>, read_write>, %value_param:mat3x3<f32>):void -> %b3 {
-  %b3 = block {
+%tint_store_and_preserve_padding = func(%target:ptr<storage, mat3x3<f32>, read_write>, %value_param:mat3x3<f32>):void {
+  $B3: {
     %15:ptr<storage, vec3<f32>, read_write> = access %target, 0u
     %16:vec3<f32> = access %value_param, 0u
     store %15, %16
diff --git a/src/tint/lang/core/ir/transform/robustness_test.cc b/src/tint/lang/core/ir/transform/robustness_test.cc
index 5865509..1829c79 100644
--- a/src/tint/lang/core/ir/transform/robustness_test.cc
+++ b/src/tint/lang/core/ir/transform/robustness_test.cc
@@ -66,8 +66,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:u32 = load_vector_element %vec, 5u
     ret %3
@@ -77,8 +77,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:u32 = load_vector_element %vec, 3u
     ret %3
@@ -103,8 +103,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %idx:u32 = let 5u
     %4:u32 = load_vector_element %vec, %idx
@@ -115,8 +115,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %idx:u32 = let 5u
     %4:u32 = min %idx, 3u
@@ -144,8 +144,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = load_vector_element %vec, %idx
     ret %4
@@ -155,8 +155,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
@@ -183,8 +183,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:i32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = load_vector_element %vec, %idx
     ret %4
@@ -194,8 +194,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:i32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = convert %idx
     %5:u32 = min %4, 3u
@@ -221,8 +221,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, 5u, 0u
     ret
@@ -232,8 +232,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, 3u, 0u
     ret
@@ -258,8 +258,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %idx:u32 = let 5u
     store_vector_element %vec, %idx, 0u
@@ -270,8 +270,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %idx:u32 = let 5u
     %4:u32 = min %idx, 3u
@@ -299,8 +299,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):void -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, %idx, 0u
     ret
@@ -310,8 +310,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):void -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
@@ -338,8 +338,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:i32):void -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, %idx, 0u
     ret
@@ -349,8 +349,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:i32):void -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %4:u32 = convert %idx
     %5:u32 = min %4, 3u
@@ -377,8 +377,8 @@
     });
 
     auto* src = R"(
-%foo = func():vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func():vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %mat, 2u
     %4:vec4<f32> = load %3
@@ -408,8 +408,8 @@
     });
 
     auto* src = R"(
-%foo = func():vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func():vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %idx:u32 = let 2u
     %4:ptr<function, vec4<f32>, read_write> = access %mat, %idx
@@ -421,8 +421,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func():vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %idx:u32 = let 2u
     %4:u32 = min %idx, 3u
@@ -452,8 +452,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %4:ptr<function, vec4<f32>, read_write> = access %mat, %idx
     %5:vec4<f32> = load %4
@@ -464,8 +464,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %4:u32 = min %idx, 3u
     %5:ptr<function, vec4<f32>, read_write> = access %mat, %4
@@ -494,8 +494,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %4:ptr<function, vec4<f32>, read_write> = access %mat, %idx
     %5:vec4<f32> = load %4
@@ -506,8 +506,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):vec4<f32> {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %4:u32 = convert %idx
     %5:u32 = min %4, 3u
@@ -535,8 +535,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %arr, 2u
     %4:u32 = load %3
@@ -566,8 +566,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %idx:u32 = let 2u
     %4:ptr<function, u32, read_write> = access %arr, %idx
@@ -579,8 +579,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %idx:u32 = let 2u
     %4:u32 = min %idx, 3u
@@ -610,8 +610,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %4:ptr<function, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
@@ -622,8 +622,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %4:u32 = min %idx, 3u
     %5:ptr<function, u32, read_write> = access %arr, %4
@@ -652,8 +652,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:i32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %4:ptr<function, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
@@ -664,8 +664,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:i32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:i32):u32 {
+  $B1: {
     %arr:ptr<function, array<u32, 4>, read_write> = var
     %4:u32 = convert %idx
     %5:u32 = min %4, 3u
@@ -699,8 +699,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx1:u32, %idx2:u32, %idx3:u32, %idx4:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx1:u32, %idx2:u32, %idx3:u32, %idx4:u32):u32 {
+  $B1: {
     %arr:ptr<function, array<array<array<array<u32, 4>, 5>, 6>, 7>, read_write> = var
     %7:ptr<function, u32, read_write> = access %arr, %idx1, %idx2, %idx3, %idx4
     %8:u32 = load %7
@@ -711,8 +711,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx1:u32, %idx2:u32, %idx3:u32, %idx4:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx1:u32, %idx2:u32, %idx3:u32, %idx4:u32):u32 {
+  $B1: {
     %arr:ptr<function, array<array<array<array<u32, 4>, 5>, 6>, 7>, read_write> = var
     %7:u32 = min %idx1, 6u
     %8:u32 = min %idx2, 5u
@@ -755,8 +755,8 @@
   arr:array<mat3x4<f32>, 4> @offset(0)
 }
 
-%foo = func(%idx1:u32, %idx2:u32, %idx3:u32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx1:u32, %idx2:u32, %idx3:u32):vec4<f32> {
+  $B1: {
     %arr:ptr<function, array<structure, 8>, read_write> = var
     %6:ptr<function, vec4<f32>, read_write> = access %arr, %idx1, 0u, %idx2, %idx3
     %7:vec4<f32> = load %6
@@ -771,8 +771,8 @@
   arr:array<mat3x4<f32>, 4> @offset(0)
 }
 
-%foo = func(%idx1:u32, %idx2:u32, %idx3:u32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%idx1:u32, %idx2:u32, %idx3:u32):vec4<f32> {
+  $B1: {
     %arr:ptr<function, array<structure, 8>, read_write> = var
     %6:u32 = min %idx1, 7u
     %7:u32 = min %idx2, 3u
@@ -808,12 +808,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<private, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = load_vector_element %vec, %idx
     ret %4
   }
@@ -822,12 +822,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<private, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
     ret %5
@@ -855,12 +855,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<private, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     store_vector_element %vec, %idx, 0u
     ret
   }
@@ -869,12 +869,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<private, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
     ret
@@ -903,12 +903,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<private, array<u32, 4>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<private, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -918,12 +918,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<private, array<u32, 4>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:ptr<private, u32, read_write> = access %arr, %4
     %6:u32 = load %5
@@ -952,12 +952,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<push_constant, vec4<u32>, read> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = load_vector_element %vec, %idx
     ret %4
   }
@@ -966,12 +966,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<push_constant, vec4<u32>, read> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
     ret %5
@@ -999,12 +999,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<push_constant, vec4<u32>, read> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     store_vector_element %vec, %idx, 0u
     ret
   }
@@ -1013,12 +1013,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<push_constant, vec4<u32>, read> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
     ret
@@ -1047,12 +1047,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<push_constant, array<u32, 4>, read> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<push_constant, u32, read> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1062,12 +1062,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<push_constant, array<u32, 4>, read> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:ptr<push_constant, u32, read> = access %arr, %4
     %6:u32 = load %5
@@ -1097,12 +1097,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<storage, vec4<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = load_vector_element %vec, %idx
     ret %4
   }
@@ -1111,12 +1111,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<storage, vec4<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
     ret %5
@@ -1145,12 +1145,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<storage, vec4<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     store_vector_element %vec, %idx, 0u
     ret
   }
@@ -1159,12 +1159,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<storage, vec4<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
     ret
@@ -1194,12 +1194,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<storage, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1209,12 +1209,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32, 4>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:ptr<storage, u32, read_write> = access %arr, %4
     %6:u32 = load %5
@@ -1244,12 +1244,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<uniform, vec4<u32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = load_vector_element %vec, %idx
     ret %4
   }
@@ -1258,12 +1258,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<uniform, vec4<u32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
     ret %5
@@ -1292,12 +1292,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<uniform, vec4<u32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     store_vector_element %vec, %idx, 0u
     ret
   }
@@ -1306,12 +1306,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<uniform, vec4<u32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
     ret
@@ -1341,12 +1341,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<uniform, array<u32, 4>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<uniform, u32, read> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1356,12 +1356,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<uniform, array<u32, 4>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:ptr<uniform, u32, read> = access %arr, %4
     %6:u32 = load %5
@@ -1390,12 +1390,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<workgroup, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = load_vector_element %vec, %idx
     ret %4
   }
@@ -1404,12 +1404,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<workgroup, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:u32 = load_vector_element %vec, %4
     ret %5
@@ -1437,12 +1437,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<workgroup, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     store_vector_element %vec, %idx, 0u
     ret
   }
@@ -1451,12 +1451,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %vec:ptr<workgroup, vec4<u32>, read_write> = var
 }
 
-%foo = func(%idx:u32):void -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):void {
+  $B2: {
     %4:u32 = min %idx, 3u
     store_vector_element %vec, %4, 0u
     ret
@@ -1485,12 +1485,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<workgroup, array<u32, 4>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<workgroup, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1500,12 +1500,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<workgroup, array<u32, 4>, read_write> = var
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = min %idx, 3u
     %5:ptr<workgroup, u32, read_write> = access %arr, %4
     %6:u32 = load %5
@@ -1541,8 +1541,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %3:u32 = access vec4<u32>(1u, 2u, 3u, 4u), %idx
     ret %3
   }
@@ -1551,8 +1551,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %3:u32 = min %idx, 3u
     %4:u32 = access vec4<u32>(1u, 2u, 3u, 4u), %3
     ret %4
@@ -1584,8 +1584,8 @@
     });
 
     auto* src = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %3:u32 = access array<u32, 4>(1u, 2u, 3u, 4u), %idx
     ret %3
   }
@@ -1594,8 +1594,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%idx:u32):u32 {
+  $B1: {
     %3:u32 = min %idx, 3u
     %4:u32 = access array<u32, 4>(1u, 2u, 3u, 4u), %3
     ret %4
@@ -1621,8 +1621,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arr:array<u32, 4>, %idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arr:array<u32, 4>, %idx:u32):u32 {
+  $B1: {
     %4:u32 = access %arr, %idx
     ret %4
   }
@@ -1631,8 +1631,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arr:array<u32, 4>, %idx:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arr:array<u32, 4>, %idx:u32):u32 {
+  $B1: {
     %4:u32 = min %idx, 3u
     %5:u32 = access %arr, %4
     ret %5
@@ -1666,12 +1666,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, u32, read_write> = access %arr, 42u
     %4:u32 = load %3
     ret %4
@@ -1681,12 +1681,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:u32 = arrayLength %arr
     %4:u32 = sub %3, 1u
     %5:u32 = min 42u, %4
@@ -1719,12 +1719,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<storage, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1734,12 +1734,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = arrayLength %arr
     %5:u32 = sub %4, 1u
     %6:u32 = min %idx, %5
@@ -1779,12 +1779,12 @@
   arr:array<u32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, structure, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, u32, read_write> = access %buffer, 0u, 42u
     %4:u32 = load %3
     ret %4
@@ -1798,12 +1798,12 @@
   arr:array<u32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, structure, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, array<u32>, read_write> = access %buffer, 0u
     %4:u32 = arrayLength %3
     %5:u32 = sub %4, 1u
@@ -1846,12 +1846,12 @@
   arr:array<u32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, structure, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<storage, u32, read_write> = access %buffer, 0u, %idx
     %5:u32 = load %4
     ret %5
@@ -1865,12 +1865,12 @@
   arr:array<u32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, structure, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<storage, array<u32>, read_write> = access %buffer, 0u
     %5:u32 = arrayLength %4
     %6:u32 = sub %5, 1u
@@ -1904,12 +1904,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:ptr<storage, u32, read_write> = access %arr, %idx
     %5:u32 = load %4
     ret %5
@@ -1919,12 +1919,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %arr:ptr<storage, array<u32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%idx:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%idx:u32):u32 {
+  $B2: {
     %4:u32 = arrayLength %arr
     %5:u32 = sub %4, 1u
     %6:u32 = min %idx, %5
@@ -1962,12 +1962,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func():vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<u32> {
+  $B2: {
     %3:texture_2d<f32> = load %texture
     %4:vec2<u32> = textureDimensions %3
     ret %4
@@ -2002,12 +2002,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%level:u32):vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func(%level:u32):vec2<u32> {
+  $B2: {
     %4:texture_2d<f32> = load %texture
     %5:vec2<u32> = textureDimensions %4, %level
     ret %5
@@ -2017,12 +2017,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%level:u32):vec2<u32> -> %b2 {
-  %b2 = block {
+%foo = func(%level:u32):vec2<u32> {
+  $B2: {
     %4:texture_2d<f32> = load %texture
     %5:u32 = textureNumLevels %4
     %6:u32 = sub %5, 1u
@@ -2074,19 +2074,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_1d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_1d<f32> = load %texture
     %6:vec4<f32> = textureLoad %5, %coords, %level
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:u32, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %10:texture_1d<f32> = load %texture
     %11:vec4<f32> = textureLoad %10, %coords_1, %level_1
     ret %11
@@ -2096,12 +2096,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_1d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_1d<f32> = load %texture
     %6:u32 = textureDimensions %5
     %7:u32 = sub %6, 1u
@@ -2115,8 +2115,8 @@
     ret %14
   }
 }
-%load_unsigned = func(%coords_1:u32, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %18:texture_1d<f32> = load %texture
     %19:u32 = textureDimensions %18
     %20:u32 = sub %19, 1u
@@ -2171,19 +2171,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_2d<f32> = load %texture
     %6:vec4<f32> = textureLoad %5, %coords, %level
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %10:texture_2d<f32> = load %texture
     %11:vec4<f32> = textureLoad %10, %coords_1, %level_1
     ret %11
@@ -2193,12 +2193,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_2d<f32> = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -2212,8 +2212,8 @@
     ret %14
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %18:texture_2d<f32> = load %texture
     %19:vec2<u32> = textureDimensions %18
     %20:vec2<u32> = sub %19, vec2<u32>(1u)
@@ -2271,19 +2271,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d_array<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):vec4<f32> {
+  $B2: {
     %6:texture_2d_array<f32> = load %texture
     %7:vec4<f32> = textureLoad %6, %coords, %layer, %level
     ret %7
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
+  $B3: {
     %12:texture_2d_array<f32> = load %texture
     %13:vec4<f32> = textureLoad %12, %coords_1, %layer_1, %level_1
     ret %13
@@ -2293,12 +2293,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_2d_array<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):vec4<f32> {
+  $B2: {
     %6:texture_2d_array<f32> = load %texture
     %7:vec2<u32> = textureDimensions %6
     %8:vec2<u32> = sub %7, vec2<u32>(1u)
@@ -2316,8 +2316,8 @@
     ret %19
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
+  $B3: {
     %24:texture_2d_array<f32> = load %texture
     %25:vec2<u32> = textureDimensions %24
     %26:vec2<u32> = sub %25, vec2<u32>(1u)
@@ -2375,19 +2375,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_3d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_3d<f32> = load %texture
     %6:vec4<f32> = textureLoad %5, %coords, %level
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %10:texture_3d<f32> = load %texture
     %11:vec4<f32> = textureLoad %10, %coords_1, %level_1
     ret %11
@@ -2397,12 +2397,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_3d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_3d<f32> = load %texture
     %6:vec3<u32> = textureDimensions %5
     %7:vec3<u32> = sub %6, vec3<u32>(1u)
@@ -2416,8 +2416,8 @@
     ret %14
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %18:texture_3d<f32> = load %texture
     %19:vec3<u32> = textureDimensions %18
     %20:vec3<u32> = sub %19, vec3<u32>(1u)
@@ -2473,19 +2473,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_multisampled_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_multisampled_2d<f32> = load %texture
     %6:vec4<f32> = textureLoad %5, %coords, %level
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %10:texture_multisampled_2d<f32> = load %texture
     %11:vec4<f32> = textureLoad %10, %coords_1, %level_1
     ret %11
@@ -2495,12 +2495,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_multisampled_2d<f32>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):vec4<f32> {
+  $B2: {
     %5:texture_multisampled_2d<f32> = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -2510,8 +2510,8 @@
     ret %10
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):vec4<f32> {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %14:texture_multisampled_2d<f32> = load %texture
     %15:vec2<u32> = textureDimensions %14
     %16:vec2<u32> = sub %15, vec2<u32>(1u)
@@ -2560,19 +2560,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_2d, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):f32 {
+  $B2: {
     %5:texture_depth_2d = load %texture
     %6:f32 = textureLoad %5, %coords, %level
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):f32 {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %10:texture_depth_2d = load %texture
     %11:f32 = textureLoad %10, %coords_1, %level_1
     ret %11
@@ -2582,12 +2582,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_2d, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %level:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %level:i32):f32 {
+  $B2: {
     %5:texture_depth_2d = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -2601,8 +2601,8 @@
     ret %14
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %level_1:u32):f32 {  # %coords_1: 'coords', %level_1: 'level'
+  $B3: {
     %18:texture_depth_2d = load %texture
     %19:vec2<u32> = textureDimensions %18
     %20:vec2<u32> = sub %19, vec2<u32>(1u)
@@ -2659,19 +2659,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_2d_array, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):f32 {
+  $B2: {
     %6:texture_depth_2d_array = load %texture
     %7:f32 = textureLoad %6, %coords, %layer, %level
     ret %7
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):f32 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
+  $B3: {
     %12:texture_depth_2d_array = load %texture
     %13:f32 = textureLoad %12, %coords_1, %layer_1, %level_1
     ret %13
@@ -2681,12 +2681,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_2d_array, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %level:i32):f32 {
+  $B2: {
     %6:texture_depth_2d_array = load %texture
     %7:vec2<u32> = textureDimensions %6
     %8:vec2<u32> = sub %7, vec2<u32>(1u)
@@ -2704,8 +2704,8 @@
     ret %19
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %level_1:u32):f32 {  # %coords_1: 'coords', %layer_1: 'layer', %level_1: 'level'
+  $B3: {
     %24:texture_depth_2d_array = load %texture
     %25:vec2<u32> = textureDimensions %24
     %26:vec2<u32> = sub %25, vec2<u32>(1u)
@@ -2761,19 +2761,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_multisampled_2d, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %index:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %index:i32):f32 {
+  $B2: {
     %5:texture_depth_multisampled_2d = load %texture
     %6:f32 = textureLoad %5, %coords, %index
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %index_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %index_1: 'index'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %index_1:u32):f32 {  # %coords_1: 'coords', %index_1: 'index'
+  $B3: {
     %10:texture_depth_multisampled_2d = load %texture
     %11:f32 = textureLoad %10, %coords_1, %index_1
     ret %11
@@ -2783,12 +2783,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_depth_multisampled_2d, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %index:i32):f32 -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %index:i32):f32 {
+  $B2: {
     %5:texture_depth_multisampled_2d = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -2798,8 +2798,8 @@
     ret %10
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %index_1:u32):f32 -> %b3 {  # %coords_1: 'coords', %index_1: 'index'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %index_1:u32):f32 {  # %coords_1: 'coords', %index_1: 'index'
+  $B3: {
     %14:texture_depth_multisampled_2d = load %texture
     %15:vec2<u32> = textureDimensions %14
     %16:vec2<u32> = sub %15, vec2<u32>(1u)
@@ -2845,19 +2845,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %4:texture_external = load %texture
     %5:vec4<f32> = textureLoad %4, %coords
     ret %5
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %8:texture_external = load %texture
     %9:vec4<f32> = textureLoad %8, %coords_1
     ret %9
@@ -2867,12 +2867,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_external, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %4:texture_external = load %texture
     %5:vec2<u32> = textureDimensions %4
     %6:vec2<u32> = sub %5, vec2<u32>(1u)
@@ -2882,8 +2882,8 @@
     ret %9
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %12:texture_external = load %texture
     %13:vec2<u32> = textureDimensions %12
     %14:vec2<u32> = sub %13, vec2<u32>(1u)
@@ -2935,19 +2935,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_1d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32):vec4<f32> {
+  $B2: {
     %4:texture_storage_1d<rgba8unorm, read_write> = load %texture
     %5:vec4<f32> = textureLoad %4, %coords
     ret %5
   }
 }
-%load_unsigned = func(%coords_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %8:texture_storage_1d<rgba8unorm, read_write> = load %texture
     %9:vec4<f32> = textureLoad %8, %coords_1
     ret %9
@@ -2957,12 +2957,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_1d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32):vec4<f32> {
+  $B2: {
     %4:texture_storage_1d<rgba8unorm, read_write> = load %texture
     %5:u32 = textureDimensions %4
     %6:u32 = sub %5, 1u
@@ -2972,8 +2972,8 @@
     ret %9
   }
 }
-%load_unsigned = func(%coords_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %12:texture_storage_1d<rgba8unorm, read_write> = load %texture
     %13:u32 = textureDimensions %12
     %14:u32 = sub %13, 1u
@@ -3025,19 +3025,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_2d<rgba8unorm, read_write> = load %texture
     %5:vec4<f32> = textureLoad %4, %coords
     ret %5
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %8:texture_storage_2d<rgba8unorm, read_write> = load %texture
     %9:vec4<f32> = textureLoad %8, %coords_1
     ret %9
@@ -3047,12 +3047,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_2d<rgba8unorm, read_write> = load %texture
     %5:vec2<u32> = textureDimensions %4
     %6:vec2<u32> = sub %5, vec2<u32>(1u)
@@ -3062,8 +3062,8 @@
     ret %9
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %12:texture_storage_2d<rgba8unorm, read_write> = load %texture
     %13:vec2<u32> = textureDimensions %12
     %14:vec2<u32> = sub %13, vec2<u32>(1u)
@@ -3119,19 +3119,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32):vec4<f32> {
+  $B2: {
     %5:texture_storage_2d_array<rgba8unorm, read_write> = load %texture
     %6:vec4<f32> = textureLoad %5, %coords, %layer
     ret %6
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32):vec4<f32> {  # %coords_1: 'coords', %layer_1: 'layer'
+  $B3: {
     %10:texture_storage_2d_array<rgba8unorm, read_write> = load %texture
     %11:vec4<f32> = textureLoad %10, %coords_1, %layer_1
     ret %11
@@ -3141,12 +3141,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32):vec4<f32> {
+  $B2: {
     %5:texture_storage_2d_array<rgba8unorm, read_write> = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -3160,8 +3160,8 @@
     ret %14
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32):vec4<f32> -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32):vec4<f32> {  # %coords_1: 'coords', %layer_1: 'layer'
+  $B3: {
     %18:texture_storage_2d_array<rgba8unorm, read_write> = load %texture
     %19:vec2<u32> = textureDimensions %18
     %20:vec2<u32> = sub %19, vec2<u32>(1u)
@@ -3216,19 +3216,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_3d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_3d<rgba8unorm, read_write> = load %texture
     %5:vec4<f32> = textureLoad %4, %coords
     ret %5
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %8:texture_storage_3d<rgba8unorm, read_write> = load %texture
     %9:vec4<f32> = textureLoad %8, %coords_1
     ret %9
@@ -3238,12 +3238,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_3d<rgba8unorm, read_write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>):vec4<f32> -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>):vec4<f32> {
+  $B2: {
     %4:texture_storage_3d<rgba8unorm, read_write> = load %texture
     %5:vec3<u32> = textureDimensions %4
     %6:vec3<u32> = sub %5, vec3<u32>(1u)
@@ -3253,8 +3253,8 @@
     ret %9
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>):vec4<f32> -> %b3 {  # %coords_1: 'coords'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>):vec4<f32> {  # %coords_1: 'coords'
+  $B3: {
     %12:texture_storage_3d<rgba8unorm, read_write> = load %texture
     %13:vec3<u32> = textureDimensions %12
     %14:vec3<u32> = sub %13, vec3<u32>(1u)
@@ -3308,19 +3308,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_1d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_1d<rgba8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %value
     ret
   }
 }
-%load_unsigned = func(%coords_1:u32, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %10:texture_storage_1d<rgba8unorm, write> = load %texture
     %11:void = textureStore %10, %coords_1, %value_1
     ret
@@ -3330,12 +3330,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_1d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:i32, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:i32, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_1d<rgba8unorm, write> = load %texture
     %6:u32 = textureDimensions %5
     %7:u32 = sub %6, 1u
@@ -3345,8 +3345,8 @@
     ret
   }
 }
-%load_unsigned = func(%coords_1:u32, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:u32, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %14:texture_storage_1d<rgba8unorm, write> = load %texture
     %15:u32 = textureDimensions %14
     %16:u32 = sub %15, 1u
@@ -3400,19 +3400,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_2d<rgba8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %value
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %10:texture_storage_2d<rgba8unorm, write> = load %texture
     %11:void = textureStore %10, %coords_1, %value_1
     ret
@@ -3422,12 +3422,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_2d<rgba8unorm, write> = load %texture
     %6:vec2<u32> = textureDimensions %5
     %7:vec2<u32> = sub %6, vec2<u32>(1u)
@@ -3437,8 +3437,8 @@
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %14:texture_storage_2d<rgba8unorm, write> = load %texture
     %15:vec2<u32> = textureDimensions %14
     %16:vec2<u32> = sub %15, vec2<u32>(1u)
@@ -3494,19 +3494,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %value:vec4<f32>):void {
+  $B2: {
     %6:texture_storage_2d_array<rgba8unorm, write> = load %texture
     %7:void = textureStore %6, %coords, %layer, %value
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %layer_1: 'layer', %value_1: 'value'
+  $B3: {
     %12:texture_storage_2d_array<rgba8unorm, write> = load %texture
     %13:void = textureStore %12, %coords_1, %layer_1, %value_1
     ret
@@ -3516,12 +3516,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_2d_array<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec2<i32>, %layer:i32, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec2<i32>, %layer:i32, %value:vec4<f32>):void {
+  $B2: {
     %6:texture_storage_2d_array<rgba8unorm, write> = load %texture
     %7:vec2<u32> = textureDimensions %6
     %8:vec2<u32> = sub %7, vec2<u32>(1u)
@@ -3535,8 +3535,8 @@
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %layer_1: 'layer', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec2<u32>, %layer_1:u32, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %layer_1: 'layer', %value_1: 'value'
+  $B3: {
     %20:texture_storage_2d_array<rgba8unorm, write> = load %texture
     %21:vec2<u32> = textureDimensions %20
     %22:vec2<u32> = sub %21, vec2<u32>(1u)
@@ -3593,19 +3593,19 @@
     }
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_3d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_3d<rgba8unorm, write> = load %texture
     %6:void = textureStore %5, %coords, %value
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %10:texture_storage_3d<rgba8unorm, write> = load %texture
     %11:void = textureStore %10, %coords_1, %value_1
     ret
@@ -3615,12 +3615,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %texture:ptr<handle, texture_storage_3d<rgba8unorm, write>, read> = var @binding_point(0, 0)
 }
 
-%load_signed = func(%coords:vec3<i32>, %value:vec4<f32>):void -> %b2 {
-  %b2 = block {
+%load_signed = func(%coords:vec3<i32>, %value:vec4<f32>):void {
+  $B2: {
     %5:texture_storage_3d<rgba8unorm, write> = load %texture
     %6:vec3<u32> = textureDimensions %5
     %7:vec3<u32> = sub %6, vec3<u32>(1u)
@@ -3630,8 +3630,8 @@
     ret
   }
 }
-%load_unsigned = func(%coords_1:vec3<u32>, %value_1:vec4<f32>):void -> %b3 {  # %coords_1: 'coords', %value_1: 'value'
-  %b3 = block {
+%load_unsigned = func(%coords_1:vec3<u32>, %value_1:vec4<f32>):void {  # %coords_1: 'coords', %value_1: 'value'
+  $B3: {
     %14:texture_storage_3d<rgba8unorm, write> = load %texture
     %15:vec3<u32> = textureDimensions %14
     %16:vec3<u32> = sub %15, vec3<u32>(1u)
diff --git a/src/tint/lang/core/ir/transform/std140_test.cc b/src/tint/lang/core/ir/transform/std140_test.cc
index b12a51d..4b819bb 100644
--- a/src/tint/lang/core/ir/transform/std140_test.cc
+++ b/src/tint/lang/core/ir/transform/std140_test.cc
@@ -48,8 +48,8 @@
     func->Block()->Append(b.Return(func));
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     ret
   }
 }
@@ -83,12 +83,12 @@
   a:mat2x4<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat2x4<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat2x4<f32> {
+  $B2: {
     %3:ptr<uniform, mat2x4<f32>, read> = access %buffer, 0u
     %4:mat2x4<f32> = load %3
     ret %4
@@ -127,12 +127,12 @@
   a:mat2x4<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<storage, MyStruct, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():mat2x4<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat2x4<f32> {
+  $B2: {
     %3:ptr<storage, mat2x4<f32>, read_write> = access %buffer, 0u
     %4:mat2x4<f32> = load %3
     ret %4
@@ -172,12 +172,12 @@
   arr:array<mat2x2<f32>, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat2x2<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat2x2<f32> {
+  $B2: {
     %3:ptr<uniform, mat2x2<f32>, read> = access %buffer, 0u, 2u
     %4:mat2x2<f32> = load %3
     ret %4
@@ -216,12 +216,12 @@
   a:mat3x2<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat3x2<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat3x2<f32> {
+  $B2: {
     %3:ptr<uniform, mat3x2<f32>, read> = access %buffer, 0u
     %4:mat3x2<f32> = load %3
     ret %4
@@ -241,12 +241,12 @@
   a_col2:vec2<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat3x2<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat3x2<f32> {
+  $B2: {
     %3:ptr<uniform, vec2<f32>, read> = access %buffer, 0u
     %4:vec2<f32> = load %3
     %5:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
@@ -287,12 +287,12 @@
   a:mat3x2<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():vec2<f32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<f32> {
+  $B2: {
     %3:ptr<uniform, vec2<f32>, read> = access %buffer, 0u, 1u
     %4:vec2<f32> = load %3
     ret %4
@@ -312,12 +312,12 @@
   a_col2:vec2<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():vec2<f32> -> %b2 {
-  %b2 = block {
+%foo = func():vec2<f32> {
+  $B2: {
     %3:ptr<uniform, vec2<f32>, read> = access %buffer, 0u
     %4:vec2<f32> = load %3
     %5:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
@@ -359,12 +359,12 @@
   a:mat3x2<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():f32 -> %b2 {
-  %b2 = block {
+%foo = func():f32 {
+  $B2: {
     %3:ptr<uniform, vec2<f32>, read> = access %buffer, 0u, 1u
     %4:f32 = load_vector_element %3, 1u
     ret %4
@@ -384,12 +384,12 @@
   a_col2:vec2<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():f32 -> %b2 {
-  %b2 = block {
+%foo = func():f32 {
+  $B2: {
     %3:ptr<uniform, vec2<f32>, read> = access %buffer, 0u
     %4:vec2<f32> = load %3
     %5:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
@@ -431,12 +431,12 @@
   a:mat3x2<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():MyStruct -> %b2 {
-  %b2 = block {
+%foo = func():MyStruct {
+  $B2: {
     %3:MyStruct = load %buffer
     ret %3
   }
@@ -455,19 +455,19 @@
   a_col2:vec2<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():MyStruct -> %b2 {
-  %b2 = block {
+%foo = func():MyStruct {
+  $B2: {
     %3:MyStruct_std140 = load %buffer
     %4:MyStruct = call %convert_MyStruct, %3
     ret %4
   }
 }
-%convert_MyStruct = func(%input:MyStruct_std140):MyStruct -> %b3 {
-  %b3 = block {
+%convert_MyStruct = func(%input:MyStruct_std140):MyStruct {
+  $B3: {
     %7:vec2<f32> = access %input, 0u
     %8:vec2<f32> = access %input, 1u
     %9:vec2<f32> = access %input, 2u
@@ -513,12 +513,12 @@
   arr:array<Inner, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Outer -> %b2 {
-  %b2 = block {
+%foo = func():Outer {
+  $B2: {
     %3:Outer = load %buffer
     ret %3
   }
@@ -545,29 +545,29 @@
   arr:array<Inner_std140, 4> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Outer -> %b2 {
-  %b2 = block {
+%foo = func():Outer {
+  $B2: {
     %3:Outer_std140 = load %buffer
     %4:Outer = call %convert_Outer, %3
     ret %4
   }
 }
-%convert_Outer = func(%input:Outer_std140):Outer -> %b3 {
-  %b3 = block {
+%convert_Outer = func(%input:Outer_std140):Outer {
+  $B3: {
     %7:array<Inner_std140, 4> = access %input, 0u
     %8:ptr<function, array<Inner, 4>, read_write> = var
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 0u
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration 0u  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %10:bool = gte %idx:u32, 4u
-        if %10 [t: %b7] {  # if_1
-          %b7 = block {  # true
+        if %10 [t: $B7] {  # if_1
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
@@ -575,11 +575,11 @@
         %12:Inner_std140 = access %7, %idx:u32
         %13:Inner = call %convert_Inner, %12
         store %11, %13
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %15:u32 = add %idx:u32, 1u
-        next_iteration %b5 %15
+        next_iteration %15  # -> $B5
       }
     }
     %16:array<Inner, 4> = load %8
@@ -587,8 +587,8 @@
     ret %17
   }
 }
-%convert_Inner = func(%input_1:Inner_std140):Inner -> %b8 {  # %input_1: 'input'
-  %b8 = block {
+%convert_Inner = func(%input_1:Inner_std140):Inner {  # %input_1: 'input'
+  $B8: {
     %19:vec2<f32> = access %input_1, 0u
     %20:vec2<f32> = access %input_1, 1u
     %21:vec2<f32> = access %input_1, 2u
@@ -633,12 +633,12 @@
   inner:Inner @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Inner -> %b2 {
-  %b2 = block {
+%foo = func():Inner {
+  $B2: {
     %3:ptr<uniform, Inner, read> = access %buffer, 0u
     %4:Inner = load %3
     ret %4
@@ -666,20 +666,20 @@
   inner:Inner_std140 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Inner -> %b2 {
-  %b2 = block {
+%foo = func():Inner {
+  $B2: {
     %3:ptr<uniform, Inner_std140, read> = access %buffer, 0u
     %4:Inner_std140 = load %3
     %5:Inner = call %convert_Inner, %4
     ret %5
   }
 }
-%convert_Inner = func(%input:Inner_std140):Inner -> %b3 {
-  %b3 = block {
+%convert_Inner = func(%input:Inner_std140):Inner {
+  $B3: {
     %8:vec2<f32> = access %input, 0u
     %9:vec2<f32> = access %input, 1u
     %10:vec2<f32> = access %input, 2u
@@ -725,12 +725,12 @@
   inner:Inner @offset(32)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Outer -> %b2 {
-  %b2 = block {
+%foo = func():Outer {
+  $B2: {
     %3:Outer = load %buffer
     ret %3
   }
@@ -755,19 +755,19 @@
   inner:Inner @offset(32)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():Outer -> %b2 {
-  %b2 = block {
+%foo = func():Outer {
+  $B2: {
     %3:Outer_std140 = load %buffer
     %4:Outer = call %convert_Outer, %3
     ret %4
   }
 }
-%convert_Outer = func(%input:Outer_std140):Outer -> %b3 {
-  %b3 = block {
+%convert_Outer = func(%input:Outer_std140):Outer {
+  $B3: {
     %7:vec2<f32> = access %input, 0u
     %8:vec2<f32> = access %input, 1u
     %9:vec2<f32> = access %input, 2u
@@ -830,12 +830,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<Inner, 4>, read> = access %buffer, 1u
     %4:ptr<uniform, Inner, read> = access %3, 2u
     %5:ptr<uniform, mat3x2<f32>, read> = access %4, 1u
@@ -883,12 +883,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<Inner_std140, 4>, read> = access %buffer, 1u
     %4:ptr<uniform, Inner_std140, read> = access %3, 2u
     %5:ptr<uniform, vec2<f32>, read> = access %4, 1u
@@ -901,14 +901,14 @@
     %12:vec2<f32> = access %11, 2u
     %13:array<Inner_std140, 4> = load %3
     %14:ptr<function, array<Inner, 4>, read_write> = var
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 0u
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration 0u  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %16:bool = gte %idx:u32, 4u
-        if %16 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %16 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -916,11 +916,11 @@
         %18:Inner_std140 = access %13, %idx:u32
         %19:Inner = call %convert_Inner, %18
         store %17, %19
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %21:u32 = add %idx:u32, 1u
-        next_iteration %b4 %21
+        next_iteration %21  # -> $B4
       }
     }
     %22:array<Inner, 4> = load %14
@@ -935,8 +935,8 @@
     ret
   }
 }
-%convert_Inner = func(%input:Inner_std140):Inner -> %b7 {
-  %b7 = block {
+%convert_Inner = func(%input:Inner_std140):Inner {
+  $B7: {
     %32:i32 = access %input, 0u
     %33:vec2<f32> = access %input, 1u
     %34:vec2<f32> = access %input, 2u
@@ -1001,12 +1001,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<Inner, 4>, read> = access %buffer, 1u
     %arr_ptr:ptr<uniform, array<Inner, 4>, read> = let %3
     %5:ptr<uniform, Inner, read> = access %arr_ptr, 2u
@@ -1058,12 +1058,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, array<Inner_std140, 4>, read> = access %buffer, 1u
     %4:ptr<uniform, Inner_std140, read> = access %3, 2u
     %5:ptr<uniform, vec2<f32>, read> = access %4, 1u
@@ -1076,14 +1076,14 @@
     %12:vec2<f32> = access %11, 2u
     %13:array<Inner_std140, 4> = load %3
     %14:ptr<function, array<Inner, 4>, read_write> = var
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 0u
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration 0u  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %16:bool = gte %idx:u32, 4u
-        if %16 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %16 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -1091,11 +1091,11 @@
         %18:Inner_std140 = access %13, %idx:u32
         %19:Inner = call %convert_Inner, %18
         store %17, %19
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %21:u32 = add %idx:u32, 1u
-        next_iteration %b4 %21
+        next_iteration %21  # -> $B4
       }
     }
     %22:array<Inner, 4> = load %14
@@ -1110,8 +1110,8 @@
     ret
   }
 }
-%convert_Inner = func(%input:Inner_std140):Inner -> %b7 {
-  %b7 = block {
+%convert_Inner = func(%input:Inner_std140):Inner {
+  $B7: {
     %32:i32 = access %input, 0u
     %33:vec2<f32> = access %input, 1u
     %34:vec2<f32> = access %input, 2u
@@ -1179,12 +1179,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%arr_idx:i32, %col_idx:i32, %el_idx:i32):void -> %b2 {
-  %b2 = block {
+%foo = func(%arr_idx:i32, %col_idx:i32, %el_idx:i32):void {
+  $B2: {
     %6:ptr<uniform, array<Inner, 4>, read> = access %buffer, 1u
     %7:ptr<uniform, Inner, read> = access %6, %arr_idx
     %8:ptr<uniform, mat3x2<f32>, read> = access %7, 1u
@@ -1232,12 +1232,12 @@
   d:i32 @offset(168)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, Outer_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func(%arr_idx:i32, %col_idx:i32, %el_idx:i32):void -> %b2 {
-  %b2 = block {
+%foo = func(%arr_idx:i32, %col_idx:i32, %el_idx:i32):void {
+  $B2: {
     %6:ptr<uniform, array<Inner_std140, 4>, read> = access %buffer, 1u
     %7:ptr<uniform, Inner_std140, read> = access %6, %arr_idx
     %8:ptr<uniform, vec2<f32>, read> = access %7, 1u
@@ -1250,14 +1250,14 @@
     %15:vec2<f32> = access %14, %col_idx
     %16:array<Inner_std140, 4> = load %6
     %17:ptr<function, array<Inner, 4>, read_write> = var
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 0u
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration 0u  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %19:bool = gte %idx:u32, 4u
-        if %19 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %19 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -1265,11 +1265,11 @@
         %21:Inner_std140 = access %16, %idx:u32
         %22:Inner = call %convert_Inner, %21
         store %20, %22
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %24:u32 = add %idx:u32, 1u
-        next_iteration %b4 %24
+        next_iteration %24  # -> $B4
       }
     }
     %25:array<Inner, 4> = load %17
@@ -1284,8 +1284,8 @@
     ret
   }
 }
-%convert_Inner = func(%input:Inner_std140):Inner -> %b7 {
-  %b7 = block {
+%convert_Inner = func(%input:Inner_std140):Inner {
+  $B7: {
     %35:i32 = access %input, 0u
     %36:vec2<f32> = access %input, 1u
     %37:vec2<f32> = access %input, 2u
@@ -1340,12 +1340,12 @@
   b:i32 @offset(128)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, i32, read> = access %buffer, 0u
     %4:i32 = load %3
     %a:i32 = let %4
@@ -1377,12 +1377,12 @@
   b:i32 @offset(128)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:ptr<uniform, i32, read> = access %buffer, 0u
     %4:i32 = load %3
     %a:i32 = let %4
@@ -1432,12 +1432,12 @@
   a:mat4x3<f32> @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat4x3<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat4x3<f32> {
+  $B2: {
     %3:ptr<uniform, mat4x3<f32>, read> = access %buffer, 0u
     %4:mat4x3<f32> = load %3
     ret %4
@@ -1458,12 +1458,12 @@
   a_col3:vec3<f32> @offset(48)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():mat4x3<f32> -> %b2 {
-  %b2 = block {
+%foo = func():mat4x3<f32> {
+  $B2: {
     %3:ptr<uniform, vec3<f32>, read> = access %buffer, 0u
     %4:vec3<f32> = load %3
     %5:ptr<uniform, vec3<f32>, read> = access %buffer, 1u
@@ -1578,65 +1578,65 @@
   b:mat3x2<f32> @offset(64)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%load_struct_a = func():mat4x4<f32> -> %b2 {
-  %b2 = block {
+%load_struct_a = func():mat4x4<f32> {
+  $B2: {
     %3:MyStruct = load %buffer
     %4:mat4x4<f32> = access %3, 0u
     ret %4
   }
 }
-%load_struct_b = func():mat3x2<f32> -> %b3 {
-  %b3 = block {
+%load_struct_b = func():mat3x2<f32> {
+  $B3: {
     %6:MyStruct = load %buffer
     %7:mat3x2<f32> = access %6, 1u
     ret %7
   }
 }
-%load_mat_a = func():vec4<f32> -> %b4 {
-  %b4 = block {
+%load_mat_a = func():vec4<f32> {
+  $B4: {
     %9:ptr<uniform, mat4x4<f32>, read> = access %buffer, 0u
     %10:mat4x4<f32> = load %9
     %11:vec4<f32> = access %10, 0u
     ret %11
   }
 }
-%load_mat_b = func():vec2<f32> -> %b5 {
-  %b5 = block {
+%load_mat_b = func():vec2<f32> {
+  $B5: {
     %13:ptr<uniform, mat3x2<f32>, read> = access %buffer, 1u
     %14:mat3x2<f32> = load %13
     %15:vec2<f32> = access %14, 0u
     ret %15
   }
 }
-%load_vec_a = func():f32 -> %b6 {
-  %b6 = block {
+%load_vec_a = func():f32 {
+  $B6: {
     %17:ptr<uniform, vec4<f32>, read> = access %buffer, 0u, 1u
     %18:vec4<f32> = load %17
     %19:f32 = access %18, 1u
     ret %19
   }
 }
-%load_vec_b = func():f32 -> %b7 {
-  %b7 = block {
+%load_vec_b = func():f32 {
+  $B7: {
     %21:ptr<uniform, vec2<f32>, read> = access %buffer, 1u, 1u
     %22:vec2<f32> = load %21
     %23:f32 = access %22, 1u
     ret %23
   }
 }
-%lve_a = func():f32 -> %b8 {
-  %b8 = block {
+%lve_a = func():f32 {
+  $B8: {
     %25:ptr<uniform, vec4<f32>, read> = access %buffer, 0u, 1u
     %26:f32 = load_vector_element %25, 1u
     ret %26
   }
 }
-%lve_b = func():f32 -> %b9 {
-  %b9 = block {
+%lve_b = func():f32 {
+  $B9: {
     %28:ptr<uniform, vec2<f32>, read> = access %buffer, 1u, 1u
     %29:f32 = load_vector_element %28, 1u
     ret %29
@@ -1658,36 +1658,36 @@
   b_col2:vec2<f32> @offset(80)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%load_struct_a = func():mat4x4<f32> -> %b2 {
-  %b2 = block {
+%load_struct_a = func():mat4x4<f32> {
+  $B2: {
     %3:MyStruct_std140 = load %buffer
     %4:MyStruct = call %convert_MyStruct, %3
     %6:mat4x4<f32> = access %4, 0u
     ret %6
   }
 }
-%load_struct_b = func():mat3x2<f32> -> %b3 {
-  %b3 = block {
+%load_struct_b = func():mat3x2<f32> {
+  $B3: {
     %8:MyStruct_std140 = load %buffer
     %9:MyStruct = call %convert_MyStruct, %8
     %10:mat3x2<f32> = access %9, 1u
     ret %10
   }
 }
-%load_mat_a = func():vec4<f32> -> %b4 {
-  %b4 = block {
+%load_mat_a = func():vec4<f32> {
+  $B4: {
     %12:ptr<uniform, mat4x4<f32>, read> = access %buffer, 0u
     %13:mat4x4<f32> = load %12
     %14:vec4<f32> = access %13, 0u
     ret %14
   }
 }
-%load_mat_b = func():vec2<f32> -> %b5 {
-  %b5 = block {
+%load_mat_b = func():vec2<f32> {
+  $B5: {
     %16:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
     %17:vec2<f32> = load %16
     %18:ptr<uniform, vec2<f32>, read> = access %buffer, 2u
@@ -1699,16 +1699,16 @@
     ret %23
   }
 }
-%load_vec_a = func():f32 -> %b6 {
-  %b6 = block {
+%load_vec_a = func():f32 {
+  $B6: {
     %25:ptr<uniform, vec4<f32>, read> = access %buffer, 0u, 1u
     %26:vec4<f32> = load %25
     %27:f32 = access %26, 1u
     ret %27
   }
 }
-%load_vec_b = func():f32 -> %b7 {
-  %b7 = block {
+%load_vec_b = func():f32 {
+  $B7: {
     %29:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
     %30:vec2<f32> = load %29
     %31:ptr<uniform, vec2<f32>, read> = access %buffer, 2u
@@ -1721,15 +1721,15 @@
     ret %37
   }
 }
-%lve_a = func():f32 -> %b8 {
-  %b8 = block {
+%lve_a = func():f32 {
+  $B8: {
     %39:ptr<uniform, vec4<f32>, read> = access %buffer, 0u, 1u
     %40:f32 = load_vector_element %39, 1u
     ret %40
   }
 }
-%lve_b = func():f32 -> %b9 {
-  %b9 = block {
+%lve_b = func():f32 {
+  $B9: {
     %42:ptr<uniform, vec2<f32>, read> = access %buffer, 1u
     %43:vec2<f32> = load %42
     %44:ptr<uniform, vec2<f32>, read> = access %buffer, 2u
@@ -1742,8 +1742,8 @@
     ret %50
   }
 }
-%convert_MyStruct = func(%input:MyStruct_std140):MyStruct -> %b10 {
-  %b10 = block {
+%convert_MyStruct = func(%input:MyStruct_std140):MyStruct {
+  $B10: {
     %52:mat4x4<f32> = access %input, 0u
     %53:vec2<f32> = access %input, 1u
     %54:vec2<f32> = access %input, 2u
@@ -1792,12 +1792,12 @@
   d:mat4x4<f16> @offset(56)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:MyStruct = load %buffer
     %struct:MyStruct = let %3
     %5:ptr<uniform, mat4x4<f16>, read> = access %buffer, 3u
@@ -1838,12 +1838,12 @@
   d_col3:vec4<f16> @offset(80)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %buffer:ptr<uniform, MyStruct_std140, read> = var @binding_point(0, 0)
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
+%foo = func():void {
+  $B2: {
     %3:MyStruct_std140 = load %buffer
     %4:MyStruct = call %convert_MyStruct, %3
     %struct:MyStruct = let %4
@@ -1879,8 +1879,8 @@
     ret
   }
 }
-%convert_MyStruct = func(%input:MyStruct_std140):MyStruct -> %b3 {
-  %b3 = block {
+%convert_MyStruct = func(%input:MyStruct_std140):MyStruct {
+  $B3: {
     %37:vec2<f16> = access %input, 0u
     %38:vec2<f16> = access %input, 1u
     %39:mat2x2<f16> = construct %37, %38
diff --git a/src/tint/lang/core/ir/transform/value_to_let_test.cc b/src/tint/lang/core/ir/transform/value_to_let_test.cc
index 91e04d9..46e1c12 100644
--- a/src/tint/lang/core/ir/transform/value_to_let_test.cc
+++ b/src/tint/lang/core/ir/transform/value_to_let_test.cc
@@ -53,8 +53,8 @@
     b.Append(func->Block(), [&] { b.Return(func); });
 
     auto* src = R"(
-%F = func():void -> %b1 {
-  %b1 = block {
+%F = func():void {
+  $B1: {
     ret
   }
 }
@@ -78,8 +78,8 @@
     });
 
     auto* src = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %x:i32 = let 1i
     %y:i32 = let 2i
     %4:i32 = add %x, %y
@@ -118,12 +118,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -131,8 +131,8 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %x:i32 = call %rmw, 1i
     %y:i32 = select 2i, %x, false
     ret %y
@@ -170,12 +170,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -183,8 +183,8 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %x:i32 = call %rmw, 1i
     %y:i32 = call %rmw, %x
     %z:i32 = call %rmw, %y
@@ -223,12 +223,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -236,8 +236,8 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %8:i32 = call %rmw, 1i
     %x:i32 = let %8
     %y:i32 = add %x, %x
@@ -269,14 +269,14 @@
     });
 
     auto* src = R"(
-%g = func(%p:ptr<function, i32, read_write>):i32 -> %b1 {
-  %b1 = block {
+%g = func(%p:ptr<function, i32, read_write>):i32 {
+  $B1: {
     %3:i32 = load %p
     ret %3
   }
 }
-%F = func():i32 -> %b2 {
-  %b2 = block {
+%F = func():i32 {
+  $B2: {
     %v:ptr<function, i32, read_write> = var
     %6:i32 = call %g, %v
     %x:i32 = let %6
@@ -305,8 +305,8 @@
     });
 
     auto* src = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %l:i32 = load %v
     %4:i32 = add %l, %l
@@ -317,8 +317,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %3:i32 = load %v
     %l:i32 = let %3
@@ -343,8 +343,8 @@
     });
 
     auto* src = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %l:i32 = load %v
     store %v, 1i
@@ -355,8 +355,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %3:i32 = load %v
     %l:i32 = let %3
@@ -393,12 +393,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -406,8 +406,8 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %x:i32 = call %rmw, 1i
     %y:i32 = call %rmw, 2i
     %z:i32 = add %x, %y
@@ -418,12 +418,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -431,8 +431,8 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %8:i32 = call %rmw, 1i
     %x:i32 = let %8
     %y:i32 = call %rmw, 2i
@@ -475,12 +475,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -488,11 +488,11 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %x:i32 = call %rmw, 1i
-    if true [t: %b4] {  # if_1
-      %b4 = block {  # true
+    if true [t: $B4] {  # if_1
+      $B4: {  # true
         ret %x
       }
     }
@@ -503,12 +503,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %i:ptr<private, i32, read_write> = var
 }
 
-%rmw = func(%p:i32):i32 -> %b2 {
-  %b2 = block {
+%rmw = func(%p:i32):i32 {
+  $B2: {
     %4:i32 = load %i
     %5:i32 = add %4, %p
     %v:i32 = let %5
@@ -516,12 +516,12 @@
     ret %v
   }
 }
-%F = func():i32 -> %b3 {
-  %b3 = block {
+%F = func():i32 {
+  $B3: {
     %8:i32 = call %rmw, 1i
     %x:i32 = let %8
-    if true [t: %b4] {  # if_1
-      %b4 = block {  # true
+    if true [t: $B4] {  # if_1
+      $B4: {  # true
         ret %x
       }
     }
@@ -550,8 +550,8 @@
     });
 
     auto* src = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %3:i32 = load %v
     %4:i32 = add %3, 1i
@@ -563,8 +563,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%F = func():i32 -> %b1 {
-  %b1 = block {
+%F = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
     %3:i32 = load %v
     %4:i32 = add %3, 1i
@@ -597,8 +597,8 @@
     });
 
     auto* src = R"(
-%F = func():void -> %b1 {
-  %b1 = block {
+%F = func():void {
+  $B1: {
     %i:i32 = max 1i, 2i
     %v:ptr<function, i32, read_write> = var, %i
     %x:i32 = max 3i, 4i
@@ -612,8 +612,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%F = func():void -> %b1 {
-  %b1 = block {
+%F = func():void {
+  $B1: {
     %i:i32 = max 1i, 2i
     %v:ptr<function, i32, read_write> = var, %i
     %x:i32 = max 3i, 4i
diff --git a/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors_test.cc b/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors_test.cc
index 826ba54..7bca08f 100644
--- a/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors_test.cc
+++ b/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors_test.cc
@@ -49,8 +49,8 @@
     });
 
     auto* src = R"(
-%foo = func():mat3x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func():mat3x3<f32> {
+  $B1: {
     %2:mat3x3<f32> = construct
     ret %2
   }
@@ -76,8 +76,8 @@
     });
 
     auto* src = R"(
-%foo = func(%value:mat3x3<f32>):mat3x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%value:mat3x3<f32>):mat3x3<f32> {
+  $B1: {
     %3:mat3x3<f32> = construct %value
     ret %3
   }
@@ -105,8 +105,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:vec3<f32>, %v2:vec3<f32>, %v3:vec3<f32>):mat3x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:vec3<f32>, %v2:vec3<f32>, %v3:vec3<f32>):mat3x3<f32> {
+  $B1: {
     %5:mat3x3<f32> = construct %v1, %v2, %v3
     ret %5
   }
@@ -135,8 +135,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32):mat2x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32):mat2x2<f32> {
+  $B1: {
     %6:mat2x2<f32> = construct %v1, %v2, %v3, %v4
     ret %6
   }
@@ -145,8 +145,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32):mat2x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32):mat2x2<f32> {
+  $B1: {
     %6:vec2<f32> = construct %v1, %v2
     %7:vec2<f32> = construct %v3, %v4
     %8:mat2x2<f32> = construct %6, %7
@@ -176,8 +176,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat2x3<f32> {
+  $B1: {
     %8:mat2x3<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6
     ret %8
   }
@@ -186,8 +186,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat2x3<f32> {
+  $B1: {
     %8:vec3<f32> = construct %v1, %v2, %v3
     %9:vec3<f32> = construct %v4, %v5, %v6
     %10:mat2x3<f32> = construct %8, %9
@@ -219,8 +219,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat2x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat2x4<f32> {
+  $B1: {
     %10:mat2x4<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8
     ret %10
   }
@@ -229,8 +229,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat2x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat2x4<f32> {
+  $B1: {
     %10:vec4<f32> = construct %v1, %v2, %v3, %v4
     %11:vec4<f32> = construct %v5, %v6, %v7, %v8
     %12:mat2x4<f32> = construct %10, %11
@@ -260,8 +260,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat3x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat3x2<f32> {
+  $B1: {
     %8:mat3x2<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6
     ret %8
   }
@@ -270,8 +270,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat3x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32):mat3x2<f32> {
+  $B1: {
     %8:vec2<f32> = construct %v1, %v2
     %9:vec2<f32> = construct %v3, %v4
     %10:vec2<f32> = construct %v5, %v6
@@ -305,8 +305,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32):mat3x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32):mat3x3<f32> {
+  $B1: {
     %11:mat3x3<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8, %v9
     ret %11
   }
@@ -315,8 +315,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32):mat3x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32):mat3x3<f32> {
+  $B1: {
     %11:vec3<f32> = construct %v1, %v2, %v3
     %12:vec3<f32> = construct %v4, %v5, %v6
     %13:vec3<f32> = construct %v7, %v8, %v9
@@ -353,8 +353,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat3x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat3x4<f32> {
+  $B1: {
     %14:mat3x4<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8, %v9, %v10, %v11, %v12
     ret %14
   }
@@ -363,8 +363,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat3x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat3x4<f32> {
+  $B1: {
     %14:vec4<f32> = construct %v1, %v2, %v3, %v4
     %15:vec4<f32> = construct %v5, %v6, %v7, %v8
     %16:vec4<f32> = construct %v9, %v10, %v11, %v12
@@ -397,8 +397,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat4x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat4x2<f32> {
+  $B1: {
     %10:mat4x2<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8
     ret %10
   }
@@ -407,8 +407,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat4x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32):mat4x2<f32> {
+  $B1: {
     %10:vec2<f32> = construct %v1, %v2
     %11:vec2<f32> = construct %v3, %v4
     %12:vec2<f32> = construct %v5, %v6
@@ -446,8 +446,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat4x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat4x3<f32> {
+  $B1: {
     %14:mat4x3<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8, %v9, %v10, %v11, %v12
     ret %14
   }
@@ -456,8 +456,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat4x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32):mat4x3<f32> {
+  $B1: {
     %14:vec3<f32> = construct %v1, %v2, %v3
     %15:vec3<f32> = construct %v4, %v5, %v6
     %16:vec3<f32> = construct %v7, %v8, %v9
@@ -500,8 +500,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32, %v13:f32, %v14:f32, %v15:f32, %v16:f32):mat4x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32, %v13:f32, %v14:f32, %v15:f32, %v16:f32):mat4x4<f32> {
+  $B1: {
     %18:mat4x4<f32> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8, %v9, %v10, %v11, %v12, %v13, %v14, %v15, %v16
     ret %18
   }
@@ -510,8 +510,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32, %v13:f32, %v14:f32, %v15:f32, %v16:f32):mat4x4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f32, %v2:f32, %v3:f32, %v4:f32, %v5:f32, %v6:f32, %v7:f32, %v8:f32, %v9:f32, %v10:f32, %v11:f32, %v12:f32, %v13:f32, %v14:f32, %v15:f32, %v16:f32):mat4x4<f32> {
+  $B1: {
     %18:vec4<f32> = construct %v1, %v2, %v3, %v4
     %19:vec4<f32> = construct %v5, %v6, %v7, %v8
     %20:vec4<f32> = construct %v9, %v10, %v11, %v12
@@ -546,8 +546,8 @@
     });
 
     auto* src = R"(
-%foo = func(%v1:f16, %v2:f16, %v3:f16, %v4:f16, %v5:f16, %v6:f16, %v7:f16, %v8:f16, %v9:f16):mat3x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f16, %v2:f16, %v3:f16, %v4:f16, %v5:f16, %v6:f16, %v7:f16, %v8:f16, %v9:f16):mat3x3<f16> {
+  $B1: {
     %11:mat3x3<f16> = construct %v1, %v2, %v3, %v4, %v5, %v6, %v7, %v8, %v9
     ret %11
   }
@@ -556,8 +556,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%v1:f16, %v2:f16, %v3:f16, %v4:f16, %v5:f16, %v6:f16, %v7:f16, %v8:f16, %v9:f16):mat3x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%v1:f16, %v2:f16, %v3:f16, %v4:f16, %v5:f16, %v6:f16, %v7:f16, %v8:f16, %v9:f16):mat3x3<f16> {
+  $B1: {
     %11:vec3<f16> = construct %v1, %v2, %v3
     %12:vec3<f16> = construct %v4, %v5, %v6
     %13:vec3<f16> = construct %v7, %v8, %v9
diff --git a/src/tint/lang/core/ir/transform/zero_init_workgroup_memory_test.cc b/src/tint/lang/core/ir/transform/zero_init_workgroup_memory_test.cc
index 37ba499..0e9c0b1 100644
--- a/src/tint/lang/core/ir/transform/zero_init_workgroup_memory_test.cc
+++ b/src/tint/lang/core/ir/transform/zero_init_workgroup_memory_test.cc
@@ -62,8 +62,8 @@
     });
 
     auto* expect = R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     ret
   }
 }
@@ -83,12 +83,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, i32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -112,12 +112,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = load %wgvar
     ret
   }
@@ -126,15 +126,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, false
         exit_if  # if_1
       }
@@ -161,12 +161,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, i32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = load %wgvar
     ret
   }
@@ -175,15 +175,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, i32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, 0i
         exit_if  # if_1
       }
@@ -210,12 +210,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, u32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %wgvar
     ret
   }
@@ -224,15 +224,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, u32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, 0u
         exit_if  # if_1
       }
@@ -259,12 +259,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, f32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f32 = load %wgvar
     ret
   }
@@ -273,15 +273,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, f32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, 0.0f
         exit_if  # if_1
       }
@@ -308,12 +308,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, f16, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f16 = load %wgvar
     ret
   }
@@ -322,15 +322,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, f16, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, 0.0h
         exit_if  # if_1
       }
@@ -357,12 +357,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = atomicLoad %wgvar
     ret
   }
@@ -371,15 +371,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         %5:void = atomicStore %wgvar, 0i
         exit_if  # if_1
       }
@@ -406,12 +406,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = atomicLoad %wgvar
     ret
   }
@@ -420,15 +420,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         %5:void = atomicStore %wgvar, 0u
         exit_if  # if_1
       }
@@ -455,12 +455,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<i32, 4>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func():void {
+  $B2: {
     %3:array<i32, 4> = load %wgvar
     ret
   }
@@ -469,30 +469,30 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<i32, 4>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 4u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
         %6:ptr<workgroup, i32, read_write> = access %wgvar, %idx:u32
         store %6, 0i
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %7:u32 = add %idx:u32, 66u
-        next_iteration %b4 %7
+        next_iteration %7  # -> $B4
       }
     }
     %8:void = workgroupBarrier
@@ -517,12 +517,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<u32, 5>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func():void {
+  $B2: {
     %3:array<array<u32, 5>, 7> = load %wgvar
     ret
   }
@@ -531,20 +531,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<u32, 5>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 35u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -552,11 +552,11 @@
         %7:u32 = div %idx:u32, 5u
         %8:ptr<workgroup, u32, read_write> = access %wgvar, %7, %6
         store %8, 0u
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %9:u32 = add %idx:u32, 66u
-        next_iteration %b4 %9
+        next_iteration %9  # -> $B4
       }
     }
     %10:void = workgroupBarrier
@@ -581,12 +581,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 7>, 5>, 3>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:array<array<array<i32, 7>, 5>, 3> = load %wgvar
     ret
   }
@@ -595,20 +595,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 7>, 5>, 3>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 105u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -618,11 +618,11 @@
         %9:u32 = div %idx:u32, 35u
         %10:ptr<workgroup, i32, read_write> = access %wgvar, %9, %8, %6
         store %10, 0i
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %11:u32 = add %idx:u32, 1u
-        next_iteration %b4 %11
+        next_iteration %11  # -> $B4
       }
     }
     %12:void = workgroupBarrier
@@ -647,12 +647,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 1>, 5>, 3>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:array<array<array<i32, 1>, 5>, 3> = load %wgvar
     ret
   }
@@ -661,20 +661,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 1>, 5>, 3>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 15u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -682,11 +682,11 @@
         %7:u32 = div %idx:u32, 5u
         %8:ptr<workgroup, i32, read_write> = access %wgvar, %7, %6, 0u
         store %8, 0i
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %9:u32 = add %idx:u32, 1u
-        next_iteration %b4 %9
+        next_iteration %9  # -> $B4
       }
     }
     %10:void = workgroupBarrier
@@ -711,12 +711,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 3>, 1>, 5>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:array<array<array<i32, 3>, 1>, 5> = load %wgvar
     ret
   }
@@ -725,20 +725,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 3>, 1>, 5>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 15u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -746,11 +746,11 @@
         %7:u32 = div %idx:u32, 3u
         %8:ptr<workgroup, i32, read_write> = access %wgvar, %7, 0u, %6
         store %8, 0i
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %9:u32 = add %idx:u32, 1u
-        next_iteration %b4 %9
+        next_iteration %9  # -> $B4
       }
     }
     %10:void = workgroupBarrier
@@ -775,12 +775,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 3>, 5>, 1>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:array<array<array<i32, 3>, 5>, 1> = load %wgvar
     ret
   }
@@ -789,20 +789,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<array<i32, 3>, 5>, 1>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 15u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -810,11 +810,11 @@
         %7:u32 = div %idx:u32, 3u
         %8:ptr<workgroup, i32, read_write> = access %wgvar, 0u, %7, %6
         store %8, 0i
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %9:u32 = add %idx:u32, 1u
-        next_iteration %b4 %9
+        next_iteration %9  # -> $B4
       }
     }
     %10:void = workgroupBarrier
@@ -839,12 +839,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<i32, 1>, 1>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:array<array<i32, 1>, 1> = load %wgvar
     ret
   }
@@ -853,15 +853,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<array<i32, 1>, 1>, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         %5:ptr<workgroup, i32, read_write> = access %wgvar, 0u, 0u
         store %5, 0i
         exit_if  # if_1
@@ -900,12 +900,12 @@
   c:f32 @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, MyStruct, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:MyStruct = load %wgvar
     ret
   }
@@ -920,15 +920,15 @@
   c:f32 @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, MyStruct, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, MyStruct(0i, 0u, 0.0f)
         exit_if  # if_1
       }
@@ -975,12 +975,12 @@
   d:bool @offset(12)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, Outer, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:Outer = load %wgvar
     ret
   }
@@ -1000,15 +1000,15 @@
   d:bool @offset(12)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, Outer, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, Outer(0.0f, Inner(0i, 0u), false)
         exit_if  # if_1
       }
@@ -1055,12 +1055,12 @@
   d:bool @offset(12)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, Outer, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:Outer = load %wgvar
     ret
   }
@@ -1080,15 +1080,15 @@
   d:bool @offset(12)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, Outer, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         %5:ptr<workgroup, f32, read_write> = access %wgvar, 0u
         store %5, 0.0f
         %6:ptr<workgroup, i32, read_write> = access %wgvar, 1u, 0u
@@ -1143,12 +1143,12 @@
   d:bool @offset(108)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<Outer, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(7, 3, 2) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(7, 3, 2) func():void {
+  $B2: {
     %3:array<Outer, 7> = load %wgvar
     ret
   }
@@ -1168,20 +1168,20 @@
   d:bool @offset(108)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, array<Outer, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(7, 3, 2) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
-    loop [i: %b3, b: %b4, c: %b5] {  # loop_1
-      %b3 = block {  # initializer
-        next_iteration %b4 %tint_local_index
+%main = @compute @workgroup_size(7, 3, 2) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
+    loop [i: $B3, b: $B4, c: $B5] {  # loop_1
+      $B3: {  # initializer
+        next_iteration %tint_local_index  # -> $B4
       }
-      %b4 = block (%idx:u32) {  # body
+      $B4 (%idx:u32): {  # body
         %5:bool = gte %idx:u32, 7u
-        if %5 [t: %b6] {  # if_1
-          %b6 = block {  # true
+        if %5 [t: $B6] {  # if_1
+          $B6: {  # true
             exit_loop  # loop_1
           }
         }
@@ -1189,21 +1189,21 @@
         store %6, 0.0f
         %7:ptr<workgroup, bool, read_write> = access %wgvar, %idx:u32, 2u
         store %7, false
-        continue %b5
+        continue  # -> $B5
       }
-      %b5 = block {  # continuing
+      $B5: {  # continuing
         %8:u32 = add %idx:u32, 42u
-        next_iteration %b4 %8
+        next_iteration %8  # -> $B4
       }
     }
-    loop [i: %b7, b: %b8, c: %b9] {  # loop_2
-      %b7 = block {  # initializer
-        next_iteration %b8 %tint_local_index
+    loop [i: $B7, b: $B8, c: $B9] {  # loop_2
+      $B7: {  # initializer
+        next_iteration %tint_local_index  # -> $B8
       }
-      %b8 = block (%idx_1:u32) {  # body
+      $B8 (%idx_1:u32): {  # body
         %10:bool = gte %idx_1:u32, 91u
-        if %10 [t: %b10] {  # if_2
-          %b10 = block {  # true
+        if %10 [t: $B10] {  # if_2
+          $B10: {  # true
             exit_loop  # loop_2
           }
         }
@@ -1215,11 +1215,11 @@
         %15:u32 = div %idx_1:u32, 13u
         %16:ptr<workgroup, atomic<u32>, read_write> = access %wgvar, %15, 1u, %14, 1u
         %17:void = atomicStore %16, 0u
-        continue %b9
+        continue  # -> $B9
       }
-      %b9 = block {  # continuing
+      $B9: {  # continuing
         %18:u32 = add %idx_1:u32, 42u
-        next_iteration %b8 %18
+        next_iteration %18  # -> $B8
       }
     }
     %19:void = workgroupBarrier
@@ -1248,14 +1248,14 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var_a:ptr<workgroup, bool, read_write> = var
   %var_b:ptr<workgroup, array<i32, 4>, read_write> = var
   %var_c:ptr<workgroup, array<array<u32, 5>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func():void {
+  $B2: {
     %5:bool = load %var_a
     %6:array<i32, 4> = load %var_b
     %7:array<array<u32, 5>, 7> = load %var_c
@@ -1266,49 +1266,49 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var_a:ptr<workgroup, bool, read_write> = var
   %var_b:ptr<workgroup, array<i32, 4>, read_write> = var
   %var_c:ptr<workgroup, array<array<u32, 5>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %6:bool = eq %tint_local_index, 0u
-    if %6 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %6 [t: $B3] {  # if_1
+      $B3: {  # true
         store %var_a, false
         exit_if  # if_1
       }
     }
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 %tint_local_index
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration %tint_local_index  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %8:bool = gte %idx:u32, 4u
-        if %8 [t: %b7] {  # if_2
-          %b7 = block {  # true
+        if %8 [t: $B7] {  # if_2
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
         %9:ptr<workgroup, i32, read_write> = access %var_b, %idx:u32
         store %9, 0i
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %10:u32 = add %idx:u32, 66u
-        next_iteration %b5 %10
+        next_iteration %10  # -> $B5
       }
     }
-    loop [i: %b8, b: %b9, c: %b10] {  # loop_2
-      %b8 = block {  # initializer
-        next_iteration %b9 %tint_local_index
+    loop [i: $B8, b: $B9, c: $B10] {  # loop_2
+      $B8: {  # initializer
+        next_iteration %tint_local_index  # -> $B9
       }
-      %b9 = block (%idx_1:u32) {  # body
+      $B9 (%idx_1:u32): {  # body
         %12:bool = gte %idx_1:u32, 35u
-        if %12 [t: %b11] {  # if_3
-          %b11 = block {  # true
+        if %12 [t: $B11] {  # if_3
+          $B11: {  # true
             exit_loop  # loop_2
           }
         }
@@ -1316,11 +1316,11 @@
         %14:u32 = div %idx_1:u32, 5u
         %15:ptr<workgroup, u32, read_write> = access %var_c, %14, %13
         store %15, 0u
-        continue %b10
+        continue  # -> $B10
       }
-      %b10 = block {  # continuing
+      $B10: {  # continuing
         %16:u32 = add %idx_1:u32, 66u
-        next_iteration %b9 %16
+        next_iteration %16  # -> $B9
       }
     }
     %17:void = workgroupBarrier
@@ -1353,15 +1353,15 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var_a:ptr<workgroup, bool, read_write> = var
   %var_b:ptr<workgroup, i32, read_write> = var
   %var_c:ptr<workgroup, array<i32, 42>, read_write> = var
   %var_d:ptr<workgroup, array<array<u32, 6>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func():void {
+  $B2: {
     %6:bool = load %var_a
     %7:i32 = load %var_b
     %8:array<i32, 42> = load %var_c
@@ -1373,31 +1373,31 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var_a:ptr<workgroup, bool, read_write> = var
   %var_b:ptr<workgroup, i32, read_write> = var
   %var_c:ptr<workgroup, array<i32, 42>, read_write> = var
   %var_d:ptr<workgroup, array<array<u32, 6>, 7>, read_write> = var
 }
 
-%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(11, 2, 3) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %7:bool = eq %tint_local_index, 0u
-    if %7 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %7 [t: $B3] {  # if_1
+      $B3: {  # true
         store %var_a, false
         store %var_b, 0i
         exit_if  # if_1
       }
     }
-    loop [i: %b4, b: %b5, c: %b6] {  # loop_1
-      %b4 = block {  # initializer
-        next_iteration %b5 %tint_local_index
+    loop [i: $B4, b: $B5, c: $B6] {  # loop_1
+      $B4: {  # initializer
+        next_iteration %tint_local_index  # -> $B5
       }
-      %b5 = block (%idx:u32) {  # body
+      $B5 (%idx:u32): {  # body
         %9:bool = gte %idx:u32, 42u
-        if %9 [t: %b7] {  # if_2
-          %b7 = block {  # true
+        if %9 [t: $B7] {  # if_2
+          $B7: {  # true
             exit_loop  # loop_1
           }
         }
@@ -1407,11 +1407,11 @@
         %12:u32 = div %idx:u32, 6u
         %13:ptr<workgroup, u32, read_write> = access %var_d, %12, %11
         store %13, 0u
-        continue %b6
+        continue  # -> $B6
       }
-      %b6 = block {  # continuing
+      $B6: {  # continuing
         %14:u32 = add %idx:u32, 66u
-        next_iteration %b5 %14
+        next_iteration %14  # -> $B5
       }
     }
     %15:void = workgroupBarrier
@@ -1444,12 +1444,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%global_id:vec4<u32> [@global_invocation_id], %index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%global_id:vec4<u32> [@global_invocation_id], %index:u32 [@local_invocation_index]):void {
+  $B2: {
     %5:bool = load %wgvar
     ret
   }
@@ -1458,15 +1458,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%global_id:vec4<u32> [@global_invocation_id], %index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%global_id:vec4<u32> [@global_invocation_id], %index:u32 [@local_invocation_index]):void {
+  $B2: {
     %5:bool = eq %index, 0u
-    if %5 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %5 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, false
         exit_if  # if_1
       }
@@ -1526,12 +1526,12 @@
   index:u32 @offset(12), @builtin(local_invocation_index)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%params:MyStruct):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%params:MyStruct):void {
+  $B2: {
     %4:bool = load %wgvar
     ret
   }
@@ -1545,16 +1545,16 @@
   index:u32 @offset(12), @builtin(local_invocation_index)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%params:MyStruct):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%params:MyStruct):void {
+  $B2: {
     %4:u32 = access %params, 1u
     %5:bool = eq %4, 0u
-    if %5 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %5 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, false
         exit_if  # if_1
       }
@@ -1597,23 +1597,23 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
-    if true [t: %b3] {  # if_1
-      %b3 = block {  # true
-        switch 42i [c: (default, %b4)] {  # switch_1
-          %b4 = block {  # case
-            loop [b: %b5, c: %b6] {  # loop_1
-              %b5 = block {  # body
-                continue %b6
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
+    if true [t: $B3] {  # if_1
+      $B3: {  # true
+        switch 42i [c: (default, $B4)] {  # switch_1
+          $B4: {  # case
+            loop [b: $B5, c: $B6] {  # loop_1
+              $B5: {  # body
+                continue  # -> $B6
               }
-              %b6 = block {  # continuing
+              $B6: {  # continuing
                 %3:bool = load %wgvar
-                break_if %3 %b5
+                break_if %3  # -> [t: exit_loop loop_1, f: $B5]
               }
             }
             exit_switch  # switch_1
@@ -1629,31 +1629,31 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B2: {
     %4:bool = eq %tint_local_index, 0u
-    if %4 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_1
+      $B3: {  # true
         store %wgvar, false
         exit_if  # if_1
       }
     }
     %5:void = workgroupBarrier
-    if true [t: %b4] {  # if_2
-      %b4 = block {  # true
-        switch 42i [c: (default, %b5)] {  # switch_1
-          %b5 = block {  # case
-            loop [b: %b6, c: %b7] {  # loop_1
-              %b6 = block {  # body
-                continue %b7
+    if true [t: $B4] {  # if_2
+      $B4: {  # true
+        switch 42i [c: (default, $B5)] {  # switch_1
+          $B5: {  # case
+            loop [b: $B6, c: $B7] {  # loop_1
+              $B6: {  # body
+                continue  # -> $B7
               }
-              %b7 = block {  # continuing
+              $B7: {  # continuing
                 %6:bool = load %wgvar
-                break_if %6 %b6
+                break_if %6  # -> [t: exit_loop loop_1, f: $B6]
               }
             }
             exit_switch  # switch_1
@@ -1721,28 +1721,28 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        continue %b4
+%foo = func():void {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %3:bool = load %wgvar
-        break_if %3 %b3
+        break_if %3  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
   }
 }
-%foo_1 = func():void -> %b5 {  # %foo_1: 'foo'
-  %b5 = block {
-    if true [t: %b6] {  # if_1
-      %b6 = block {  # true
+%foo_1 = func():void {  # %foo_1: 'foo'
+  $B5: {
+    if true [t: $B6] {  # if_1
+      $B6: {  # true
         %5:void = call %foo
         exit_if  # if_1
       }
@@ -1750,19 +1750,19 @@
     ret
   }
 }
-%func = @compute @workgroup_size(1, 1, 1) func():void -> %b7 {
-  %b7 = block {
-    if true [t: %b8] {  # if_2
-      %b8 = block {  # true
-        switch 42i [c: (default, %b9)] {  # switch_1
-          %b9 = block {  # case
-            loop [b: %b10, c: %b11] {  # loop_2
-              %b10 = block {  # body
-                continue %b11
+%func = @compute @workgroup_size(1, 1, 1) func():void {
+  $B7: {
+    if true [t: $B8] {  # if_2
+      $B8: {  # true
+        switch 42i [c: (default, $B9)] {  # switch_1
+          $B9: {  # case
+            loop [b: $B10, c: $B11] {  # loop_2
+              $B10: {  # body
+                continue  # -> $B11
               }
-              %b11 = block {  # continuing
+              $B11: {  # continuing
                 %7:void = call %foo_1
-                break_if true %b10
+                break_if true  # -> [t: exit_loop loop_2, f: $B10]
               }
             }
             exit_switch  # switch_1
@@ -1778,28 +1778,28 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        continue %b4
+%foo = func():void {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %3:bool = load %wgvar
-        break_if %3 %b3
+        break_if %3  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
   }
 }
-%foo_1 = func():void -> %b5 {  # %foo_1: 'foo'
-  %b5 = block {
-    if true [t: %b6] {  # if_1
-      %b6 = block {  # true
+%foo_1 = func():void {  # %foo_1: 'foo'
+  $B5: {
+    if true [t: $B6] {  # if_1
+      $B6: {  # true
         %5:void = call %foo
         exit_if  # if_1
       }
@@ -1807,27 +1807,27 @@
     ret
   }
 }
-%func = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b7 {
-  %b7 = block {
+%func = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B7: {
     %8:bool = eq %tint_local_index, 0u
-    if %8 [t: %b8] {  # if_2
-      %b8 = block {  # true
+    if %8 [t: $B8] {  # if_2
+      $B8: {  # true
         store %wgvar, false
         exit_if  # if_2
       }
     }
     %9:void = workgroupBarrier
-    if true [t: %b9] {  # if_3
-      %b9 = block {  # true
-        switch 42i [c: (default, %b10)] {  # switch_1
-          %b10 = block {  # case
-            loop [b: %b11, c: %b12] {  # loop_2
-              %b11 = block {  # body
-                continue %b12
+    if true [t: $B9] {  # if_3
+      $B9: {  # true
+        switch 42i [c: (default, $B10)] {  # switch_1
+          $B10: {  # case
+            loop [b: $B11, c: $B12] {  # loop_2
+              $B11: {  # body
+                continue  # -> $B12
               }
-              %b12 = block {  # continuing
+              $B12: {  # continuing
                 %10:void = call %foo_1
-                break_if true %b11
+                break_if true  # -> [t: exit_loop loop_2, f: $B11]
               }
             }
             exit_switch  # switch_1
@@ -1875,32 +1875,32 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        continue %b4
+%foo = func():void {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %3:bool = load %wgvar
-        break_if %3 %b3
+        break_if %3  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
   }
 }
-%ep1 = @compute @workgroup_size(1, 1, 1) func():void -> %b5 {
-  %b5 = block {
+%ep1 = @compute @workgroup_size(1, 1, 1) func():void {
+  $B5: {
     %5:void = call %foo
     ret
   }
 }
-%ep2 = @compute @workgroup_size(1, 1, 1) func():void -> %b6 {
-  %b6 = block {
+%ep2 = @compute @workgroup_size(1, 1, 1) func():void {
+  $B6: {
     %7:void = call %foo
     ret
   }
@@ -1909,29 +1909,29 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, bool, read_write> = var
 }
 
-%foo = func():void -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        continue %b4
+%foo = func():void {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %3:bool = load %wgvar
-        break_if %3 %b3
+        break_if %3  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret
   }
 }
-%ep1 = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void -> %b5 {
-  %b5 = block {
+%ep1 = @compute @workgroup_size(1, 1, 1) func(%tint_local_index:u32 [@local_invocation_index]):void {
+  $B5: {
     %6:bool = eq %tint_local_index, 0u
-    if %6 [t: %b6] {  # if_1
-      %b6 = block {  # true
+    if %6 [t: $B6] {  # if_1
+      $B6: {  # true
         store %wgvar, false
         exit_if  # if_1
       }
@@ -1941,11 +1941,11 @@
     ret
   }
 }
-%ep2 = @compute @workgroup_size(1, 1, 1) func(%tint_local_index_1:u32 [@local_invocation_index]):void -> %b7 {  # %tint_local_index_1: 'tint_local_index'
-  %b7 = block {
+%ep2 = @compute @workgroup_size(1, 1, 1) func(%tint_local_index_1:u32 [@local_invocation_index]):void {  # %tint_local_index_1: 'tint_local_index'
+  $B7: {
     %11:bool = eq %tint_local_index_1, 0u
-    if %11 [t: %b8] {  # if_2
-      %b8 = block {  # true
+    if %11 [t: $B8] {  # if_2
+      $B8: {  # true
         store %wgvar, false
         exit_if  # if_2
       }
diff --git a/src/tint/lang/core/ir/validator_test.cc b/src/tint/lang/core/ir/validator_test.cc
index 8742f8a..16bb823 100644
--- a/src/tint/lang/core/ir/validator_test.cc
+++ b/src/tint/lang/core/ir/validator_test.cc
@@ -68,18 +68,18 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:2:3 error: loop: root block: invalid instruction: tint::core::ir::Loop
-  loop [b: %b2] {  # loop_1
+  loop [b: $B2] {  # loop_1
   ^^^^^^^^^^^^^
 
 :1:1 note: In block
-%b1 = block {  # root
-^^^^^^^^^^^
+$B1: {  # root
+^^^
 
 note: # Disassembly
-%b1 = block {  # root
-  loop [b: %b2] {  # loop_1
-    %b2 = block {  # body
-      continue %b3
+$B1: {  # root
+  loop [b: $B2] {  # loop_1
+    $B2: {  # body
+      continue  # -> $B3
     }
   }
 }
@@ -103,16 +103,16 @@
                                      ^^^
 
 :1:1 note: In block
-%b1 = block {  # root
-^^^^^^^^^^^
+$B1: {  # root
+^^^
 
 note: # Disassembly
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%f = func():void -> %b2 {
-  %b2 = block {
+%f = func():void {
+  $B2: {
     ret
   }
 }
@@ -140,17 +140,17 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:1:1 error: function 'my_func' added to module multiple times
-%my_func = func(%2:i32, %3:f32):void -> %b1 {
+%my_func = func(%2:i32, %3:f32):void {
 ^^^^^^^^
 
 note: # Disassembly
-%my_func = func(%2:i32, %3:f32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:i32, %3:f32):void {
+  $B1: {
     ret
   }
 }
-%my_func = func(%2:i32, %3:f32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:i32, %3:f32):void {
+  $B1: {
     ret
   }
 }
@@ -169,12 +169,12 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:1:17 error: destroyed parameter found in function parameter list
-%my_func = func(%my_param:f32):void -> %b1 {
+%my_func = func(%my_param:f32):void {
                 ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func(%my_param:f32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%my_param:f32):void {
+  $B1: {
     ret
   }
 }
@@ -193,12 +193,12 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:1:17 error: function parameter has nullptr parent function
-%my_func = func(%my_param:f32):void -> %b1 {
+%my_func = func(%my_param:f32):void {
                 ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func(%my_param:f32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%my_param:f32):void {
+  $B1: {
     ret
   }
 }
@@ -218,21 +218,21 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:1:18 error: function parameter has incorrect parent function
-%my_func1 = func(%my_param:f32):void -> %b1 {
+%my_func1 = func(%my_param:f32):void {
                  ^^^^^^^^^^^^^
 
 :6:1 note: parent function declared here
-%my_func2 = func(%my_param:f32):void -> %b2 {
+%my_func2 = func(%my_param:f32):void {
 ^^^^^^^^^
 
 note: # Disassembly
-%my_func1 = func(%my_param:f32):void -> %b1 {
-  %b1 = block {
+%my_func1 = func(%my_param:f32):void {
+  $B1: {
     ret
   }
 }
-%my_func2 = func(%my_param:f32):void -> %b2 {
-  %b2 = block {
+%my_func2 = func(%my_param:f32):void {
+  $B2: {
     ret
   }
 }
@@ -258,12 +258,12 @@
                    ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:void = call %g
     ret
   }
@@ -289,18 +289,18 @@
                    ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:void = call %g
     ret
   }
 }
-%g = @compute func():void -> %b2 {
-  %b2 = block {
+%g = @compute func():void {
+  $B2: {
     ret
   }
 }
@@ -326,17 +326,17 @@
                    ^^
 
 :7:3 note: In block
-  %b2 = block {
-  ^^^^^^^^^^^
+  $B2: {
+  ^^^
 
 note: # Disassembly
-%g = func(%2:i32, %3:i32):void -> %b1 {
-  %b1 = block {
+%g = func(%2:i32, %3:i32):void {
+  $B1: {
     ret
   }
 }
-%f = func():void -> %b2 {
-  %b2 = block {
+%f = func():void {
+  $B2: {
     %5:void = call %g, 42i
     ret
   }
@@ -363,17 +363,17 @@
                    ^^
 
 :7:3 note: In block
-  %b2 = block {
-  ^^^^^^^^^^^
+  $B2: {
+  ^^^
 
 note: # Disassembly
-%g = func(%2:i32, %3:i32):void -> %b1 {
-  %b1 = block {
+%g = func(%2:i32, %3:i32):void {
+  $B1: {
     ret
   }
 }
-%f = func():void -> %b2 {
-  %b2 = block {
+%f = func():void {
+  $B2: {
     %5:void = call %g, 1i, 2i, 3i
     ret
   }
@@ -400,17 +400,17 @@
                            ^^^^
 
 :7:3 note: In block
-  %b2 = block {
-  ^^^^^^^^^^^
+  $B2: {
+  ^^^
 
 note: # Disassembly
-%g = func(%2:i32, %3:i32, %4:i32):void -> %b1 {
-  %b1 = block {
+%g = func(%2:i32, %3:i32, %4:i32):void {
+  $B1: {
     ret
   }
 }
-%f = func():void -> %b2 {
-  %b2 = block {
+%f = func():void {
+  $B2: {
     %6:void = call %g, 1i, 2.0f, 3i
     ret
   }
@@ -425,12 +425,12 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:2:3 error: block: does not end in a terminator instruction
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
   }
 }
 )");
@@ -456,22 +456,22 @@
                                         ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     ret
   }
 }
-%g = func():void -> %b2 {
-  %b2 = block {
+%g = func():void {
+  $B2: {
     ret
   }
 }
@@ -494,15 +494,15 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
-              R"(:4:20 error: destroyed parameter found in block parameter list
-      %b2 = block (%my_param:f32) {  # body
-                   ^^^^^^^^^^^^^
+              R"(:4:12 error: destroyed parameter found in block parameter list
+      $B2 (%my_param:f32): {  # body
+           ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%my_param:f32) {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%my_param:f32): {  # body
         exit_loop  # loop_1
       }
     }
@@ -528,15 +528,15 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
-              R"(:4:20 error: block parameter has nullptr parent block
-      %b2 = block (%my_param:f32) {  # body
-                   ^^^^^^^^^^^^^
+              R"(:4:12 error: block parameter has nullptr parent block
+      $B2 (%my_param:f32): {  # body
+           ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%my_param:f32) {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%my_param:f32): {  # body
         exit_loop  # loop_1
       }
     }
@@ -562,23 +562,23 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
-              R"(:4:20 error: block parameter has incorrect parent block
-      %b2 = block (%my_param:f32) {  # body
-                   ^^^^^^^^^^^^^
+              R"(:4:12 error: block parameter has incorrect parent block
+      $B2 (%my_param:f32): {  # body
+           ^^^^^^^^^^^^^
 
 :7:7 note: parent block declared here
-      %b3 = block (%my_param:f32) {  # continuing
-      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+      $B3 (%my_param:f32): {  # continuing
+      ^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block (%my_param:f32) {  # body
-        continue %b3 %my_param:f32
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2 (%my_param:f32): {  # body
+        continue %my_param:f32  # -> $B3
       }
-      %b3 = block (%my_param:f32) {  # continuing
-        next_iteration %b2 %my_param:f32
+      $B3 (%my_param:f32): {  # continuing
+        next_iteration %my_param:f32  # -> $B2
       }
     }
     ret
@@ -605,12 +605,12 @@
                         ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:vec3<f32>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:vec3<f32>):void {
+  $B1: {
     %3:f32 = access %2, -1i
     ret
   }
@@ -636,16 +636,16 @@
                             ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 :3:29 note: acceptable range: [0..1]
     %3:f32 = access %2, 1u, 3u
                             ^^
 
 note: # Disassembly
-%my_func = func(%2:mat3x2<f32>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:mat3x2<f32>):void {
+  $B1: {
     %3:f32 = access %2, 1u, 3u
     ret
   }
@@ -672,16 +672,16 @@
                                                       ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 :3:55 note: acceptable range: [0..1]
     %3:ptr<private, f32, read_write> = access %2, 1u, 3u
                                                       ^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void {
+  $B1: {
     %3:ptr<private, f32, read_write> = access %2, 1u, 3u
     ret
   }
@@ -706,12 +706,12 @@
                         ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:f32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:f32):void {
+  $B1: {
     %3:f32 = access %2, 1u
     ret
   }
@@ -737,12 +737,12 @@
                                                   ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, f32, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, f32, read_write>):void {
+  $B1: {
     %3:ptr<private, f32, read_write> = access %2, 1u
     ret
   }
@@ -774,8 +774,8 @@
                         ^^
 
 :7:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
 MyStruct = struct @align(4) {
@@ -783,8 +783,8 @@
   b:i32 @offset(4)
 }
 
-%my_func = func(%2:MyStruct, %3:i32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:MyStruct, %3:i32):void {
+  $B1: {
     %4:i32 = access %2, %3
     ret
   }
@@ -817,8 +817,8 @@
                         ^^
 
 :7:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
 MyStruct = struct @align(4) {
@@ -826,8 +826,8 @@
   b:i32 @offset(4)
 }
 
-%my_func = func(%2:ptr<private, MyStruct, read_write>, %3:i32):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, MyStruct, read_write>, %3:i32):void {
+  $B1: {
     %4:i32 = access %2, %3
     ret
   }
@@ -853,12 +853,12 @@
              ^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:mat3x2<f32>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:mat3x2<f32>):void {
+  $B1: {
     %3:i32 = access %2, 1u, 1u
     ret
   }
@@ -885,12 +885,12 @@
                                        ^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void {
+  $B1: {
     %3:ptr<private, i32, read_write> = access %2, 1u, 1u
     ret
   }
@@ -917,12 +917,12 @@
              ^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, array<array<f32, 2>, 3>, read_write>):void {
+  $B1: {
     %3:f32 = access %2, 1u, 1u
     ret
   }
@@ -948,12 +948,12 @@
                         ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, vec3<f32>, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, vec3<f32>, read_write>):void {
+  $B1: {
     %3:f32 = access %2, 1u
     ret
   }
@@ -993,12 +993,12 @@
                             ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<private, mat3x2<f32>, read_write>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<private, mat3x2<f32>, read_write>):void {
+  $B1: {
     %3:f32 = access %2, 1u, 1u
     ret
   }
@@ -1039,12 +1039,12 @@
                                  ^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<storage, array<f32, 2>, read>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<storage, array<f32, 2>, read>):void {
+  $B1: {
     %3:ptr<uniform, f32, read> = access %2, 1u
     ret
   }
@@ -1071,12 +1071,12 @@
                                        ^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func(%2:ptr<storage, array<f32, 2>, read>):void -> %b1 {
-  %b1 = block {
+%my_func = func(%2:ptr<storage, array<f32, 2>, read>):void {
+  $B1: {
     %3:ptr<storage, f32, read_write> = access %2, 1u
     ret
   }
@@ -1128,12 +1128,12 @@
     ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     ret
     ret
   }
@@ -1166,16 +1166,16 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:4:7 error: block: does not end in a terminator instruction
-      %b2 = block {  # true
-      ^^^^^^^^^^^
+      $B2: {  # true
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -1198,21 +1198,21 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(), R"(:3:8 error: if: condition must be a `bool` type
-    if 1i [t: %b2, f: %b3] {  # if_1
+    if 1i [t: $B2, f: $B3] {  # if_1
        ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if 1i [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if 1i [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -1235,21 +1235,21 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(), R"(:3:8 error: if: operand is undefined
-    if undef [t: %b2, f: %b3] {  # if_1
+    if undef [t: $B2, f: $B3] {  # if_1
        ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if undef [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if undef [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -1274,21 +1274,21 @@
     auto res = ir::Validate(mod);
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(), R"(:3:5 error: if: result is undefined
-    undef = if true [t: %b2, f: %b3] {  # if_1
+    undef = if true [t: $B2, f: $B3] {  # if_1
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    undef = if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    undef = if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -1322,14 +1322,14 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(),
               R"(:4:7 error: block: does not end in a terminator instruction
-      %b2 = block {  # body
-      ^^^^^^^^^^^
+      $B2: {  # body
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
       }
     }
     ret
@@ -1349,11 +1349,11 @@
   ^^^^^
 
 :1:1 note: In block
-%b1 = block {  # root
-^^^^^^^^^^^
+$B1: {  # root
+^^^
 
 note: # Disassembly
-%b1 = block {  # root
+$B1: {  # root
   undef = var
 }
 
@@ -1376,12 +1376,12 @@
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     undef = var
     ret
   }
@@ -1406,12 +1406,12 @@
                                         ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, f32, read_write> = var, %3
     ret
   }
@@ -1435,12 +1435,12 @@
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     undef = let 1i
     ret
   }
@@ -1464,12 +1464,12 @@
                  ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:f32 = let undef
     ret
   }
@@ -1494,12 +1494,12 @@
              ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:f32 = let 1i
     ret
   }
@@ -1525,12 +1525,12 @@
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^$ARROWS^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     <destroyed tint::core::ir::Var $ADDRESS>
     ret
   }
@@ -1562,12 +1562,12 @@
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, f32, read_write> = var
     ret
   }
@@ -1593,12 +1593,12 @@
                                              ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, f32, read_write> = var, %3
     ret
   }
@@ -1624,12 +1624,12 @@
                                              ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, f32, read_write> = var, %3
     ret
   }
@@ -1651,8 +1651,8 @@
     ASSERT_NE(res, Success);
     EXPECT_EQ(res.Failure().reason.Str(), R"(error: load: orphaned instruction: load
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, f32, read_write> = var
     ret
   }
@@ -1674,12 +1674,12 @@
                  ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:i32 = add undef, 2i
     ret
   }
@@ -1701,12 +1701,12 @@
                      ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:i32 = add 2i, undef
     ret
   }
@@ -1731,12 +1731,12 @@
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     undef = add 3i, 2i
     ret
   }
@@ -1758,12 +1758,12 @@
                       ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:i32 = negation undef
     ret
   }
@@ -1788,12 +1788,12 @@
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     undef = negation 2i
     ret
   }
@@ -1819,12 +1819,12 @@
     ^^^^^^^^^^^^^^^^^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:f32 = complement 2i
     ret
   }
@@ -1860,14 +1860,14 @@
         ^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # true
-      ^^^^^^^^^^^
+      $B2: {  # true
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         exit_if  # undef
       }
     }
@@ -1899,18 +1899,18 @@
         ^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # true
-      ^^^^^^^^^^^
+      $B2: {  # true
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
+      $B2: {  # true
         exit_if 1i  # if_1
       }
       # implicit false block: exit_if undef, undef
@@ -1943,18 +1943,18 @@
         ^^^^^^^^^^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # true
-      ^^^^^^^^^^^
+      $B2: {  # true
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
+      $B2: {  # true
         exit_if 1i, 2.0f, 3i  # if_1
       }
       # implicit false block: exit_if undef, undef
@@ -2004,18 +2004,18 @@
                     ^^
 
 :4:7 note: In block
-      %b2 = block {  # true
-      ^^^^^^^^^^^
+      $B2: {  # true
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = if true [t: $B2] {  # if_1
+      $B2: {  # true
         exit_if 1i, 2i  # if_1
       }
       # implicit false block: exit_if undef, undef
@@ -2044,14 +2044,14 @@
     ^^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         ret
       }
     }
@@ -2087,20 +2087,20 @@
             ^^^^^^^
 
 :6:11 note: In block
-          %b3 = block {  # true
-          ^^^^^^^^^^^
+          $B3: {  # true
+          ^^^
 
 :5:9 note: first control instruction jumped
-        if true [t: %b3] {  # if_2
+        if true [t: $B3] {  # if_2
         ^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        if true [t: %b3] {  # if_2
-          %b3 = block {  # true
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        if true [t: $B3] {  # if_2
+          $B3: {  # true
             exit_if  # if_1
           }
         }
@@ -2140,20 +2140,20 @@
             ^^^^^^^
 
 :6:11 note: In block
-          %b3 = block {  # case
-          ^^^^^^^^^^^
+          $B3: {  # case
+          ^^^
 
 :5:9 note: first control instruction jumped
-        switch 1i [c: (1i, %b3)] {  # switch_1
+        switch 1i [c: (1i, $B3)] {  # switch_1
         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        switch 1i [c: (1i, %b3)] {  # switch_1
-          %b3 = block {  # case
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        switch 1i [c: (1i, $B3)] {  # switch_1
+          $B3: {  # case
             exit_if  # if_1
           }
         }
@@ -2192,20 +2192,20 @@
             ^^^^^^^
 
 :6:11 note: In block
-          %b3 = block {  # body
-          ^^^^^^^^^^^
+          $B3: {  # body
+          ^^^
 
 :5:9 note: first control instruction jumped
-        loop [b: %b3] {  # loop_1
+        loop [b: $B3] {  # loop_1
         ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        loop [b: %b3] {  # loop_1
-          %b3 = block {  # body
+%my_func = func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        loop [b: $B3] {  # loop_1
+          $B3: {  # body
             exit_if  # if_1
           }
         }
@@ -2251,14 +2251,14 @@
         ^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # case
-      ^^^^^^^^^^^
+      $B2: {  # case
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%my_func = func():void {
+  $B1: {
+    switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch  # undef
       }
     }
@@ -2292,18 +2292,18 @@
         ^^^^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # case
-      ^^^^^^^^^^^
+      $B2: {  # case
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch 1i  # switch_1
       }
     }
@@ -2336,18 +2336,18 @@
         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # case
-      ^^^^^^^^^^^
+      $B2: {  # case
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch 1i, 2.0f, 3i  # switch_1
       }
     }
@@ -2398,18 +2398,18 @@
                         ^^
 
 :4:7 note: In block
-      %b2 = block {  # case
-      ^^^^^^^^^^^
+      $B2: {  # case
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch 1i, 2i  # switch_1
       }
     }
@@ -2442,19 +2442,19 @@
         ^^^^^^^^^^^
 
 :9:7 note: In block
-      %b3 = block {  # true
-      ^^^^^^^^^^^
+      $B3: {  # true
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%my_func = func():void {
+  $B1: {
+    switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret
       }
     }
-    if true [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if true [t: $B3] {  # if_1
+      $B3: {  # true
         exit_switch  # switch_1
       }
     }
@@ -2523,20 +2523,20 @@
             ^^^^^^^^^^^
 
 :6:11 note: In block
-          %b3 = block {  # case
-          ^^^^^^^^^^^
+          $B3: {  # case
+          ^^^
 
 :5:9 note: first control instruction jumped
-        switch false [c: (default, %b3)] {  # switch_2
+        switch false [c: (default, $B3)] {  # switch_2
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
-        switch false [c: (default, %b3)] {  # switch_2
-          %b3 = block {  # case
+%my_func = func():void {
+  $B1: {
+    switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
+        switch false [c: (default, $B3)] {  # switch_2
+          $B3: {  # case
             exit_switch  # switch_1
           }
         }
@@ -2574,20 +2574,20 @@
             ^^^^^^^^^^^
 
 :6:11 note: In block
-          %b3 = block {  # body
-          ^^^^^^^^^^^
+          $B3: {  # body
+          ^^^
 
 :5:9 note: first control instruction jumped
-        loop [b: %b3] {  # loop_1
+        loop [b: $B3] {  # loop_1
         ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    switch true [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
-        loop [b: %b3] {  # loop_1
-          %b3 = block {  # body
+%my_func = func():void {
+  $B1: {
+    switch true [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
+        loop [b: $B3] {  # loop_1
+          $B3: {  # body
             exit_switch  # switch_1
           }
         }
@@ -2631,18 +2631,18 @@
         ^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # body
-      ^^^^^^^^^^^
+      $B2: {  # body
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         exit_loop  # undef
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -2674,22 +2674,22 @@
         ^^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # body
-      ^^^^^^^^^^^
+      $B2: {  # body
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         exit_loop 1i  # loop_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -2721,22 +2721,22 @@
         ^^^^^^^^^^^^^^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # body
-      ^^^^^^^^^^^
+      $B2: {  # body
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         exit_loop 1i, 2.0f, 3i  # loop_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -2786,22 +2786,22 @@
                       ^^
 
 :4:7 note: In block
-      %b2 = block {  # body
-      ^^^^^^^^^^^
+      $B2: {  # body
+      ^^^
 
 :3:5 note: control instruction
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    %2:i32, %3:f32 = loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    %2:i32, %3:f32 = loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         exit_loop 1i, 2i  # loop_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -2832,22 +2832,22 @@
         ^^^^^^^^^
 
 :12:7 note: In block
-      %b4 = block {  # true
-      ^^^^^^^^^^^
+      $B4: {  # true
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         ret
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
-    if true [t: %b4] {  # if_1
-      %b4 = block {  # true
+    if true [t: $B4] {  # if_1
+      $B4: {  # true
         exit_loop  # loop_1
       }
     }
@@ -2915,27 +2915,27 @@
             ^^^^^^^^^
 
 :6:11 note: In block
-          %b4 = block {  # case
-          ^^^^^^^^^^^
+          $B4: {  # case
+          ^^^
 
 :5:9 note: first control instruction jumped
-        switch false [c: (default, %b4)] {  # switch_1
+        switch false [c: (default, $B4)] {  # switch_1
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        switch false [c: (default, %b4)] {  # switch_1
-          %b4 = block {  # case
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        switch false [c: (default, $B4)] {  # switch_1
+          $B4: {  # case
             exit_loop  # loop_1
           }
         }
         exit_loop  # loop_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -2970,27 +2970,27 @@
             ^^^^^^^^^
 
 :6:11 note: In block
-          %b4 = block {  # body
-          ^^^^^^^^^^^
+          $B4: {  # body
+          ^^^
 
 :5:9 note: first control instruction jumped
-        loop [b: %b4] {  # loop_2
+        loop [b: $B4] {  # loop_2
         ^^^^^^^^^^^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        loop [b: %b4] {  # loop_2
-          %b4 = block {  # body
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        loop [b: $B4] {  # loop_2
+          $B4: {  # body
             exit_loop  # loop_1
           }
         }
         exit_loop  # loop_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -3020,17 +3020,17 @@
         ^^^^^^^^^
 
 :7:7 note: In block
-      %b3 = block {  # continuing
-      ^^^^^^^^^^^
+      $B3: {  # continuing
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         exit_loop  # loop_1
       }
     }
@@ -3066,27 +3066,27 @@
             ^^^^^^^^^
 
 :9:11 note: In block
-          %b4 = block {  # true
-          ^^^^^^^^^^^
+          $B4: {  # true
+          ^^^
 
 :7:7 note: in continuing block
-      %b3 = block {  # continuing
-      ^^^^^^^^^^^
+      $B3: {  # continuing
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+%my_func = func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        if true [t: %b4] {  # if_1
-          %b4 = block {  # true
+      $B3: {  # continuing
+        if true [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
-        next_iteration %b2
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -3118,21 +3118,21 @@
         ^^^^^^^^^
 
 :4:7 note: In block
-      %b2 = block {  # initializer
-      ^^^^^^^^^^^
+      $B2: {  # initializer
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
+%my_func = func():void {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
         exit_loop  # loop_1
       }
-      %b3 = block {  # body
-        continue %b4
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
-        next_iteration %b3
+      $B4: {  # continuing
+        next_iteration  # -> $B3
       }
     }
     ret
@@ -3168,30 +3168,30 @@
             ^^^^^^^^^
 
 :6:11 note: In block
-          %b5 = block {  # true
-          ^^^^^^^^^^^
+          $B5: {  # true
+          ^^^
 
 :4:7 note: in initializer block
-      %b2 = block {  # initializer
-      ^^^^^^^^^^^
+      $B2: {  # initializer
+      ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
-        if true [t: %b5] {  # if_1
-          %b5 = block {  # true
+%my_func = func():void {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
+        if true [t: $B5] {  # if_1
+          $B5: {  # true
             exit_loop  # loop_1
           }
         }
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
-        continue %b4
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
-        next_iteration %b3
+      $B4: {  # continuing
+        next_iteration  # -> $B3
       }
     }
     ret
@@ -3231,12 +3231,12 @@
     ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     ret
   }
 }
@@ -3256,12 +3256,12 @@
     ^^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     ret 42i
   }
 }
@@ -3281,12 +3281,12 @@
     ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():i32 -> %b1 {
-  %b1 = block {
+%my_func = func():i32 {
+  $B1: {
     ret
   }
 }
@@ -3307,12 +3307,12 @@
     ^^^^^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():i32 -> %b1 {
-  %b1 = block {
+%my_func = func():i32 {
+  $B1: {
     ret 42.0f
   }
 }
@@ -3335,12 +3335,12 @@
                   ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:i32 = load undef
     ret
   }
@@ -3366,12 +3366,12 @@
                   ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %l:i32 = let 1i
     %3:f32 = load %l
     ret
@@ -3398,12 +3398,12 @@
                   ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:f32 = load %2
     ret
@@ -3427,12 +3427,12 @@
           ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     store undef, 42i
     ret
   }
@@ -3456,12 +3456,12 @@
               ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, undef
     ret
@@ -3487,12 +3487,12 @@
               ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %l:i32 = let 1i
     store %l, 42u
     ret
@@ -3518,12 +3518,12 @@
               ^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 42u
     ret
@@ -3550,12 +3550,12 @@
     ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, vec3<f32>, read_write> = var
     undef = load_vector_element %2, 1i
     ret
@@ -3580,12 +3580,12 @@
                                  ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:f32 = load_vector_element undef, 1i
     ret
   }
@@ -3610,12 +3610,12 @@
                                      ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, vec3<f32>, read_write> = var
     %3:f32 = load_vector_element %2, undef
     ret
@@ -3640,12 +3640,12 @@
                          ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     store_vector_element undef, 1i, 2i
     ret
   }
@@ -3670,20 +3670,20 @@
                              ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 :4:37 error: store_vector_element: value type does not match vector pointer element type
     store_vector_element %2, undef, 2i
                                     ^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, vec3<f32>, read_write> = var
     store_vector_element %2, undef, 2i
     ret
@@ -3709,12 +3709,12 @@
                                  ^^^^^
 
 :2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
+  $B1: {
+  ^^^
 
 note: # Disassembly
-%my_func = func():void -> %b1 {
-  %b1 = block {
+%my_func = func():void {
+  $B1: {
     %2:ptr<function, vec3<f32>, read_write> = var
     store_vector_element %2, 1i, undef
     ret
diff --git a/src/tint/lang/glsl/writer/writer_ast_fuzz.cc b/src/tint/lang/glsl/writer/writer_ast_fuzz.cc
index 577f4f2..839e466 100644
--- a/src/tint/lang/glsl/writer/writer_ast_fuzz.cc
+++ b/src/tint/lang/glsl/writer/writer_ast_fuzz.cc
@@ -35,13 +35,31 @@
 namespace tint::glsl::writer {
 namespace {
 
-void ASTFuzzer(const tint::Program& program, Options options) {
+bool CanRun(const tint::Program& program, const Options& options) {
     if (program.AST().HasOverrides()) {
-        return;
+        return false;  // Overrides are not supported.
     }
 
-    if (options.first_instance_offset > 0x10000) {
-        return;  // Excessive values can cause OOM.
+    // Excessive values can cause OOM / timeouts in the PadStructs transform.
+    static constexpr uint32_t kMaxOffset = 0x1000;
+
+    if (options.first_instance_offset > kMaxOffset) {
+        return false;
+    }
+
+    if (options.depth_range_offsets) {
+        if (options.depth_range_offsets->max > kMaxOffset ||
+            options.depth_range_offsets->min > kMaxOffset) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void ASTFuzzer(const tint::Program& program, const Options& options) {
+    if (!CanRun(program, options)) {
+        return;
     }
 
     auto inspector = tint::inspector::Inspector(program);
diff --git a/src/tint/lang/msl/writer/raise/builtin_polyfill_test.cc b/src/tint/lang/msl/writer/raise/builtin_polyfill_test.cc
index b61a9a0..915307b 100644
--- a/src/tint/lang/msl/writer/raise/builtin_polyfill_test.cc
+++ b/src/tint/lang/msl/writer/raise/builtin_polyfill_test.cc
@@ -52,8 +52,8 @@
     });
 
     auto* src = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = workgroupBarrier
     ret
   }
@@ -62,8 +62,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = msl.threadgroup_barrier 4u
     ret
   }
@@ -84,8 +84,8 @@
     });
 
     auto* src = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = storageBarrier
     ret
   }
@@ -94,8 +94,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = msl.threadgroup_barrier 1u
     ret
   }
@@ -116,8 +116,8 @@
     });
 
     auto* src = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = textureBarrier
     ret
   }
@@ -126,8 +126,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     %2:void = msl.threadgroup_barrier 2u
     ret
   }
diff --git a/src/tint/lang/spirv/reader/lower/vector_element_pointer_test.cc b/src/tint/lang/spirv/reader/lower/vector_element_pointer_test.cc
index e7160a5..ade391c 100644
--- a/src/tint/lang/spirv/reader/lower/vector_element_pointer_test.cc
+++ b/src/tint/lang/spirv/reader/lower/vector_element_pointer_test.cc
@@ -48,8 +48,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %2:u32 = access %vec, 2u
     ret %2
   }
@@ -73,8 +73,8 @@
     });
 
     auto* src = R"(
-%foo = func():vec4<u32> -> %b1 {
-  %b1 = block {
+%foo = func():vec4<u32> {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, vec4<u32>, read_write> = access %vec
     %4:vec4<u32> = load %3
@@ -102,8 +102,8 @@
     });
 
     auto* src = R"(
-%foo = func():vec4<u32> -> %b1 {
-  %b1 = block {
+%foo = func():vec4<u32> {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, vec4<u32>, read_write> = access %vec
     %4:ptr<function, vec4<u32>, read_write> = access %3
@@ -131,8 +131,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %vec, 2u
     ret
@@ -142,8 +142,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     ret
   }
@@ -165,8 +165,8 @@
     });
 
     auto* src = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %vec, 2u
     %4:u32 = load %3
@@ -177,8 +177,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():u32 -> %b1 {
-  %b1 = block {
+%foo = func():u32 {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:u32 = load_vector_element %vec, 2u
     ret %3
@@ -201,8 +201,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %vec, 2u
     store %3, 42u
@@ -213,8 +213,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, 2u, 42u
     ret
@@ -238,8 +238,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %vec, 2u
     %4:ptr<function, u32, read_write> = access %3
@@ -251,8 +251,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %vec, 2u, 42u
     ret
@@ -277,8 +277,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %vec, 2u
     %4:u32 = load %3
@@ -291,8 +291,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %vec:ptr<function, vec4<u32>, read_write> = var
     %3:u32 = load_vector_element %vec, 2u
     %4:u32 = add %3, 1u
@@ -317,8 +317,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %3:ptr<function, f32, read_write> = access %mat, 1u, 2u
     store %3, 42.0f
@@ -329,8 +329,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %mat:ptr<function, mat4x4<f32>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %mat, 1u
     store_vector_element %3, 2u, 42.0f
@@ -354,8 +354,8 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %arr:ptr<function, array<vec4<f32>, 4>, read_write> = var
     %3:ptr<function, f32, read_write> = access %arr, 1u, 2u
     store %3, 42.0f
@@ -366,8 +366,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %arr:ptr<function, array<vec4<f32>, 4>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %arr, 1u
     store_vector_element %3, 2u, 42.0f
@@ -400,8 +400,8 @@
   vec:vec4<f32> @offset(0)
 }
 
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %str:ptr<function, str, read_write> = var
     %3:ptr<function, f32, read_write> = access %str, 0u, 2u
     store %3, 42.0f
@@ -416,8 +416,8 @@
   vec:vec4<f32> @offset(0)
 }
 
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %str:ptr<function, str, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %str, 0u
     store_vector_element %3, 2u, 42.0f
@@ -452,8 +452,8 @@
   inner:array<mat4x4<f32>, 4> @offset(0)
 }
 
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %arr:ptr<function, array<str, 4>, read_write> = var
     %3:ptr<function, f32, read_write> = access %arr, 1u, 0u, 3u, 2u, 1u
     store %3, 42.0f
@@ -468,8 +468,8 @@
   inner:array<mat4x4<f32>, 4> @offset(0)
 }
 
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %arr:ptr<function, array<str, 4>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %arr, 1u, 0u, 3u, 2u
     store_vector_element %3, 1u, 42.0f
diff --git a/src/tint/lang/spirv/reader/parser/composite_test.cc b/src/tint/lang/spirv/reader/parser/composite_test.cc
index 6a0ce9f..463e33b 100644
--- a/src/tint/lang/spirv/reader/parser/composite_test.cc
+++ b/src/tint/lang/spirv/reader/parser/composite_test.cc
@@ -57,7 +57,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b2 = block {
+%2 = func():vec4<u32> {
+  $B2: {
     %3:vec4<u32> = construct 1u, 2u, 3u, 4u
     ret %3
   }
@@ -95,7 +96,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b2 = block {
+%2 = func():mat4x3<f32> {
+  $B2: {
     %3:vec3<f32> = construct 1.0f, 2.0f, 3.0f
     %4:vec3<f32> = construct 2.0f, 3.0f, 1.0f
     %5:vec3<f32> = construct 3.0f, 2.0f, 1.0f
@@ -133,7 +135,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b2 = block {
+%2 = func():array<u32, 4> {
+  $B2: {
     %3:array<u32, 4> = construct 1u, 2u, 3u, 4u
     ret %3
   }
@@ -172,7 +175,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b2 = block {
+%2 = func():array<vec4<u32>, 4> {
+  $B2: {
     %3:vec4<u32> = construct 1u, 2u, 3u, 4u
     %4:vec4<u32> = construct 2u, 3u, 4u, 1u
     %5:vec4<u32> = construct 3u, 4u, 1u, 2u
@@ -222,13 +226,13 @@
   tint_symbol_2:array<vec4<u32>, 2> @offset(32)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     ret
   }
 }
-%2 = func():tint_symbol_3 -> %b2 {
-  %b2 = block {
+%2 = func():tint_symbol_3 {
+  $B2: {
     %3:vec4<u32> = construct 1u, 2u, 3u, 4u
     %4:vec4<u32> = construct 2u, 3u, 4u, 1u
     %5:vec4<u32> = construct 3u, 4u, 1u, 2u
@@ -264,8 +268,8 @@
                OpFunctionEnd
 )",
               R"(
-%2 = func(%3:vec4<u32>):u32 -> %b2 {
-  %b2 = block {
+%2 = func(%3:vec4<u32>):u32 {
+  $B2: {
     %4:u32 = access %3, 2u
     ret %4
   }
@@ -299,8 +303,8 @@
                OpFunctionEnd
 )",
               R"(
-%2 = func(%3:mat4x3<f32>):vec3<f32> -> %b2 {
-  %b2 = block {
+%2 = func(%3:mat4x3<f32>):vec3<f32> {
+  $B2: {
     %4:vec3<f32> = access %3, 2u
     ret %4
   }
@@ -334,8 +338,8 @@
                OpFunctionEnd
 )",
               R"(
-%2 = func(%3:mat4x3<f32>):f32 -> %b2 {
-  %b2 = block {
+%2 = func(%3:mat4x3<f32>):f32 {
+  $B2: {
     %4:f32 = access %3, 2u, 1u
     ret %4
   }
@@ -368,8 +372,8 @@
                OpFunctionEnd
 )",
               R"(
-%2 = func(%3:array<u32, 4>):u32 -> %b2 {
-  %b2 = block {
+%2 = func(%3:array<u32, 4>):u32 {
+  $B2: {
     %4:u32 = access %3, 2u
     ret %4
   }
@@ -403,8 +407,8 @@
                OpFunctionEnd
 )",
               R"(
-%2 = func(%3:array<vec3<u32>, 4>):u32 -> %b2 {
-  %b2 = block {
+%2 = func(%3:array<vec3<u32>, 4>):u32 {
+  $B2: {
     %4:u32 = access %3, 1u, 2u
     ret %4
   }
@@ -441,13 +445,13 @@
   tint_symbol_1:u32 @offset(4)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     ret
   }
 }
-%2 = func(%3:tint_symbol_2):u32 -> %b2 {
-  %b2 = block {
+%2 = func(%3:tint_symbol_2):u32 {
+  $B2: {
     %4:u32 = access %3, 1u
     ret %4
   }
diff --git a/src/tint/lang/spirv/reader/parser/constant_test.cc b/src/tint/lang/spirv/reader/parser/constant_test.cc
index 862db10..b509dc0 100644
--- a/src/tint/lang/spirv/reader/parser/constant_test.cc
+++ b/src/tint/lang/spirv/reader/parser/constant_test.cc
@@ -64,8 +64,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:void = call %2, true
     %6:void = call %2, false
     %7:void = call %2, false
@@ -115,8 +115,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:void = call %2, 0i
     %6:void = call %2, 1i
     %7:void = call %2, -1i
@@ -165,8 +165,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:void = call %2, 0u
     %6:void = call %2, 1u
     %7:void = call %2, 4294967295u
@@ -218,8 +218,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:void = call %2, 0.0h
     %6:void = call %2, 1.0h
     %7:void = call %2, 65504.0h
@@ -272,8 +272,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:void = call %2, 0.0f
     %6:void = call %2, 1.0f
     %7:void = call %2, 340282346638528859811704183484516925440.0f
@@ -321,8 +321,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:vec2<bool> = call %2, vec2<bool>(true, false)
     %6:vec2<bool> = call %2, vec2<bool>(false)
     ret
@@ -367,8 +367,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:vec3<i32> = call %2, vec3<i32>(0i, 1i, -1i)
     %6:vec3<i32> = call %2, vec3<i32>(0i)
     ret
@@ -414,8 +414,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:vec4<f32> = call %2, vec4<f32>(0.0f, 1.0f, 340282346638528859811704183484516925440.0f, -340282346638528859811704183484516925440.0f)
     %6:vec4<f32> = call %2, vec4<f32>(0.0f)
     ret
@@ -462,8 +462,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:mat2x4<f32> = call %2, mat2x4<f32>(vec4<f32>(0.0f), vec4<f32>(1.0f))
     %6:mat2x4<f32> = call %2, mat2x4<f32>(vec4<f32>(0.0f))
     ret
@@ -513,8 +513,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:mat3x2<f16> = call %2, mat3x2<f16>(vec2<f16>(0.0h), vec2<f16>(1.0h), vec2<f16>(65504.0h))
     %6:mat3x2<f16> = call %2, mat3x2<f16>(vec2<f16>(0.0h))
     ret
@@ -561,8 +561,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:array<i32, 4> = call %2, array<i32, 4>(0i, 1i, -1i, 2147483647i)
     %6:array<i32, 4> = call %2, array<i32, 4>(0i)
     ret
@@ -614,8 +614,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:array<array<f32, 4>, 2> = call %2, array<array<f32, 4>, 2>(array<f32, 4>(0.0f, 1.0f, 340282346638528859811704183484516925440.0f, -340282346638528859811704183484516925440.0f), array<f32, 4>(-340282346638528859811704183484516925440.0f, 340282346638528859811704183484516925440.0f, 1.0f, 0.0f))
     %6:array<array<f32, 4>, 2> = call %2, array<array<f32, 4>, 2>(array<f32, 4>(0.0f))
     ret
@@ -660,8 +660,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:tint_symbol_2 = call %2, tint_symbol_2(42i, -1.0f)
     %6:tint_symbol_2 = call %2, tint_symbol_2(0i, 0.0f)
     ret
@@ -715,8 +715,8 @@
                OpFunctionEnd
 )",
               R"(
-%4 = func():void -> %b3 {
-  %b3 = block {
+%4 = func():void {
+  $B3: {
     %5:tint_symbol_5 = call %2, tint_symbol_5(array<tint_symbol_2, 2>(tint_symbol_2(42i, -1.0f), tint_symbol_2(-1i, 42.0f)), array<tint_symbol_2, 2>(tint_symbol_2(-1i, 42.0f), tint_symbol_2(42i, -1.0f)))
     %6:tint_symbol_5 = call %2, tint_symbol_5(array<tint_symbol_2, 2>(tint_symbol_2(0i, 0.0f)))
     ret
diff --git a/src/tint/lang/spirv/reader/parser/function_test.cc b/src/tint/lang/spirv/reader/parser/function_test.cc
index a66b1e0..d268ebb 100644
--- a/src/tint/lang/spirv/reader/parser/function_test.cc
+++ b/src/tint/lang/spirv/reader/parser/function_test.cc
@@ -44,8 +44,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     ret
   }
 }
@@ -66,8 +66,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @compute @workgroup_size(3, 4, 5) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(3, 4, 5) func():void {
+  $B1: {
     ret
   }
 }
@@ -88,8 +88,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @fragment func():void -> %b1 {
-  %b1 = block {
+%main = @fragment func():void {
+  $B1: {
     ret
   }
 }
@@ -109,8 +109,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @vertex func():void -> %b1 {
-  %b1 = block {
+%main = @vertex func():void {
+  $B1: {
     ret
   }
 }
@@ -139,13 +139,13 @@
                OpFunctionEnd
 )",
               R"(
-%foo = @compute @workgroup_size(3, 4, 5) func():void -> %b1 {
-  %b1 = block {
+%foo = @compute @workgroup_size(3, 4, 5) func():void {
+  $B1: {
     ret
   }
 }
-%bar = @compute @workgroup_size(6, 7, 8) func():void -> %b2 {
-  %b2 = block {
+%bar = @compute @workgroup_size(6, 7, 8) func():void {
+  $B2: {
     ret
   }
 }
@@ -173,13 +173,13 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func():void -> %b1 {
-  %b1 = block {
+%1 = func():void {
+  $B1: {
     ret
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:void = call %1
     ret
   }
@@ -208,14 +208,14 @@
                OpFunctionEnd
 )",
               R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:void = call %3
     ret
   }
 }
-%3 = func():void -> %b2 {
-  %b2 = block {
+%3 = func():void {
+  $B2: {
     ret
   }
 }
@@ -249,13 +249,13 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func(%2:bool):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:bool):void {
+  $B1: {
     ret
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %4:void = call %1, true
     %5:void = call %1, false
     ret
@@ -298,19 +298,19 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func(%2:bool):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:bool):void {
+  $B1: {
     ret
   }
 }
-%3 = func(%4:bool):void -> %b2 {
-  %b2 = block {
+%3 = func(%4:bool):void {
+  $B2: {
     %5:void = call %1, %4
     ret
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b3 {
-  %b3 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B3: {
     %7:void = call %3, true
     %8:void = call %3, false
     ret
@@ -346,13 +346,13 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func(%2:bool, %3:bool):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:bool, %3:bool):void {
+  $B1: {
     ret
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %5:void = call %1, true, false
     ret
   }
@@ -384,13 +384,13 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func():bool -> %b1 {
-  %b1 = block {
+%1 = func():bool {
+  $B1: {
     ret true
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = call %1
     ret
   }
@@ -428,19 +428,19 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func():bool -> %b1 {
-  %b1 = block {
+%1 = func():bool {
+  $B1: {
     ret true
   }
 }
-%2 = func():bool -> %b2 {
-  %b2 = block {
+%2 = func():bool {
+  $B2: {
     %3:bool = call %2
     ret %3
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b3 {
-  %b3 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B3: {
     %5:bool = call %1
     ret
   }
@@ -473,13 +473,13 @@
                OpFunctionEnd
 )",
               R"(
-%1 = func(%2:bool):bool -> %b1 {
-  %b1 = block {
+%1 = func(%2:bool):bool {
+  $B1: {
     ret %2
   }
 }
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %4:bool = call %1, true
     ret
   }
diff --git a/src/tint/lang/spirv/reader/parser/memory_test.cc b/src/tint/lang/spirv/reader/parser/memory_test.cc
index acb3972..90e4945 100644
--- a/src/tint/lang/spirv/reader/parser/memory_test.cc
+++ b/src/tint/lang/spirv/reader/parser/memory_test.cc
@@ -48,7 +48,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, u32, read_write> = var
     %3:u32 = load %2
     ret
@@ -75,7 +76,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     %3:vec4<u32> = load %2
     ret
@@ -105,7 +107,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 2u
     %4:u32 = load %3
@@ -135,7 +138,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, mat3x4<f32>, read_write> = var
     %3:mat3x4<f32> = load %2
     ret
@@ -167,7 +171,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, mat3x4<f32>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %2, 2u
     %4:vec4<f32> = load %3
@@ -196,7 +201,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<u32, 4>, read_write> = var
     %3:array<u32, 4> = load %2
     ret
@@ -227,7 +233,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<u32, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 2u
     %4:u32 = load %3
@@ -255,7 +262,13 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+tint_symbol_2 = struct @align(4) {
+  tint_symbol:u32 @offset(0)
+  tint_symbol_1:u32 @offset(4)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, tint_symbol_2, read_write> = var
     %3:tint_symbol_2 = load %2
     ret
@@ -285,7 +298,13 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+tint_symbol_2 = struct @align(4) {
+  tint_symbol:u32 @offset(0)
+  tint_symbol_1:u32 @offset(4)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, tint_symbol_2, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 1u
     %4:u32 = load %3
@@ -313,7 +332,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, u32, read_write> = var
     store %2, 42u
     ret
@@ -341,7 +361,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     store %2, vec4<u32>(0u)
     ret
@@ -372,7 +393,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 2u
     store %3, 42u
@@ -403,7 +425,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, mat3x4<f32>, read_write> = var
     store %2, mat3x4<f32>(vec4<f32>(0.0f))
     ret
@@ -436,7 +459,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, mat3x4<f32>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %2, 2u
     store %3, vec4<f32>(0.0f)
@@ -466,7 +490,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<u32, 4>, read_write> = var
     store %2, array<u32, 4>(0u)
     ret
@@ -498,7 +523,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<u32, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 2u
     store %3, 42u
@@ -527,7 +553,13 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+tint_symbol_2 = struct @align(4) {
+  tint_symbol:u32 @offset(0)
+  tint_symbol_1:u32 @offset(4)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, tint_symbol_2, read_write> = var
     store %2, tint_symbol_2(0u)
     ret
@@ -558,7 +590,13 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+tint_symbol_2 = struct @align(4) {
+  tint_symbol:u32 @offset(0)
+  tint_symbol_1:u32 @offset(4)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, tint_symbol_2, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 1u
     store %3, 42u
@@ -596,7 +634,14 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+  tint_symbol:array<u32, 4> @offset(0)
+  tint_symbol_1:array<u32, 4> @offset(16)
+  tint_symbol_2:array<u32, 4> @offset(32)
+  tint_symbol_3:array<u32, 4> @offset(48)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<tint_symbol_4, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 1u, 2u, 3u
     %4:u32 = load %3
@@ -639,7 +684,14 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+  tint_symbol:array<u32, 4> @offset(0)
+  tint_symbol_1:array<u32, 4> @offset(16)
+  tint_symbol_2:array<u32, 4> @offset(32)
+  tint_symbol_3:array<u32, 4> @offset(48)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<tint_symbol_4, 4>, read_write> = var
     %3:ptr<function, tint_symbol_4, read_write> = access %2, 1u
     %4:ptr<function, array<u32, 4>, read_write> = access %3, 2u
@@ -671,7 +723,8 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, u32, read_write> = var
     %3:ptr<function, u32, read_write> = access %2
     %4:ptr<function, u32, read_write> = access %3
@@ -711,7 +764,14 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+  tint_symbol:array<u32, 4> @offset(0)
+  tint_symbol_1:array<u32, 4> @offset(16)
+  tint_symbol_2:array<u32, 4> @offset(32)
+  tint_symbol_3:array<u32, 4> @offset(48)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<tint_symbol_4, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 1i, 2u, 3i
     %4:u32 = load %3
@@ -750,7 +810,14 @@
                OpFunctionEnd
 )",
               R"(
-  %b1 = block {
+  tint_symbol:array<u32, 4> @offset(0)
+  tint_symbol_1:array<u32, 4> @offset(16)
+  tint_symbol_2:array<u32, 4> @offset(32)
+  tint_symbol_3:array<u32, 4> @offset(48)
+}
+
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, array<tint_symbol_4, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %2, 1u, 2u, 3u
     %4:u32 = load %3
@@ -797,13 +864,13 @@
   tint_symbol:u32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read> = var @binding_point(1, 2)
   %2:ptr<storage, tint_symbol_1, read_write> = var @binding_point(1, 3)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %4:ptr<storage, u32, read> = access %1, 0u
     %5:ptr<storage, u32, read_write> = access %2, 0u
     %6:u32 = load %4
diff --git a/src/tint/lang/spirv/reader/parser/struct_test.cc b/src/tint/lang/spirv/reader/parser/struct_test.cc
index bedb4e2..88d7349 100644
--- a/src/tint/lang/spirv/reader/parser/struct_test.cc
+++ b/src/tint/lang/spirv/reader/parser/struct_test.cc
@@ -90,8 +90,8 @@
   tint_symbol_1:i32 @offset(4)
 }
 
-%1 = func(%2:tint_symbol_2):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:tint_symbol_2):void {
+  $B1: {
     ret
   }
 }
@@ -128,8 +128,8 @@
   tint_symbol_1:i32 @offset(4)
 }
 
-%1 = func(%2:tint_symbol_2, %3:tint_symbol_2):tint_symbol_2 -> %b1 {
-  %b1 = block {
+%1 = func(%2:tint_symbol_2, %3:tint_symbol_2):tint_symbol_2 {
+  $B1: {
     ret %2
   }
 }
@@ -178,8 +178,8 @@
   tint_symbol_8:tint_symbol_2 @offset(24)
 }
 
-%1 = func(%2:tint_symbol_9):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:tint_symbol_9):void {
+  $B1: {
     ret
   }
 }
@@ -221,8 +221,8 @@
   tint_symbol_3:i32 @offset(64)
 }
 
-%1 = func(%2:tint_symbol_4):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:tint_symbol_4):void {
+  $B1: {
     ret
   }
 }
diff --git a/src/tint/lang/spirv/reader/parser/var_test.cc b/src/tint/lang/spirv/reader/parser/var_test.cc
index f524b23..f7bbc1b 100644
--- a/src/tint/lang/spirv/reader/parser/var_test.cc
+++ b/src/tint/lang/spirv/reader/parser/var_test.cc
@@ -47,8 +47,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, u32, read_write> = var
     ret
   }
@@ -74,8 +74,8 @@
                OpFunctionEnd
 )",
               R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, u32, read_write> = var, 42u
     ret
   }
@@ -100,12 +100,12 @@
                OpFunctionEnd
 )",
               R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, u32, read_write> = var
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -130,12 +130,12 @@
                OpFunctionEnd
 )",
               R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, u32, read_write> = var, 42u
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -170,12 +170,12 @@
   tint_symbol:u32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read> = var @binding_point(1, 2)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -209,12 +209,12 @@
   tint_symbol:u32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read_write> = var @binding_point(1, 2)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -252,13 +252,13 @@
   tint_symbol:u32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, tint_symbol_1, read> = var @binding_point(1, 2)
   %2:ptr<storage, tint_symbol_1, read_write> = var @binding_point(1, 3)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
@@ -292,12 +292,12 @@
   tint_symbol:u32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<uniform, tint_symbol_1, read> = var @binding_point(1, 2)
 }
 
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     ret
   }
 }
diff --git a/src/tint/lang/spirv/reader/reader_test.cc b/src/tint/lang/spirv/reader/reader_test.cc
index 40c07da..20a0ebb 100644
--- a/src/tint/lang/spirv/reader/reader_test.cc
+++ b/src/tint/lang/spirv/reader/reader_test.cc
@@ -110,8 +110,8 @@
 )");
     ASSERT_EQ(got, Success);
     EXPECT_EQ(got, R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     %3:u32 = load_vector_element %2, 2u
     ret
@@ -144,8 +144,8 @@
 )");
     ASSERT_EQ(got, Success);
     EXPECT_EQ(got, R"(
-%main = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%main = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %2:ptr<function, vec4<u32>, read_write> = var
     store_vector_element %2, 2u, 42u
     ret
diff --git a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
index 29b11d0..1049aac 100644
--- a/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
+++ b/src/tint/lang/spirv/writer/raise/builtin_polyfill_test.cc
@@ -71,12 +71,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, array<i32>, read_write> = access %var, 2u
     %4:u32 = arrayLength %3
     ret %4
@@ -92,12 +92,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, array<i32>, read_write> = access %var, 2u
     %4:u32 = spirv.array_length %var, 2u
     ret %4
@@ -137,12 +137,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %a:ptr<storage, Buffer, read_write> = let %var
     %b:ptr<storage, Buffer, read_write> = let %a
     %5:ptr<storage, array<i32>, read_write> = access %b, 2u
@@ -160,12 +160,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %a:ptr<storage, Buffer, read_write> = let %var
     %b:ptr<storage, Buffer, read_write> = let %a
     %5:ptr<storage, array<i32>, read_write> = access %b, 2u
@@ -207,12 +207,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, array<i32>, read_write> = access %var, 2u
     %a:ptr<storage, array<i32>, read_write> = let %3
     %b:ptr<storage, array<i32>, read_write> = let %a
@@ -230,12 +230,12 @@
   arr:array<i32> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<storage, Buffer, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func():u32 -> %b2 {
-  %b2 = block {
+%foo = func():u32 {
+  $B2: {
     %3:ptr<storage, array<i32>, read_write> = access %var, 2u
     %a:ptr<storage, array<i32>, read_write> = let %3
     %b:ptr<storage, array<i32>, read_write> = let %a
@@ -265,12 +265,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicAdd %1, %arg1
     ret %4
   }
@@ -279,12 +279,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, atomic<i32>, read_write> = var @binding_point(0, 0)
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_iadd %1, 1u, 0u, %arg1
     ret %4
   }
@@ -309,12 +309,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicAdd %1, %arg1
     ret %4
   }
@@ -323,12 +323,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_iadd %1, 2u, 0u, %arg1
     ret %4
   }
@@ -353,12 +353,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicAnd %1, %arg1
     ret %4
   }
@@ -367,12 +367,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_and %1, 2u, 0u, %arg1
     ret %4
   }
@@ -405,12 +405,12 @@
   exchanged:bool @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%cmp:i32, %val:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%cmp:i32, %val:i32):i32 {
+  $B2: {
     %5:__atomic_compare_exchange_result_i32 = atomicCompareExchangeWeak %1, %cmp, %val
     %6:i32 = access %5, 0u
     ret %6
@@ -425,12 +425,12 @@
   exchanged:bool @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%cmp:i32, %val:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%cmp:i32, %val:i32):i32 {
+  $B2: {
     %5:i32 = spirv.atomic_compare_exchange %1, 2u, 0u, 0u, %val, %cmp
     %6:bool = eq %5, %cmp
     %7:__atomic_compare_exchange_result_i32 = construct %5, %6
@@ -458,12 +458,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicExchange %1, %arg1
     ret %4
   }
@@ -472,12 +472,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_exchange %1, 2u, 0u, %arg1
     ret %4
   }
@@ -500,12 +500,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func():i32 -> %b2 {
-  %b2 = block {
+%foo = func():i32 {
+  $B2: {
     %3:i32 = atomicLoad %1
     ret %3
   }
@@ -514,12 +514,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func():i32 -> %b2 {
-  %b2 = block {
+%foo = func():i32 {
+  $B2: {
     %3:i32 = spirv.atomic_load %1, 2u, 0u
     ret %3
   }
@@ -544,12 +544,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicMax %1, %arg1
     ret %4
   }
@@ -558,12 +558,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_smax %1, 2u, 0u, %arg1
     ret %4
   }
@@ -588,12 +588,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%foo = func(%arg1:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:u32):u32 {
+  $B2: {
     %4:u32 = atomicMax %1, %arg1
     ret %4
   }
@@ -602,12 +602,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%foo = func(%arg1:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:u32):u32 {
+  $B2: {
     %4:u32 = spirv.atomic_umax %1, 2u, 0u, %arg1
     ret %4
   }
@@ -632,12 +632,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicMin %1, %arg1
     ret %4
   }
@@ -646,12 +646,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_smin %1, 2u, 0u, %arg1
     ret %4
   }
@@ -676,12 +676,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%foo = func(%arg1:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:u32):u32 {
+  $B2: {
     %4:u32 = atomicMin %1, %arg1
     ret %4
   }
@@ -690,12 +690,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<u32>, read_write> = var
 }
 
-%foo = func(%arg1:u32):u32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:u32):u32 {
+  $B2: {
     %4:u32 = spirv.atomic_umin %1, 2u, 0u, %arg1
     ret %4
   }
@@ -720,12 +720,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicOr %1, %arg1
     ret %4
   }
@@ -734,12 +734,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_or %1, 2u, 0u, %arg1
     ret %4
   }
@@ -764,12 +764,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):void -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):void {
+  $B2: {
     %4:void = atomicStore %1, %arg1
     ret
   }
@@ -778,12 +778,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):void -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):void {
+  $B2: {
     %4:void = spirv.atomic_store %1, 2u, 0u, %arg1
     ret
   }
@@ -808,12 +808,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicSub %1, %arg1
     ret %4
   }
@@ -822,12 +822,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_isub %1, 2u, 0u, %arg1
     ret %4
   }
@@ -852,12 +852,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = atomicXor %1, %arg1
     ret %4
   }
@@ -866,12 +866,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<workgroup, atomic<i32>, read_write> = var
 }
 
-%foo = func(%arg1:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%arg1:i32):i32 {
+  $B2: {
     %4:i32 = spirv.atomic_xor %1, 2u, 0u, %arg1
     ret %4
   }
@@ -895,8 +895,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>):f32 {
+  $B1: {
     %4:f32 = dot %arg1, %arg2
     ret %4
   }
@@ -905,8 +905,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>):f32 {
+  $B1: {
     %4:f32 = spirv.dot %arg1, %arg2
     ret %4
   }
@@ -930,8 +930,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:vec2<i32>, %arg2:vec2<i32>):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec2<i32>, %arg2:vec2<i32>):i32 {
+  $B1: {
     %4:i32 = dot %arg1, %arg2
     ret %4
   }
@@ -940,8 +940,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:vec2<i32>, %arg2:vec2<i32>):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec2<i32>, %arg2:vec2<i32>):i32 {
+  $B1: {
     %4:i32 = access %arg1, 0u
     %5:i32 = access %arg2, 0u
     %6:i32 = mul %4, %5
@@ -971,8 +971,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:vec4<u32>, %arg2:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<u32>, %arg2:vec4<u32>):u32 {
+  $B1: {
     %4:u32 = dot %arg1, %arg2
     ret %4
   }
@@ -981,8 +981,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:vec4<u32>, %arg2:vec4<u32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<u32>, %arg2:vec4<u32>):u32 {
+  $B1: {
     %4:u32 = access %arg1, 0u
     %5:u32 = access %arg2, 0u
     %6:u32 = mul %4, %5
@@ -1020,8 +1020,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:u32, %arg2:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:u32, %arg2:u32):i32 {
+  $B1: {
     %4:i32 = dot4I8Packed %arg1, %arg2
     ret %4
   }
@@ -1030,8 +1030,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:u32, %arg2:u32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:u32, %arg2:u32):i32 {
+  $B1: {
     %4:i32 = spirv.sdot %arg1, %arg2, 0u
     ret %4
   }
@@ -1055,8 +1055,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:u32, %arg2:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:u32, %arg2:u32):u32 {
+  $B1: {
     %4:u32 = dot4U8Packed %arg1, %arg2
     ret %4
   }
@@ -1065,8 +1065,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:u32, %arg2:u32):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:u32, %arg2:u32):u32 {
+  $B1: {
     %4:u32 = spirv.udot %arg1, %arg2, 0u
     ret %4
   }
@@ -1091,8 +1091,8 @@
     });
 
     auto* src = R"(
-%foo = func(%argf:i32, %argt:i32, %cond:bool):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%argf:i32, %argt:i32, %cond:bool):i32 {
+  $B1: {
     %5:i32 = select %argf, %argt, %cond
     ret %5
   }
@@ -1101,8 +1101,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%argf:i32, %argt:i32, %cond:bool):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%argf:i32, %argt:i32, %cond:bool):i32 {
+  $B1: {
     %5:i32 = spirv.select %cond, %argt, %argf
     ret %5
   }
@@ -1127,8 +1127,8 @@
     });
 
     auto* src = R"(
-%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:vec4<bool>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:vec4<bool>):vec4<i32> {
+  $B1: {
     %5:vec4<i32> = select %argf, %argt, %cond
     ret %5
   }
@@ -1137,8 +1137,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:vec4<bool>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:vec4<bool>):vec4<i32> {
+  $B1: {
     %5:vec4<i32> = spirv.select %cond, %argt, %argf
     ret %5
   }
@@ -1163,8 +1163,8 @@
     });
 
     auto* src = R"(
-%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:bool):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:bool):vec4<i32> {
+  $B1: {
     %5:vec4<i32> = select %argf, %argt, %cond
     ret %5
   }
@@ -1173,8 +1173,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:bool):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%argf:vec4<i32>, %argt:vec4<i32>, %cond:bool):vec4<i32> {
+  $B1: {
     %5:vec4<bool> = construct %cond, %cond, %cond, %cond
     %6:vec4<i32> = spirv.select %5, %argt, %argf
     ret %6
@@ -1201,8 +1201,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %coords:vec2<i32>, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %coords:vec2<i32>, %lod:i32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureLoad %t, %coords, %lod
     ret %5
   }
@@ -1211,8 +1211,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %coords:vec2<i32>, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %coords:vec2<i32>, %lod:i32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = spirv.image_fetch %t, %coords, 2u, %lod
     ret %5
   }
@@ -1240,8 +1240,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:i32, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:i32, %lod:i32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureLoad %t, %coords, %array_idx, %lod
     ret %6
   }
@@ -1250,8 +1250,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:i32, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:i32, %lod:i32):vec4<f32> {
+  $B1: {
     %6:vec3<i32> = construct %coords, %array_idx
     %7:vec4<f32> = spirv.image_fetch %t, %6, 2u, %lod
     ret %7
@@ -1280,8 +1280,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:u32, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:u32, %lod:i32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureLoad %t, %coords, %array_idx, %lod
     ret %6
   }
@@ -1290,8 +1290,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:u32, %lod:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %coords:vec2<i32>, %array_idx:u32, %lod:i32):vec4<f32> {
+  $B1: {
     %6:i32 = convert %array_idx
     %7:vec3<i32> = construct %coords, %6
     %8:vec4<f32> = spirv.image_fetch %t, %7, 2u, %lod
@@ -1319,8 +1319,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_multisampled_2d<f32>, %coords:vec2<i32>, %sample_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_multisampled_2d<f32>, %coords:vec2<i32>, %sample_idx:i32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureLoad %t, %coords, %sample_idx
     ret %5
   }
@@ -1329,8 +1329,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_multisampled_2d<f32>, %coords:vec2<i32>, %sample_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_multisampled_2d<f32>, %coords:vec2<i32>, %sample_idx:i32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = spirv.image_fetch %t, %coords, 64u, %sample_idx
     ret %5
   }
@@ -1356,8 +1356,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %coords:vec2<i32>, %lod:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %coords:vec2<i32>, %lod:i32):f32 {
+  $B1: {
     %5:f32 = textureLoad %t, %coords, %lod
     ret %5
   }
@@ -1366,8 +1366,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %coords:vec2<i32>, %lod:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %coords:vec2<i32>, %lod:i32):f32 {
+  $B1: {
     %5:vec4<f32> = spirv.image_fetch %t, %coords, 2u, %lod
     %6:f32 = access %5, 0u
     ret %6
@@ -1394,8 +1394,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_1d<f32>, %s:sampler, %coords:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_1d<f32>, %s:sampler, %coords:f32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureSample %t, %s, %coords
     ret %5
   }
@@ -1404,8 +1404,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_1d<f32>, %s:sampler, %coords:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_1d<f32>, %s:sampler, %coords:f32):vec4<f32> {
+  $B1: {
     %5:spirv.sampled_image<texture_1d<f32>> = spirv.sampled_image %t, %s
     %6:vec4<f32> = spirv.image_sample_implicit_lod %5, %coords, 0u
     ret %6
@@ -1432,8 +1432,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureSample %t, %s, %coords
     ret %5
   }
@@ -1442,8 +1442,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %6:vec4<f32> = spirv.image_sample_implicit_lod %5, %coords, 0u
     ret %6
@@ -1471,8 +1471,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureSample %t, %s, %coords, vec2<i32>(1i)
     ret %5
   }
@@ -1481,8 +1481,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %6:vec4<f32> = spirv.image_sample_implicit_lod %5, %coords, 8u, vec2<i32>(1i)
     ret %6
@@ -1511,8 +1511,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureSample %t, %s, %coords, %array_idx, vec2<i32>(1i)
     ret %6
   }
@@ -1521,8 +1521,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d_array<f32>> = spirv.sampled_image %t, %s
     %7:f32 = convert %array_idx
     %8:vec3<f32> = construct %coords, %7
@@ -1553,8 +1553,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureSampleBias %t, %s, %coords, %bias
     ret %6
   }
@@ -1563,8 +1563,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_sample_implicit_lod %6, %coords, 1u, %bias
     ret %7
@@ -1593,8 +1593,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureSampleBias %t, %s, %coords, %bias, vec2<i32>(1i)
     ret %6
   }
@@ -1603,8 +1603,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %bias:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_sample_implicit_lod %6, %coords, 9u, %bias, vec2<i32>(1i)
     ret %7
@@ -1634,8 +1634,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %bias:f32):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureSampleBias %t, %s, %coords, %array_idx, %bias, vec2<i32>(1i)
     ret %7
   }
@@ -1644,8 +1644,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %bias:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %bias:f32):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_2d_array<f32>> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -1675,8 +1675,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:f32 = textureSampleCompare %t, %s, %coords, %dref
     ret %6
   }
@@ -1685,8 +1685,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:f32 = spirv.image_sample_dref_implicit_lod %6, %coords, %dref, 0u
     ret %7
@@ -1715,8 +1715,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:f32 = textureSampleCompare %t, %s, %coords, %dref, vec2<i32>(1i)
     ret %6
   }
@@ -1725,8 +1725,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:f32 = spirv.image_sample_dref_implicit_lod %6, %coords, %dref, 8u, vec2<i32>(1i)
     ret %7
@@ -1756,8 +1756,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 {
+  $B1: {
     %7:f32 = textureSampleCompare %t, %s, %coords, %array_idx, %bias, vec2<i32>(1i)
     ret %7
   }
@@ -1766,8 +1766,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 {
+  $B1: {
     %7:spirv.sampled_image<texture_depth_2d_array> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -1798,8 +1798,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:f32 = textureSampleCompareLevel %t, %s, %coords, %dref
     ret %6
   }
@@ -1808,8 +1808,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:f32 = spirv.image_sample_dref_explicit_lod %6, %coords, %dref, 2u, 0.0f
     ret %7
@@ -1838,8 +1838,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:f32 = textureSampleCompareLevel %t, %s, %coords, %dref, vec2<i32>(1i)
     ret %6
   }
@@ -1848,8 +1848,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %dref:f32):f32 {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:f32 = spirv.image_sample_dref_explicit_lod %6, %coords, %dref, 10u, 0.0f, vec2<i32>(1i)
     ret %7
@@ -1879,8 +1879,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 {
+  $B1: {
     %7:f32 = textureSampleCompareLevel %t, %s, %coords, %array_idx, %bias, vec2<i32>(1i)
     ret %7
   }
@@ -1889,8 +1889,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:i32, %bias:f32):f32 {
+  $B1: {
     %7:spirv.sampled_image<texture_depth_2d_array> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -1922,8 +1922,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureSampleGrad %t, %s, %coords, %ddx, %ddy
     ret %7
   }
@@ -1932,8 +1932,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %8:vec4<f32> = spirv.image_sample_explicit_lod %7, %coords, 4u, %ddx, %ddy
     ret %8
@@ -1963,8 +1963,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureSampleGrad %t, %s, %coords, %ddx, %ddy, vec2<i32>(1i)
     ret %7
   }
@@ -1973,8 +1973,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %8:vec4<f32> = spirv.image_sample_explicit_lod %7, %coords, 12u, %ddx, %ddy, vec2<i32>(1i)
     ret %8
@@ -2005,8 +2005,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %8:vec4<f32> = textureSampleGrad %t, %s, %coords, %array_idx, %ddx, %ddy, vec2<i32>(1i)
     ret %8
   }
@@ -2015,8 +2015,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %ddx:vec2<f32>, %ddy:vec2<f32>):vec4<f32> {
+  $B1: {
     %8:spirv.sampled_image<texture_2d_array<f32>> = spirv.sampled_image %t, %s
     %9:f32 = convert %array_idx
     %10:vec3<f32> = construct %coords, %9
@@ -2047,8 +2047,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureSampleLevel %t, %s, %coords, %lod
     ret %6
   }
@@ -2057,8 +2057,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_sample_explicit_lod %6, %coords, 2u, %lod
     ret %7
@@ -2087,8 +2087,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureSampleLevel %t, %s, %coords, %lod, vec2<i32>(1i)
     ret %6
   }
@@ -2097,8 +2097,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>, %lod:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_sample_explicit_lod %6, %coords, 10u, %lod, vec2<i32>(1i)
     ret %7
@@ -2128,8 +2128,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %lod:f32):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureSampleLevel %t, %s, %coords, %array_idx, %lod, vec2<i32>(1i)
     ret %7
   }
@@ -2138,8 +2138,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %lod:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %coords:vec2<f32>, %array_idx:i32, %lod:f32):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_2d_array<f32>> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -2170,8 +2170,8 @@
     });
 
     auto* src = R"(
-%foo = func(%component:i32, %t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%component:i32, %t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureGather %component, %t, %s, %coords
     ret %6
   }
@@ -2180,8 +2180,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%component:i32, %t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%component:i32, %t:texture_2d<f32>, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_gather %6, %coords, %component, 0u
     ret %7
@@ -2210,8 +2210,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %component:i32, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %component:i32, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureGather %component, %t, %s, %coords, vec2<i32>(1i)
     ret %6
   }
@@ -2220,8 +2220,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %s:sampler, %component:i32, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %s:sampler, %component:i32, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_2d<f32>> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_gather %6, %coords, %component, 8u, vec2<i32>(1i)
     ret %7
@@ -2251,8 +2251,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %component:i32, %coords:vec2<f32>, %array_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %component:i32, %coords:vec2<f32>, %array_idx:i32):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureGather %component, %t, %s, %coords, %array_idx, vec2<i32>(1i)
     ret %7
   }
@@ -2261,8 +2261,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>, %s:sampler, %component:i32, %coords:vec2<f32>, %array_idx:i32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>, %s:sampler, %component:i32, %coords:vec2<f32>, %array_idx:i32):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_2d_array<f32>> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -2291,8 +2291,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = textureGather %t, %s, %coords
     ret %5
   }
@@ -2301,8 +2301,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler, %coords:vec2<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler, %coords:vec2<f32>):vec4<f32> {
+  $B1: {
     %5:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %6:vec4<f32> = spirv.image_gather %5, %coords, 0u, 0u
     ret %6
@@ -2331,8 +2331,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureGatherCompare %t, %s, %coords, %depth
     ret %6
   }
@@ -2341,8 +2341,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_dref_gather %6, %coords, %depth, 0u
     ret %7
@@ -2371,8 +2371,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> {
+  $B1: {
     %6:vec4<f32> = textureGatherCompare %t, %s, %coords, %depth, vec2<i32>(1i)
     ret %6
   }
@@ -2381,8 +2381,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d, %s:sampler_comparison, %coords:vec2<f32>, %depth:f32):vec4<f32> {
+  $B1: {
     %6:spirv.sampled_image<texture_depth_2d> = spirv.sampled_image %t, %s
     %7:vec4<f32> = spirv.image_dref_gather %6, %coords, %depth, 8u, vec2<i32>(1i)
     ret %7
@@ -2412,8 +2412,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:u32, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:u32, %depth:f32):vec4<f32> {
+  $B1: {
     %7:vec4<f32> = textureGatherCompare %t, %s, %coords, %array_idx, %depth
     ret %7
   }
@@ -2422,8 +2422,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:u32, %depth:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array, %s:sampler_comparison, %coords:vec2<f32>, %array_idx:u32, %depth:f32):vec4<f32> {
+  $B1: {
     %7:spirv.sampled_image<texture_depth_2d_array> = spirv.sampled_image %t, %s
     %8:f32 = convert %array_idx
     %9:vec3<f32> = construct %coords, %8
@@ -2455,8 +2455,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_storage_2d<r32uint, write>, %coords:vec2<i32>, %texel:vec4<u32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d<r32uint, write>, %coords:vec2<i32>, %texel:vec4<u32>):void {
+  $B1: {
     %5:void = textureStore %t, %coords, %texel
     ret
   }
@@ -2465,8 +2465,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_storage_2d<r32uint, write>, %coords:vec2<i32>, %texel:vec4<u32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d<r32uint, write>, %coords:vec2<i32>, %texel:vec4<u32>):void {
+  $B1: {
     %5:void = spirv.image_write %t, %coords, %texel, 0u
     ret
   }
@@ -2496,8 +2496,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_storage_2d_array<rgba8sint, write>, %coords:vec2<i32>, %array_idx:i32, %texel:vec4<i32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<rgba8sint, write>, %coords:vec2<i32>, %array_idx:i32, %texel:vec4<i32>):void {
+  $B1: {
     %6:void = textureStore %t, %coords, %array_idx, %texel
     ret
   }
@@ -2506,8 +2506,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_storage_2d_array<rgba8sint, write>, %coords:vec2<i32>, %array_idx:i32, %texel:vec4<i32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<rgba8sint, write>, %coords:vec2<i32>, %array_idx:i32, %texel:vec4<i32>):void {
+  $B1: {
     %6:vec3<i32> = construct %coords, %array_idx
     %7:void = spirv.image_write %t, %6, %texel, 0u
     ret
@@ -2538,8 +2538,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_storage_2d_array<rgba32uint, write>, %coords:vec2<i32>, %array_idx:u32, %texel:vec4<u32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<rgba32uint, write>, %coords:vec2<i32>, %array_idx:u32, %texel:vec4<u32>):void {
+  $B1: {
     %6:void = textureStore %t, %coords, %array_idx, %texel
     ret
   }
@@ -2548,8 +2548,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_storage_2d_array<rgba32uint, write>, %coords:vec2<i32>, %array_idx:u32, %texel:vec4<u32>):void -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<rgba32uint, write>, %coords:vec2<i32>, %array_idx:u32, %texel:vec4<u32>):void {
+  $B1: {
     %6:i32 = convert %array_idx
     %7:vec3<i32> = construct %coords, %6
     %8:void = spirv.image_write %t, %7, %texel, 0u
@@ -2575,8 +2575,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = textureDimensions %t
     ret %3
   }
@@ -2585,8 +2585,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = spirv.image_query_size_lod %t, 0u
     ret %3
   }
@@ -2611,8 +2611,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d<f32>, %lod:i32):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %lod:i32):vec2<u32> {
+  $B1: {
     %4:vec2<u32> = textureDimensions %t, %lod
     ret %4
   }
@@ -2621,8 +2621,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d<f32>, %lod:i32):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d<f32>, %lod:i32):vec2<u32> {
+  $B1: {
     %4:vec2<u32> = spirv.image_query_size_lod %t, %lod
     ret %4
   }
@@ -2646,8 +2646,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = textureDimensions %t
     ret %3
   }
@@ -2656,8 +2656,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>):vec2<u32> {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size_lod %t, 0u
     %4:vec2<u32> = swizzle %3, xy
     ret %4
@@ -2682,8 +2682,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_multisampled_2d<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_multisampled_2d<f32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = textureDimensions %t
     ret %3
   }
@@ -2692,8 +2692,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_multisampled_2d<f32>):vec2<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_multisampled_2d<f32>):vec2<u32> {
+  $B1: {
     %3:vec2<u32> = spirv.image_query_size %t
     ret %3
   }
@@ -2717,8 +2717,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_2d_array<f32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>):u32 {
+  $B1: {
     %3:u32 = textureNumLayers %t
     ret %3
   }
@@ -2727,8 +2727,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_2d_array<f32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_2d_array<f32>):u32 {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size_lod %t, 0u
     %4:u32 = access %3, 2u
     ret %4
@@ -2753,8 +2753,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_cube_array<f32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_cube_array<f32>):u32 {
+  $B1: {
     %3:u32 = textureNumLayers %t
     ret %3
   }
@@ -2763,8 +2763,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_cube_array<f32>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_cube_array<f32>):u32 {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size_lod %t, 0u
     %4:u32 = access %3, 2u
     ret %4
@@ -2789,8 +2789,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_2d_array):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array):u32 {
+  $B1: {
     %3:u32 = textureNumLayers %t
     ret %3
   }
@@ -2799,8 +2799,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_2d_array):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_2d_array):u32 {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size_lod %t, 0u
     %4:u32 = access %3, 2u
     ret %4
@@ -2825,8 +2825,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_depth_cube_array):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_cube_array):u32 {
+  $B1: {
     %3:u32 = textureNumLayers %t
     ret %3
   }
@@ -2835,8 +2835,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_depth_cube_array):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_depth_cube_array):u32 {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size_lod %t, 0u
     %4:u32 = access %3, 2u
     ret %4
@@ -2864,8 +2864,8 @@
     });
 
     auto* src = R"(
-%foo = func(%t:texture_storage_2d_array<r32float, write>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<r32float, write>):u32 {
+  $B1: {
     %3:u32 = textureNumLayers %t
     ret %3
   }
@@ -2874,8 +2874,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%t:texture_storage_2d_array<r32float, write>):u32 -> %b1 {
-  %b1 = block {
+%foo = func(%t:texture_storage_2d_array<r32float, write>):u32 {
+  $B1: {
     %3:vec3<u32> = spirv.image_query_size %t
     %4:u32 = access %3, 2u
     ret %4
@@ -2899,8 +2899,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:f32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%arg:f32):f32 {
+  $B1: {
     %3:f32 = quantizeToF16 %arg
     ret %3
   }
@@ -2926,8 +2926,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<f32>):vec4<f32> {
+  $B1: {
     %3:vec4<f32> = quantizeToF16 %arg
     ret %3
   }
@@ -2936,8 +2936,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:vec4<f32>):vec4<f32> {
+  $B1: {
     %3:f32 = access %arg, 0u
     %4:f32 = quantizeToF16 %3
     %5:f32 = access %arg, 1u
diff --git a/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc b/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
index ef4afaa..3e9bb3d 100644
--- a/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
+++ b/src/tint/lang/spirv/writer/raise/expand_implicit_splats_test.cc
@@ -50,8 +50,8 @@
     });
 
     auto* expect = R"(
-%foo = func(%vector:vec2<i32>):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%vector:vec2<i32>):vec2<i32> {
+  $B1: {
     %3:vec2<i32> = construct %vector
     ret %3
   }
@@ -75,8 +75,8 @@
     });
 
     auto* expect = R"(
-%foo = func(%scalar:i32, %vector:vec2<i32>):vec3<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32, %vector:vec2<i32>):vec3<i32> {
+  $B1: {
     %4:vec3<i32> = construct %scalar, %vector
     ret %4
   }
@@ -99,8 +99,8 @@
     });
 
     auto* expect = R"(
-%foo = func(%scalar:i32):vec3<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32):vec3<i32> {
+  $B1: {
     %3:vec3<i32> = construct %scalar, %scalar, %scalar
     ret %3
   }
@@ -123,8 +123,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:i32):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32):vec2<i32> {
+  $B1: {
     %3:vec2<i32> = construct %scalar
     ret %3
   }
@@ -133,8 +133,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:i32):vec2<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32):vec2<i32> {
+  $B1: {
     %3:vec2<i32> = construct %scalar, %scalar
     ret %3
   }
@@ -157,8 +157,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:u32):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:u32):vec3<u32> {
+  $B1: {
     %3:vec3<u32> = construct %scalar
     ret %3
   }
@@ -167,8 +167,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:u32):vec3<u32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:u32):vec3<u32> {
+  $B1: {
     %3:vec3<u32> = construct %scalar, %scalar, %scalar
     ret %3
   }
@@ -191,8 +191,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32):vec4<f32> {
+  $B1: {
     %3:vec4<f32> = construct %scalar
     ret %3
   }
@@ -201,8 +201,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32):vec4<f32> {
+  $B1: {
     %3:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     ret %3
   }
@@ -226,8 +226,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = add %vector, %scalar
     ret %4
   }
@@ -236,8 +236,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = add %vector, %4
     ret %5
@@ -262,8 +262,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = add %scalar, %vector
     ret %4
   }
@@ -272,8 +272,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = add %4, %vector
     ret %5
@@ -298,8 +298,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = sub %vector, %scalar
     ret %4
   }
@@ -308,8 +308,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = sub %vector, %4
     ret %5
@@ -334,8 +334,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = sub %scalar, %vector
     ret %4
   }
@@ -344,8 +344,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = sub %4, %vector
     ret %5
@@ -370,8 +370,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = div %vector, %scalar
     ret %4
   }
@@ -380,8 +380,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = div %vector, %4
     ret %5
@@ -406,8 +406,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = div %scalar, %vector
     ret %4
   }
@@ -416,8 +416,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = div %4, %vector
     ret %5
@@ -442,8 +442,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = mod %vector, %scalar
     ret %4
   }
@@ -452,8 +452,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = mod %vector, %4
     ret %5
@@ -478,8 +478,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = mod %scalar, %vector
     ret %4
   }
@@ -488,8 +488,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<f32> = mod %4, %vector
     ret %5
@@ -514,8 +514,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = mul %vector, %scalar
     ret %4
   }
@@ -524,8 +524,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = spirv.vector_times_scalar %vector, %scalar
     ret %4
   }
@@ -549,8 +549,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = mul %scalar, %vector
     ret %4
   }
@@ -559,8 +559,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:f32, %vector:vec4<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = spirv.vector_times_scalar %vector, %scalar
     ret %4
   }
@@ -584,8 +584,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = mul %vector, %scalar
     ret %4
   }
@@ -594,8 +594,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<i32> = mul %vector, %4
     ret %5
@@ -620,8 +620,8 @@
     });
 
     auto* src = R"(
-%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = mul %scalar, %vector
     ret %4
   }
@@ -630,8 +630,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> -> %b1 {
-  %b1 = block {
+%foo = func(%scalar:i32, %vector:vec4<i32>):vec4<i32> {
+  $B1: {
     %4:vec4<i32> = construct %scalar, %scalar, %scalar, %scalar
     %5:vec4<i32> = mul %4, %vector
     ret %5
@@ -657,8 +657,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>, %factor:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>, %factor:f32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = mix %arg1, %arg2, %factor
     ret %5
   }
@@ -667,8 +667,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>, %factor:f32):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec4<f32>, %arg2:vec4<f32>, %factor:f32):vec4<f32> {
+  $B1: {
     %5:vec4<f32> = construct %factor, %factor, %factor, %factor
     %6:vec4<f32> = mix %arg1, %arg2, %5
     ret %6
diff --git a/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic_test.cc b/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic_test.cc
index 89a025d..835a4e1 100644
--- a/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic_test.cc
+++ b/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic_test.cc
@@ -52,8 +52,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat2x3<f32>, %arg2:mat2x3<f32>):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x3<f32>, %arg2:mat2x3<f32>):mat2x3<f32> {
+  $B1: {
     %4:mat2x3<f32> = add %arg1, %arg2
     ret %4
   }
@@ -62,8 +62,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat2x3<f32>, %arg2:mat2x3<f32>):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x3<f32>, %arg2:mat2x3<f32>):mat2x3<f32> {
+  $B1: {
     %4:vec3<f32> = access %arg1, 0u
     %5:vec3<f32> = access %arg2, 0u
     %6:vec3<f32> = add %4, %5
@@ -93,8 +93,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat4x2<f16>, %arg2:mat4x2<f16>):mat4x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat4x2<f16>, %arg2:mat4x2<f16>):mat4x2<f16> {
+  $B1: {
     %4:mat4x2<f16> = add %arg1, %arg2
     ret %4
   }
@@ -103,8 +103,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat4x2<f16>, %arg2:mat4x2<f16>):mat4x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat4x2<f16>, %arg2:mat4x2<f16>):mat4x2<f16> {
+  $B1: {
     %4:vec2<f16> = access %arg1, 0u
     %5:vec2<f16> = access %arg2, 0u
     %6:vec2<f16> = add %4, %5
@@ -140,8 +140,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat3x2<f32>, %arg2:mat3x2<f32>):mat3x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x2<f32>, %arg2:mat3x2<f32>):mat3x2<f32> {
+  $B1: {
     %4:mat3x2<f32> = sub %arg1, %arg2
     ret %4
   }
@@ -150,8 +150,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat3x2<f32>, %arg2:mat3x2<f32>):mat3x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x2<f32>, %arg2:mat3x2<f32>):mat3x2<f32> {
+  $B1: {
     %4:vec2<f32> = access %arg1, 0u
     %5:vec2<f32> = access %arg2, 0u
     %6:vec2<f32> = sub %4, %5
@@ -184,8 +184,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat2x4<f16>, %arg2:mat2x4<f16>):mat2x4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x4<f16>, %arg2:mat2x4<f16>):mat2x4<f16> {
+  $B1: {
     %4:mat2x4<f16> = sub %arg1, %arg2
     ret %4
   }
@@ -194,8 +194,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat2x4<f16>, %arg2:mat2x4<f16>):mat2x4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x4<f16>, %arg2:mat2x4<f16>):mat2x4<f16> {
+  $B1: {
     %4:vec4<f16> = access %arg1, 0u
     %5:vec4<f16> = access %arg2, 0u
     %6:vec4<f16> = sub %4, %5
@@ -225,8 +225,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat2x3<f32>, %arg2:f32):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x3<f32>, %arg2:f32):mat2x3<f32> {
+  $B1: {
     %4:mat2x3<f32> = mul %arg1, %arg2
     ret %4
   }
@@ -235,8 +235,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat2x3<f32>, %arg2:f32):mat2x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat2x3<f32>, %arg2:f32):mat2x3<f32> {
+  $B1: {
     %4:mat2x3<f32> = spirv.matrix_times_scalar %arg1, %arg2
     ret %4
   }
@@ -260,8 +260,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat3x4<f32>, %arg2:vec3<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x4<f32>, %arg2:vec3<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = mul %arg1, %arg2
     ret %4
   }
@@ -270,8 +270,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat3x4<f32>, %arg2:vec3<f32>):vec4<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x4<f32>, %arg2:vec3<f32>):vec4<f32> {
+  $B1: {
     %4:vec4<f32> = spirv.matrix_times_vector %arg1, %arg2
     ret %4
   }
@@ -295,8 +295,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat4x2<f32>, %arg2:mat2x4<f32>):mat2x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat4x2<f32>, %arg2:mat2x4<f32>):mat2x2<f32> {
+  $B1: {
     %4:mat2x2<f32> = mul %arg1, %arg2
     ret %4
   }
@@ -305,8 +305,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat4x2<f32>, %arg2:mat2x4<f32>):mat2x2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat4x2<f32>, %arg2:mat2x4<f32>):mat2x2<f32> {
+  $B1: {
     %4:mat2x2<f32> = spirv.matrix_times_matrix %arg1, %arg2
     ret %4
   }
@@ -330,8 +330,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:f16, %arg2:mat3x2<f16>):mat3x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:f16, %arg2:mat3x2<f16>):mat3x2<f16> {
+  $B1: {
     %4:mat3x2<f16> = mul %arg1, %arg2
     ret %4
   }
@@ -340,8 +340,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:f16, %arg2:mat3x2<f16>):mat3x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:f16, %arg2:mat3x2<f16>):mat3x2<f16> {
+  $B1: {
     %4:mat3x2<f16> = spirv.matrix_times_scalar %arg2, %arg1
     ret %4
   }
@@ -365,8 +365,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:vec3<f16>, %arg2:mat4x3<f16>):vec4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec3<f16>, %arg2:mat4x3<f16>):vec4<f16> {
+  $B1: {
     %4:vec4<f16> = mul %arg1, %arg2
     ret %4
   }
@@ -375,8 +375,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:vec3<f16>, %arg2:mat4x3<f16>):vec4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:vec3<f16>, %arg2:mat4x3<f16>):vec4<f16> {
+  $B1: {
     %4:vec4<f16> = spirv.vector_times_matrix %arg1, %arg2
     ret %4
   }
@@ -400,8 +400,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg1:mat3x3<f16>, %arg2:mat3x3<f16>):mat3x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x3<f16>, %arg2:mat3x3<f16>):mat3x3<f16> {
+  $B1: {
     %4:mat3x3<f16> = mul %arg1, %arg2
     ret %4
   }
@@ -410,8 +410,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg1:mat3x3<f16>, %arg2:mat3x3<f16>):mat3x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg1:mat3x3<f16>, %arg2:mat3x3<f16>):mat3x3<f16> {
+  $B1: {
     %4:mat3x3<f16> = spirv.matrix_times_matrix %arg1, %arg2
     ret %4
   }
@@ -434,8 +434,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:mat2x3<f32>):mat2x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat2x3<f32>):mat2x3<f16> {
+  $B1: {
     %3:mat2x3<f16> = convert %arg
     ret %3
   }
@@ -444,8 +444,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:mat2x3<f32>):mat2x3<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat2x3<f32>):mat2x3<f16> {
+  $B1: {
     %3:vec3<f32> = access %arg, 0u
     %4:vec3<f16> = convert %3
     %5:vec3<f32> = access %arg, 1u
@@ -472,8 +472,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:mat4x4<f32>):mat4x4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat4x4<f32>):mat4x4<f16> {
+  $B1: {
     %3:mat4x4<f16> = convert %arg
     ret %3
   }
@@ -482,8 +482,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:mat4x4<f32>):mat4x4<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat4x4<f32>):mat4x4<f16> {
+  $B1: {
     %3:vec4<f32> = access %arg, 0u
     %4:vec4<f16> = convert %3
     %5:vec4<f32> = access %arg, 1u
@@ -514,8 +514,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:mat4x3<f16>):mat4x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat4x3<f16>):mat4x3<f32> {
+  $B1: {
     %3:mat4x3<f32> = convert %arg
     ret %3
   }
@@ -524,8 +524,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:mat4x3<f16>):mat4x3<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat4x3<f16>):mat4x3<f32> {
+  $B1: {
     %3:vec3<f16> = access %arg, 0u
     %4:vec3<f32> = convert %3
     %5:vec3<f16> = access %arg, 1u
@@ -556,8 +556,8 @@
     });
 
     auto* src = R"(
-%foo = func(%arg:mat2x2<f32>):mat2x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat2x2<f32>):mat2x2<f16> {
+  $B1: {
     %3:mat2x2<f16> = convert %arg
     ret %3
   }
@@ -566,8 +566,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%arg:mat2x2<f32>):mat2x2<f16> -> %b1 {
-  %b1 = block {
+%foo = func(%arg:mat2x2<f32>):mat2x2<f16> {
+  $B1: {
     %3:vec2<f32> = access %arg, 0u
     %4:vec2<f16> = convert %3
     %5:vec2<f32> = access %arg, 1u
diff --git a/src/tint/lang/spirv/writer/raise/merge_return_test.cc b/src/tint/lang/spirv/writer/raise/merge_return_test.cc
index cc18a71..75998f5 100644
--- a/src/tint/lang/spirv/writer/raise/merge_return_test.cc
+++ b/src/tint/lang/spirv/writer/raise/merge_return_test.cc
@@ -47,8 +47,8 @@
     b.Append(func->Block(), [&] { b.Return(func, b.Add(ty.i32(), in, 1_i)); });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %3:i32 = add %2, 1i
     ret %3
   }
@@ -78,14 +78,14 @@
         b.Return(func, ifelse->Result(0));
     });
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
-    %3:i32 = if %4 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:i32):i32 {
+  $B1: {
+    %3:i32 = if %4 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         %5:i32 = add %2, 1i
         exit_if %5  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         %6:i32 = add %2, 2i
         exit_if %6  # if_1
       }
@@ -125,24 +125,24 @@
     });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
-    switch %2 [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+%foo = func(%2:i32):i32 {
+  $B1: {
+    switch %2 [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch  # switch_1
       }
     }
-    loop [b: %b3] {  # loop_1
-      %b3 = block {  # body
+    loop [b: $B3] {  # loop_1
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
-    %3:i32 = if %4 [t: %b4, f: %b5] {  # if_1
-      %b4 = block {  # true
+    %3:i32 = if %4 [t: $B4, f: $B5] {  # if_1
+      $B4: {  # true
         %5:i32 = add %2, 1i
         exit_if %5  # if_1
       }
-      %b5 = block {  # false
+      $B5: {  # false
         %6:i32 = add %2, 2i
         exit_if %6  # if_1
       }
@@ -174,13 +174,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -191,13 +191,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -227,13 +227,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -244,13 +244,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -278,13 +278,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):i32 {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret 1i
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -295,23 +295,23 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:bool):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         store %continue_execution, false
         store %return_value, 1i
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_2
+      $B4: {  # true
         store %return_value, 2i
         exit_if  # if_2
       }
@@ -342,13 +342,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
-    %3:i32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):i32 {
+  $B1: {
+    %3:i32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret 1i
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if 2i  # if_1
       }
     }
@@ -359,23 +359,23 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:bool):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    %5:i32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    %5:i32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         store %continue_execution, false
         store %return_value, 1i
         exit_if undef  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if 2i  # if_1
       }
     }
     %6:bool = load %continue_execution
-    if %6 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %6 [t: $B4] {  # if_2
+      $B4: {  # true
         store %return_value, %5
         exit_if  # if_2
       }
@@ -407,13 +407,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
-    %3:i32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):i32 {
+  $B1: {
+    %3:i32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret 1i
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if undef  # if_1
       }
     }
@@ -424,23 +424,23 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:bool):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    %5:i32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    %5:i32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         store %continue_execution, false
         store %return_value, 1i
         exit_if undef  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if undef  # if_1
       }
     }
     %6:bool = load %continue_execution
-    if %6 [t: %b4] {  # if_2
-      %b4 = block {  # true
+    if %6 [t: $B4] {  # if_2
+      $B4: {  # true
         store %return_value, %5
         exit_if  # if_2
       }
@@ -470,13 +470,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -488,13 +488,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -533,21 +533,21 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    %3:i32, %4:f32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
-        if %2 [t: %b4, f: %b5] {  # if_2
-          %b4 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    %3:i32, %4:f32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
+        if %2 [t: $B4, f: $B5] {  # if_2
+          $B4: {  # true
             ret
           }
-          %b5 = block {  # false
+          $B5: {  # false
             ret
           }
         }
         unreachable
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -559,21 +559,21 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    %3:i32, %4:f32 = if %2 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
-        if %2 [t: %b4, f: %b5] {  # if_2
-          %b4 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    %3:i32, %4:f32 = if %2 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
+        if %2 [t: $B4, f: $B5] {  # if_2
+          $B4: {  # true
             exit_if  # if_2
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_if  # if_2
           }
         }
         exit_if undef, undef  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if undef, undef  # if_1
       }
     }
@@ -608,15 +608,15 @@
     });
 
     auto* src = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             ret
           }
-          %b4 = block {  # false
+          $B4: {  # false
             ret
           }
         }
@@ -631,15 +631,15 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:bool):void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+%foo = func(%2:bool):void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             exit_if  # if_1
           }
-          %b4 = block {  # false
+          $B4: {  # false
             exit_if  # if_1
           }
         }
@@ -674,17 +674,17 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):void -> %b2 {
-  %b2 = block {
-    if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func(%3:bool):void {
+  $B2: {
+    if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         ret
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if  # if_1
       }
     }
@@ -697,25 +697,25 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):void -> %b2 {
-  %b2 = block {
+%foo = func(%3:bool):void {
+  $B2: {
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b5] {  # if_2
-      %b5 = block {  # true
+    if %5 [t: $B5] {  # if_2
+      $B5: {  # true
         store %1, 42i
         exit_if  # if_2
       }
@@ -750,17 +750,17 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):void -> %b2 {
-  %b2 = block {
-    if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func(%3:bool):void {
+  $B2: {
+    if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         ret
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if  # if_1
       }
     }
@@ -773,25 +773,25 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):void -> %b2 {
-  %b2 = block {
+%foo = func(%3:bool):void {
+  $B2: {
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         exit_if  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if  # if_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b5] {  # if_2
-      %b5 = block {  # true
+    if %5 [t: $B5] {  # if_2
+      $B5: {  # true
         store %1, 42i
         exit_if  # if_2
       }
@@ -838,31 +838,31 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
-    if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
+    if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         ret 3i
       }
-      %b4 = block {  # false
-        if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 ret 1i
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             store %1, 1i
             ret 2i
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_2
           }
         }
@@ -880,36 +880,36 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         store %return_value, 3i
         exit_if  # if_1
       }
-      %b4 = block {  # false
-        if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 store %continue_execution, false
                 store %return_value, 1i
                 exit_if  # if_3
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             %8:bool = load %continue_execution
-            if %8 [t: %b9] {  # if_4
-              %b9 = block {  # true
+            if %8 [t: $B9] {  # if_4
+              $B9: {  # true
                 store %1, 1i
                 store %continue_execution, false
                 store %return_value, 2i
@@ -918,13 +918,13 @@
             }
             exit_if  # if_2
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_2
           }
         }
         %9:bool = load %continue_execution
-        if %9 [t: %b10] {  # if_5
-          %b10 = block {  # true
+        if %9 [t: $B10] {  # if_5
+          $B10: {  # true
             store %1, 2i
             exit_if  # if_5
           }
@@ -933,8 +933,8 @@
       }
     }
     %10:bool = load %continue_execution
-    if %10 [t: %b11] {  # if_6
-      %b11 = block {  # true
+    if %10 [t: $B11] {  # if_6
+      $B11: {  # true
         store %1, 3i
         %11:i32 = add 5i, 6i
         store %return_value, %11
@@ -981,30 +981,30 @@
         b.Return(func, 3_i);
     });
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
-    if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
+    if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         ret 3i
       }
-      %b4 = block {  # false
-        if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 ret 1i
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             exit_if  # if_2
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_2
           }
         }
@@ -1019,36 +1019,36 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         store %return_value, 3i
         exit_if  # if_1
       }
-      %b4 = block {  # false
-        if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 store %continue_execution, false
                 store %return_value, 1i
                 exit_if  # if_3
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             exit_if  # if_2
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_2
           }
         }
@@ -1056,8 +1056,8 @@
       }
     }
     %8:bool = load %continue_execution
-    if %8 [t: %b9] {  # if_4
-      %b9 = block {  # true
+    if %8 [t: $B9] {  # if_4
+      $B9: {  # true
         store %return_value, 3i
         exit_if  # if_4
       }
@@ -1107,31 +1107,31 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
-    %6:i32 = if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
+    %6:i32 = if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         ret 3i
       }
-      %b4 = block {  # false
-        %7:i32 = if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        %7:i32 = if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 ret 1i
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             %8:i32 = add 42i, 1i
             exit_if %8  # if_2
           }
-          %b6 = block {  # false
+          $B6: {  # false
             %9:i32 = add 43i, 2i
             exit_if %9  # if_2
           }
@@ -1149,36 +1149,36 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%condA:bool, %condB:bool, %condC:bool):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    %8:i32 = if %condA [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    %8:i32 = if %condA [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         store %continue_execution, false
         store %return_value, 3i
         exit_if undef  # if_1
       }
-      %b4 = block {  # false
-        %9:i32 = if %condB [t: %b5, f: %b6] {  # if_2
-          %b5 = block {  # true
-            if %condC [t: %b7, f: %b8] {  # if_3
-              %b7 = block {  # true
+      $B4: {  # false
+        %9:i32 = if %condB [t: $B5, f: $B6] {  # if_2
+          $B5: {  # true
+            if %condC [t: $B7, f: $B8] {  # if_3
+              $B7: {  # true
                 store %continue_execution, false
                 store %return_value, 1i
                 exit_if  # if_3
               }
-              %b8 = block {  # false
+              $B8: {  # false
                 exit_if  # if_3
               }
             }
             %10:bool = load %continue_execution
-            %11:i32 = if %10 [t: %b9] {  # if_4
-              %b9 = block {  # true
+            %11:i32 = if %10 [t: $B9] {  # if_4
+              $B9: {  # true
                 %12:i32 = add 42i, 1i
                 exit_if %12  # if_4
               }
@@ -1186,14 +1186,14 @@
             }
             exit_if %11  # if_2
           }
-          %b6 = block {  # false
+          $B6: {  # false
             %13:i32 = add 43i, 2i
             exit_if %13  # if_2
           }
         }
         %14:bool = load %continue_execution
-        %15:i32 = if %14 [t: %b10] {  # if_5
-          %b10 = block {  # true
+        %15:i32 = if %14 [t: $B10] {  # if_5
+          $B10: {  # true
             %16:i32 = add %9, 1i
             exit_if %16  # if_5
           }
@@ -1203,8 +1203,8 @@
       }
     }
     %17:bool = load %continue_execution
-    if %17 [t: %b11] {  # if_6
-      %b11 = block {  # true
+    if %17 [t: $B11] {  # if_6
+      $B11: {  # true
         %18:i32 = add %8, 1i
         store %return_value, %18
         exit_if  # if_6
@@ -1243,23 +1243,23 @@
     });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %3:bool = eq %2, 1i
-    if %3 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %3 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 101i
       }
     }
     %4:bool = eq %2, 2i
-    if %4 [t: %b3] {  # if_2
-      %b3 = block {  # true
+    if %4 [t: $B3] {  # if_2
+      $B3: {  # true
         ret 202i
       }
     }
     %5:bool = eq %2, 3i
-    if %5 [t: %b4] {  # if_3
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_3
+      $B4: {  # true
         ret 303i
       }
     }
@@ -1270,43 +1270,43 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
     %5:bool = eq %2, 1i
-    if %5 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %5 [t: $B2] {  # if_1
+      $B2: {  # true
         store %continue_execution, false
         store %return_value, 101i
         exit_if  # if_1
       }
     }
     %6:bool = load %continue_execution
-    if %6 [t: %b3] {  # if_2
-      %b3 = block {  # true
+    if %6 [t: $B3] {  # if_2
+      $B3: {  # true
         %7:bool = eq %2, 2i
-        if %7 [t: %b4] {  # if_3
-          %b4 = block {  # true
+        if %7 [t: $B4] {  # if_3
+          $B4: {  # true
             store %continue_execution, false
             store %return_value, 202i
             exit_if  # if_3
           }
         }
         %8:bool = load %continue_execution
-        if %8 [t: %b5] {  # if_4
-          %b5 = block {  # true
+        if %8 [t: $B5] {  # if_4
+          $B5: {  # true
             %9:bool = eq %2, 3i
-            if %9 [t: %b6] {  # if_5
-              %b6 = block {  # true
+            if %9 [t: $B6] {  # if_5
+              $B6: {  # true
                 store %continue_execution, false
                 store %return_value, 303i
                 exit_if  # if_5
               }
             }
             %10:bool = load %continue_execution
-            if %10 [t: %b7] {  # if_6
-              %b7 = block {  # true
+            if %10 [t: $B7] {  # if_6
+              $B7: {  # true
                 store %return_value, 404i
                 exit_if  # if_6
               }
@@ -1347,20 +1347,20 @@
     });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %3:bool = eq %2, 1i
-    if %3 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %3 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 101i
       }
     }
     %4:bool = eq %2, 2i
-    if %4 [t: %b3, f: %b4] {  # if_2
-      %b3 = block {  # true
+    if %4 [t: $B3, f: $B4] {  # if_2
+      $B3: {  # true
         ret 202i
       }
-      %b4 = block {  # false
+      $B4: {  # false
         ret 303i
       }
     }
@@ -1371,29 +1371,29 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
     %5:bool = eq %2, 1i
-    if %5 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %5 [t: $B2] {  # if_1
+      $B2: {  # true
         store %continue_execution, false
         store %return_value, 101i
         exit_if  # if_1
       }
     }
     %6:bool = load %continue_execution
-    if %6 [t: %b3] {  # if_2
-      %b3 = block {  # true
+    if %6 [t: $B3] {  # if_2
+      $B3: {  # true
         %7:bool = eq %2, 2i
-        if %7 [t: %b4, f: %b5] {  # if_3
-          %b4 = block {  # true
+        if %7 [t: $B4, f: $B5] {  # if_3
+          $B4: {  # true
             store %continue_execution, false
             store %return_value, 202i
             exit_if  # if_3
           }
-          %b5 = block {  # false
+          $B5: {  # false
             store %continue_execution, false
             store %return_value, 303i
             exit_if  # if_3
@@ -1423,10 +1423,10 @@
         b.Unreachable();
     });
     auto* src = R"(
-%foo = func():i32 -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+%foo = func():i32 {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret 42i
       }
     }
@@ -1437,11 +1437,11 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():i32 -> %b1 {
-  %b1 = block {
+%foo = func():i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         store %return_value, 42i
         exit_loop  # loop_1
       }
@@ -1486,28 +1486,28 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):i32 -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        if %3 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+%foo = func(%3:bool):i32 {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        if %3 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             ret 42i
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         store %1, 2i
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         store %1, 1i
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     store %1, 3i
@@ -1518,43 +1518,43 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%3:bool):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        if %3 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        if %3 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             store %continue_execution, false
             store %return_value, 42i
             exit_if  # if_1
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         %6:bool = load %continue_execution
-        if %6 [t: %b7] {  # if_2
-          %b7 = block {  # true
+        if %6 [t: $B7] {  # if_2
+          $B7: {  # true
             store %1, 2i
-            continue %b4
+            continue  # -> $B4
           }
         }
         exit_loop  # loop_1
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         store %1, 1i
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     %7:bool = load %continue_execution
-    if %7 [t: %b8] {  # if_3
-      %b8 = block {  # true
+    if %7 [t: $B8] {  # if_3
+      $B8: {  # true
         store %1, 3i
         store %return_value, 43i
         exit_if  # if_3
@@ -1600,28 +1600,28 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):i32 -> %b2 {
-  %b2 = block {
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        if %3 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+%foo = func(%3:bool):i32 {
+  $B2: {
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        if %3 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             ret 42i
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         store %1, 2i
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         store %1, 1i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
     }
     unreachable
@@ -1631,38 +1631,38 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:bool):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%3:bool):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    loop [b: %b3, c: %b4] {  # loop_1
-      %b3 = block {  # body
-        if %3 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+    loop [b: $B3, c: $B4] {  # loop_1
+      $B3: {  # body
+        if %3 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             store %continue_execution, false
             store %return_value, 42i
             exit_if  # if_1
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         %6:bool = load %continue_execution
-        if %6 [t: %b7] {  # if_2
-          %b7 = block {  # true
+        if %6 [t: $B7] {  # if_2
+          $B7: {  # true
             store %1, 2i
-            continue %b4
+            continue  # -> $B4
           }
         }
         exit_loop  # loop_1
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         store %1, 1i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
     }
     %7:i32 = load %return_value
@@ -1804,13 +1804,13 @@
     });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
-    switch %2 [c: (1i, %b2), c: (default, %b3)] {  # switch_1
-      %b2 = block {  # case
+%foo = func(%2:i32):i32 {
+  $B1: {
+    switch %2 [c: (1i, $B2), c: (default, $B3)] {  # switch_1
+      $B2: {  # case
         ret 42i
       }
-      %b3 = block {  # case
+      $B3: {  # case
         exit_switch  # switch_1
       }
     }
@@ -1821,23 +1821,23 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    switch %2 [c: (1i, %b2), c: (default, %b3)] {  # switch_1
-      %b2 = block {  # case
+    switch %2 [c: (1i, $B2), c: (default, $B3)] {  # switch_1
+      $B2: {  # case
         store %continue_execution, false
         store %return_value, 42i
         exit_switch  # switch_1
       }
-      %b3 = block {  # case
+      $B3: {  # case
         exit_switch  # switch_1
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b4] {  # if_1
-      %b4 = block {  # true
+    if %5 [t: $B4] {  # if_1
+      $B4: {  # true
         store %return_value, 0i
         exit_if  # if_1
       }
@@ -1879,27 +1879,27 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:i32):i32 -> %b2 {
-  %b2 = block {
-    switch %3 [c: (1i, %b3), c: (default, %b4)] {  # switch_1
-      %b3 = block {  # case
+%foo = func(%3:i32):i32 {
+  $B2: {
+    switch %3 [c: (1i, $B3), c: (default, $B4)] {  # switch_1
+      $B3: {  # case
         %4:bool = eq %3, 1i
-        if %4 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+        if %4 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             ret 42i
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         store %1, 2i
         exit_switch  # switch_1
       }
-      %b4 = block {  # case
+      $B4: {  # case
         exit_switch  # switch_1
       }
     }
@@ -1910,43 +1910,43 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
-%foo = func(%3:i32):i32 -> %b2 {
-  %b2 = block {
+%foo = func(%3:i32):i32 {
+  $B2: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    switch %3 [c: (1i, %b3), c: (default, %b4)] {  # switch_1
-      %b3 = block {  # case
+    switch %3 [c: (1i, $B3), c: (default, $B4)] {  # switch_1
+      $B3: {  # case
         %6:bool = eq %3, 1i
-        if %6 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+        if %6 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             store %continue_execution, false
             store %return_value, 42i
             exit_if  # if_1
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_if  # if_1
           }
         }
         %7:bool = load %continue_execution
-        if %7 [t: %b7] {  # if_2
-          %b7 = block {  # true
+        if %7 [t: $B7] {  # if_2
+          $B7: {  # true
             store %1, 2i
             exit_switch  # switch_1
           }
         }
         exit_switch  # switch_1
       }
-      %b4 = block {  # case
+      $B4: {  # case
         exit_switch  # switch_1
       }
     }
     %8:bool = load %continue_execution
-    if %8 [t: %b8] {  # if_3
-      %b8 = block {  # true
+    if %8 [t: $B8] {  # if_3
+      $B8: {  # true
         store %return_value, 0i
         exit_if  # if_3
       }
@@ -1979,19 +1979,19 @@
     });
 
     auto* src = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
-    %3:i32 = switch %2 [c: (1i, %b2), c: (2i, %b3), c: (3i, %b4), c: (default, %b5)] {  # switch_1
-      %b2 = block {  # case
+%foo = func(%2:i32):i32 {
+  $B1: {
+    %3:i32 = switch %2 [c: (1i, $B2), c: (2i, $B3), c: (3i, $B4), c: (default, $B5)] {  # switch_1
+      $B2: {  # case
         ret 42i
       }
-      %b3 = block {  # case
+      $B3: {  # case
         ret 99i
       }
-      %b4 = block {  # case
+      $B4: {  # case
         exit_switch 1i  # switch_1
       }
-      %b5 = block {  # case
+      $B5: {  # case
         exit_switch 0i  # switch_1
       }
     }
@@ -2002,31 +2002,31 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:i32):i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    %5:i32 = switch %2 [c: (1i, %b2), c: (2i, %b3), c: (3i, %b4), c: (default, %b5)] {  # switch_1
-      %b2 = block {  # case
+    %5:i32 = switch %2 [c: (1i, $B2), c: (2i, $B3), c: (3i, $B4), c: (default, $B5)] {  # switch_1
+      $B2: {  # case
         store %continue_execution, false
         store %return_value, 42i
         exit_switch undef  # switch_1
       }
-      %b3 = block {  # case
+      $B3: {  # case
         store %continue_execution, false
         store %return_value, 99i
         exit_switch undef  # switch_1
       }
-      %b4 = block {  # case
+      $B4: {  # case
         exit_switch 1i  # switch_1
       }
-      %b5 = block {  # case
+      $B5: {  # case
         exit_switch 0i  # switch_1
       }
     }
     %6:bool = load %continue_execution
-    if %6 [t: %b6] {  # if_1
-      %b6 = block {  # true
+    if %6 [t: $B6] {  # if_1
+      $B6: {  # true
         store %return_value, %5
         exit_if  # if_1
       }
@@ -2055,16 +2055,16 @@
     });
 
     auto* src = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b3] {  # if_1
-          %b3 = block {  # true
+%foo = func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
+        if true [t: $B3] {  # if_1
+          $B3: {  # true
             ret
           }
         }
-        continue %b4
+        continue  # -> $B4
       }
     }
     unreachable
@@ -2074,21 +2074,21 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():void -> %b1 {
-  %b1 = block {
+%foo = func():void {
+  $B1: {
     %continue_execution:ptr<function, bool, read_write> = var, true
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b3] {  # if_1
-          %b3 = block {  # true
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
+        if true [t: $B3] {  # if_1
+          $B3: {  # true
             store %continue_execution, false
             exit_if  # if_1
           }
         }
         %3:bool = load %continue_execution
-        if %3 [t: %b4] {  # if_2
-          %b4 = block {  # true
-            continue %b5
+        if %3 [t: $B4] {  # if_2
+          $B4: {  # true
+            continue  # -> $B5
           }
         }
         exit_loop  # loop_1
@@ -2116,12 +2116,12 @@
     });
 
     auto* src = R"(
-%foo = func():i32 -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        if true [t: %b3] {  # if_2
-          %b3 = block {  # true
+%foo = func():i32 {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        if true [t: $B3] {  # if_2
+          $B3: {  # true
             ret 1i
           }
         }
@@ -2135,22 +2135,22 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%foo = func():i32 -> %b1 {
-  %b1 = block {
+%foo = func():i32 {
+  $B1: {
     %return_value:ptr<function, i32, read_write> = var
     %continue_execution:ptr<function, bool, read_write> = var, true
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        if true [t: %b3] {  # if_2
-          %b3 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        if true [t: $B3] {  # if_2
+          $B3: {  # true
             store %continue_execution, false
             store %return_value, 1i
             exit_if  # if_2
           }
         }
         %4:bool = load %continue_execution
-        if %4 [t: %b4] {  # if_3
-          %b4 = block {  # true
+        if %4 [t: $B4] {  # if_3
+          $B4: {  # true
             store %continue_execution, false
             store %return_value, 2i
             exit_if  # if_3
@@ -2160,8 +2160,8 @@
       }
     }
     %5:bool = load %continue_execution
-    if %5 [t: %b5] {  # if_4
-      %b5 = block {  # true
+    if %5 [t: $B5] {  # if_4
+      $B5: {  # true
         store %return_value, 3i
         exit_if  # if_4
       }
diff --git a/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer_test.cc b/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer_test.cc
index 5dc737d..e50d515 100644
--- a/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer_test.cc
+++ b/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer_test.cc
@@ -58,18 +58,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<f32, 4>, read_write> = var
 }
 
-%target = func(%value:array<f32, 4>):f32 -> %b2 {
-  %b2 = block {
+%target = func(%value:array<f32, 4>):f32 {
+  $B2: {
     %4:f32 = access %value, 1i
     ret %4
   }
 }
-%caller = func():f32 -> %b3 {
-  %b3 = block {
+%caller = func():f32 {
+  $B3: {
     %6:array<f32, 4> = load %var
     %7:f32 = call %target, %6
     ret %7
@@ -104,19 +104,19 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%value:ptr<private, mat3x3<f32>, read_write>):vec3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:ptr<private, mat3x3<f32>, read_write>):vec3<f32> {
+  $B2: {
     %4:ptr<private, vec3<f32>, read_write> = access %value, 1i
     %5:vec3<f32> = load %4
     ret %5
   }
 }
-%caller = func():vec3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():vec3<f32> {
+  $B3: {
     %7:vec3<f32> = call %target, %var
     ret %7
   }
@@ -142,12 +142,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%caller = func():f32 -> %b2 {
-  %b2 = block {
+%caller = func():f32 {
+  $B2: {
     %3:mat3x3<f32> = load %var
     %4:f32 = determinant %3
     ret %4
@@ -182,18 +182,18 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%value:mat3x3<f32>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:mat3x3<f32>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = mul %value, 2.0f
     ret %4
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %6:mat3x3<f32> = load %var
     %7:mat3x3<f32> = call %target, %6
     ret %7
@@ -203,19 +203,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%3:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = load %3
     %5:mat3x3<f32> = mul %4, 2.0f
     ret %5
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %7:mat3x3<f32> = load %var
     %8:ptr<function, mat3x3<f32>, read_write> = var, %7
     %9:mat3x3<f32> = call %target, %8
@@ -254,19 +254,19 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<mat3x3<f32>, 4>, read_write> = var
 }
 
-%target = func(%value_a:mat3x3<f32>, %scalar:f32, %value_b:mat3x3<f32>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value_a:mat3x3<f32>, %scalar:f32, %value_b:mat3x3<f32>):mat3x3<f32> {
+  $B2: {
     %6:mat3x3<f32> = mul %value_a, %scalar
     %7:mat3x3<f32> = add %6, %value_b
     ret %7
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %9:ptr<private, mat3x3<f32>, read_write> = access %var, 0u
     %10:mat3x3<f32> = load %9
     %11:ptr<private, mat3x3<f32>, read_write> = access %var, 1u
@@ -279,12 +279,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<mat3x3<f32>, 4>, read_write> = var
 }
 
-%target = func(%3:ptr<function, mat3x3<f32>, read_write>, %scalar:f32, %5:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, mat3x3<f32>, read_write>, %scalar:f32, %5:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> {
+  $B2: {
     %6:mat3x3<f32> = load %5
     %7:mat3x3<f32> = load %3
     %8:mat3x3<f32> = mul %7, %scalar
@@ -292,8 +292,8 @@
     ret %9
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %11:ptr<private, mat3x3<f32>, read_write> = access %var, 0u
     %12:mat3x3<f32> = load %11
     %13:ptr<private, mat3x3<f32>, read_write> = access %var, 1u
@@ -331,19 +331,19 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%value:mat3x3<f32>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:mat3x3<f32>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = add %value, %value
     %5:mat3x3<f32> = mul %4, %value
     ret %5
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %7:mat3x3<f32> = load %var
     %8:mat3x3<f32> = call %target, %7
     ret %8
@@ -353,20 +353,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%3:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, mat3x3<f32>, read_write>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = load %3
     %5:mat3x3<f32> = add %4, %4
     %6:mat3x3<f32> = mul %5, %4
     ret %6
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %8:mat3x3<f32> = load %var
     %9:ptr<function, mat3x3<f32>, read_write> = var, %8
     %10:mat3x3<f32> = call %target, %9
@@ -412,32 +412,32 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%value:mat3x3<f32>, %scalar:f32):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:mat3x3<f32>, %scalar:f32):mat3x3<f32> {
+  $B2: {
     %5:mat3x3<f32> = mul %value, %scalar
     ret %5
   }
 }
-%caller_a = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller_a = func():mat3x3<f32> {
+  $B3: {
     %7:mat3x3<f32> = load %var
     %8:mat3x3<f32> = call %target, %7, 2.0f
     ret %8
   }
 }
-%caller_b = func():mat3x3<f32> -> %b4 {
-  %b4 = block {
+%caller_b = func():mat3x3<f32> {
+  $B4: {
     %10:mat3x3<f32> = load %var
     %11:mat3x3<f32> = call %target, %10, 3.0f
     ret %11
   }
 }
-%caller_c = func():mat3x3<f32> -> %b5 {
-  %b5 = block {
+%caller_c = func():mat3x3<f32> {
+  $B5: {
     %13:mat3x3<f32> = load %var
     %14:mat3x3<f32> = call %target, %13, 4.0f
     ret %14
@@ -447,35 +447,35 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, mat3x3<f32>, read_write> = var
 }
 
-%target = func(%3:ptr<function, mat3x3<f32>, read_write>, %scalar:f32):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, mat3x3<f32>, read_write>, %scalar:f32):mat3x3<f32> {
+  $B2: {
     %5:mat3x3<f32> = load %3
     %6:mat3x3<f32> = mul %5, %scalar
     ret %6
   }
 }
-%caller_a = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller_a = func():mat3x3<f32> {
+  $B3: {
     %8:mat3x3<f32> = load %var
     %9:ptr<function, mat3x3<f32>, read_write> = var, %8
     %10:mat3x3<f32> = call %target, %9, 2.0f
     ret %10
   }
 }
-%caller_b = func():mat3x3<f32> -> %b4 {
-  %b4 = block {
+%caller_b = func():mat3x3<f32> {
+  $B4: {
     %12:mat3x3<f32> = load %var
     %13:ptr<function, mat3x3<f32>, read_write> = var, %12
     %14:mat3x3<f32> = call %target, %13, 3.0f
     ret %14
   }
 }
-%caller_c = func():mat3x3<f32> -> %b5 {
-  %b5 = block {
+%caller_c = func():mat3x3<f32> {
+  $B5: {
     %16:mat3x3<f32> = load %var
     %17:ptr<function, mat3x3<f32>, read_write> = var, %16
     %18:mat3x3<f32> = call %target, %17, 4.0f
@@ -511,20 +511,20 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<mat3x3<f32>, 2>, read_write> = var
 }
 
-%target = func(%value:array<mat3x3<f32>, 2>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:array<mat3x3<f32>, 2>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = access %value, 0u
     %5:mat3x3<f32> = access %value, 1u
     %6:mat3x3<f32> = add %4, %5
     ret %6
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %8:array<mat3x3<f32>, 2> = load %var
     %9:mat3x3<f32> = call %target, %8
     ret %9
@@ -534,12 +534,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<mat3x3<f32>, 2>, read_write> = var
 }
 
-%target = func(%3:ptr<function, array<mat3x3<f32>, 2>, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, array<mat3x3<f32>, 2>, read_write>):mat3x3<f32> {
+  $B2: {
     %4:array<mat3x3<f32>, 2> = load %3
     %5:mat3x3<f32> = access %4, 0u
     %6:mat3x3<f32> = access %4, 1u
@@ -547,8 +547,8 @@
     ret %7
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %9:array<mat3x3<f32>, 2> = load %var
     %10:ptr<function, array<mat3x3<f32>, 2>, read_write> = var, %9
     %11:mat3x3<f32> = call %target, %10
@@ -592,20 +592,20 @@
   s:f32 @offset(48)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, MyStruct, read_write> = var
 }
 
-%target = func(%value:MyStruct):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:MyStruct):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = access %value, 0u
     %5:f32 = access %value, 1u
     %6:mat3x3<f32> = mul %4, %5
     ret %6
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %8:MyStruct = load %var
     %9:mat3x3<f32> = call %target, %8
     ret %9
@@ -620,12 +620,12 @@
   s:f32 @offset(48)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, MyStruct, read_write> = var
 }
 
-%target = func(%3:ptr<function, MyStruct, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, MyStruct, read_write>):mat3x3<f32> {
+  $B2: {
     %4:MyStruct = load %3
     %5:mat3x3<f32> = access %4, 0u
     %6:f32 = access %4, 1u
@@ -633,8 +633,8 @@
     ret %7
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %9:MyStruct = load %var
     %10:ptr<function, MyStruct, read_write> = var, %9
     %11:mat3x3<f32> = call %target, %10
@@ -682,12 +682,12 @@
   s:f32 @offset(96)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<MyStruct, 4>, read_write> = var
 }
 
-%target = func(%value:array<MyStruct, 4>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%value:array<MyStruct, 4>):mat3x3<f32> {
+  $B2: {
     %4:mat3x3<f32> = access %value, 2u, 0u, 0u
     %5:mat3x3<f32> = access %value, 2u, 0u, 1u
     %6:f32 = access %value, 2u, 1u
@@ -696,8 +696,8 @@
     ret %8
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %10:array<MyStruct, 4> = load %var
     %11:mat3x3<f32> = call %target, %10
     ret %11
@@ -712,12 +712,12 @@
   s:f32 @offset(96)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %var:ptr<private, array<MyStruct, 4>, read_write> = var
 }
 
-%target = func(%3:ptr<function, array<MyStruct, 4>, read_write>):mat3x3<f32> -> %b2 {
-  %b2 = block {
+%target = func(%3:ptr<function, array<MyStruct, 4>, read_write>):mat3x3<f32> {
+  $B2: {
     %4:array<MyStruct, 4> = load %3
     %5:mat3x3<f32> = access %4, 2u, 0u, 0u
     %6:mat3x3<f32> = access %4, 2u, 0u, 1u
@@ -727,8 +727,8 @@
     ret %9
   }
 }
-%caller = func():mat3x3<f32> -> %b3 {
-  %b3 = block {
+%caller = func():mat3x3<f32> {
+  $B3: {
     %11:array<MyStruct, 4> = load %var
     %12:ptr<function, array<MyStruct, 4>, read_write> = var, %11
     %13:mat3x3<f32> = call %target, %12
diff --git a/src/tint/lang/spirv/writer/raise/shader_io_test.cc b/src/tint/lang/spirv/writer/raise/shader_io_test.cc
index 61d3ef7..4faaf5d 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io_test.cc
+++ b/src/tint/lang/spirv/writer/raise/shader_io_test.cc
@@ -48,8 +48,8 @@
     });
 
     auto* src = R"(
-%foo = @compute func():void -> %b1 {
-  %b1 = block {
+%foo = @compute func():void {
+  $B1: {
     ret
   }
 }
@@ -91,10 +91,10 @@
     });
 
     auto* src = R"(
-%foo = @fragment func(%front_facing:bool [@front_facing], %position:vec4<f32> [@invariant, @position], %color1:f32 [@location(0)], %color2:f32 [@location(1), @interpolate(linear, sample)]):void -> %b1 {
-  %b1 = block {
-    if %front_facing [t: %b2] {  # if_1
-      %b2 = block {  # true
+%foo = @fragment func(%front_facing:bool [@front_facing], %position:vec4<f32> [@invariant, @position], %color1:f32 [@location(0)], %color2:f32 [@location(1), @interpolate(linear, sample)]):void {
+  $B1: {
+    if %front_facing [t: $B2] {  # if_1
+      $B2: {  # true
         %6:f32 = add %color1, %color2
         %7:vec4<f32> = mul %position, %6
         exit_if  # if_1
@@ -107,17 +107,17 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %foo_front_facing_Input:ptr<__in, bool, read> = var @builtin(front_facing)
   %foo_position_Input:ptr<__in, vec4<f32>, read> = var @invariant @builtin(position)
   %foo_loc0_Input:ptr<__in, f32, read> = var @location(0)
   %foo_loc1_Input:ptr<__in, f32, read> = var @location(1) @interpolate(linear, sample)
 }
 
-%foo_inner = func(%front_facing:bool, %position:vec4<f32>, %color1:f32, %color2:f32):void -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo_inner = func(%front_facing:bool, %position:vec4<f32>, %color1:f32, %color2:f32):void {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         %10:f32 = add %color1, %color2
         %11:vec4<f32> = mul %position, %10
         exit_if  # if_1
@@ -126,8 +126,8 @@
     ret
   }
 }
-%foo = @fragment func():void -> %b4 {
-  %b4 = block {
+%foo = @fragment func():void {
+  $B4: {
     %13:bool = load %foo_front_facing_Input
     %14:vec4<f32> = load %foo_position_Input
     %15:f32 = load %foo_loc0_Input
@@ -227,11 +227,11 @@
   color2:f32 @offset(36), @location(1), @interpolate(linear, sample)
 }
 
-%foo = @fragment func(%inputs:Inputs):void -> %b1 {
-  %b1 = block {
+%foo = @fragment func(%inputs:Inputs):void {
+  $B1: {
     %3:bool = access %inputs, 0i
-    if %3 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %3 [t: $B2] {  # if_1
+      $B2: {  # true
         %4:vec4<f32> = access %inputs, 1i
         %5:f32 = access %inputs, 2i
         %6:f32 = access %inputs, 3i
@@ -254,18 +254,18 @@
   color2:f32 @offset(36)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_front_facing_Input:ptr<__in, bool, read> = var @builtin(front_facing)
   %foo_position_Input:ptr<__in, vec4<f32>, read> = var @invariant @builtin(position)
   %foo_loc0_Input:ptr<__in, f32, read> = var @location(0)
   %foo_loc1_Input:ptr<__in, f32, read> = var @location(1) @interpolate(linear, sample)
 }
 
-%foo_inner = func(%inputs:Inputs):void -> %b2 {
-  %b2 = block {
+%foo_inner = func(%inputs:Inputs):void {
+  $B2: {
     %7:bool = access %inputs, 0i
-    if %7 [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if %7 [t: $B3] {  # if_1
+      $B3: {  # true
         %8:vec4<f32> = access %inputs, 1i
         %9:f32 = access %inputs, 2i
         %10:f32 = access %inputs, 3i
@@ -277,8 +277,8 @@
     ret
   }
 }
-%foo = @fragment func():void -> %b4 {
-  %b4 = block {
+%foo = @fragment func():void {
+  $B4: {
     %14:bool = load %foo_front_facing_Input
     %15:vec4<f32> = load %foo_position_Input
     %16:f32 = load %foo_loc0_Input
@@ -354,10 +354,10 @@
   color1:f32 @offset(16), @location(0)
 }
 
-%foo = @fragment func(%front_facing:bool [@front_facing], %inputs:Inputs, %color2:f32 [@location(1), @interpolate(linear, sample)]):void -> %b1 {
-  %b1 = block {
-    if %front_facing [t: %b2] {  # if_1
-      %b2 = block {  # true
+%foo = @fragment func(%front_facing:bool [@front_facing], %inputs:Inputs, %color2:f32 [@location(1), @interpolate(linear, sample)]):void {
+  $B1: {
+    if %front_facing [t: $B2] {  # if_1
+      $B2: {  # true
         %5:vec4<f32> = access %inputs, 0i
         %6:f32 = access %inputs, 1i
         %7:f32 = add %6, %color2
@@ -377,17 +377,17 @@
   color1:f32 @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_front_facing_Input:ptr<__in, bool, read> = var @builtin(front_facing)
   %foo_position_Input:ptr<__in, vec4<f32>, read> = var @invariant @builtin(position)
   %foo_loc0_Input:ptr<__in, f32, read> = var @location(0)
   %foo_loc1_Input:ptr<__in, f32, read> = var @location(1) @interpolate(linear, sample)
 }
 
-%foo_inner = func(%front_facing:bool, %inputs:Inputs, %color2:f32):void -> %b2 {
-  %b2 = block {
-    if %front_facing [t: %b3] {  # if_1
-      %b3 = block {  # true
+%foo_inner = func(%front_facing:bool, %inputs:Inputs, %color2:f32):void {
+  $B2: {
+    if %front_facing [t: $B3] {  # if_1
+      $B3: {  # true
         %9:vec4<f32> = access %inputs, 0i
         %10:f32 = access %inputs, 1i
         %11:f32 = add %10, %color2
@@ -398,8 +398,8 @@
     ret
   }
 }
-%foo = @fragment func():void -> %b4 {
-  %b4 = block {
+%foo = @fragment func():void {
+  $B4: {
     %14:bool = load %foo_front_facing_Input
     %15:vec4<f32> = load %foo_position_Input
     %16:f32 = load %foo_loc0_Input
@@ -429,8 +429,8 @@
     });
 
     auto* src = R"(
-%foo = @vertex func():vec4<f32> [@invariant, @position] -> %b1 {
-  %b1 = block {
+%foo = @vertex func():vec4<f32> [@invariant, @position] {
+  $B1: {
     %2:vec4<f32> = construct 0.5f
     ret %2
   }
@@ -439,18 +439,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %foo_position_Output:ptr<__out, vec4<f32>, write> = var @invariant @builtin(position)
 }
 
-%foo_inner = func():vec4<f32> -> %b2 {
-  %b2 = block {
+%foo_inner = func():vec4<f32> {
+  $B2: {
     %3:vec4<f32> = construct 0.5f
     ret %3
   }
 }
-%foo = @vertex func():void -> %b3 {
-  %b3 = block {
+%foo = @vertex func():void {
+  $B3: {
     %5:vec4<f32> = call %foo_inner
     store %foo_position_Output, %5
     ret
@@ -475,8 +475,8 @@
     });
 
     auto* src = R"(
-%foo = @fragment func():vec4<f32> [@location(1)] -> %b1 {
-  %b1 = block {
+%foo = @fragment func():vec4<f32> [@location(1)] {
+  $B1: {
     %2:vec4<f32> = construct 0.5f
     ret %2
   }
@@ -485,18 +485,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %foo_loc1_Output:ptr<__out, vec4<f32>, write> = var @location(1)
 }
 
-%foo_inner = func():vec4<f32> -> %b2 {
-  %b2 = block {
+%foo_inner = func():vec4<f32> {
+  $B2: {
     %3:vec4<f32> = construct 0.5f
     ret %3
   }
 }
-%foo = @fragment func():void -> %b3 {
-  %b3 = block {
+%foo = @fragment func():void {
+  $B3: {
     %5:vec4<f32> = call %foo_inner
     store %foo_loc1_Output, %5
     ret
@@ -570,8 +570,8 @@
   color2:f32 @offset(20), @location(1), @interpolate(linear, sample)
 }
 
-%foo = @vertex func():Outputs -> %b1 {
-  %b1 = block {
+%foo = @vertex func():Outputs {
+  $B1: {
     %2:vec4<f32> = construct 0.0f
     %3:Outputs = construct %2, 0.25f, 0.75f
     ret %3
@@ -587,21 +587,21 @@
   color2:f32 @offset(20)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_position_Output:ptr<__out, vec4<f32>, write> = var @invariant @builtin(position)
   %foo_loc0_Output:ptr<__out, f32, write> = var @location(0)
   %foo_loc1_Output:ptr<__out, f32, write> = var @location(1) @interpolate(linear, sample)
 }
 
-%foo_inner = func():Outputs -> %b2 {
-  %b2 = block {
+%foo_inner = func():Outputs {
+  $B2: {
     %5:vec4<f32> = construct 0.0f
     %6:Outputs = construct %5, 0.25f, 0.75f
     ret %6
   }
 }
-%foo = @vertex func():void -> %b3 {
-  %b3 = block {
+%foo = @vertex func():void {
+  $B3: {
     %8:Outputs = call %foo_inner
     %9:vec4<f32> = access %8, 0u
     store %foo_position_Output, %9
@@ -663,8 +663,8 @@
   color2:f32 @offset(4), @location(0)
 }
 
-%foo = @fragment func():Output -> %b1 {
-  %b1 = block {
+%foo = @fragment func():Output {
+  $B1: {
     %2:Output = construct 0.25f, 0.75f
     ret %2
   }
@@ -678,19 +678,19 @@
   color2:f32 @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_loc0_idx0_Output:ptr<__out, f32, write> = var @location(0) @blend_src(0)
   %foo_loc0_idx1_Output:ptr<__out, f32, write> = var @location(0) @blend_src(1)
 }
 
-%foo_inner = func():Output -> %b2 {
-  %b2 = block {
+%foo_inner = func():Output {
+  $B2: {
     %4:Output = construct 0.25f, 0.75f
     ret %4
   }
 }
-%foo = @fragment func():void -> %b3 {
-  %b3 = block {
+%foo = @fragment func():void {
+  $B3: {
     %6:Output = call %foo_inner
     %7:f32 = access %6, 0u
     store %foo_loc0_idx0_Output, %7
@@ -771,16 +771,16 @@
   color:vec4<f32> @offset(16), @location(0)
 }
 
-%vert = @vertex func():Interface -> %b1 {
-  %b1 = block {
+%vert = @vertex func():Interface {
+  $B1: {
     %2:vec4<f32> = construct 0.0f
     %3:vec4<f32> = construct 1.0f
     %4:Interface = construct %2, %3
     ret %4
   }
 }
-%frag = @fragment func(%inputs:Interface):vec4<f32> [@location(0)] -> %b2 {
-  %b2 = block {
+%frag = @fragment func(%inputs:Interface):vec4<f32> [@location(0)] {
+  $B2: {
     %7:vec4<f32> = access %inputs, 0u
     %8:vec4<f32> = access %inputs, 1u
     %9:vec4<f32> = add %7, %8
@@ -796,7 +796,7 @@
   color:vec4<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %vert_position_Output:ptr<__out, vec4<f32>, write> = var @builtin(position)
   %vert_loc0_Output:ptr<__out, vec4<f32>, write> = var @location(0)
   %frag_position_Input:ptr<__in, vec4<f32>, read> = var @builtin(position)
@@ -804,24 +804,24 @@
   %frag_loc0_Output:ptr<__out, vec4<f32>, write> = var @location(0)
 }
 
-%vert_inner = func():Interface -> %b2 {
-  %b2 = block {
+%vert_inner = func():Interface {
+  $B2: {
     %7:vec4<f32> = construct 0.0f
     %8:vec4<f32> = construct 1.0f
     %9:Interface = construct %7, %8
     ret %9
   }
 }
-%frag_inner = func(%inputs:Interface):vec4<f32> -> %b3 {
-  %b3 = block {
+%frag_inner = func(%inputs:Interface):vec4<f32> {
+  $B3: {
     %12:vec4<f32> = access %inputs, 0u
     %13:vec4<f32> = access %inputs, 1u
     %14:vec4<f32> = add %12, %13
     ret %14
   }
 }
-%vert = @vertex func():void -> %b4 {
-  %b4 = block {
+%vert = @vertex func():void {
+  $B4: {
     %16:Interface = call %vert_inner
     %17:vec4<f32> = access %16, 0u
     store %vert_position_Output, %17
@@ -830,8 +830,8 @@
     ret
   }
 }
-%frag = @fragment func():void -> %b5 {
-  %b5 = block {
+%frag = @fragment func():void {
+  $B5: {
     %20:vec4<f32> = load %frag_position_Input
     %21:vec4<f32> = load %frag_loc0_Input
     %22:Interface = construct %20, %21
@@ -894,12 +894,12 @@
   color:vec4<f32> @offset(16), @location(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, Outputs, read> = var
 }
 
-%vert = @vertex func():Outputs -> %b2 {
-  %b2 = block {
+%vert = @vertex func():Outputs {
+  $B2: {
     %3:Outputs = load %1
     ret %3
   }
@@ -913,20 +913,20 @@
   color:vec4<f32> @offset(16)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<storage, Outputs, read> = var
   %vert_position_Output:ptr<__out, vec4<f32>, write> = var @builtin(position)
   %vert_loc0_Output:ptr<__out, vec4<f32>, write> = var @location(0)
 }
 
-%vert_inner = func():Outputs -> %b2 {
-  %b2 = block {
+%vert_inner = func():Outputs {
+  $B2: {
     %5:Outputs = load %1
     ret %5
   }
 }
-%vert = @vertex func():void -> %b3 {
-  %b3 = block {
+%vert = @vertex func():void {
+  $B3: {
     %7:Outputs = call %vert_inner
     %8:vec4<f32> = access %7, 0u
     store %vert_position_Output, %8
@@ -991,8 +991,8 @@
   mask:u32 @offset(4), @builtin(sample_mask)
 }
 
-%foo = @fragment func(%mask_in:u32 [@sample_mask]):Outputs -> %b1 {
-  %b1 = block {
+%foo = @fragment func(%mask_in:u32 [@sample_mask]):Outputs {
+  $B1: {
     %3:Outputs = construct 0.5f, %mask_in
     ret %3
   }
@@ -1006,20 +1006,20 @@
   mask:u32 @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_sample_mask_Input:ptr<__in, array<u32, 1>, read> = var @builtin(sample_mask)
   %foo_loc0_Output:ptr<__out, f32, write> = var @location(0)
   %foo_sample_mask_Output:ptr<__out, array<u32, 1>, write> = var @builtin(sample_mask)
 }
 
-%foo_inner = func(%mask_in:u32):Outputs -> %b2 {
-  %b2 = block {
+%foo_inner = func(%mask_in:u32):Outputs {
+  $B2: {
     %6:Outputs = construct 0.5f, %mask_in
     ret %6
   }
 }
-%foo = @fragment func():void -> %b3 {
-  %b3 = block {
+%foo = @fragment func():void {
+  $B3: {
     %8:ptr<__in, u32, read> = access %foo_sample_mask_Input, 0u
     %9:u32 = load %8
     %10:Outputs = call %foo_inner, %9
@@ -1105,20 +1105,20 @@
   color:f32 @offset(0), @location(1), @interpolate(linear, sample)
 }
 
-%vert = @vertex func(%input:MyStruct, %ival:i32 [@location(1), @interpolate(flat)]):vec4<f32> [@invariant, @position] -> %b1 {
-  %b1 = block {
+%vert = @vertex func(%input:MyStruct, %ival:i32 [@location(1), @interpolate(flat)]):vec4<f32> [@invariant, @position] {
+  $B1: {
     %4:vec4<f32> = construct 0.5f
     ret %4
   }
 }
-%frag1 = @fragment func():MyStruct -> %b2 {
-  %b2 = block {
+%frag1 = @fragment func():MyStruct {
+  $B2: {
     %6:MyStruct = construct 0.5f
     ret %6
   }
 }
-%frag2 = @fragment func():i32 [@location(0), @interpolate(flat)] -> %b3 {
-  %b3 = block {
+%frag2 = @fragment func():i32 [@location(0), @interpolate(flat)] {
+  $B3: {
     ret 42i
   }
 }
@@ -1130,7 +1130,7 @@
   color:f32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %vert_loc1_Input:ptr<__in, f32, read> = var @location(1)
   %vert_loc1_Input_1:ptr<__in, i32, read> = var @location(1)  # %vert_loc1_Input_1: 'vert_loc1_Input'
   %vert_position_Output:ptr<__out, vec4<f32>, write> = var @invariant @builtin(position)
@@ -1138,25 +1138,25 @@
   %frag2_loc0_Output:ptr<__out, i32, write> = var @location(0)
 }
 
-%vert_inner = func(%input:MyStruct, %ival:i32):vec4<f32> -> %b2 {
-  %b2 = block {
+%vert_inner = func(%input:MyStruct, %ival:i32):vec4<f32> {
+  $B2: {
     %9:vec4<f32> = construct 0.5f
     ret %9
   }
 }
-%frag1_inner = func():MyStruct -> %b3 {
-  %b3 = block {
+%frag1_inner = func():MyStruct {
+  $B3: {
     %11:MyStruct = construct 0.5f
     ret %11
   }
 }
-%frag2_inner = func():i32 -> %b4 {
-  %b4 = block {
+%frag2_inner = func():i32 {
+  $B4: {
     ret 42i
   }
 }
-%vert = @vertex func():void -> %b5 {
-  %b5 = block {
+%vert = @vertex func():void {
+  $B5: {
     %14:f32 = load %vert_loc1_Input
     %15:MyStruct = construct %14
     %16:i32 = load %vert_loc1_Input_1
@@ -1165,16 +1165,16 @@
     ret
   }
 }
-%frag1 = @fragment func():void -> %b6 {
-  %b6 = block {
+%frag1 = @fragment func():void {
+  $B6: {
     %19:MyStruct = call %frag1_inner
     %20:f32 = access %19, 0u
     store %frag1_loc1_Output, %20
     ret
   }
 }
-%frag2 = @fragment func():void -> %b7 {
-  %b7 = block {
+%frag2 = @fragment func():void {
+  $B7: {
     %22:i32 = call %frag2_inner
     store %frag2_loc0_Output, %22
     ret
@@ -1231,8 +1231,8 @@
   depth:f32 @offset(4), @builtin(frag_depth)
 }
 
-%foo = @fragment func():Outputs -> %b1 {
-  %b1 = block {
+%foo = @fragment func():Outputs {
+  $B1: {
     %2:Outputs = construct 0.5f, 2.0f
     ret %2
   }
@@ -1251,20 +1251,20 @@
   max:f32 @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %foo_loc0_Output:ptr<__out, f32, write> = var @location(0)
   %foo_frag_depth_Output:ptr<__out, f32, write> = var @builtin(frag_depth)
   %tint_frag_depth_clamp_args:ptr<push_constant, FragDepthClampArgs, read> = var
 }
 
-%foo_inner = func():Outputs -> %b2 {
-  %b2 = block {
+%foo_inner = func():Outputs {
+  $B2: {
     %5:Outputs = construct 0.5f, 2.0f
     ret %5
   }
 }
-%foo = @fragment func():void -> %b3 {
-  %b3 = block {
+%foo = @fragment func():void {
+  $B3: {
     %7:Outputs = call %foo_inner
     %8:f32 = access %7, 0u
     store %foo_loc0_Output, %8
@@ -1332,20 +1332,20 @@
   depth:f32 @offset(4), @builtin(frag_depth)
 }
 
-%ep1 = @fragment func():Outputs -> %b1 {
-  %b1 = block {
+%ep1 = @fragment func():Outputs {
+  $B1: {
     %2:Outputs = construct 0.5f, 2.0f
     ret %2
   }
 }
-%ep2 = @fragment func():Outputs -> %b2 {
-  %b2 = block {
+%ep2 = @fragment func():Outputs {
+  $B2: {
     %4:Outputs = construct 0.5f, 2.0f
     ret %4
   }
 }
-%ep3 = @fragment func():Outputs -> %b3 {
-  %b3 = block {
+%ep3 = @fragment func():Outputs {
+  $B3: {
     %6:Outputs = construct 0.5f, 2.0f
     ret %6
   }
@@ -1364,7 +1364,7 @@
   max:f32 @offset(4)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %ep1_loc0_Output:ptr<__out, f32, write> = var @location(0)
   %ep1_frag_depth_Output:ptr<__out, f32, write> = var @builtin(frag_depth)
   %tint_frag_depth_clamp_args:ptr<push_constant, FragDepthClampArgs, read> = var
@@ -1374,26 +1374,26 @@
   %ep3_frag_depth_Output:ptr<__out, f32, write> = var @builtin(frag_depth)
 }
 
-%ep1_inner = func():Outputs -> %b2 {
-  %b2 = block {
+%ep1_inner = func():Outputs {
+  $B2: {
     %9:Outputs = construct 0.5f, 2.0f
     ret %9
   }
 }
-%ep2_inner = func():Outputs -> %b3 {
-  %b3 = block {
+%ep2_inner = func():Outputs {
+  $B3: {
     %11:Outputs = construct 0.5f, 2.0f
     ret %11
   }
 }
-%ep3_inner = func():Outputs -> %b4 {
-  %b4 = block {
+%ep3_inner = func():Outputs {
+  $B4: {
     %13:Outputs = construct 0.5f, 2.0f
     ret %13
   }
 }
-%ep1 = @fragment func():void -> %b5 {
-  %b5 = block {
+%ep1 = @fragment func():void {
+  $B5: {
     %15:Outputs = call %ep1_inner
     %16:f32 = access %15, 0u
     store %ep1_loc0_Output, %16
@@ -1406,8 +1406,8 @@
     ret
   }
 }
-%ep2 = @fragment func():void -> %b6 {
-  %b6 = block {
+%ep2 = @fragment func():void {
+  $B6: {
     %23:Outputs = call %ep2_inner
     %24:f32 = access %23, 0u
     store %ep2_loc0_Output, %24
@@ -1420,8 +1420,8 @@
     ret
   }
 }
-%ep3 = @fragment func():void -> %b7 {
-  %b7 = block {
+%ep3 = @fragment func():void {
+  $B7: {
     %31:Outputs = call %ep3_inner
     %32:f32 = access %31, 0u
     store %ep3_loc0_Output, %32
@@ -1453,8 +1453,8 @@
     });
 
     auto* src = R"(
-%foo = @vertex func():vec4<f32> [@position] -> %b1 {
-  %b1 = block {
+%foo = @vertex func():vec4<f32> [@position] {
+  $B1: {
     %2:vec4<f32> = construct 0.5f
     ret %2
   }
@@ -1463,19 +1463,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %foo_position_Output:ptr<__out, vec4<f32>, write> = var @builtin(position)
   %foo___point_size_Output:ptr<__out, f32, write> = var @builtin(__point_size)
 }
 
-%foo_inner = func():vec4<f32> -> %b2 {
-  %b2 = block {
+%foo_inner = func():vec4<f32> {
+  $B2: {
     %4:vec4<f32> = construct 0.5f
     ret %4
   }
 }
-%foo = @vertex func():void -> %b3 {
-  %b3 = block {
+%foo = @vertex func():void {
+  $B3: {
     %6:vec4<f32> = call %foo_inner
     store %foo_position_Output, %6
     store %foo___point_size_Output, 1.0f
@@ -1536,8 +1536,8 @@
   out2:vec4<f16> @offset(8), @location(2)
 }
 
-%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs -> %b1 {
-  %b1 = block {
+%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs {
+  $B1: {
     %4:Outputs = construct %in1, %in2
     ret %4
   }
@@ -1551,21 +1551,21 @@
   out2:vec4<f16> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %main_loc2_Input:ptr<__in, f16, read> = var @location(2)
   %main_Input:ptr<__in, vec4<f16>, read> = var
   %main_loc1_Output:ptr<__out, f16, write> = var @location(1)
   %main_loc2_Output:ptr<__out, vec4<f16>, write> = var @location(2)
 }
 
-%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs -> %b2 {
-  %b2 = block {
+%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs {
+  $B2: {
     %8:Outputs = construct %in1, %in2
     ret %8
   }
 }
-%main = @fragment func():void -> %b3 {
-  %b3 = block {
+%main = @fragment func():void {
+  $B3: {
     %10:f16 = load %main_loc2_Input
     %11:vec4<f16> = load %main_Input
     %12:Outputs = call %main_inner, %10, %11
@@ -1630,8 +1630,8 @@
   out2:vec4<f16> @offset(8), @location(2)
 }
 
-%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs -> %b1 {
-  %b1 = block {
+%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs {
+  $B1: {
     %4:Outputs = construct %in1, %in2
     ret %4
   }
@@ -1645,21 +1645,21 @@
   out2:vec4<f16> @offset(8)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %main_loc2_Input:ptr<__in, f32, read> = var @location(2)
   %main_Input:ptr<__in, vec4<f32>, read> = var
   %main_loc1_Output:ptr<__out, f32, write> = var @location(1)
   %main_loc2_Output:ptr<__out, vec4<f32>, write> = var @location(2)
 }
 
-%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs -> %b2 {
-  %b2 = block {
+%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs {
+  $B2: {
     %8:Outputs = construct %in1, %in2
     ret %8
   }
 }
-%main = @fragment func():void -> %b3 {
-  %b3 = block {
+%main = @fragment func():void {
+  $B3: {
     %10:f32 = load %main_loc2_Input
     %11:f16 = convert %10
     %12:vec4<f32> = load %main_Input
diff --git a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index_test.cc b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index_test.cc
index 657488b..59b0f27 100644
--- a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index_test.cc
+++ b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index_test.cc
@@ -52,8 +52,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:array<i32, 4>):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<i32, 4>):i32 {
+  $B1: {
     %3:i32 = access %2, 1i
     ret %3
   }
@@ -75,8 +75,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:mat2x2<f32>):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:mat2x2<f32>):f32 {
+  $B1: {
     %3:f32 = access %2, 1i, 0i
     ret %3
   }
@@ -100,8 +100,8 @@
     block->Append(b.Return(func, load));
 
     auto* expect = R"(
-%foo = func(%2:ptr<function, array<i32, 4>, read_write>, %3:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:ptr<function, array<i32, 4>, read_write>, %3:i32):i32 {
+  $B1: {
     %4:ptr<function, i32, read_write> = access %2, %3
     %5:i32 = load %4
     ret %5
@@ -126,8 +126,8 @@
     block->Append(b.Return(func, load));
 
     auto* expect = R"(
-%foo = func(%2:ptr<function, mat2x2<f32>, read_write>, %3:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:ptr<function, mat2x2<f32>, read_write>, %3:i32):f32 {
+  $B1: {
     %4:ptr<function, vec2<f32>, read_write> = access %2, %3
     %5:f32 = load_vector_element %4, %3
     ret %5
@@ -151,8 +151,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:vec4<f32>, %3:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:vec4<f32>, %3:i32):f32 {
+  $B1: {
     %4:f32 = access %2, %3
     ret %4
   }
@@ -175,8 +175,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:array<i32, 4>, %3:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<i32, 4>, %3:i32):i32 {
+  $B1: {
     %4:ptr<function, array<i32, 4>, read_write> = var, %2
     %5:ptr<function, i32, read_write> = access %4, %3
     %6:i32 = load %5
@@ -201,8 +201,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:mat2x2<f32>, %3:i32):vec2<f32> -> %b1 {
-  %b1 = block {
+%foo = func(%2:mat2x2<f32>, %3:i32):vec2<f32> {
+  $B1: {
     %4:ptr<function, mat2x2<f32>, read_write> = var, %2
     %5:ptr<function, vec2<f32>, read_write> = access %4, %3
     %6:vec2<f32> = load %5
@@ -227,8 +227,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:mat2x2<f32>, %3:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:mat2x2<f32>, %3:i32):f32 {
+  $B1: {
     %4:ptr<function, mat2x2<f32>, read_write> = var, %2
     %5:ptr<function, vec2<f32>, read_write> = access %4, %3
     %6:f32 = load_vector_element %5, %3
@@ -253,8 +253,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 {
+  $B1: {
     %4:ptr<function, array<array<array<i32, 4>, 4>, 4>, read_write> = var, %2
     %5:ptr<function, i32, read_write> = access %4, %3, 1u, %3
     %6:i32 = load %5
@@ -279,8 +279,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 {
+  $B1: {
     %4:array<i32, 4> = access %2, 1u, 2u
     %5:ptr<function, array<i32, 4>, read_write> = var, %4
     %6:ptr<function, i32, read_write> = access %5, %3
@@ -306,8 +306,8 @@
     block->Append(b.Return(func, access));
 
     auto* expect = R"(
-%foo = func(%2:array<array<array<array<i32, 4>, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<array<array<array<i32, 4>, 4>, 4>, 4>, %3:i32):i32 {
+  $B1: {
     %4:array<array<array<i32, 4>, 4>, 4> = access %2, 1u
     %5:ptr<function, array<array<array<i32, 4>, 4>, 4>, read_write> = var, %4
     %6:ptr<function, i32, read_write> = access %5, %3, 2u, %3
@@ -345,8 +345,8 @@
   arr2:array<f32, 1024> @offset(4160)
 }
 
-%foo = func(%2:MyStruct, %3:i32):f32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:MyStruct, %3:i32):f32 {
+  $B1: {
     %4:mat4x4<f32> = access %2, 1u
     %5:ptr<function, mat4x4<f32>, read_write> = var, %4
     %6:ptr<function, vec4<f32>, read_write> = access %5, %3
@@ -376,8 +376,8 @@
     block->Append(b.Return(func, access_c));
 
     auto* expect = R"(
-%foo = func(%2:array<i32, 4>, %3:i32, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<i32, 4>, %3:i32, %4:i32, %5:i32):i32 {
+  $B1: {
     %6:ptr<function, array<i32, 4>, read_write> = var, %2
     %7:ptr<function, i32, read_write> = access %6, %3
     %8:i32 = load %7
@@ -410,8 +410,8 @@
     block->Append(b.Return(func, access_c));
 
     auto* expect = R"(
-%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
+%foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32, %4:i32, %5:i32):i32 {
+  $B1: {
     %6:array<i32, 4> = access %2, 1u, 2u
     %7:ptr<function, array<i32, 4>, read_write> = var, %6
     %8:ptr<function, i32, read_write> = access %7, %3
@@ -449,14 +449,14 @@
     });
 
     auto* src = R"(
-%func = func(%2:array<i32, 4>, %3:bool, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
-    if %3 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%func = func(%2:array<i32, 4>, %3:bool, %4:i32, %5:i32):i32 {
+  $B1: {
+    if %3 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         %6:i32 = access %2, %4
         ret %6
       }
-      %b3 = block {  # false
+      $B3: {  # false
         %7:i32 = access %2, %5
         ret %7
       }
@@ -468,16 +468,16 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%func = func(%2:array<i32, 4>, %3:bool, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
+%func = func(%2:array<i32, 4>, %3:bool, %4:i32, %5:i32):i32 {
+  $B1: {
     %6:ptr<function, array<i32, 4>, read_write> = var, %2
-    if %3 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    if %3 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         %7:ptr<function, i32, read_write> = access %6, %4
         %8:i32 = load %7
         ret %8
       }
-      %b3 = block {  # false
+      $B3: {  # false
         %9:ptr<function, i32, read_write> = access %6, %5
         %10:i32 = load %9
         ret %10
@@ -513,14 +513,14 @@
     });
 
     auto* src = R"(
-%func = func(%2:array<array<i32, 4>, 4>, %3:bool, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
-    if %3 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+%func = func(%2:array<array<i32, 4>, 4>, %3:bool, %4:i32, %5:i32):i32 {
+  $B1: {
+    if %3 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         %6:i32 = access %2, 0u, %4
         ret %6
       }
-      %b3 = block {  # false
+      $B3: {  # false
         %7:i32 = access %2, 0u, %5
         ret %7
       }
@@ -532,17 +532,17 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%func = func(%2:array<array<i32, 4>, 4>, %3:bool, %4:i32, %5:i32):i32 -> %b1 {
-  %b1 = block {
+%func = func(%2:array<array<i32, 4>, 4>, %3:bool, %4:i32, %5:i32):i32 {
+  $B1: {
     %6:array<i32, 4> = access %2, 0u
     %7:ptr<function, array<i32, 4>, read_write> = var, %6
-    if %3 [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    if %3 [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         %8:ptr<function, i32, read_write> = access %7, %4
         %9:i32 = load %8
         ret %9
       }
-      %b3 = block {  # false
+      $B3: {  # false
         %10:ptr<function, i32, read_write> = access %7, %5
         %11:i32 = load %10
         ret %11
@@ -581,16 +581,16 @@
     });
 
     auto* src = R"(
-%func = func(%2:bool, %3:i32, %4:i32):i32 -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%5:array<i32, 4>) {  # body
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+%func = func(%2:bool, %3:i32, %4:i32):i32 {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%5:array<i32, 4>): {  # body
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             %6:i32 = access %5:array<i32, 4>, %3
             ret %6
           }
-          %b4 = block {  # false
+          $B4: {  # false
             %7:i32 = access %5:array<i32, 4>, %4
             ret %7
           }
@@ -605,18 +605,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%func = func(%2:bool, %3:i32, %4:i32):i32 -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%5:array<i32, 4>) {  # body
+%func = func(%2:bool, %3:i32, %4:i32):i32 {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%5:array<i32, 4>): {  # body
         %6:ptr<function, array<i32, 4>, read_write> = var, %5:array<i32, 4>
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             %7:ptr<function, i32, read_write> = access %6, %3
             %8:i32 = load %7
             ret %8
           }
-          %b4 = block {  # false
+          $B4: {  # false
             %9:ptr<function, i32, read_write> = access %6, %4
             %10:i32 = load %9
             ret %10
@@ -660,16 +660,16 @@
     });
 
     auto* src = R"(
-%func = func(%2:bool, %3:i32, %4:i32):i32 -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%5:array<array<i32, 4>, 4>) {  # body
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+%func = func(%2:bool, %3:i32, %4:i32):i32 {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%5:array<array<i32, 4>, 4>): {  # body
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             %6:i32 = access %5:array<array<i32, 4>, 4>, 0u, %3
             ret %6
           }
-          %b4 = block {  # false
+          $B4: {  # false
             %7:i32 = access %5:array<array<i32, 4>, 4>, 0u, %4
             ret %7
           }
@@ -684,19 +684,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%func = func(%2:bool, %3:i32, %4:i32):i32 -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block (%5:array<array<i32, 4>, 4>) {  # body
+%func = func(%2:bool, %3:i32, %4:i32):i32 {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2 (%5:array<array<i32, 4>, 4>): {  # body
         %6:array<i32, 4> = access %5:array<array<i32, 4>, 4>, 0u
         %7:ptr<function, array<i32, 4>, read_write> = var, %6
-        if %2 [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+        if %2 [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             %8:ptr<function, i32, read_write> = access %7, %3
             %9:i32 = load %8
             ret %9
           }
-          %b4 = block {  # false
+          $B4: {  # false
             %10:ptr<function, i32, read_write> = access %7, %4
             %11:i32 = load %10
             ret %11
@@ -740,20 +740,20 @@
     });
 
     auto* src = R"(
-%func_a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%func_a = func(%2:i32):i32 {
+  $B1: {
     %3:i32 = access array<i32, 4>(0i), %2
     ret %3
   }
 }
-%func_b = func(%5:i32):i32 -> %b2 {
-  %b2 = block {
+%func_b = func(%5:i32):i32 {
+  $B2: {
     %6:i32 = access array<i32, 4>(0i), %5
     ret %6
   }
 }
-%func_c = func(%8:i32):i32 -> %b3 {
-  %b3 = block {
+%func_c = func(%8:i32):i32 {
+  $B3: {
     %9:i32 = access array<i32, 4>(0i), %8
     ret %9
   }
@@ -762,26 +762,26 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, array<i32, 4>, read_write> = var, array<i32, 4>(0i)
 }
 
-%func_a = func(%3:i32):i32 -> %b2 {
-  %b2 = block {
+%func_a = func(%3:i32):i32 {
+  $B2: {
     %4:ptr<private, i32, read_write> = access %1, %3
     %5:i32 = load %4
     ret %5
   }
 }
-%func_b = func(%7:i32):i32 -> %b3 {
-  %b3 = block {
+%func_b = func(%7:i32):i32 {
+  $B3: {
     %8:ptr<private, i32, read_write> = access %1, %7
     %9:i32 = load %8
     ret %9
   }
 }
-%func_c = func(%11:i32):i32 -> %b4 {
-  %b4 = block {
+%func_c = func(%11:i32):i32 {
+  $B4: {
     %12:ptr<private, i32, read_write> = access %1, %11
     %13:i32 = load %12
     ret %13
@@ -820,20 +820,20 @@
     });
 
     auto* src = R"(
-%func_a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%func_a = func(%2:i32):i32 {
+  $B1: {
     %3:i32 = access array<array<i32, 4>, 4>(array<i32, 4>(0i)), 0u, %2
     ret %3
   }
 }
-%func_b = func(%5:i32):i32 -> %b2 {
-  %b2 = block {
+%func_b = func(%5:i32):i32 {
+  $B2: {
     %6:i32 = access array<array<i32, 4>, 4>(array<i32, 4>(0i)), 0u, %5
     ret %6
   }
 }
-%func_c = func(%8:i32):i32 -> %b3 {
-  %b3 = block {
+%func_c = func(%8:i32):i32 {
+  $B3: {
     %9:i32 = access array<array<i32, 4>, 4>(array<i32, 4>(0i)), 0u, %8
     ret %9
   }
@@ -842,26 +842,26 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, array<i32, 4>, read_write> = var, array<i32, 4>(0i)
 }
 
-%func_a = func(%3:i32):i32 -> %b2 {
-  %b2 = block {
+%func_a = func(%3:i32):i32 {
+  $B2: {
     %4:ptr<private, i32, read_write> = access %1, %3
     %5:i32 = load %4
     ret %5
   }
 }
-%func_b = func(%7:i32):i32 -> %b3 {
-  %b3 = block {
+%func_b = func(%7:i32):i32 {
+  $B3: {
     %8:ptr<private, i32, read_write> = access %1, %7
     %9:i32 = load %8
     ret %9
   }
 }
-%func_c = func(%11:i32):i32 -> %b4 {
-  %b4 = block {
+%func_c = func(%11:i32):i32 {
+  $B4: {
     %12:ptr<private, i32, read_write> = access %1, %11
     %13:i32 = load %12
     ret %13
diff --git a/src/tint/lang/wgsl/ast/transform/BUILD.cmake b/src/tint/lang/wgsl/ast/transform/BUILD.cmake
index 13dc91b..9f17000 100644
--- a/src/tint/lang/wgsl/ast/transform/BUILD.cmake
+++ b/src/tint/lang/wgsl/ast/transform/BUILD.cmake
@@ -251,11 +251,23 @@
   lang/wgsl/ast/transform/add_block_attribute_fuzz.cc
   lang/wgsl/ast/transform/add_empty_entry_point_fuzz.cc
   lang/wgsl/ast/transform/array_length_from_uniform_fuzz.cc
+  lang/wgsl/ast/transform/binding_remapper_fuzz.cc
+  lang/wgsl/ast/transform/builtin_polyfill_fuzz.cc
+  lang/wgsl/ast/transform/canonicalize_entry_point_io_fuzz.cc
+  lang/wgsl/ast/transform/clamp_frag_depth_fuzz.cc
+  lang/wgsl/ast/transform/demote_to_helper_fuzz.cc
+  lang/wgsl/ast/transform/direct_variable_access_fuzz.cc
+  lang/wgsl/ast/transform/disable_uniformity_analysis_fuzz.cc
+  lang/wgsl/ast/transform/expand_compound_assignment_fuzz.cc
+  lang/wgsl/ast/transform/first_index_offset_fuzz.cc
+  lang/wgsl/ast/transform/fold_constants_fuzz.cc
+  lang/wgsl/ast/transform/multiplanar_external_texture_fuzz.cc
   lang/wgsl/ast/transform/zero_init_workgroup_memory_fuzz.cc
 )
 
 tint_target_add_dependencies(tint_lang_wgsl_ast_transform_fuzz fuzz
   tint_api_common
+  tint_api_options
   tint_lang_core
   tint_lang_core_constant
   tint_lang_core_type
diff --git a/src/tint/lang/wgsl/ast/transform/BUILD.gn b/src/tint/lang/wgsl/ast/transform/BUILD.gn
index 63bcb03..76bcf95 100644
--- a/src/tint/lang/wgsl/ast/transform/BUILD.gn
+++ b/src/tint/lang/wgsl/ast/transform/BUILD.gn
@@ -241,10 +241,22 @@
       "add_block_attribute_fuzz.cc",
       "add_empty_entry_point_fuzz.cc",
       "array_length_from_uniform_fuzz.cc",
+      "binding_remapper_fuzz.cc",
+      "builtin_polyfill_fuzz.cc",
+      "canonicalize_entry_point_io_fuzz.cc",
+      "clamp_frag_depth_fuzz.cc",
+      "demote_to_helper_fuzz.cc",
+      "direct_variable_access_fuzz.cc",
+      "disable_uniformity_analysis_fuzz.cc",
+      "expand_compound_assignment_fuzz.cc",
+      "first_index_offset_fuzz.cc",
+      "fold_constants_fuzz.cc",
+      "multiplanar_external_texture_fuzz.cc",
       "zero_init_workgroup_memory_fuzz.cc",
     ]
     deps = [
       "${tint_src_dir}/api/common",
+      "${tint_src_dir}/api/options",
       "${tint_src_dir}/lang/core",
       "${tint_src_dir}/lang/core/constant",
       "${tint_src_dir}/lang/core/type",
diff --git a/src/tint/lang/wgsl/ast/transform/binding_remapper.cc b/src/tint/lang/wgsl/ast/transform/binding_remapper.cc
index 31ef518..5501dd5 100644
--- a/src/tint/lang/wgsl/ast/transform/binding_remapper.cc
+++ b/src/tint/lang/wgsl/ast/transform/binding_remapper.cc
@@ -47,6 +47,7 @@
 
 namespace tint::ast::transform {
 
+BindingRemapper::Remappings::Remappings() = default;
 BindingRemapper::Remappings::Remappings(BindingPoints bp, AccessControls ac, bool may_collide)
     : binding_points(std::move(bp)),
       access_controls(std::move(ac)),
diff --git a/src/tint/lang/wgsl/ast/transform/binding_remapper.h b/src/tint/lang/wgsl/ast/transform/binding_remapper.h
index a21a090..ff8785d 100644
--- a/src/tint/lang/wgsl/ast/transform/binding_remapper.h
+++ b/src/tint/lang/wgsl/ast/transform/binding_remapper.h
@@ -33,6 +33,7 @@
 #include "src/tint/api/common/binding_point.h"
 #include "src/tint/lang/core/access.h"
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -53,6 +54,9 @@
     /// Data holds information about shader usage and constant buffer offsets.
     struct Remappings final : public Castable<Remappings, Data> {
         /// Constructor
+        Remappings();
+
+        /// Constructor
         /// @param bp a map of new binding points
         /// @param ac a map of new access controls
         /// @param may_collide If true, then validation will be disabled for
@@ -66,14 +70,17 @@
         ~Remappings() override;
 
         /// A map of old binding point to new binding point
-        const BindingPoints binding_points;
+        BindingPoints binding_points;
 
         /// A map of old binding point to new access controls
-        const AccessControls access_controls;
+        AccessControls access_controls;
 
         /// If true, then validation will be disabled for binding point collisions
         /// generated by this transform
-        const bool allow_collisions;
+        bool allow_collisions = false;
+
+        /// Reflection for this class
+        TINT_REFLECT(Remappings, binding_points, access_controls, allow_collisions);
     };
 
     /// Constructor
diff --git a/src/tint/lang/wgsl/ast/transform/binding_remapper_fuzz.cc b/src/tint/lang/wgsl/ast/transform/binding_remapper_fuzz.cc
new file mode 100644
index 0000000..2f27549
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/binding_remapper_fuzz.cc
@@ -0,0 +1,89 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/api/common/binding_point.h"
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/core/access.h"
+#include "src/tint/lang/wgsl/ast/module.h"
+#include "src/tint/lang/wgsl/ast/transform/binding_remapper.h"
+#include "src/tint/lang/wgsl/sem/variable.h"
+
+namespace tint::ast::transform {
+namespace {
+
+bool CanRun(const Program& program, const BindingRemapper::Remappings& remappings) {
+    if (!remappings.access_controls.empty()) {
+        // Changing access is likely to cause WGSL validation failures. Just skip these for now.
+        return false;
+    }
+
+    if (!remappings.allow_collisions) {
+        Hashset<BindingPoint, 8> binding_points;
+        for (auto* global : program.AST().GlobalVariables()) {
+            if (auto* sem = program.Sem().Get<sem::GlobalVariable>(global)) {
+                if (auto binding_point = sem->Attributes().binding_point) {
+                    binding_points.Add(binding_point.value());
+                }
+            }
+        }
+        Hashset<BindingPoint, 8> new_binding_points;
+        for (auto& remapping : remappings.binding_points) {
+            if (binding_points.Remove(remapping.first)) {
+                if (!new_binding_points.Add(remapping.second)) {
+                    return false;  // Binding collision
+                }
+            }
+        }
+        for (auto& binding_point : new_binding_points) {
+            if (!binding_points.Add(binding_point)) {
+                return false;  // Binding collision
+            }
+        }
+    }
+    return true;
+}
+
+void BindingRemapperFuzzer(const Program& program, const BindingRemapper::Remappings& remappings) {
+    if (!CanRun(program, remappings)) {
+        return;
+    }
+
+    DataMap inputs;
+    inputs.Add<BindingRemapper::Remappings>(std::move(remappings));
+
+    DataMap outputs;
+    if (auto result = BindingRemapper{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "BindingRemapper returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::BindingRemapperFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
index f82fe95..640af4d 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
@@ -1602,6 +1602,7 @@
     return State{src, *cfg}.Run();
 }
 
+BuiltinPolyfill::Config::Config() = default;
 BuiltinPolyfill::Config::Config(const Builtins& b) : builtins(b) {}
 BuiltinPolyfill::Config::Config(const Config&) = default;
 BuiltinPolyfill::Config::~Config() = default;
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.h b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.h
index bdbe157..6f999b1 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.h
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.h
@@ -29,6 +29,7 @@
 #define SRC_TINT_LANG_WGSL_AST_TRANSFORM_BUILTIN_POLYFILL_H_
 
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -108,12 +109,43 @@
         /// Should `pack4xU8Clamp()` be polyfilled?
         /// TODO(tint:1497): remove the option once the bug in DXC is fixed.
         bool pack_4xu8_clamp = false;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Builtins,
+                     acosh,
+                     asinh,
+                     atanh,
+                     bgra8unorm,
+                     bitshift_modulo,
+                     clamp_int,
+                     count_leading_zeros,
+                     count_trailing_zeros,
+                     conv_f32_to_iu32,
+                     extract_bits,
+                     first_leading_bit,
+                     first_trailing_bit,
+                     fwidth_fine,
+                     insert_bits,
+                     int_div_mod,
+                     precise_float_mod,
+                     reflect_vec2_f32,
+                     saturate,
+                     sign_int,
+                     texture_sample_base_clamp_to_edge_2d_f32,
+                     quantize_to_vec_f16,
+                     workgroup_uniform_load,
+                     dot_4x8_packed,
+                     pack_unpack_4x8,
+                     pack_4xu8_clamp);
     };
 
     /// Config is consumed by the BuiltinPolyfill transform.
     /// Config specifies the builtins that should be polyfilled.
     struct Config final : public Castable<Config, Data> {
         /// Constructor
+        Config();
+
+        /// Constructor
         /// @param b the list of builtins to polyfill
         explicit Config(const Builtins& b);
 
@@ -124,7 +156,10 @@
         ~Config() override;
 
         /// The builtins to polyfill
-        const Builtins builtins;
+        Builtins builtins;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Config, builtins);
     };
 
     /// @copydoc Transform::Apply
@@ -138,4 +173,11 @@
 
 }  // namespace tint::ast::transform
 
+namespace tint {
+
+/// Level reflection information
+TINT_REFLECT_ENUM_RANGE(ast::transform::BuiltinPolyfill::Level, kNone, kFull);
+
+}  // namespace tint
+
 #endif  // SRC_TINT_LANG_WGSL_AST_TRANSFORM_BUILTIN_POLYFILL_H_
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill_fuzz.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill_fuzz.cc
new file mode 100644
index 0000000..adce548
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill_fuzz.cc
@@ -0,0 +1,49 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/builtin_polyfill.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void BuiltinPolyfillFuzzer(const Program& program, const BuiltinPolyfill::Config& config) {
+    DataMap inputs;
+    inputs.Add<BuiltinPolyfill::Config>(std::move(config));
+
+    DataMap outputs;
+    if (auto result = BuiltinPolyfill{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "BuiltinPolyfill returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::BuiltinPolyfillFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
index 3e2029b..e61f615 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
@@ -1011,6 +1011,8 @@
     return resolver::Resolve(b);
 }
 
+CanonicalizeEntryPointIO::Config::Config() = default;
+
 CanonicalizeEntryPointIO::Config::Config(ShaderStyle style,
                                          uint32_t sample_mask,
                                          bool emit_point_size,
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
index ddf761d..9899e3d 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
@@ -32,6 +32,7 @@
 
 #include "src/tint/lang/wgsl/ast/internal_attribute.h"
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -115,6 +116,9 @@
     /// Configuration options for the transform.
     struct Config final : public Castable<Config, Data> {
         /// Constructor
+        Config();
+
+        /// Constructor
         /// @param style the approach to use for emitting shader IO.
         /// @param sample_mask an optional sample mask to combine with shader masks
         /// @param emit_vertex_point_size `true` to generate a pointsize builtin
@@ -131,17 +135,24 @@
         ~Config() override;
 
         /// The approach to use for emitting shader IO.
-        const ShaderStyle shader_style;
+        ShaderStyle shader_style = ShaderStyle::kSpirv;
 
         /// A fixed sample mask to combine into masks produced by fragment shaders.
-        const uint32_t fixed_sample_mask;
+        uint32_t fixed_sample_mask = 0xffffffff;
 
         /// Set to `true` to generate a pointsize builtin and have it set to 1.0
         /// from all vertex shaders in the module.
-        const bool emit_vertex_point_size;
+        bool emit_vertex_point_size = false;
 
         /// Set to `true` to replace f16 IO types with f32 types and convert them.
-        const bool polyfill_f16_io = false;
+        bool polyfill_f16_io = false;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Config,
+                     shader_style,
+                     fixed_sample_mask,
+                     emit_vertex_point_size,
+                     polyfill_f16_io);
     };
 
     /// HLSLWaveIntrinsic is an InternalAttribute that is used to decorate a stub function so that
@@ -189,4 +200,11 @@
 
 }  // namespace tint::ast::transform
 
+namespace tint {
+
+/// Reflection for ShaderStyle
+TINT_REFLECT_ENUM_RANGE(ast::transform::CanonicalizeEntryPointIO::ShaderStyle, kSpirv, kHlsl);
+
+}  // namespace tint
+
 #endif  // SRC_TINT_LANG_WGSL_AST_TRANSFORM_CANONICALIZE_ENTRY_POINT_IO_H_
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_fuzz.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_fuzz.cc
new file mode 100644
index 0000000..136291a
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_fuzz.cc
@@ -0,0 +1,51 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void CanonicalizeEntryPointIOFuzzer(const Program& program,
+                                    const CanonicalizeEntryPointIO::Config& config) {
+    DataMap inputs;
+    inputs.Add<CanonicalizeEntryPointIO::Config>(std::move(config));
+
+    DataMap outputs;
+    if (auto result = CanonicalizeEntryPointIO{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "CanonicalizeEntryPointIO returned invalid program:\n"
+                       << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::CanonicalizeEntryPointIOFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
index 66bf672..44c1118 100644
--- a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
+++ b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
@@ -221,6 +221,7 @@
     return State{src}.Run(inputs);
 }
 
+ClampFragDepth::Config::Config() = default;
 ClampFragDepth::Config::Config(std::optional<tint::DepthRangeOffsets> off) : offsets(off) {}
 
 ClampFragDepth::Config::~Config() = default;
diff --git a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.h b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.h
index 03972a0..39a73f8 100644
--- a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.h
+++ b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.h
@@ -30,6 +30,7 @@
 
 #include "src/tint/api/options/depth_range_offsets.h"
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -73,6 +74,9 @@
     /// Transform configuration options
     struct Config final : public Castable<Config, ast::transform::Data> {
         /// Constructor
+        Config();
+
+        /// Constructor
         /// @param off Offsets of the min_depth and max_depth push constants
         explicit Config(std::optional<tint::DepthRangeOffsets> off);
 
@@ -81,6 +85,9 @@
 
         /// Offsets of the min_depth and max_depth push constants
         std::optional<tint::DepthRangeOffsets> offsets;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Config, offsets);
     };
 
     /// @copydoc ast::transform::Transform::Apply
diff --git a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth_fuzz.cc b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth_fuzz.cc
new file mode 100644
index 0000000..d2ef4c8
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth_fuzz.cc
@@ -0,0 +1,49 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/clamp_frag_depth.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void ClampFragDepthFuzzer(const Program& program, const ClampFragDepth::Config& config) {
+    DataMap inputs;
+    inputs.Add<ClampFragDepth::Config>(std::move(config));
+
+    DataMap outputs;
+    if (auto result = ClampFragDepth{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "ClampFragDepth returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::ClampFragDepthFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/demote_to_helper_fuzz.cc b/src/tint/lang/wgsl/ast/transform/demote_to_helper_fuzz.cc
new file mode 100644
index 0000000..180ab67
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/demote_to_helper_fuzz.cc
@@ -0,0 +1,46 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/demote_to_helper.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void DemoteToHelperFuzzer(const Program& program) {
+    DataMap outputs;
+    if (auto result = DemoteToHelper{}.Apply(program, DataMap{}, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "DemoteToHelper returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::DemoteToHelperFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
index d92bfb0..44fc79b 100644
--- a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
@@ -1203,6 +1203,7 @@
     }
 };
 
+DirectVariableAccess::Config::Config() = default;
 DirectVariableAccess::Config::Config(const Options& opt) : options(opt) {}
 
 DirectVariableAccess::Config::~Config() = default;
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access.h b/src/tint/lang/wgsl/ast/transform/direct_variable_access.h
index d1bb9fe..16af90d 100644
--- a/src/tint/lang/wgsl/ast/transform/direct_variable_access.h
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access.h
@@ -29,6 +29,7 @@
 #define SRC_TINT_LANG_WGSL_AST_TRANSFORM_DIRECT_VARIABLE_ACCESS_H_
 
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -57,19 +58,29 @@
         bool transform_private = false;
         /// If true, then 'function' sub-object pointer arguments will be transformed.
         bool transform_function = false;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Options, transform_private, transform_function);
     };
 
     /// Config is consumed by the DirectVariableAccess transform.
     /// Config specifies the behavior of the transform.
     struct Config final : public Castable<Config, Data> {
         /// Constructor
+        Config();
+
+        /// Constructor
         /// @param options behavior of the transform
         explicit Config(const Options& options);
+
         /// Destructor
         ~Config() override;
 
         /// The transform behavior options
-        const Options options;
+        Options options;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Config, options);
     };
 
     /// @copydoc Transform::Apply
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access_fuzz.cc b/src/tint/lang/wgsl/ast/transform/direct_variable_access_fuzz.cc
new file mode 100644
index 0000000..5123798
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access_fuzz.cc
@@ -0,0 +1,51 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/direct_variable_access.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void DirectVariableAccessFuzzer(const Program& program,
+                                const DirectVariableAccess::Config& config) {
+    DataMap inputs;
+    inputs.Add<DirectVariableAccess::Config>(std::move(config));
+
+    DataMap outputs;
+    if (auto result = DirectVariableAccess{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "DirectVariableAccess returned invalid program:\n"
+                       << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::DirectVariableAccessFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/disable_uniformity_analysis_fuzz.cc b/src/tint/lang/wgsl/ast/transform/disable_uniformity_analysis_fuzz.cc
new file mode 100644
index 0000000..378eb5f
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/disable_uniformity_analysis_fuzz.cc
@@ -0,0 +1,47 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/disable_uniformity_analysis.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void DisableUniformityAnalysisFuzzer(const Program& program) {
+    DataMap outputs;
+    if (auto result = DisableUniformityAnalysis{}.Apply(program, DataMap{}, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "DisableUniformityAnalysis returned invalid program:\n"
+                       << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::DisableUniformityAnalysisFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/expand_compound_assignment_fuzz.cc b/src/tint/lang/wgsl/ast/transform/expand_compound_assignment_fuzz.cc
new file mode 100644
index 0000000..d017dbb
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/expand_compound_assignment_fuzz.cc
@@ -0,0 +1,47 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/expand_compound_assignment.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void ExpandCompoundAssignmentFuzzer(const Program& program) {
+    DataMap outputs;
+    if (auto result = ExpandCompoundAssignment{}.Apply(program, DataMap{}, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "ExpandCompoundAssignment returned invalid program:\n"
+                       << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::ExpandCompoundAssignmentFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/first_index_offset.cc b/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
index 399bb2a..a7d912c 100644
--- a/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
+++ b/src/tint/lang/wgsl/ast/transform/first_index_offset.cc
@@ -69,6 +69,7 @@
 FirstIndexOffset::BindingPoint::BindingPoint(uint32_t b, uint32_t g) : binding(b), group(g) {}
 FirstIndexOffset::BindingPoint::~BindingPoint() = default;
 
+FirstIndexOffset::Data::Data() = default;
 FirstIndexOffset::Data::Data(bool has_vtx_index, bool has_inst_index)
     : has_vertex_index(has_vtx_index), has_instance_index(has_inst_index) {}
 FirstIndexOffset::Data::Data(const Data&) = default;
diff --git a/src/tint/lang/wgsl/ast/transform/first_index_offset.h b/src/tint/lang/wgsl/ast/transform/first_index_offset.h
index c943d8b..c414485 100644
--- a/src/tint/lang/wgsl/ast/transform/first_index_offset.h
+++ b/src/tint/lang/wgsl/ast/transform/first_index_offset.h
@@ -28,7 +28,9 @@
 #ifndef SRC_TINT_LANG_WGSL_AST_TRANSFORM_FIRST_INDEX_OFFSET_H_
 #define SRC_TINT_LANG_WGSL_AST_TRANSFORM_FIRST_INDEX_OFFSET_H_
 
+#include "src/tint/lang/wgsl/ast/transform/binding_remapper.h"
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -91,12 +93,18 @@
         uint32_t binding = 0;
         /// `@group()` for the first vertex / first instance uniform buffer
         uint32_t group = 0;
+
+        /// Reflection for this struct
+        TINT_REFLECT(BindingPoint, binding, group);
     };
 
     /// Data is outputted by the FirstIndexOffset transform.
     /// Data holds information about shader usage and constant buffer offsets.
     struct Data final : public Castable<Data, transform::Data> {
         /// Constructor
+        Data();
+
+        /// Constructor
         /// @param has_vtx_index True if the shader uses vertex_index
         /// @param has_inst_index True if the shader uses instance_index
         Data(bool has_vtx_index, bool has_inst_index);
@@ -108,9 +116,12 @@
         ~Data() override;
 
         /// True if the shader uses vertex_index
-        const bool has_vertex_index;
+        bool has_vertex_index = false;
         /// True if the shader uses instance_index
-        const bool has_instance_index;
+        bool has_instance_index = false;
+
+        /// Reflection for this struct
+        TINT_REFLECT(Data, has_vertex_index, has_instance_index);
     };
 
     /// Constructor
diff --git a/src/tint/lang/wgsl/ast/transform/first_index_offset_fuzz.cc b/src/tint/lang/wgsl/ast/transform/first_index_offset_fuzz.cc
new file mode 100644
index 0000000..b7ed12e
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/first_index_offset_fuzz.cc
@@ -0,0 +1,70 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/api/common/binding_point.h"
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/module.h"
+#include "src/tint/lang/wgsl/ast/transform/first_index_offset.h"
+#include "src/tint/lang/wgsl/sem/variable.h"
+
+namespace tint::ast::transform {
+namespace {
+
+bool CanRun(const Program& program, const FirstIndexOffset::BindingPoint& binding_point) {
+    for (auto& global : program.AST().GlobalVariables()) {
+        if (auto* sem = program.Sem().Get<sem::GlobalVariable>(global)) {
+            if (sem->Attributes().binding_point ==
+                BindingPoint{binding_point.group, binding_point.binding}) {
+                // Might cause binding point collision
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+void FirstIndexOffsetFuzzer(const Program& program,
+                            const FirstIndexOffset::BindingPoint& binding_point) {
+    if (!CanRun(program, binding_point)) {
+        return;
+    }
+
+    DataMap inputs;
+    inputs.Add<FirstIndexOffset::BindingPoint>(std::move(binding_point));
+
+    DataMap outputs;
+    if (auto result = FirstIndexOffset{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "FirstIndexOffset returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::FirstIndexOffsetFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/fold_constants_fuzz.cc b/src/tint/lang/wgsl/ast/transform/fold_constants_fuzz.cc
new file mode 100644
index 0000000..4c48a90
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/fold_constants_fuzz.cc
@@ -0,0 +1,46 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/wgsl/ast/transform/fold_constants.h"
+
+namespace tint::ast::transform {
+namespace {
+
+void FoldConstantsFuzzer(const Program& program) {
+    DataMap outputs;
+    if (auto result = FoldConstants{}.Apply(program, DataMap{}, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "FoldConstants returned invalid program:\n" << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::FoldConstantsFuzzer);
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
index f1bd0c3..3d7450b 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
@@ -531,6 +531,7 @@
     }
 };
 
+MultiplanarExternalTexture::NewBindingPoints::NewBindingPoints() = default;
 MultiplanarExternalTexture::NewBindingPoints::NewBindingPoints(BindingsMap inputBindingsMap,
                                                                bool may_collide)
     : bindings_map(std::move(inputBindingsMap)), allow_collisions(may_collide) {}
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.h b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.h
index 3395047..d9ed67a 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.h
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.h
@@ -36,6 +36,7 @@
 #include "src/tint/lang/core/builtin_fn.h"
 #include "src/tint/lang/wgsl/ast/struct_member.h"
 #include "src/tint/lang/wgsl/ast/transform/transform.h"
+#include "src/tint/utils/reflection/reflection.h"
 
 namespace tint::ast::transform {
 
@@ -66,8 +67,11 @@
     /// which binding slots it should expand into.
     struct NewBindingPoints final : public Castable<NewBindingPoints, Data> {
         /// Constructor
+        NewBindingPoints();
+
+        /// Constructor
         /// @param bm a map to the new binding slots to use.
-        /// /// @param may_collide if true, then validation will be disabled for binding point
+        /// @param may_collide if true, then validation will be disabled for binding point
         /// collisions generated by this transform
         explicit NewBindingPoints(BindingsMap bm, bool may_collide = false);
 
@@ -75,11 +79,14 @@
         ~NewBindingPoints() override;
 
         /// A map of new binding points to use.
-        const BindingsMap bindings_map;
+        BindingsMap bindings_map;
 
         /// If true, then validation will be disabled for bindign poitn collisions generated by this
         /// transform.
-        const bool allow_collisions = false;
+        bool allow_collisions = false;
+
+        /// Reflection for this struct
+        TINT_REFLECT(NewBindingPoints, bindings_map, allow_collisions);
     };
 
     /// Constructor
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_fuzz.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_fuzz.cc
new file mode 100644
index 0000000..caddb35
--- /dev/null
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture_fuzz.cc
@@ -0,0 +1,106 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/api/common/binding_point.h"
+#include "src/tint/cmd/fuzz/wgsl/fuzz.h"
+#include "src/tint/lang/core/type/external_texture.h"
+#include "src/tint/lang/wgsl/ast/module.h"
+#include "src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.h"
+#include "src/tint/lang/wgsl/sem/variable.h"
+
+namespace tint::ast::transform {
+namespace {
+
+bool CanRun(const Program& program,
+            const MultiplanarExternalTexture::NewBindingPoints& remappings) {
+    Hashset<BindingPoint, 8> all_binding_points;
+    for (auto* global : program.AST().GlobalVariables()) {
+        if (auto* sem = program.Sem().Get<sem::GlobalVariable>(global)) {
+            if (auto binding_point = sem->Attributes().binding_point) {
+                if (sem->Type()->UnwrapPtrOrRef()->Is<core::type::ExternalTexture>() &&
+                    remappings.bindings_map.find(binding_point.value()) ==
+                        remappings.bindings_map.end()) {
+                    // Missing entry for external texture
+                    return false;
+                }
+
+                all_binding_points.Add(binding_point.value());
+            }
+        }
+    }
+
+    if (!remappings.allow_collisions) {
+        for (auto* global : program.AST().GlobalVariables()) {
+            if (auto* sem = program.Sem().Get<sem::GlobalVariable>(global)) {
+                if (auto binding_point = sem->Attributes().binding_point) {
+                    all_binding_points.Add(binding_point.value());
+                }
+            }
+        }
+        Hashset<BindingPoint, 8> new_binding_points;
+        for (auto& remapping : remappings.bindings_map) {
+            if (all_binding_points.Remove(remapping.first)) {
+                if (!new_binding_points.Add(remapping.second.params)) {
+                    return false;  // Binding collision
+                }
+                if (!new_binding_points.Add(remapping.second.plane_1)) {
+                    return false;  // Binding collision
+                }
+            }
+        }
+        for (auto& binding_point : new_binding_points) {
+            if (!all_binding_points.Add(binding_point)) {
+                return false;  // Binding collision
+            }
+        }
+    }
+    return true;
+}
+
+void MultiplanarExternalTextureFuzzer(
+    const Program& program,
+    const MultiplanarExternalTexture::NewBindingPoints& binding_points) {
+    if (!CanRun(program, binding_points)) {
+        return;
+    }
+
+    DataMap inputs;
+    inputs.Add<MultiplanarExternalTexture::NewBindingPoints>(std::move(binding_points));
+
+    DataMap outputs;
+    if (auto result = MultiplanarExternalTexture{}.Apply(program, inputs, outputs)) {
+        if (!result->IsValid()) {
+            TINT_ICE() << "MultiplanarExternalTexture returned invalid program:\n"
+                       << result->Diagnostics();
+        }
+    }
+}
+
+}  // namespace
+}  // namespace tint::ast::transform
+
+TINT_WGSL_PROGRAM_FUZZER(tint::ast::transform::MultiplanarExternalTextureFuzzer);
diff --git a/src/tint/lang/wgsl/reader/lower/lower_test.cc b/src/tint/lang/wgsl/reader/lower/lower_test.cc
index ba73688..4a0c91c 100644
--- a/src/tint/lang/wgsl/reader/lower/lower_test.cc
+++ b/src/tint/lang/wgsl/reader/lower/lower_test.cc
@@ -55,8 +55,8 @@
     });
 
     auto* src = R"(
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:i32 = wgsl.max 1i, 2i
     ret
   }
@@ -65,8 +65,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:i32 = max 1i, 2i
     ret
   }
@@ -91,12 +91,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = wgsl.workgroupUniformLoad %wgvar
     ret %3
   }
@@ -105,12 +105,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %wgvar:ptr<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:void = workgroupBarrier
     %4:i32 = load %wgvar
     %5:void = workgroupBarrier
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/accessor_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/accessor_test.cc
index b763ef9..cb5294e 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/accessor_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/accessor_test.cc
@@ -54,8 +54,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<u32, 3>, read_write> = var
     %3:ptr<function, u32, read_write> = access %a, 2u
     %4:u32 = load %3
@@ -80,8 +80,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<u32, 3>, read_write> = var
     %p:ptr<function, array<u32, 3>, read_write> = let %a
     %4:ptr<function, u32, read_write> = access %p, 2u
@@ -107,8 +107,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<u32, 3>, read_write> = var
     %p:ptr<function, array<u32, 3>, read_write> = let %a
     %4:ptr<function, u32, read_write> = access %p, 2u
@@ -135,8 +135,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:vec3<u32> = let vec3<u32>(0u)
     %3:u32 = access %a, 2u
     %b:u32 = let %3
@@ -160,8 +160,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec3<u32>, read_write> = var
     %3:u32 = load_vector_element %a, 2u
     %b:u32 = let %3
@@ -185,8 +185,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec3<u32>, read_write> = var
     %p:ptr<function, vec3<u32>, read_write> = let %a
     %4:u32 = load_vector_element %p, 2u
@@ -211,8 +211,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec3<u32>, read_write> = var
     %p:ptr<function, vec3<u32>, read_write> = let %a
     %4:u32 = load_vector_element %p, 2u
@@ -235,8 +235,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<array<f32, 4>, 3>, read_write> = var
     %3:ptr<function, f32, read_write> = access %a, 2u, 3u
     %4:f32 = load %3
@@ -261,8 +261,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<array<f32, 4>, 3>, read_write> = var
     %p:ptr<function, array<array<f32, 4>, 3>, read_write> = let %a
     %4:ptr<function, f32, read_write> = access %p, 2u, 3u
@@ -288,8 +288,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<array<f32, 4>, 3>, read_write> = var
     %p:ptr<function, array<array<f32, 4>, 3>, read_write> = let %a
     %4:ptr<function, f32, read_write> = access %p, 2u, 3u
@@ -313,8 +313,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, mat3x4<f32>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %a, 2u
     %4:f32 = load_vector_element %3, 3u
@@ -345,8 +345,8 @@
   foo:i32 @offset(0)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, MyStruct, read_write> = var
     %3:ptr<function, i32, read_write> = access %a, 0u
     %4:i32 = load %3
@@ -379,8 +379,8 @@
   foo:i32 @offset(0)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, MyStruct, read_write> = var
     %p:ptr<function, MyStruct, read_write> = let %a
     %4:ptr<function, i32, read_write> = access %p, 0u
@@ -414,8 +414,8 @@
   foo:i32 @offset(0)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, MyStruct, read_write> = var
     %p:ptr<function, MyStruct, read_write> = let %a
     %4:ptr<function, i32, read_write> = access %p, 0u
@@ -457,8 +457,8 @@
   foo:Inner @offset(4)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, Outer, read_write> = var
     %3:ptr<function, f32, read_write> = access %a, 1u, 0u
     %4:f32 = load %3
@@ -505,8 +505,8 @@
   foo:array<Inner, 4> @offset(16)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<Outer, 4>, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %a, 0u, 1u, 1u, 2u
     %4:vec4<f32> = load %3
@@ -529,8 +529,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, array<u32, 4>, read_write> = var
     %3:ptr<function, u32, read_write> = access %a, 2u
     store %3, 0u
@@ -552,8 +552,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec2<f32>, read_write> = var
     %3:f32 = load_vector_element %a, 1u
     %b:f32 = let %3
@@ -577,8 +577,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec2<f32>, read_write> = var
     %p:ptr<function, vec2<f32>, read_write> = let %a
     %4:f32 = load_vector_element %p, 1u
@@ -603,8 +603,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec2<f32>, read_write> = var
     %p:ptr<function, vec2<f32>, read_write> = let %a
     %4:f32 = load_vector_element %p, 1u
@@ -627,8 +627,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec3<f32>, read_write> = var
     %3:vec3<f32> = load %a
     %4:vec4<f32> = swizzle %3, zyxz
@@ -651,8 +651,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, vec3<f32>, read_write> = var
     %3:vec3<f32> = load %a
     %4:vec3<f32> = swizzle %3, zyx
@@ -688,8 +688,8 @@
   foo:vec4<f32> @offset(16)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, MyStruct, read_write> = var
     %3:ptr<function, vec4<f32>, read_write> = access %a, 1u
     %4:vec4<f32> = load %3
@@ -714,8 +714,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:vec3<u32> = let vec3<u32>(0u)
     %3:u32 = access %a, 2u
     %b:u32 = let %3
@@ -737,8 +737,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:mat3x4<f32> = let mat3x4<f32>(vec4<f32>(0.0f))
     %3:f32 = access %a, 2u, 3u
     %b:f32 = let %3
@@ -768,8 +768,8 @@
   foo:i32 @offset(0)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:MyStruct = let MyStruct(0i)
     %3:i32 = access %a, 0u
     %b:i32 = let %3
@@ -809,8 +809,8 @@
   foo:Inner @offset(4)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:Outer = let Outer(0i, Inner(0.0f))
     %3:f32 = access %a, 1u, 0u
     %b:f32 = let %3
@@ -856,8 +856,8 @@
   foo:array<Inner, 4> @offset(16)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:array<Outer, 4> = let array<Outer, 4>(Outer(0i, array<Inner, 4>(Inner(0i, 0.0f, vec4<f32>(0.0f)))))
     %3:vec4<f32> = access %a, 0u, 1u, 1u, 2u
     %b:vec4<f32> = let %3
@@ -879,8 +879,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:vec2<f32> = let vec2<f32>(0.0f)
     %3:f32 = access %a, 1u
     %b:f32 = let %3
@@ -902,8 +902,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:vec3<f32> = let vec3<f32>(0.0f)
     %3:vec4<f32> = swizzle %a, zyxz
     %b:vec4<f32> = let %3
@@ -925,8 +925,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:vec3<f32> = let vec3<f32>(0.0f)
     %3:vec3<f32> = swizzle %a, zyx
     %4:vec2<f32> = swizzle %3, yy
@@ -961,8 +961,8 @@
   foo:vec4<f32> @offset(16)
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:MyStruct = let MyStruct(0i, vec4<f32>(0.0f))
     %3:vec4<f32> = access %a, 1u
     %4:vec3<f32> = swizzle %3, zyx
@@ -989,8 +989,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %i:i32 = let 1i
     %3:i32 = access vec3<i32>(1i, 2i, 3i), %i
     %b:ptr<function, i32, read_write> = var, %3
@@ -1014,8 +1014,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %i:i32 = let 1i
     %3:i32 = access vec2<i32>(1i, 2i), %i
     %b:ptr<function, i32, read_write> = var, %3
@@ -1039,8 +1039,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %i:i32 = let 1i
     %3:i32 = add %i, 2i
     %4:i32 = sub %3, 3i
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/binary_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/binary_test.cc
index 9903836..79b7366 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/binary_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/binary_test.cc
@@ -46,13 +46,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = add %3, 4u
     %tint_symbol:u32 = let %4
@@ -70,12 +70,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = add %3, 1u
     store %v1, %4
@@ -93,12 +93,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = add %3, 1u
     store %v1, %4
@@ -116,13 +116,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = sub %3, 4u
     %tint_symbol:u32 = let %4
@@ -140,12 +140,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, i32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = load %v1
     %4:i32 = sub %3, 1i
     store %v1, %4
@@ -163,12 +163,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = sub %3, 1u
     store %v1, %4
@@ -186,13 +186,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = mul %3, 4u
     %tint_symbol:u32 = let %4
@@ -210,12 +210,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = mul %3, 1u
     store %v1, %4
@@ -233,13 +233,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = div %3, 4u
     %tint_symbol:u32 = let %4
@@ -257,12 +257,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = div %3, 1u
     store %v1, %4
@@ -280,13 +280,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = mod %3, 4u
     %tint_symbol:u32 = let %4
@@ -304,12 +304,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = mod %3, 1u
     store %v1, %4
@@ -327,13 +327,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = and %3, 4u
     %tint_symbol:u32 = let %4
@@ -351,12 +351,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, bool, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = load %v1
     %4:bool = and %3, false
     store %v1, %4
@@ -374,13 +374,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = or %3, 4u
     %tint_symbol:u32 = let %4
@@ -398,12 +398,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, bool, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = load %v1
     %4:bool = or %3, false
     store %v1, %4
@@ -421,13 +421,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = xor %3, 4u
     %tint_symbol:u32 = let %4
@@ -445,12 +445,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = xor %3, 1u
     store %v1, %4
@@ -469,25 +469,25 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool {
+  $B1: {
     ret true
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = call %my_func
-    %4:bool = if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    %4:bool = if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         exit_if false  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if false  # if_1
       }
     }
     %logical_and:bool = let %4
-    if %logical_and [t: %b5] {  # if_2
-      %b5 = block {  # true
+    if %logical_and [t: $B5] {  # if_2
+      $B5: {  # true
         exit_if  # if_2
       }
     }
@@ -506,25 +506,25 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool {
+  $B1: {
     ret true
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = call %my_func
-    %4:bool = if %3 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    %4:bool = if %3 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         exit_if true  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if true  # if_1
       }
     }
     %logical_or:bool = let %4
-    if %logical_or [t: %b5] {  # if_2
-      %b5 = block {  # true
+    if %logical_or [t: $B5] {  # if_2
+      $B5: {  # true
         exit_if  # if_2
       }
     }
@@ -542,13 +542,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = eq %3, 4u
     %tint_symbol:bool = let %4
@@ -566,13 +566,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = neq %3, 4u
     %tint_symbol:bool = let %4
@@ -590,13 +590,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = lt %3, 4u
     %tint_symbol:bool = let %4
@@ -614,13 +614,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = gt %3, 4u
     %tint_symbol:bool = let %4
@@ -638,13 +638,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = lte %3, 4u
     %tint_symbol:bool = let %4
@@ -662,13 +662,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:bool = gte %3, 4u
     %tint_symbol:bool = let %4
@@ -686,13 +686,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = shl %3, 4u
     %tint_symbol:u32 = let %4
@@ -710,12 +710,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = shl %3, 1u
     store %v1, %4
@@ -733,13 +733,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 0u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = shr %3, 4u
     %tint_symbol:u32 = let %4
@@ -757,12 +757,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = load %v1
     %4:u32 = shr %3, 1u
     store %v1, %4
@@ -782,17 +782,17 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():f32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():f32 {
+  $B1: {
     ret 0.0f
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f32 = call %my_func
     %4:bool = lt %3, 2.0f
-    %5:bool = if %4 [t: %b3, f: %b4] {  # if_1
-      %b3 = block {  # true
+    %5:bool = if %4 [t: $B3, f: $B4] {  # if_1
+      $B3: {  # true
         %6:f32 = call %my_func
         %7:f32 = call %my_func
         %8:f32 = mul 2.29999995231628417969f, %7
@@ -800,7 +800,7 @@
         %10:bool = gt 2.5f, %9
         exit_if %10  # if_1
       }
-      %b4 = block {  # false
+      $B4: {  # false
         exit_if false  # if_1
       }
     }
@@ -820,13 +820,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func(%p:bool):bool -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func(%p:bool):bool {
+  $B1: {
     ret true
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %4:bool = call %my_func, false
     %tint_symbol:bool = let %4
     ret
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/builtin_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/builtin_test.cc
index fecb029..7423f12 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/builtin_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/builtin_test.cc
@@ -46,12 +46,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, f32, read_write> = var, 1.0f
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f32 = load %i
     %4:f32 = asin %3
     %tint_symbol:f32 = let %4
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/call_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/call_test.cc
index a024c57..eb3dac7 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/call_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/call_test.cc
@@ -48,13 +48,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():f32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():f32 {
+  $B1: {
     ret 0.0f
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f32 = call %my_func
     %4:f32 = bitcast %3
     %tint_symbol:f32 = let %4
@@ -74,8 +74,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test_function = @fragment func():void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test_function = @fragment func():void {
+  $B1: {
     discard
     ret
   }
@@ -91,13 +91,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func(%p:f32):void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func(%p:f32):void {
+  $B1: {
     ret
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %4:void = call %my_func, 6.0f
     ret
   }
@@ -113,12 +113,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, i32, read_write> = var, 1i
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = load %i
     %4:f32 = convert %3
     %tint_symbol:f32 = let %4
@@ -135,7 +135,7 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, vec3<f32>, read_write> = var, vec3<f32>(0.0f)
 }
 
@@ -150,12 +150,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, f32, read_write> = var, 1.0f
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:f32 = load %i
     %4:vec3<f32> = construct 2.0f, 3.0f, %3
     %tint_symbol:vec3<f32> = let %4
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/function_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/function_test.cc
index da4dd6b..1af67b1 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/function_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/function_test.cc
@@ -47,8 +47,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @vertex func():vec4<f32> [@position] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @vertex func():vec4<f32> [@position] {
+  $B1: {
     ret vec4<f32>(0.0f)
   }
 }
@@ -62,8 +62,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():void {
+  $B1: {
     ret
   }
 }
@@ -78,8 +78,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test = @compute @workgroup_size(8, 4, 2) func():void -> %b1 {
-  %b1 = block {
+              R"(%test = @compute @workgroup_size(8, 4, 2) func():void {
+  $B1: {
     ret
   }
 }
@@ -93,8 +93,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = func():vec3<f32> -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = func():vec3<f32> {
+  $B1: {
     ret vec3<f32>(0.0f)
   }
 }
@@ -108,13 +108,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = func():f32 -> %b1 {
-  %b1 = block {
-    if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = func():f32 {
+  $B1: {
+    if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret 0.0f
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret 1.0f
       }
     }
@@ -132,8 +132,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @vertex func():vec4<f32> [@position] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @vertex func():vec4<f32> [@position] {
+  $B1: {
     ret vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f)
   }
 }
@@ -149,8 +149,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test = @vertex func():vec4<f32> [@invariant, @position] -> %b1 {
-  %b1 = block {
+              R"(%test = @vertex func():vec4<f32> [@invariant, @position] {
+  $B1: {
     ret vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f)
   }
 }
@@ -165,8 +165,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test = @fragment func():vec4<f32> [@location(1)] -> %b1 {
-  %b1 = block {
+              R"(%test = @fragment func():vec4<f32> [@location(1)] {
+  $B1: {
     ret vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f)
   }
 }
@@ -182,10 +182,9 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(
-        Disassemble(m.Get()),
-        R"(%test = @fragment func():vec4<f32> [@location(1), @interpolate(linear, centroid)] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()),
+              R"(%test = @fragment func():vec4<f32> [@location(1), @interpolate(linear, centroid)] {
+  $B1: {
     ret vec4<f32>(1.0f, 2.0f, 3.0f, 4.0f)
   }
 }
@@ -200,8 +199,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():f32 [@frag_depth] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():f32 [@frag_depth] {
+  $B1: {
     ret 1.0f
   }
 }
@@ -216,8 +215,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():u32 [@sample_mask] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test = @fragment func():u32 [@sample_mask] {
+  $B1: {
     ret 1u
   }
 }
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/let_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/let_test.cc
index bfce845..8b67280 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/let_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/let_test.cc
@@ -45,8 +45,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:i32 = let 42i
     ret
   }
@@ -61,8 +61,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:i32 = let 3i
     ret
   }
@@ -79,8 +79,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:i32 = let 1i
     %b:i32 = let %a
     %c:i32 = let %b
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/materialize_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/materialize_test.cc
index 6891335..7b1b1e6 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/materialize_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/materialize_test.cc
@@ -46,8 +46,8 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%test_function = func():f32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%test_function = func():f32 {
+  $B1: {
     ret 2.0f
   }
 }
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
index f8f2d0a..466498e 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/program_to_ir_test.cc
@@ -83,8 +83,8 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), core::ir::Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():void {
+  $B1: {
     ret
   }
 }
@@ -104,8 +104,8 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), core::ir::Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func(%a:u32):u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func(%a:u32):u32 {
+  $B1: {
     ret %a
   }
 }
@@ -126,8 +126,8 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), core::ir::Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func(%a:u32, %b:i32, %c:bool):void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func(%a:u32, %b:i32, %c:bool):void {
+  $B1: {
     ret
   }
 }
@@ -155,13 +155,13 @@
     ASSERT_EQ(1u, m.functions.Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         exit_if  # if_1
       }
     }
@@ -183,10 +183,10 @@
     ASSERT_EQ(1u, m.functions.Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         ret
       }
     }
@@ -208,13 +208,13 @@
     ASSERT_EQ(1u, m.functions.Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         exit_if  # if_1
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -236,13 +236,13 @@
     ASSERT_EQ(1u, m.functions.Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2, f: %b3] {  # if_1
-      %b2 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    if true [t: $B2, f: $B3] {  # if_1
+      $B2: {  # true
         ret
       }
-      %b3 = block {  # false
+      $B3: {  # false
         ret
       }
     }
@@ -263,12 +263,12 @@
     auto m = res.Move();
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
-        loop [b: %b3] {  # loop_1
-          %b3 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
+        loop [b: $B3] {  # loop_1
+          $B3: {  # body
             exit_loop  # loop_1
           }
         }
@@ -297,10 +297,10 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         exit_loop  # loop_1
       }
     }
@@ -327,19 +327,19 @@
     EXPECT_EQ(1u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b4] {  # if_1
-          %b4 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        if true [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -365,14 +365,14 @@
     EXPECT_EQ(1u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        break_if true %b2
+      $B3: {  # continuing
+        break_if true  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret
@@ -392,15 +392,15 @@
 
     auto m = res.Move();
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %a:bool = let true
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        break_if %a %b2
+      $B3: {  # continuing
+        break_if %a  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret
@@ -426,19 +426,19 @@
     EXPECT_EQ(1u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b4] {  # if_1
-          %b4 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        if true [t: $B4] {  # if_1
+          $B4: {  # true
             ret
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     unreachable
@@ -463,10 +463,10 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret
       }
     }
@@ -501,15 +501,15 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret
       }
     }
-    if true [t: %b3] {  # if_1
-      %b3 = block {  # true
+    if true [t: $B3] {  # if_1
+      $B3: {  # true
         ret
       }
     }
@@ -536,15 +536,15 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b3, f: %b4] {  # if_1
-          %b3 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
+        if true [t: $B3, f: $B4] {  # if_1
+          $B3: {  # true
             exit_loop  # loop_1
           }
-          %b4 = block {  # false
+          $B4: {  # false
             exit_loop  # loop_1
           }
         }
@@ -575,50 +575,50 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        loop [b: %b4, c: %b5] {  # loop_2
-          %b4 = block {  # body
-            if true [t: %b6] {  # if_1
-              %b6 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        loop [b: $B4, c: $B5] {  # loop_2
+          $B4: {  # body
+            if true [t: $B6] {  # if_1
+              $B6: {  # true
                 exit_loop  # loop_2
               }
             }
-            if true [t: %b7] {  # if_2
-              %b7 = block {  # true
-                continue %b5
+            if true [t: $B7] {  # if_2
+              $B7: {  # true
+                continue  # -> $B5
               }
             }
-            continue %b5
+            continue  # -> $B5
           }
-          %b5 = block {  # continuing
-            loop [b: %b8] {  # loop_3
-              %b8 = block {  # body
+          $B5: {  # continuing
+            loop [b: $B8] {  # loop_3
+              $B8: {  # body
                 exit_loop  # loop_3
               }
             }
-            loop [b: %b9, c: %b10] {  # loop_4
-              %b9 = block {  # body
-                continue %b10
+            loop [b: $B9, c: $B10] {  # loop_4
+              $B9: {  # body
+                continue  # -> $B10
               }
-              %b10 = block {  # continuing
-                break_if true %b9
+              $B10: {  # continuing
+                break_if true  # -> [t: exit_loop loop_4, f: $B9]
               }
             }
-            next_iteration %b4
+            next_iteration  # -> $B4
           }
         }
-        if true [t: %b11] {  # if_3
-          %b11 = block {  # true
+        if true [t: $B11] {  # if_3
+          $B11: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -643,22 +643,22 @@
     EXPECT_EQ(1u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        if false [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        if false [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -683,22 +683,22 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        if true [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        if true [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
         ret
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     ret
@@ -723,31 +723,31 @@
     EXPECT_EQ(1u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
         %i:ptr<function, i32, read_write> = var
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %3:i32 = load %i
         %4:bool = lt %3, 10i
-        if %4 [t: %b5, f: %b6] {  # if_1
-          %b5 = block {  # true
+        if %4 [t: $B5, f: $B6] {  # if_1
+          $B5: {  # true
             exit_if  # if_1
           }
-          %b6 = block {  # false
+          $B6: {  # false
             exit_loop  # loop_1
           }
         }
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         store %i, %6
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
     }
     ret
@@ -772,14 +772,14 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %i:ptr<function, i32, read_write> = var
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -805,10 +805,10 @@
     EXPECT_EQ(0u, loop->Continuing()->InboundSiblingBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         exit_loop  # loop_1
       }
     }
@@ -850,16 +850,16 @@
     EXPECT_TRUE(cases[2].selectors[0].IsDefault());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    switch 1i [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] {  # switch_1
-      %b2 = block {  # case
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    switch 1i [c: (0i, $B2), c: (1i, $B3), c: (default, $B4)] {  # switch_1
+      $B2: {  # case
         exit_switch  # switch_1
       }
-      %b3 = block {  # case
+      $B3: {  # case
         exit_switch  # switch_1
       }
-      %b4 = block {  # case
+      $B4: {  # case
         exit_switch  # switch_1
       }
     }
@@ -898,10 +898,10 @@
     EXPECT_TRUE(cases[0].selectors[2].IsDefault());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    switch 1i [c: (0i 1i default, %b2)] {  # switch_1
-      %b2 = block {  # case
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    switch 1i [c: (0i 1i default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch  # switch_1
       }
     }
@@ -929,10 +929,10 @@
     EXPECT_TRUE(cases[0].selectors[0].IsDefault());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    switch 1i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    switch 1i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         exit_switch  # switch_1
       }
     }
@@ -969,13 +969,13 @@
     // This is 1 because the if is dead-code eliminated and the return doesn't happen.
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    switch 1i [c: (0i, %b2), c: (default, %b3)] {  # switch_1
-      %b2 = block {  # case
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    switch 1i [c: (0i, $B2), c: (default, $B3)] {  # switch_1
+      $B2: {  # case
         exit_switch  # switch_1
       }
-      %b3 = block {  # case
+      $B3: {  # case
         exit_switch  # switch_1
       }
     }
@@ -1011,13 +1011,13 @@
     EXPECT_TRUE(cases[1].selectors[0].IsDefault());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
-    switch 1i [c: (0i, %b2), c: (default, %b3)] {  # switch_1
-      %b2 = block {  # case
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
+    switch 1i [c: (0i, $B2), c: (default, $B3)] {  # switch_1
+      $B2: {  # case
         ret
       }
-      %b3 = block {  # case
+      $B3: {  # case
         ret
       }
     }
@@ -1035,13 +1035,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%b = func():i32 -> %b1 {
-  %b1 = block {
+              R"(%b = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = call %b
     ret
   }
@@ -1060,8 +1060,8 @@
 
     EXPECT_EQ(
         Disassemble(m.Get()),
-        R"(%f = @fragment func(%a:vec4<f32> [@invariant, @position]):vec4<f32> [@location(1)] -> %b1 {
-  %b1 = block {
+        R"(%f = @fragment func(%a:vec4<f32> [@invariant, @position]):vec4<f32> [@location(1)] {
+  $B1: {
     ret %a
   }
 }
@@ -1076,8 +1076,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = @fragment func(%a:f32 [@location(2)]):f32 [@location(1)] -> %b1 {
-  %b1 = block {
+              R"(%f = @fragment func(%a:f32 [@location(2)]):f32 [@location(1)] {
+  $B1: {
     ret %a
   }
 }
@@ -1097,8 +1097,8 @@
 
     EXPECT_EQ(
         Disassemble(m.Get()),
-        R"(%f = @fragment func(%a:f32 [@location(2), @interpolate(linear, centroid)]):f32 [@location(1)] -> %b1 {
-  %b1 = block {
+        R"(%f = @fragment func(%a:f32 [@location(2), @interpolate(linear, centroid)]):f32 [@location(1)] {
+  $B1: {
     ret %a
   }
 }
@@ -1115,10 +1115,9 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(
-        Disassemble(m.Get()),
-        R"(%f = @fragment func(%a:f32 [@location(2), @interpolate(flat)]):f32 [@location(1)] -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()),
+              R"(%f = @fragment func(%a:f32 [@location(2), @interpolate(flat)]):f32 [@location(1)] {
+  $B1: {
     ret %a
   }
 }
@@ -1139,8 +1138,8 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), core::ir::Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():void -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():void {
+  $B1: {
     ret
   }
 }
@@ -1161,8 +1160,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func():void -> %b1 {
-  %b1 = block {
+              R"(%f = func():void {
+  $B1: {
     ret
   }
 }
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/shadowing_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/shadowing_test.cc
index f01b4da..c3251f5 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/shadowing_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/shadowing_test.cc
@@ -63,8 +63,8 @@
   i:i32 @offset(0)
 }
 
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %S:ptr<function, S, read_write> = var, S(0i)
     %3:ptr<function, i32, read_write> = access %S, 0u
     %4:i32 = load %3
@@ -91,8 +91,8 @@
   i:i32 @offset(0)
 }
 
-%f = func(%S:S):i32 -> %b1 {
-  %b1 = block {
+%f = func(%S:S):i32 {
+  $B1: {
     %3:i32 = access %S, 0u
     ret %3
   }
@@ -113,12 +113,12 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, i32, read_write> = var, 1i
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = load %i
     %4:i32 = add %3, 1i
     store %i, %4
@@ -145,12 +145,12 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %i:ptr<private, i32, read_write> = var, 1i
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = load %i
     %4:i32 = add %3, 1i
     store %i, %4
@@ -178,11 +178,11 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         %3:i32 = load %i
         %4:i32 = add %3, 1i
         store %i, %4
@@ -217,11 +217,11 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         %3:i32 = load %i
         %4:i32 = add %3, 1i
         store %i, %4
@@ -252,18 +252,18 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = lt %3, 4i
-        if %4 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
@@ -273,8 +273,8 @@
         %8:i32 = load %i_1
         ret %8
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     %9:i32 = load %i
@@ -298,18 +298,18 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = lt %3, 4i
-        if %4 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
@@ -318,8 +318,8 @@
         %i_1:i32 = let %6  # %i_1: 'i'
         ret %i_1
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     %8:i32 = load %i
@@ -342,28 +342,28 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %i_1:ptr<function, f32, read_write> = var, 0.0f  # %i_1: 'i'
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %4:f32 = load %i_1
         %5:bool = lt %4, 4.0f
-        if %5 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %5 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
         %6:f32 = load %i_1
         %j:f32 = let %6
-        continue %b6
+        continue  # -> $B6
       }
     }
     %8:i32 = load %i
@@ -386,26 +386,26 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %i_1:f32 = let 0.0f  # %i_1: 'i'
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %4:bool = lt %i_1, 4.0f
-        if %4 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
         %j:f32 = let %i_1
-        continue %b6
+        continue  # -> $B6
       }
     }
     %6:i32 = load %i
@@ -429,22 +429,22 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %x:ptr<function, i32, read_write> = var, 0i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %4:i32 = load %i
         %5:bool = lt %4, 4i
-        if %5 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %5 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
@@ -476,22 +476,22 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %x:ptr<function, i32, read_write> = var, 0i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %4:i32 = load %i
         %5:bool = lt %4, 4i
-        if %5 [t: %b4, f: %b5] {  # if_1
-          %b4 = block {  # true
+        if %5 [t: $B4, f: $B5] {  # if_1
+          $B4: {  # true
             exit_if  # if_1
           }
-          %b5 = block {  # false
+          $B5: {  # false
             exit_loop  # loop_1
           }
         }
@@ -527,15 +527,15 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
-        if %4 [t: %b4] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
@@ -544,15 +544,15 @@
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         %9:bool = eq %8, 3i
-        if %9 [t: %b5] {  # if_2
-          %b5 = block {  # true
+        if %9 [t: $B5] {  # if_2
+          $B5: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     %10:i32 = load %i
@@ -581,15 +581,15 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
-        if %4 [t: %b4] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
@@ -597,15 +597,15 @@
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         %8:bool = eq %i_1, 3i
-        if %8 [t: %b5] {  # if_2
-          %b5 = block {  # true
+        if %8 [t: $B5] {  # if_2
+          $B5: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
-        next_iteration %b2
+      $B3: {  # continuing
+        next_iteration  # -> $B2
       }
     }
     %9:i32 = load %i
@@ -635,27 +635,27 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
-        if %4 [t: %b4] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         %9:bool = gt %8, 2i
-        break_if %9 %b2
+        break_if %9  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     %10:i32 = load %i
@@ -685,26 +685,26 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %i
         %4:bool = eq %3, 2i
-        if %4 [t: %b4] {  # if_1
-          %b4 = block {  # true
+        if %4 [t: $B4] {  # if_1
+          $B4: {  # true
             exit_loop  # loop_1
           }
         }
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         %8:bool = gt %i_1, 2i
-        break_if %8 %b2
+        break_if %8  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     %9:i32 = load %i
@@ -735,23 +735,23 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
     %3:i32 = load %i
-    switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] {  # switch_1
-      %b2 = block {  # case
+    switch %3 [c: (0i, $B2), c: (1i, $B3), c: (default, $B4)] {  # switch_1
+      $B2: {  # case
         %4:i32 = load %i
         ret %4
       }
-      %b3 = block {  # case
+      $B3: {  # case
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:ptr<function, i32, read_write> = var, %6  # %i_1: 'i'
         %8:i32 = load %i_1
         ret %8
       }
-      %b4 = block {  # case
+      $B4: {  # case
         %9:i32 = load %i
         ret %9
       }
@@ -783,22 +783,22 @@
 
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%f = func():i32 {
+  $B1: {
     %i:ptr<function, i32, read_write> = var
     %3:i32 = load %i
-    switch %3 [c: (0i, %b2), c: (1i, %b3), c: (default, %b4)] {  # switch_1
-      %b2 = block {  # case
+    switch %3 [c: (0i, $B2), c: (1i, $B3), c: (default, $B4)] {  # switch_1
+      $B2: {  # case
         %4:i32 = load %i
         ret %4
       }
-      %b3 = block {  # case
+      $B3: {  # case
         %5:i32 = load %i
         %6:i32 = add %5, 1i
         %i_1:i32 = let %6  # %i_1: 'i'
         ret %i_1
       }
-      %b4 = block {  # case
+      $B4: {  # case
         %8:i32 = load %i
         ret %8
       }
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/store_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/store_test.cc
index c2f9ad1..b2ac91e 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/store_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/store_test.cc
@@ -47,12 +47,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %a:ptr<private, u32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     store %a, 4u
     ret
   }
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/unary_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/unary_test.cc
index 62c7e6f..8342e48 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/unary_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/unary_test.cc
@@ -46,13 +46,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():bool {
+  $B1: {
     ret false
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:bool = call %my_func
     %4:bool = eq %3, false
     %tint_symbol:bool = let %4
@@ -70,13 +70,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():vec4<bool> -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():vec4<bool> {
+  $B1: {
     ret vec4<bool>(false)
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:vec4<bool> = call %my_func
     %4:vec4<bool> = eq %3, vec4<bool>(false)
     %tint_symbol:vec4<bool> = let %4
@@ -94,13 +94,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():u32 {
+  $B1: {
     ret 1u
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:u32 = call %my_func
     %4:u32 = complement %3
     %tint_symbol:u32 = let %4
@@ -118,13 +118,13 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():i32 -> %b1 {
-  %b1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(%my_func = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %3:i32 = call %my_func
     %4:i32 = negation %3
     %tint_symbol:i32 = let %4
@@ -143,12 +143,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, i32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %v2:ptr<private, i32, read_write> = let %v1
     ret
   }
@@ -167,12 +167,12 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %v1:ptr<private, i32, read_write> = var
 }
 
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %v3:ptr<private, i32, read_write> = let %v1
     store %v3, 42i
     ret
diff --git a/src/tint/lang/wgsl/reader/program_to_ir/var_test.cc b/src/tint/lang/wgsl/reader/program_to_ir/var_test.cc
index b846045..c683285 100644
--- a/src/tint/lang/wgsl/reader/program_to_ir/var_test.cc
+++ b/src/tint/lang/wgsl/reader/program_to_ir/var_test.cc
@@ -45,7 +45,7 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %a:ptr<private, u32, read_write> = var
 }
 
@@ -59,7 +59,7 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %a:ptr<private, u32, read_write> = var, 2u
 }
 
@@ -72,7 +72,7 @@
     auto m = Build();
     ASSERT_EQ(m, Success);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%b1 = block {  # root
+    EXPECT_EQ(Disassemble(m.Get()), R"($B1: {  # root
   %a:ptr<storage, u32, read> = var @binding_point(2, 3)
 }
 
@@ -87,8 +87,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, u32, read_write> = var
     ret
   }
@@ -105,8 +105,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, u32, read_write> = var, 2u
     ret
   }
@@ -123,8 +123,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, u32, read_write> = var
     %3:u32 = load %a
     %4:u32 = add %3, 2u
@@ -143,8 +143,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, i32, read_write> = var
     store %a, 42i
     ret
@@ -180,13 +180,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func(%p:i32):i32 -> %b1 {
-  %b1 = block {
+              R"(%f = func(%p:i32):i32 {
+  $B1: {
     ret %p
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %a:ptr<function, array<array<array<i32, 5>, 5>, 5>, read_write> = var
     %5:i32 = call %f, 1i
     %6:i32 = call %f, 2i
@@ -226,13 +226,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func(%p:i32):i32 -> %b1 {
-  %b1 = block {
+              R"(%f = func(%p:i32):i32 {
+  $B1: {
     ret %p
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %a:ptr<function, array<vec4<f32>, 5>, read_write> = var
     %5:i32 = call %f, 1i
     %6:ptr<function, vec4<f32>, read_write> = access %a, %5
@@ -274,13 +274,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func(%p:i32):i32 -> %b1 {
-  %b1 = block {
+              R"(%f = func(%p:i32):i32 {
+  $B1: {
     ret %p
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %a:ptr<function, array<mat3x4<f32>, 5>, read_write> = var
     %5:i32 = call %f, 1i
     %6:i32 = call %f, 2i
@@ -306,8 +306,8 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b1 {
-  %b1 = block {
+              R"(%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B1: {
     %a:ptr<function, i32, read_write> = var
     %3:i32 = load %a
     %4:i32 = add %3, 42i
@@ -345,13 +345,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func(%p:i32):i32 -> %b1 {
-  %b1 = block {
+              R"(%f = func(%p:i32):i32 {
+  $B1: {
     ret %p
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %a:ptr<function, array<array<array<i32, 5>, 5>, 5>, read_write> = var
     %5:i32 = call %f, 1i
     %6:i32 = call %f, 2i
@@ -397,13 +397,13 @@
     ASSERT_EQ(m, Success);
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%f = func(%p:i32):i32 -> %b1 {
-  %b1 = block {
+              R"(%f = func(%p:i32):i32 {
+  $B1: {
     ret %p
   }
 }
-%test_function = @compute @workgroup_size(1, 1, 1) func():void -> %b2 {
-  %b2 = block {
+%test_function = @compute @workgroup_size(1, 1, 1) func():void {
+  $B2: {
     %a:ptr<function, array<mat3x4<f32>, 5>, read_write> = var
     %5:i32 = call %f, 1i
     %6:i32 = call %f, 2i
diff --git a/src/tint/lang/wgsl/writer/raise/ptr_to_ref_test.cc b/src/tint/lang/wgsl/writer/raise/ptr_to_ref_test.cc
index 851f9bb..b663af0 100644
--- a/src/tint/lang/wgsl/writer/raise/ptr_to_ref_test.cc
+++ b/src/tint/lang/wgsl/writer/raise/ptr_to_ref_test.cc
@@ -85,8 +85,8 @@
     b.Append(fn->Block(), [&] { b.Return(fn); });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):void {
+  $B1: {
     ret
   }
 }
@@ -104,7 +104,7 @@
     b.Append(mod.root_block, [&] { b.Var(ty.ptr<private_, i32>()); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, i32, read_write> = var
 }
 
@@ -112,7 +112,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %1:ref<private, i32, read_write> = var
 }
 
@@ -131,8 +131,8 @@
     });
 
     auto* src = R"(
-%1 = func():i32 -> %b1 {
-  %b1 = block {
+%1 = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     ret %3
@@ -142,8 +142,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func():i32 -> %b1 {
-  %b1 = block {
+%1 = func():i32 {
+  $B1: {
     %2:ref<function, i32, read_write> = var
     %3:i32 = load %2
     ret %3
@@ -165,8 +165,8 @@
     });
 
     auto* src = R"(
-%1 = func():void -> %b1 {
-  %b1 = block {
+%1 = func():void {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 42i
     ret
@@ -176,8 +176,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func():void -> %b1 {
-  %b1 = block {
+%1 = func():void {
+  $B1: {
     %2:ref<function, i32, read_write> = var
     store %2, 42i
     ret
@@ -197,8 +197,8 @@
     b.Append(fn->Block(), [&] { b.Return(fn, b.Load(ptr)); });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, i32, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):i32 {
+  $B1: {
     %3:i32 = load %2
     ret %3
   }
@@ -207,8 +207,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, i32, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):i32 {
+  $B1: {
     %3:ref<function, i32, read_write> = ptr-to-ref %2
     %4:i32 = load %3
     ret %4
@@ -231,8 +231,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):void {
+  $B1: {
     store %2, 42i
     ret
   }
@@ -241,8 +241,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):void {
+  $B1: {
     %3:ref<function, i32, read_write> = ptr-to-ref %2
     store %3, 42i
     ret
@@ -267,13 +267,13 @@
     });
 
     auto* src = R"(
-%1 = func(%p:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%p:ptr<function, i32, read_write>):void {
+  $B1: {
     ret
   }
 }
-%3 = func():void -> %b2 {
-  %b2 = block {
+%3 = func():void {
+  $B2: {
     %4:ptr<function, i32, read_write> = var
     %5:void = call %1, %4
     ret
@@ -283,13 +283,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%p:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%p:ptr<function, i32, read_write>):void {
+  $B1: {
     ret
   }
 }
-%3 = func():void -> %b2 {
-  %b2 = block {
+%3 = func():void {
+  $B2: {
     %4:ref<function, i32, read_write> = var
     %5:ptr<function, i32, read_write> = ref-to-ptr %4
     %6:void = call %1, %5
@@ -313,8 +313,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, i32, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):i32 {
+  $B1: {
     %l:ptr<function, i32, read_write> = let %2
     %4:i32 = load %l
     ret %4
@@ -324,8 +324,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, i32, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):i32 {
+  $B1: {
     %l:ptr<function, i32, read_write> = let %2
     %4:ref<function, i32, read_write> = ptr-to-ref %l
     %5:i32 = load %4
@@ -350,8 +350,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):void {
+  $B1: {
     %l:ptr<function, i32, read_write> = let %2
     store %l, 42i
     ret
@@ -361,8 +361,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, i32, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, i32, read_write>):void {
+  $B1: {
     %l:ptr<function, i32, read_write> = let %2
     %4:ref<function, i32, read_write> = ptr-to-ref %l
     store %4, 42i
@@ -386,8 +386,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 {
+  $B1: {
     %3:ptr<function, i32, read_write> = access %2, 2i
     %4:i32 = load %3
     ret %4
@@ -397,8 +397,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 {
+  $B1: {
     %3:ref<function, array<i32, 4>, read_write> = ptr-to-ref %2
     %4:ref<function, i32, read_write> = access %3, 2i
     %5:i32 = load %4
@@ -423,8 +423,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void {
+  $B1: {
     %3:ptr<function, i32, read_write> = access %2, 2i
     store %3, 42i
     ret
@@ -434,8 +434,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void {
+  $B1: {
     %3:ref<function, array<i32, 4>, read_write> = ptr-to-ref %2
     %4:ref<function, i32, read_write> = access %3, 2i
     store %4, 42i
@@ -460,8 +460,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 {
+  $B1: {
     %3:ptr<function, i32, read_write> = access %2, 2i
     %l:ptr<function, i32, read_write> = let %3
     %5:i32 = load %l
@@ -472,8 +472,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):i32 {
+  $B1: {
     %3:ref<function, array<i32, 4>, read_write> = ptr-to-ref %2
     %4:ref<function, i32, read_write> = access %3, 2i
     %5:ptr<function, i32, read_write> = ref-to-ptr %4
@@ -502,8 +502,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void {
+  $B1: {
     %3:ptr<function, i32, read_write> = access %2, 2i
     %l:ptr<function, i32, read_write> = let %3
     store %l, 42i
@@ -514,8 +514,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, array<i32, 4>, read_write>):void {
+  $B1: {
     %3:ref<function, array<i32, 4>, read_write> = ptr-to-ref %2
     %4:ref<function, i32, read_write> = access %3, 2i
     %5:ptr<function, i32, read_write> = ref-to-ptr %4
@@ -539,8 +539,8 @@
     b.Append(fn->Block(), [&] { b.Return(fn, b.LoadVectorElement(param, 2_i)); });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, vec3<i32>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, vec3<i32>, read_write>):i32 {
+  $B1: {
     %3:i32 = load_vector_element %2, 2i
     ret %3
   }
@@ -549,8 +549,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, vec3<i32>, read_write>):i32 -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, vec3<i32>, read_write>):i32 {
+  $B1: {
     %3:ref<function, vec3<i32>, read_write> = ptr-to-ref %2
     %4:i32 = load_vector_element %3, 2i
     ret %4
@@ -573,8 +573,8 @@
     });
 
     auto* src = R"(
-%1 = func(%2:ptr<function, vec3<i32>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, vec3<i32>, read_write>):void {
+  $B1: {
     store_vector_element %2, 2i, 42i
     ret
   }
@@ -583,8 +583,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%1 = func(%2:ptr<function, vec3<i32>, read_write>):void -> %b1 {
-  %b1 = block {
+%1 = func(%2:ptr<function, vec3<i32>, read_write>):void {
+  $B1: {
     %3:ref<function, vec3<i32>, read_write> = ptr-to-ref %2
     store_vector_element %3, 2i, 42i
     ret
diff --git a/src/tint/lang/wgsl/writer/raise/raise_test.cc b/src/tint/lang/wgsl/writer/raise/raise_test.cc
index 0e5cae6..645361c 100644
--- a/src/tint/lang/wgsl/writer/raise/raise_test.cc
+++ b/src/tint/lang/wgsl/writer/raise/raise_test.cc
@@ -51,8 +51,8 @@
     });
 
     auto* src = R"(
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:i32 = max 1i, 2i
     ret
   }
@@ -61,8 +61,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():void -> %b1 {
-  %b1 = block {
+%f = func():void {
+  $B1: {
     %2:i32 = wgsl.max 1i, 2i
     %3:i32 = let %2
     ret
@@ -87,12 +87,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:void = workgroupBarrier
     %4:i32 = load %W
     %5:void = workgroupBarrier
@@ -103,12 +103,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ref<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<workgroup, i32, read_write> = ref-to-ptr %W
     %4:i32 = wgsl.workgroupUniformLoad %3
     ret %4
@@ -134,12 +134,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ptr<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:void = workgroupBarrier
     store %W, 42i
     %4:i32 = load %W
@@ -151,12 +151,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %W:ref<workgroup, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:void = wgsl.workgroupBarrier
     store %W, 42i
     %4:i32 = load %W
diff --git a/src/tint/lang/wgsl/writer/raise/rename_conflicts_test.cc b/src/tint/lang/wgsl/writer/raise/rename_conflicts_test.cc
index b2823db..1c805b1 100644
--- a/src/tint/lang/wgsl/writer/raise/rename_conflicts_test.cc
+++ b/src/tint/lang/wgsl/writer/raise/rename_conflicts_test.cc
@@ -83,7 +83,7 @@
     b.Append(mod.root_block, [&] { b.ir.SetName(b.Var(ty.ptr<private_, i32>()), "v"); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
@@ -104,7 +104,7 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
   %v_1:ptr<private, u32, read_write> = var  # %v_1: 'v'
 }
@@ -113,7 +113,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
   %v_1:ptr<private, u32, read_write> = var
 }
@@ -134,7 +134,7 @@
   x:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<function, v, read_write> = var
 }
 
@@ -146,7 +146,7 @@
   x:i32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %v_1:ptr<function, v, read_write> = var
 }
 
@@ -164,12 +164,12 @@
     b.Append(fn->Block(), [&] { b.Return(fn); });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
-%v_1 = func():void -> %b2 {  # %v_1: 'v'
-  %b2 = block {
+%v_1 = func():void {  # %v_1: 'v'
+  $B2: {
     ret
   }
 }
@@ -177,12 +177,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
-%v_1 = func():void -> %b2 {
-  %b2 = block {
+%v_1 = func():void {
+  $B2: {
     ret
   }
 }
@@ -211,12 +211,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = load %v
     %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
     %5:i32 = load %v_1
@@ -251,12 +251,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
     %4:i32 = load %v
     %5:i32 = load %v_1
@@ -268,12 +268,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %v:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %v_1:ptr<function, i32, read_write> = var
     %4:i32 = load %v
     %5:i32 = load %v_1
@@ -309,11 +309,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         %3:i32 = load %v
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %5:i32 = load %v_1
@@ -354,11 +354,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -373,11 +373,11 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %v:ptr<function, i32, read_write> = var
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         %v_1:ptr<function, i32, read_write> = var
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -419,14 +419,14 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %v:ptr<function, i32, read_write> = var
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %3:i32 = load %v
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %5:i32 = load %v_1
@@ -470,14 +470,14 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %v:ptr<function, i32, read_write> = var
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -492,14 +492,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %v:ptr<function, i32, read_write> = var
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %v_1:ptr<function, i32, read_write> = var
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -542,17 +542,17 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
-        next_iteration %b3
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %v:ptr<function, i32, read_write> = var
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %3:i32 = load %v
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %5:i32 = load %v_1
@@ -597,17 +597,17 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
-        next_iteration %b3
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %v:ptr<function, i32, read_write> = var
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %v_1:ptr<function, i32, read_write> = var  # %v_1: 'v'
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -622,17 +622,17 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
-        next_iteration %b3
+%f = func():i32 {
+  $B1: {
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %v:ptr<function, i32, read_write> = var
-        continue %b4
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %v_1:ptr<function, i32, read_write> = var
         %4:i32 = load %v
         %5:i32 = load %v_1
@@ -662,8 +662,8 @@
     });
 
     auto* src = R"(
-%f = func(%i32:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%i32:i32):void {
+  $B1: {
     %3:ptr<function, i32, read_write> = var
     ret
   }
@@ -672,8 +672,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func(%i32_1:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%i32_1:i32):void {
+  $B1: {
     %3:ptr<function, i32, read_write> = var
     ret
   }
@@ -697,8 +697,8 @@
     });
 
     auto* src = R"(
-%f = func(%vec2:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%vec2:i32):void {
+  $B1: {
     %3:ptr<function, vec3<i32>, read_write> = var
     ret
   }
@@ -725,8 +725,8 @@
     });
 
     auto* src = R"(
-%f = func(%vec3:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%vec3:i32):void {
+  $B1: {
     %3:ptr<function, vec3<i32>, read_write> = var
     ret
   }
@@ -735,8 +735,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func(%vec3_1:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%vec3_1:i32):void {
+  $B1: {
     %3:ptr<function, vec3<i32>, read_write> = var
     ret
   }
@@ -760,8 +760,8 @@
     });
 
     auto* src = R"(
-%f = func(%mat3x2:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%mat3x2:i32):void {
+  $B1: {
     %3:ptr<function, mat2x4<f32>, read_write> = var
     ret
   }
@@ -788,8 +788,8 @@
     });
 
     auto* src = R"(
-%f = func(%mat2x4:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%mat2x4:i32):void {
+  $B1: {
     %3:ptr<function, mat2x4<f32>, read_write> = var
     ret
   }
@@ -798,8 +798,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func(%mat2x4_1:i32):void -> %b1 {
-  %b1 = block {
+%f = func(%mat2x4_1:i32):void {
+  $B1: {
     %3:ptr<function, mat2x4<f32>, read_write> = var
     ret
   }
@@ -821,8 +821,8 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %f32:ptr<function, i32, read_write> = var
     %3:i32 = construct
     ret %3
@@ -848,8 +848,8 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %i32:ptr<function, i32, read_write> = var
     %3:i32 = construct
     ret %3
@@ -859,8 +859,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %i32_1:ptr<function, i32, read_write> = var
     %3:i32 = construct
     ret %3
@@ -883,8 +883,8 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %i32:i32 = add 1i, 2i
     ret %i32
   }
@@ -909,8 +909,8 @@
     });
 
     auto* src = R"(
-%f = func():f32 -> %b1 {
-  %b1 = block {
+%f = func():f32 {
+  $B1: {
     %f32:i32 = add 1i, 2i
     %3:f32 = construct %f32
     ret %3
@@ -920,8 +920,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():f32 -> %b1 {
-  %b1 = block {
+%f = func():f32 {
+  $B1: {
     %f32_1:i32 = add 1i, 2i
     %3:f32 = construct %f32_1
     ret %3
@@ -940,7 +940,7 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %function:ptr<private, i32, read_write> = var
 }
 
@@ -960,7 +960,7 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %private:ptr<private, i32, read_write> = var
 }
 
@@ -968,7 +968,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %private_1:ptr<private, i32, read_write> = var
 }
 
@@ -985,7 +985,7 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %read:ptr<private, i32, read_write> = var
 }
 
@@ -1005,7 +1005,7 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %read_write:ptr<private, i32, read_write> = var
 }
 
@@ -1013,7 +1013,7 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %read_write_1:ptr<private, i32, read_write> = var
 }
 
@@ -1037,12 +1037,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %min:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = max 1i, 2i
     ret %3
   }
@@ -1070,12 +1070,12 @@
     });
 
     auto* src = R"(
-%b1 = block {  # root
+$B1: {  # root
   %max:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = max 1i, 2i
     ret %3
   }
@@ -1084,12 +1084,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%b1 = block {  # root
+$B1: {  # root
   %max_1:ptr<private, i32, read_write> = var
 }
 
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:i32 = max 1i, 2i
     ret %3
   }
@@ -1118,12 +1118,12 @@
   f:f32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, s, read_write> = var
 }
 
-%f32 = func():void -> %b2 {
-  %b2 = block {
+%f32 = func():void {
+  $B2: {
     ret
   }
 }
@@ -1135,12 +1135,12 @@
   f:f32 @offset(0)
 }
 
-%b1 = block {  # root
+$B1: {  # root
   %1:ptr<private, s, read_write> = var
 }
 
-%f32_1 = func():void -> %b2 {
-  %b2 = block {
+%f32_1 = func():void {
+  $B2: {
     ret
   }
 }
diff --git a/src/tint/lang/wgsl/writer/raise/value_to_let_test.cc b/src/tint/lang/wgsl/writer/raise/value_to_let_test.cc
index d9ac335..4449bd8 100644
--- a/src/tint/lang/wgsl/writer/raise/value_to_let_test.cc
+++ b/src/tint/lang/wgsl/writer/raise/value_to_let_test.cc
@@ -62,8 +62,8 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
@@ -76,8 +76,8 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
@@ -110,13 +110,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = add 1i, 2i
     %5:i32 = add 3i, 4i
     %6:i32 = add %4, %5
@@ -148,13 +148,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = call %a, 1i
     %5:i32 = add 2i, 3i
     %6:i32 = add %4, %5
@@ -186,13 +186,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = add 1i, 2i
     %5:i32 = call %a, 3i
     %6:i32 = add %4, %5
@@ -224,13 +224,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = call %a, 1i
     %5:i32 = call %a, 2i
     %6:i32 = add %4, %5
@@ -262,13 +262,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = add 3i, 4i
     %5:i32 = add 1i, 2i
     %6:i32 = add %5, %4
@@ -300,13 +300,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = add 2i, 3i
     %5:i32 = call %a, 1i
     %6:i32 = add %5, %4
@@ -338,13 +338,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = call %a, 3i
     %5:i32 = add 1i, 2i
     %6:i32 = add %5, %4
@@ -376,13 +376,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = call %a, 2i
     %5:i32 = call %a, 1i
     %6:i32 = add %5, %4
@@ -394,13 +394,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func():i32 -> %b2 {
-  %b2 = block {
+%b = func():i32 {
+  $B2: {
     %4:i32 = call %a, 2i
     %5:i32 = let %4
     %6:i32 = call %a, 1i
@@ -438,18 +438,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 1i
     %9:i32 = call %a, 2i
     %10:i32 = call %a, 3i
@@ -488,18 +488,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 2i
     %9:i32 = call %a, 1i
     %10:i32 = call %a, 3i
@@ -512,18 +512,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 2i
     %9:i32 = let %8
     %10:i32 = call %a, 1i
@@ -559,18 +559,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 1i
     %9:i32 = call %a, 3i
     %10:i32 = call %a, 2i
@@ -583,18 +583,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 1i
     %9:i32 = let %8
     %10:i32 = call %a, 3i
@@ -631,18 +631,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 3i
     %9:i32 = call %a, 1i
     %10:i32 = call %a, 2i
@@ -655,18 +655,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 3i
     %9:i32 = let %8
     %10:i32 = call %a, 1i
@@ -702,18 +702,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 2i
     %9:i32 = call %a, 3i
     %10:i32 = call %a, 1i
@@ -726,18 +726,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 2i
     %9:i32 = let %8
     %10:i32 = call %a, 3i
@@ -774,18 +774,18 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 3i
     %9:i32 = call %a, 2i
     %10:i32 = call %a, 1i
@@ -798,18 +798,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 0i
   }
 }
-%b = func(%4:i32, %5:i32, %6:i32):i32 -> %b2 {
-  %b2 = block {
+%b = func(%4:i32, %5:i32, %6:i32):i32 {
+  $B2: {
     ret 0i
   }
 }
-%c = func():i32 -> %b3 {
-  %b3 = block {
+%c = func():i32 {
+  $B3: {
     %8:i32 = call %a, 3i
     %9:i32 = let %8
     %10:i32 = call %a, 2i
@@ -840,13 +840,13 @@
     });
 
     auto* src = R"(
-%a = func():void -> %b1 {
-  %b1 = block {
+%a = func():void {
+  $B1: {
     ret
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -859,13 +859,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func():void -> %b1 {
-  %b1 = block {
+%a = func():void {
+  $B1: {
     ret
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -895,13 +895,13 @@
     });
 
     auto* src = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -914,13 +914,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -950,13 +950,13 @@
     });
 
     auto* src = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -970,13 +970,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -1006,13 +1006,13 @@
     });
 
     auto* src = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -1026,13 +1026,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func():i32 -> %b1 {
-  %b1 = block {
+%a = func():i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %3:ptr<function, i32, read_write> = var
     store %3, 1i
     %4:i32 = load %3
@@ -1068,13 +1068,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 1i
     %6:i32 = call %a, 2i
@@ -1089,13 +1089,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 1i
     %6:i32 = call %a, 2i
@@ -1128,13 +1128,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 2i
     %6:i32 = call %a, 1i
@@ -1149,13 +1149,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 2i
     %6:i32 = let %5
@@ -1189,13 +1189,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 3i
     %6:i32 = call %a, 1i
@@ -1210,13 +1210,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 3i
     %6:i32 = let %5
@@ -1250,13 +1250,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 3i
     %6:i32 = call %a, 2i
@@ -1271,13 +1271,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():i32 -> %b2 {
-  %b2 = block {
+%f = func():i32 {
+  $B2: {
     %4:ptr<function, array<array<array<i32, 3>, 4>, 5>, read_write> = var
     %5:i32 = call %a, 3i
     %6:i32 = let %5
@@ -1312,13 +1312,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 1i
     %6:i32 = call %a, 2i
@@ -1332,13 +1332,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 1i
     %6:i32 = call %a, 2i
@@ -1370,13 +1370,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 2i
     %6:i32 = call %a, 1i
@@ -1390,13 +1390,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 2i
     %6:i32 = let %5
@@ -1429,13 +1429,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 3i
     %6:i32 = call %a, 1i
@@ -1449,13 +1449,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 3i
     %6:i32 = let %5
@@ -1488,13 +1488,13 @@
     });
 
     auto* src = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 3i
     %6:i32 = call %a, 2i
@@ -1508,13 +1508,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%a = func(%2:i32):i32 -> %b1 {
-  %b1 = block {
+%a = func(%2:i32):i32 {
+  $B1: {
     ret 1i
   }
 }
-%f = func():f32 -> %b2 {
-  %b2 = block {
+%f = func():f32 {
+  $B2: {
     %4:array<mat3x4<f32>, 5> = construct
     %5:i32 = call %a, 3i
     %6:i32 = let %5
@@ -1545,11 +1545,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         ret %2
       }
     }
@@ -1580,13 +1580,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:i32 = add %3, 2i
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         ret %4
       }
     }
@@ -1598,14 +1598,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:i32 = add %3, 2i
     %5:i32 = let %4
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         ret %5
       }
     }
@@ -1629,11 +1629,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:bool = eq 1i, 2i
-    if %2 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %2 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 3i
       }
     }
@@ -1645,11 +1645,11 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:bool = eq 1i, 2i
-    if %2 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %2 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 3i
       }
     }
@@ -1676,13 +1676,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:bool = eq %3, 2i
-    if %4 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %4 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 3i
       }
     }
@@ -1694,13 +1694,13 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:bool = eq %3, 2i
-    if %4 [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if %4 [t: $B2] {  # if_1
+      $B2: {  # true
         ret 3i
       }
     }
@@ -1729,13 +1729,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         store %2, 2i
         exit_if  # if_1
       }
@@ -1748,14 +1748,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
     %4:i32 = let %3
-    if true [t: %b2] {  # if_1
-      %b2 = block {  # true
+    if true [t: $B2] {  # if_1
+      $B2: {  # true
         store %2, 2i
         exit_if  # if_1
       }
@@ -1784,11 +1784,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    switch 3i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch 3i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret %2
       }
     }
@@ -1820,13 +1820,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:i32 = add %3, 2i
-    switch 3i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch 3i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret %4
       }
     }
@@ -1838,14 +1838,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
     %4:i32 = add %3, 2i
     %5:i32 = let %4
-    switch 3i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch 3i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret %5
       }
     }
@@ -1870,11 +1870,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    switch %2 [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch %2 [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret 3i
       }
     }
@@ -1886,11 +1886,11 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    switch %2 [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch %2 [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret 3i
       }
     }
@@ -1917,12 +1917,12 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
-    switch %3 [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch %3 [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret 3i
       }
     }
@@ -1934,12 +1934,12 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var, 1i
     %3:i32 = load %2
-    switch %3 [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch %3 [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         ret 3i
       }
     }
@@ -1969,13 +1969,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
-    switch 1i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch 1i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         store %2, 2i
         exit_switch  # switch_1
       }
@@ -1988,14 +1988,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
     %4:i32 = let %3
-    switch 1i [c: (default, %b2)] {  # switch_1
-      %b2 = block {  # case
+    switch 1i [c: (default, $B2)] {  # switch_1
+      $B2: {  # case
         store %2, 2i
         exit_switch  # switch_1
       }
@@ -2028,16 +2028,16 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = add 1i, 2i
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         store %2, %3
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -2071,17 +2071,17 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         store %2, %4
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -2093,18 +2093,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
     %5:i32 = let %4
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         store %2, %5
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -2134,17 +2134,17 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         store %2, 2i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -2156,18 +2156,18 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
     %4:i32 = let %3
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         store %2, 2i
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         exit_loop  # loop_1
       }
     }
@@ -2191,11 +2191,11 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret %2
       }
     }
@@ -2225,13 +2225,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret %4
       }
     }
@@ -2243,14 +2243,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
     %5:i32 = let %4
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         ret %5
       }
     }
@@ -2279,13 +2279,13 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         store %2, 2i
         exit_loop  # loop_1
       }
@@ -2298,14 +2298,14 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
     %4:i32 = let %3
-    loop [b: %b2] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2] {  # loop_1
+      $B2: {  # body
         store %2, 2i
         exit_loop  # loop_1
       }
@@ -2331,16 +2331,16 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:i32 = add 1i, 2i
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %3:bool = eq %2, 3i
-        break_if %3 %b2
+        break_if %3  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret 0i
@@ -2370,18 +2370,18 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %5:bool = eq %4, 3i
-        break_if %5 %b2
+        break_if %5  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret 0i
@@ -2394,19 +2394,19 @@
     Run(ValueToLet);
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     %3:i32 = load %2
     %4:i32 = add %3, 2i
     %5:i32 = let %4
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %6:bool = eq %5, 3i
-        break_if %6 %b2
+        break_if %6  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret 0i
@@ -2433,18 +2433,18 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         store %2, 2i
-        break_if true %b2
+        break_if true  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret %3
@@ -2455,19 +2455,19 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
     %3:i32 = load %2
     %4:i32 = let %3
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
-        continue %b3
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         store %2, 2i
-        break_if true %b2
+        break_if true  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret %4
@@ -2498,16 +2498,16 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %3:i32 = load %2
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %4:i32 = add %3, 1i
         store %2, %4
         exit_loop  # loop_1
@@ -2521,17 +2521,17 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [i: %b2, b: %b3] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3] {  # loop_1
+      $B2: {  # initializer
         %3:i32 = load %2
         %4:i32 = let %3
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
+      $B3: {  # body
         %5:i32 = add %4, 1i
         store %2, %5
         exit_loop  # loop_1
@@ -2566,22 +2566,22 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
         %3:i32 = load %2
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
-        continue %b4
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %4:i32 = add %3, 1i
         store %2, %4
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret 3i
@@ -2592,23 +2592,23 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [i: %b2, b: %b3, c: %b4] {  # loop_1
-      %b2 = block {  # initializer
+    loop [i: $B2, b: $B3, c: $B4] {  # loop_1
+      $B2: {  # initializer
         %3:i32 = load %2
         %4:i32 = let %3
-        next_iteration %b3
+        next_iteration  # -> $B3
       }
-      %b3 = block {  # body
-        continue %b4
+      $B3: {  # body
+        continue  # -> $B4
       }
-      %b4 = block {  # continuing
+      $B4: {  # continuing
         %5:i32 = add %4, 1i
         store %2, %5
-        break_if true %b3
+        break_if true  # -> [t: exit_loop loop_1, f: $B3]
       }
     }
     ret 3i
@@ -2640,19 +2640,19 @@
     });
 
     auto* src = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %2
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %4:i32 = add %3, 1i
         store %2, %4
-        break_if true %b2
+        break_if true  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret 3i
@@ -2663,20 +2663,20 @@
     EXPECT_EQ(src, str());
 
     auto* expect = R"(
-%f = func():i32 -> %b1 {
-  %b1 = block {
+%f = func():i32 {
+  $B1: {
     %2:ptr<function, i32, read_write> = var
     store %2, 1i
-    loop [b: %b2, c: %b3] {  # loop_1
-      %b2 = block {  # body
+    loop [b: $B2, c: $B3] {  # loop_1
+      $B2: {  # body
         %3:i32 = load %2
         %4:i32 = let %3
-        continue %b3
+        continue  # -> $B3
       }
-      %b3 = block {  # continuing
+      $B3: {  # continuing
         %5:i32 = add %4, 1i
         store %2, %5
-        break_if true %b2
+        break_if true  # -> [t: exit_loop loop_1, f: $B2]
       }
     }
     ret 3i
diff --git a/src/tint/utils/macros/foreach.h b/src/tint/utils/macros/foreach.h
index 9ec27cc..f234a38 100644
--- a/src/tint/utils/macros/foreach.h
+++ b/src/tint/utils/macros/foreach.h
@@ -39,13 +39,15 @@
 /// TINT_COUNT_ARGUMENTS_NTH_ARG is used by TINT_COUNT_ARGUMENTS to get the number of arguments in a
 /// variadic macro call.
 #define TINT_COUNT_ARGUMENTS_NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, \
-                                     _15, _16, N, ...)                                            \
+                                     _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26,  \
+                                     _27, _28, _29, _30, _31, _32, N, ...)                        \
     N
 
 /// TINT_COUNT_ARGUMENTS evaluates to the number of arguments passed to the macro
-#define TINT_COUNT_ARGUMENTS(...)                                                                 \
-    TINT_MSVC_EXPAND_BUG(TINT_COUNT_ARGUMENTS_NTH_ARG(__VA_ARGS__, 16, 15, 14, 13, 12, 11, 10, 9, \
-                                                      8, 7, 6, 5, 4, 3, 2, 1, 0))
+#define TINT_COUNT_ARGUMENTS(...)                                                                \
+    TINT_MSVC_EXPAND_BUG(TINT_COUNT_ARGUMENTS_NTH_ARG(                                           \
+        __VA_ARGS__, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, \
+        13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
 
 // Correctness checks.
 static_assert(1 == TINT_COUNT_ARGUMENTS(a), "TINT_COUNT_ARGUMENTS broken");
@@ -100,5 +102,88 @@
 #define TINT_FOREACH_15(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
     TINT_FOREACH_14(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14)          \
     CB(_15)
+#define TINT_FOREACH_16(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
+    TINT_FOREACH_15(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15)          \
+    CB(_16)
+#define TINT_FOREACH_17(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17)                                                                       \
+    TINT_FOREACH_16(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16)     \
+    CB(_17)
+#define TINT_FOREACH_18(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18)                                                                  \
+    TINT_FOREACH_17(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17)                                                                           \
+    CB(_18)
+#define TINT_FOREACH_19(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19)                                                             \
+    TINT_FOREACH_18(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18)                                                                      \
+    CB(_19)
+#define TINT_FOREACH_20(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20)                                                        \
+    TINT_FOREACH_19(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19)                                                                 \
+    CB(_20)
+#define TINT_FOREACH_21(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21)                                                   \
+    TINT_FOREACH_20(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20)                                                            \
+    CB(_21)
+#define TINT_FOREACH_22(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22)                                              \
+    TINT_FOREACH_21(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21)                                                       \
+    CB(_22)
+#define TINT_FOREACH_23(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23)                                         \
+    TINT_FOREACH_22(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22)                                                  \
+    CB(_23)
+#define TINT_FOREACH_24(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24)                                    \
+    TINT_FOREACH_23(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23)                                             \
+    CB(_24)
+#define TINT_FOREACH_25(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25)                               \
+    TINT_FOREACH_24(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24)                                        \
+    CB(_25)
+#define TINT_FOREACH_26(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26)                          \
+    TINT_FOREACH_25(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25)                                   \
+    CB(_26)
+#define TINT_FOREACH_27(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27)                     \
+    TINT_FOREACH_26(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26)                              \
+    CB(_27)
+#define TINT_FOREACH_28(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28)                \
+    TINT_FOREACH_27(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27)                         \
+    CB(_28)
+#define TINT_FOREACH_29(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29)           \
+    TINT_FOREACH_28(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28)                    \
+    CB(_29)
+#define TINT_FOREACH_30(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30)      \
+    TINT_FOREACH_29(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29)               \
+    CB(_30)
+#define TINT_FOREACH_31(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31) \
+    TINT_FOREACH_30(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30)          \
+    CB(_31)
+#define TINT_FOREACH_32(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, \
+                        _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, \
+                        _32)                                                                       \
+    TINT_FOREACH_31(CB, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
+                    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31)     \
+    CB(_32)
 
 #endif  // SRC_TINT_UTILS_MACROS_FOREACH_H_