diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index ce779bc..11f6a78 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -1699,6 +1699,7 @@
       "constant/manager_test.cc",
       "constant/scalar_test.cc",
       "constant/splat_test.cc",
+      "constant/value_test.cc",
     ]
   }
 
@@ -2280,6 +2281,7 @@
       sources = [
         "ir/binary_test.cc",
         "ir/bitcast_test.cc",
+        "ir/block_test.cc",
         "ir/constant_test.cc",
         "ir/discard_test.cc",
         "ir/from_program_binary_test.cc",
@@ -2292,6 +2294,7 @@
         "ir/from_program_test.cc",
         "ir/from_program_unary_test.cc",
         "ir/from_program_var_test.cc",
+        "ir/instruction_test.cc",
         "ir/load_test.cc",
         "ir/module_test.cc",
         "ir/store_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 2ecb97a..40dd3ee 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -940,6 +940,7 @@
     constant/manager_test.cc
     constant/scalar_test.cc
     constant/splat_test.cc
+    constant/value_test.cc
     debug_test.cc
     diagnostic/diagnostic_test.cc
     diagnostic/formatter_test.cc
@@ -1483,6 +1484,7 @@
     list(APPEND TINT_TEST_SRCS
       ir/binary_test.cc
       ir/bitcast_test.cc
+      ir/block_test.cc
       ir/constant_test.cc
       ir/discard_test.cc
       ir/from_program_binary_test.cc
@@ -1495,6 +1497,7 @@
       ir/from_program_test.cc
       ir/from_program_unary_test.cc
       ir/from_program_var_test.cc
+      ir/instruction_test.cc
       ir/load_test.cc
       ir/module_test.cc
       ir/store_test.cc
diff --git a/src/tint/constant/splat_test.cc b/src/tint/constant/splat_test.cc
index 0e2f21e..e310d63 100644
--- a/src/tint/constant/splat_test.cc
+++ b/src/tint/constant/splat_test.cc
@@ -31,9 +31,9 @@
     auto* fNeg0 = constants.Get(-0_f);
     auto* fPos1 = constants.Get(1_f);
 
-    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 2);
-    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 2);
-    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 2);
+    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 3);
+    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 3);
+    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 3);
 
     EXPECT_TRUE(SpfPos0->AllZero());
     EXPECT_FALSE(SpfNeg0->AllZero());
@@ -47,9 +47,9 @@
     auto* fNeg0 = constants.Get(-0_f);
     auto* fPos1 = constants.Get(1_f);
 
-    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 2);
-    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 2);
-    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 2);
+    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 3);
+    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 3);
+    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 3);
 
     EXPECT_TRUE(SpfPos0->AnyZero());
     EXPECT_FALSE(SpfNeg0->AnyZero());
diff --git a/src/tint/constant/value.cc b/src/tint/constant/value.cc
index 7545731..989f2ba 100644
--- a/src/tint/constant/value.cc
+++ b/src/tint/constant/value.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/constant/value.h"
 
+#include "src/tint/constant/splat.h"
 #include "src/tint/switch.h"
 #include "src/tint/type/array.h"
 #include "src/tint/type/matrix.h"
@@ -30,51 +31,68 @@
 
 /// Equal returns true if the constants `a` and `b` are of the same type and value.
 bool Value::Equal(const constant::Value* b) const {
+    if (this == b) {
+        return true;
+    }
     if (Hash() != b->Hash()) {
         return false;
     }
     if (Type() != b->Type()) {
         return false;
     }
+
+    auto elements_equal = [&](size_t count) {
+        if (count == 0) {
+            return true;
+        }
+
+        // Avoid per-element comparisons if the constants are splats
+        bool a_is_splat = Is<Splat>();
+        bool b_is_splat = b->Is<Splat>();
+        if (a_is_splat && b_is_splat) {
+            return Index(0)->Equal(b->Index(0));
+        }
+
+        if (a_is_splat) {
+            auto* el_a = Index(0);
+            for (size_t i = 0; i < count; i++) {
+                if (!el_a->Equal(b->Index(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        if (b_is_splat) {
+            auto* el_b = b->Index(0);
+            for (size_t i = 0; i < count; i++) {
+                if (!Index(i)->Equal(el_b)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // Per-element comparison
+        for (size_t i = 0; i < count; i++) {
+            if (!Index(i)->Equal(b->Index(i))) {
+                return false;
+            }
+        }
+        return true;
+    };
+
     return Switch(
         Type(),  //
-        [&](const type::Vector* vec) {
-            for (size_t i = 0; i < vec->Width(); i++) {
-                if (!Index(i)->Equal(b->Index(i))) {
-                    return false;
-                }
-            }
-            return true;
-        },
-        [&](const type::Matrix* mat) {
-            for (size_t i = 0; i < mat->columns(); i++) {
-                if (!Index(i)->Equal(b->Index(i))) {
-                    return false;
-                }
-            }
-            return true;
-        },
+        [&](const type::Vector* vec) { return elements_equal(vec->Width()); },
+        [&](const type::Matrix* mat) { return elements_equal(mat->columns()); },
+        [&](const type::Struct* str) { return elements_equal(str->Members().Length()); },
         [&](const type::Array* arr) {
-            if (auto count = arr->ConstantCount()) {
-                for (size_t i = 0; i < count; i++) {
-                    if (!Index(i)->Equal(b->Index(i))) {
-                        return false;
-                    }
-                }
-                return true;
+            if (auto n = arr->ConstantCount()) {
+                return elements_equal(*n);
             }
-
             return false;
         },
-        [&](const type::Struct* str) {
-            auto count = str->Members().Length();
-            for (size_t i = 0; i < count; i++) {
-                if (!Index(i)->Equal(b->Index(i))) {
-                    return false;
-                }
-            }
-            return true;
-        },
         [&](Default) {
             auto va = InternalValue();
             auto vb = b->InternalValue();
diff --git a/src/tint/constant/value_test.cc b/src/tint/constant/value_test.cc
new file mode 100644
index 0000000..e715c21
--- /dev/null
+++ b/src/tint/constant/value_test.cc
@@ -0,0 +1,78 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/constant/splat.h"
+
+#include "src/tint/constant/scalar.h"
+#include "src/tint/constant/test_helper.h"
+
+namespace tint::constant {
+namespace {
+
+using namespace tint::number_suffixes;  // NOLINT
+
+using ConstantTest_Value = TestHelper;
+
+TEST_F(ConstantTest_Value, Equal_Scalar_Scalar) {
+    EXPECT_TRUE(constants.Get(10_i)->Equal(constants.Get(10_i)));
+    EXPECT_FALSE(constants.Get(10_i)->Equal(constants.Get(20_i)));
+    EXPECT_FALSE(constants.Get(20_i)->Equal(constants.Get(10_i)));
+
+    EXPECT_TRUE(constants.Get(10_u)->Equal(constants.Get(10_u)));
+    EXPECT_FALSE(constants.Get(10_u)->Equal(constants.Get(20_u)));
+    EXPECT_FALSE(constants.Get(20_u)->Equal(constants.Get(10_u)));
+
+    EXPECT_TRUE(constants.Get(10_f)->Equal(constants.Get(10_f)));
+    EXPECT_FALSE(constants.Get(10_f)->Equal(constants.Get(20_f)));
+    EXPECT_FALSE(constants.Get(20_f)->Equal(constants.Get(10_f)));
+}
+
+TEST_F(ConstantTest_Value, Equal_Splat_Splat) {
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+
+    auto* vec3f_1_1_1 = constants.Splat(vec3f, constants.Get(1_f), 3);
+    auto* vec3f_2_2_2 = constants.Splat(vec3f, constants.Get(2_f), 3);
+
+    EXPECT_TRUE(vec3f_1_1_1->Equal(vec3f_1_1_1));
+    EXPECT_FALSE(vec3f_2_2_2->Equal(vec3f_1_1_1));
+    EXPECT_FALSE(vec3f_1_1_1->Equal(vec3f_2_2_2));
+}
+
+TEST_F(ConstantTest_Value, Equal_Composite_Composite) {
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+
+    auto* vec3f_1_1_2 = constants.Composite(
+        vec3f, utils::Vector{constants.Get(1_f), constants.Get(1_f), constants.Get(2_f)});
+    auto* vec3f_1_2_1 = constants.Composite(
+        vec3f, utils::Vector{constants.Get(1_f), constants.Get(2_f), constants.Get(1_f)});
+
+    EXPECT_TRUE(vec3f_1_1_2->Equal(vec3f_1_1_2));
+    EXPECT_FALSE(vec3f_1_2_1->Equal(vec3f_1_1_2));
+    EXPECT_FALSE(vec3f_1_1_2->Equal(vec3f_1_2_1));
+}
+
+TEST_F(ConstantTest_Value, Equal_Splat_Composite) {
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
+
+    auto* vec3f_1_1_1 = constants.Splat(vec3f, constants.Get(1_f), 3);
+    auto* vec3f_1_2_1 = constants.Composite(
+        vec3f, utils::Vector{constants.Get(1_f), constants.Get(2_f), constants.Get(1_f)});
+
+    EXPECT_TRUE(vec3f_1_1_1->Equal(vec3f_1_1_1));
+    EXPECT_FALSE(vec3f_1_2_1->Equal(vec3f_1_1_1));
+    EXPECT_FALSE(vec3f_1_1_1->Equal(vec3f_1_2_1));
+}
+
+}  // namespace
+}  // namespace tint::constant
diff --git a/src/tint/debug.h b/src/tint/debug.h
index 5caeb5d..8b8c4b3 100644
--- a/src/tint/debug.h
+++ b/src/tint/debug.h
@@ -119,4 +119,21 @@
         }                                                                                \
     } while (false)
 
+/// TINT_ASSERT_OR_RETURN() is a macro for checking the expression is true, triggering a
+/// TINT_ICE if it is not and returning from the calling function.
+/// The ICE message contains the callsite's file and line.
+/// @warning: Unlike TINT_ICE() and TINT_UNREACHABLE(), TINT_ASSERT_OR_RETURN() does not
+/// append a message to an existing tint::diag::List. As such, TINT_ASSERT_OR_RETURN()
+/// may silently fail in builds where SetInternalCompilerErrorReporter() is not
+/// called. Only use in places where there's no sensible place to put proper
+/// error handling.
+#define TINT_ASSERT_OR_RETURN(system, condition)                                         \
+    do {                                                                                 \
+        if (TINT_UNLIKELY(!(condition))) {                                               \
+            tint::diag::List diagnostics;                                                \
+            TINT_ICE(system, diagnostics) << "TINT_ASSERT(" #system ", " #condition ")"; \
+            return;                                                                      \
+        }                                                                                \
+    } while (false)
+
 #endif  // SRC_TINT_DEBUG_H_
diff --git a/src/tint/ir/binary_test.cc b/src/tint/ir/binary_test.cc
index 281d04b..4c4fab8 100644
--- a/src/tint/ir/binary_test.cc
+++ b/src/tint/ir/binary_test.cc
@@ -21,9 +21,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_InstructionTest = TestHelper;
+using IR_BinaryTest = TestHelper;
 
-TEST_F(IR_InstructionTest, CreateAnd) {
+TEST_F(IR_BinaryTest, CreateAnd) {
     Module mod;
     Builder b{mod};
 
@@ -44,7 +44,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateOr) {
+TEST_F(IR_BinaryTest, CreateOr) {
     Module mod;
     Builder b{mod};
 
@@ -64,7 +64,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateXor) {
+TEST_F(IR_BinaryTest, CreateXor) {
     Module mod;
     Builder b{mod};
 
@@ -84,7 +84,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateEqual) {
+TEST_F(IR_BinaryTest, CreateEqual) {
     Module mod;
     Builder b{mod};
 
@@ -104,7 +104,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateNotEqual) {
+TEST_F(IR_BinaryTest, CreateNotEqual) {
     Module mod;
     Builder b{mod};
 
@@ -124,7 +124,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateLessThan) {
+TEST_F(IR_BinaryTest, CreateLessThan) {
     Module mod;
     Builder b{mod};
 
@@ -144,7 +144,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateGreaterThan) {
+TEST_F(IR_BinaryTest, CreateGreaterThan) {
     Module mod;
     Builder b{mod};
 
@@ -164,7 +164,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateLessThanEqual) {
+TEST_F(IR_BinaryTest, CreateLessThanEqual) {
     Module mod;
     Builder b{mod};
 
@@ -184,7 +184,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateGreaterThanEqual) {
+TEST_F(IR_BinaryTest, CreateGreaterThanEqual) {
     Module mod;
     Builder b{mod};
 
@@ -204,7 +204,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateNot) {
+TEST_F(IR_BinaryTest, CreateNot) {
     Module mod;
     Builder b{mod};
     const auto* inst = b.Not(mod.Types().bool_(), b.Constant(true));
@@ -223,7 +223,7 @@
     EXPECT_FALSE(rhs->As<constant::Scalar<bool>>()->ValueAs<bool>());
 }
 
-TEST_F(IR_InstructionTest, CreateShiftLeft) {
+TEST_F(IR_BinaryTest, CreateShiftLeft) {
     Module mod;
     Builder b{mod};
 
@@ -243,7 +243,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateShiftRight) {
+TEST_F(IR_BinaryTest, CreateShiftRight) {
     Module mod;
     Builder b{mod};
 
@@ -263,7 +263,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateAdd) {
+TEST_F(IR_BinaryTest, CreateAdd) {
     Module mod;
     Builder b{mod};
 
@@ -283,7 +283,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateSubtract) {
+TEST_F(IR_BinaryTest, CreateSubtract) {
     Module mod;
     Builder b{mod};
 
@@ -303,7 +303,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateMultiply) {
+TEST_F(IR_BinaryTest, CreateMultiply) {
     Module mod;
     Builder b{mod};
 
@@ -323,7 +323,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateDivide) {
+TEST_F(IR_BinaryTest, CreateDivide) {
     Module mod;
     Builder b{mod};
 
@@ -343,7 +343,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateModulo) {
+TEST_F(IR_BinaryTest, CreateModulo) {
     Module mod;
     Builder b{mod};
 
@@ -363,7 +363,7 @@
     EXPECT_EQ(2_i, rhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, Binary_Usage) {
+TEST_F(IR_BinaryTest, Binary_Usage) {
     Module mod;
     Builder b{mod};
     const auto* inst = b.And(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
@@ -379,7 +379,7 @@
     EXPECT_EQ(inst->RHS()->Usage()[0], inst);
 }
 
-TEST_F(IR_InstructionTest, Binary_Usage_DuplicateValue) {
+TEST_F(IR_BinaryTest, Binary_Usage_DuplicateValue) {
     Module mod;
     Builder b{mod};
     auto val = b.Constant(4_i);
diff --git a/src/tint/ir/bitcast_test.cc b/src/tint/ir/bitcast_test.cc
index bf66e39..d63853f 100644
--- a/src/tint/ir/bitcast_test.cc
+++ b/src/tint/ir/bitcast_test.cc
@@ -22,9 +22,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_InstructionTest = TestHelper;
+using IR_BitcastTest = TestHelper;
 
-TEST_F(IR_InstructionTest, Bitcast) {
+TEST_F(IR_BitcastTest, Bitcast) {
     Module mod;
     Builder b{mod};
     const auto* inst = b.Bitcast(mod.Types().i32(), b.Constant(4_i));
@@ -40,7 +40,7 @@
     EXPECT_EQ(4_i, val->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, Bitcast_Usage) {
+TEST_F(IR_BitcastTest, Bitcast_Usage) {
     Module mod;
     Builder b{mod};
     const auto* inst = b.Bitcast(mod.Types().i32(), b.Constant(4_i));
diff --git a/src/tint/ir/block.cc b/src/tint/ir/block.cc
index 4da1287..8942ea9 100644
--- a/src/tint/ir/block.cc
+++ b/src/tint/ir/block.cc
@@ -22,16 +22,141 @@
 
 Block::~Block() = default;
 
-void Block::AddInstruction(Instruction* inst) {
-    instructions_.Push(inst);
+void Block::Prepend(Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+
     inst->SetBlock(this);
+    instructions_.count += 1;
+
+    if (instructions_.first == nullptr) {
+        instructions_.first = inst;
+        instructions_.last = inst;
+    } else {
+        inst->next = instructions_.first;
+        instructions_.first->prev = inst;
+        instructions_.first = inst;
+    }
+}
+
+void Block::Append(Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+
+    inst->SetBlock(this);
+    instructions_.count += 1;
+
+    if (instructions_.first == nullptr) {
+        instructions_.first = inst;
+        instructions_.last = inst;
+    } else {
+        inst->prev = instructions_.last;
+        instructions_.last->next = inst;
+        instructions_.last = inst;
+    }
+}
+
+void Block::InsertBefore(Instruction* before, Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, before);
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, before->Block() == this);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+
+    inst->SetBlock(this);
+    instructions_.count += 1;
+
+    inst->next = before;
+    inst->prev = before->prev;
+    before->prev = inst;
+
+    if (inst->prev) {
+        inst->prev->next = inst;
+    }
+
+    if (before == instructions_.first) {
+        instructions_.first = inst;
+    }
+}
+
+void Block::InsertAfter(Instruction* after, Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, after);
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, after->Block() == this);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+
+    inst->SetBlock(this);
+    instructions_.count += 1;
+
+    inst->prev = after;
+    inst->next = after->next;
+    after->next = inst;
+
+    if (inst->next) {
+        inst->next->prev = inst;
+    }
+    if (after == instructions_.last) {
+        instructions_.last = inst;
+    }
+}
+
+void Block::Replace(Instruction* target, Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, target);
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, target->Block() == this);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == nullptr);
+
+    inst->SetBlock(this);
+    target->SetBlock(nullptr);
+
+    inst->next = target->next;
+    inst->prev = target->prev;
+
+    target->next = nullptr;
+    target->prev = nullptr;
+
+    if (inst->next) {
+        inst->next->prev = inst;
+    }
+    if (inst->prev) {
+        inst->prev->next = inst;
+    }
+
+    if (target == instructions_.first) {
+        instructions_.first = inst;
+    }
+    if (target == instructions_.last) {
+        instructions_.last = inst;
+    }
+}
+
+void Block::Remove(Instruction* inst) {
+    TINT_ASSERT_OR_RETURN(IR, inst);
+    TINT_ASSERT_OR_RETURN(IR, inst->Block() == this);
+
+    inst->SetBlock(nullptr);
+    instructions_.count -= 1;
+
+    if (inst->prev) {
+        inst->prev->next = inst->next;
+    }
+    if (inst->next) {
+        inst->next->prev = inst->prev;
+    }
+    if (inst == instructions_.first) {
+        instructions_.first = inst->next;
+    }
+    if (inst == instructions_.last) {
+        instructions_.last = inst->prev;
+    }
+
+    inst->prev = nullptr;
+    inst->next = nullptr;
 }
 
 void Block::SetInstructions(utils::VectorRef<Instruction*> instructions) {
     for (auto* i : instructions) {
-        i->SetBlock(this);
+        Append(i);
     }
-    instructions_ = std::move(instructions);
 }
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/block.h b/src/tint/ir/block.h
index 20a2da7..6b1697a 100644
--- a/src/tint/ir/block.h
+++ b/src/tint/ir/block.h
@@ -35,7 +35,7 @@
 
     /// @returns true if this is block has a branch target set
     bool HasBranchTarget() const {
-        return !instructions_.IsEmpty() && instructions_.Back()->Is<ir::Branch>();
+        return instructions_.last != nullptr && instructions_.last->Is<ir::Branch>();
     }
 
     /// @return the node this block branches to or nullptr if the block doesn't branch
@@ -43,7 +43,7 @@
         if (!HasBranchTarget()) {
             return nullptr;
         }
-        return instructions_.Back()->As<ir::Branch>();
+        return instructions_.last->As<ir::Branch>();
     }
 
     /// Sets the instructions in the block
@@ -51,11 +51,74 @@
     void SetInstructions(utils::VectorRef<Instruction*> instructions);
 
     /// @returns the instructions in the block
-    utils::VectorRef<const Instruction*> Instructions() const { return instructions_; }
+    Instruction* Instructions() const { return instructions_.first; }
 
+    /// Iterator for the instructions inside a block
+    class Iterator {
+      public:
+        /// Constructor
+        /// @param inst the instruction to start iterating from
+        explicit Iterator(Instruction* inst) : inst_(inst) {}
+        ~Iterator() = default;
+
+        /// Dereference operator
+        /// @returns the instruction for this iterator
+        Instruction* operator*() const { return inst_; }
+
+        /// Comparison operator
+        /// @param itr to compare against
+        /// @returns true if this iterator and @p itr point to the same instruction
+        bool operator==(const Iterator& itr) const { return itr.inst_ == inst_; }
+
+        /// Not equal operator
+        /// @param itr to compare against
+        /// @returns true if this iterator and @p itr point to different instructions
+        bool operator!=(const Iterator& itr) const { return !(*this == itr); }
+
+        /// Increment operator
+        /// @returns this iterator advanced to the next element
+        Iterator& operator++() {
+            inst_ = inst_->next;
+            return *this;
+        }
+
+      private:
+        Instruction* inst_ = nullptr;
+    };
+
+    /// @returns the iterator pointing to the start of the instruction list
+    Iterator begin() const { return Iterator{instructions_.first}; }
+
+    /// @returns the ending iterator
+    Iterator end() const { return Iterator{nullptr}; }
+
+    /// Adds the instruction to the beginning of the block
+    /// @param inst the instruction to add
+    void Prepend(Instruction* inst);
     /// Adds the instruction to the end of the block
     /// @param inst the instruction to add
-    void AddInstruction(Instruction* inst);
+    void Append(Instruction* inst);
+    /// Adds the new instruction before the given instruction
+    /// @param before the instruction to insert before
+    /// @param inst the instruction to insert
+    void InsertBefore(Instruction* before, Instruction* inst);
+    /// Adds the new instruction after the given instruction
+    /// @param after the instruction to insert after
+    /// @param inst the instruction to insert
+    void InsertAfter(Instruction* after, Instruction* inst);
+    /// Replaces the target instruction with the new instruction
+    /// @param target the instruction to replace
+    /// @param inst the instruction to insert
+    void Replace(Instruction* target, Instruction* inst);
+    /// Removes the target instruction
+    /// @param inst the instruction to remove
+    void Remove(Instruction* inst);
+
+    /// @returns true if the block contains no instructions
+    bool IsEmpty() const { return Length() == 0; }
+
+    /// @returns the number of instructions in the block
+    size_t Length() const { return instructions_.count; }
 
     /// Sets the params to the block
     /// @param params the params for the block
@@ -73,7 +136,12 @@
     void AddInboundBranch(ir::Branch* node) { inbound_branches_.Push(node); }
 
   private:
-    utils::Vector<const Instruction*, 16> instructions_;
+    struct {
+        Instruction* first = nullptr;
+        Instruction* last = nullptr;
+        size_t count = 0;
+    } instructions_;
+
     utils::Vector<const BlockParam*, 0> params_;
 
     /// The list of branches into this node. This list maybe empty for several
diff --git a/src/tint/ir/block_test.cc b/src/tint/ir/block_test.cc
new file mode 100644
index 0000000..adce60f
--- /dev/null
+++ b/src/tint/ir/block_test.cc
@@ -0,0 +1,668 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/ir/block.h"
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+#include "src/tint/ir/builder.h"
+#include "src/tint/ir/module.h"
+
+namespace tint::ir {
+namespace {
+
+class IR_BlockTest : public ::testing::Test {
+  public:
+    Module mod;
+    Builder b{mod};
+};
+
+TEST_F(IR_BlockTest, SetInstructions) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst1, inst2, inst3});
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Append) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Append(inst1);
+    blk->Append(inst2);
+    blk->Append(inst3);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Prepend) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Prepend(inst3);
+    blk->Prepend(inst2);
+    blk->Prepend(inst1);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, InsertBefore_AtStart) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Append(inst2);
+    blk->InsertBefore(inst2, inst1);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(2u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, InsertBefore_Middle) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Append(inst1);
+    blk->Append(inst3);
+    blk->InsertBefore(inst3, inst2);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, InsertAfter_AtEnd) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Append(inst1);
+    blk->InsertAfter(inst1, inst2);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(2u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, InsertAfter_Middle) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->Append(inst1);
+    blk->Append(inst3);
+    blk->InsertAfter(inst1, inst2);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Replace_Middle) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst3 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst1, inst4, inst3});
+    blk->Replace(inst4, inst2);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    ASSERT_EQ(inst3->Block(), blk);
+    EXPECT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(3u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst3);
+    ASSERT_EQ(inst->prev, inst2);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Replace_Start) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst4, inst2});
+    blk->Replace(inst4, inst1);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    EXPECT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(2u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Replace_End) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst1, inst4});
+    blk->Replace(inst4, inst2);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    ASSERT_EQ(inst2->Block(), blk);
+    EXPECT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(2u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Replace_OnlyNode) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst4});
+    blk->Replace(inst4, inst1);
+
+    ASSERT_EQ(inst1->Block(), blk);
+    EXPECT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(1u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Remove_Middle) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst1, inst4, inst2});
+    blk->Remove(inst4);
+
+    ASSERT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(2u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    inst = inst->next;
+
+    ASSERT_EQ(inst, inst2);
+    ASSERT_EQ(inst->prev, inst1);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Remove_Start) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst4, inst1});
+    blk->Remove(inst4);
+
+    ASSERT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(1u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Remove_End) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst1, inst4});
+    blk->Remove(inst4);
+
+    ASSERT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_FALSE(blk->IsEmpty());
+    EXPECT_EQ(1u, blk->Length());
+
+    auto* inst = blk->Instructions();
+    ASSERT_EQ(inst, inst1);
+    ASSERT_EQ(inst->prev, nullptr);
+    ASSERT_EQ(inst->next, nullptr);
+}
+
+TEST_F(IR_BlockTest, Remove_OnlyNode) {
+    auto* inst4 = b.CreateLoop();
+
+    auto* blk = b.CreateBlock();
+    blk->SetInstructions(utils::Vector{inst4});
+    blk->Remove(inst4);
+
+    ASSERT_EQ(inst4->Block(), nullptr);
+
+    EXPECT_TRUE(blk->IsEmpty());
+    EXPECT_EQ(0u, blk->Length());
+}
+
+TEST_F(IR_BlockTest, Fail_PrependNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* blk = b.CreateBlock();
+            blk->Prepend(nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_PrependAlreadyInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Prepend(inst1);
+
+            blk->Prepend(inst1);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_AppendNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* blk = b.CreateBlock();
+            blk->Append(nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_AppendAlreadyInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Append(inst1);
+            blk->Append(inst1);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertBeforeNullptrInst) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->InsertBefore(nullptr, inst1);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertBeforeInstNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Append(inst1);
+            blk->InsertBefore(inst1, nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertBeforeDifferentBlock) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            auto* blk2 = b.CreateBlock();
+            blk2->Append(inst1);
+            blk1->InsertBefore(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertBeforeAlreadyInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            blk1->Append(inst1);
+            blk1->Append(inst2);
+            blk1->InsertBefore(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertAfterNullptrInst) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->InsertAfter(nullptr, inst1);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertAfterInstNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Append(inst1);
+            blk->InsertAfter(inst1, nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertAfterDifferentBlock) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            auto* blk2 = b.CreateBlock();
+            blk2->Append(inst1);
+            blk1->InsertAfter(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_InsertAfterAlreadyInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            blk1->Append(inst1);
+            blk1->Append(inst2);
+            blk1->InsertAfter(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_ReplaceNullptrInst) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Replace(nullptr, inst1);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_ReplaceInstNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Append(inst1);
+            blk->Replace(inst1, nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_ReplaceDifferentBlock) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            auto* blk2 = b.CreateBlock();
+            blk2->Append(inst1);
+            blk1->Replace(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_ReplaceAlreadyInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            blk1->Append(inst1);
+            blk1->Append(inst2);
+            blk1->Replace(inst1, inst2);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_RemoveNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* blk = b.CreateBlock();
+            blk->Remove(nullptr);
+        },
+        "internal compiler error");
+}
+
+TEST_F(IR_BlockTest, Fail_RemoveDifferentBlock) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk1 = b.CreateBlock();
+            auto* blk2 = b.CreateBlock();
+            blk2->Append(inst1);
+            blk1->Remove(inst1);
+        },
+        "internal compiler error");
+}
+
+}  // namespace
+}  // namespace tint::ir
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index c7155d5..6ca9356 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -70,7 +70,7 @@
 }
 
 void Disassembler::EmitBlockInstructions(const Block* b) {
-    for (const auto* inst : b->Instructions()) {
+    for (const auto* inst : *b) {
         Indent();
         EmitInstruction(inst);
     }
diff --git a/src/tint/ir/discard_test.cc b/src/tint/ir/discard_test.cc
index 054727f..a09c2e9 100644
--- a/src/tint/ir/discard_test.cc
+++ b/src/tint/ir/discard_test.cc
@@ -19,9 +19,9 @@
 namespace tint::ir {
 namespace {
 
-using IR_InstructionTest = TestHelper;
+using IR_DiscardTest = TestHelper;
 
-TEST_F(IR_InstructionTest, Discard) {
+TEST_F(IR_DiscardTest, Discard) {
     Module mod;
     Builder b{mod};
 
diff --git a/src/tint/ir/from_program.cc b/src/tint/ir/from_program.cc
index 4a442ee..a3c36e3 100644
--- a/src/tint/ir/from_program.cc
+++ b/src/tint/ir/from_program.cc
@@ -173,7 +173,7 @@
         TINT_ASSERT(IR, current_block_);
         TINT_ASSERT(IR, !current_block_->HasBranchTarget());
 
-        current_block_->AddInstruction(br);
+        current_block_->Append(br);
         current_block_ = nullptr;
     }
 
@@ -487,7 +487,7 @@
             return;
         }
         auto store = builder_.Store(lhs.Get(), rhs.Get());
-        current_block_->AddInstruction(store);
+        current_block_->Append(store);
     }
 
     void EmitIncrementDecrement(const ast::IncrementDecrementStatement* stmt) {
@@ -498,7 +498,7 @@
 
         // Load from the LHS.
         auto* lhs_value = builder_.Load(lhs.Get());
-        current_block_->AddInstruction(lhs_value);
+        current_block_->Append(lhs_value);
 
         auto* ty = lhs_value->Type();
 
@@ -511,10 +511,10 @@
         } else {
             inst = builder_.Subtract(ty, lhs_value, rhs);
         }
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
 
         auto store = builder_.Store(lhs.Get(), inst);
-        current_block_->AddInstruction(store);
+        current_block_->Append(store);
     }
 
     void EmitCompoundAssignment(const ast::CompoundAssignmentStatement* stmt) {
@@ -530,7 +530,7 @@
 
         // Load from the LHS.
         auto* lhs_value = builder_.Load(lhs.Get());
-        current_block_->AddInstruction(lhs_value);
+        current_block_->Append(lhs_value);
 
         auto* ty = lhs_value->Type();
 
@@ -580,10 +580,10 @@
                 TINT_ICE(IR, diagnostics_) << "missing binary operand type";
                 return;
         }
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
 
         auto store = builder_.Store(lhs.Get(), inst);
-        current_block_->AddInstruction(store);
+        current_block_->Append(store);
     }
 
     void EmitBlock(const ast::BlockStatement* block) {
@@ -603,7 +603,7 @@
             return;
         }
         auto* if_inst = builder_.CreateIf(reg.Get());
-        current_block_->AddInstruction(if_inst);
+        current_block_->Append(if_inst);
 
         {
             ControlStackScope scope(this, if_inst);
@@ -638,7 +638,7 @@
 
     void EmitLoop(const ast::LoopStatement* stmt) {
         auto* loop_inst = builder_.CreateLoop();
-        current_block_->AddInstruction(loop_inst);
+        current_block_->Append(loop_inst);
 
         {
             ControlStackScope scope(this, loop_inst);
@@ -682,7 +682,7 @@
 
     void EmitWhile(const ast::WhileStatement* stmt) {
         auto* loop_inst = builder_.CreateLoop();
-        current_block_->AddInstruction(loop_inst);
+        current_block_->Append(loop_inst);
 
         // Continue is always empty, just go back to the start
         current_block_ = loop_inst->Continuing();
@@ -701,7 +701,7 @@
 
             // Create an `if (cond) {} else {break;}` control flow
             auto* if_inst = builder_.CreateIf(reg.Get());
-            current_block_->AddInstruction(if_inst);
+            current_block_->Append(if_inst);
 
             current_block_ = if_inst->True();
             SetBranch(builder_.ExitIf(if_inst));
@@ -723,7 +723,7 @@
 
     void EmitForLoop(const ast::ForLoopStatement* stmt) {
         auto* loop_inst = builder_.CreateLoop();
-        current_block_->AddInstruction(loop_inst);
+        current_block_->Append(loop_inst);
 
         // Make sure the initializer ends up in a contained scope
         scopes_.Push();
@@ -748,7 +748,7 @@
 
                 // Create an `if (cond) {} else {break;}` control flow
                 auto* if_inst = builder_.CreateIf(reg.Get());
-                current_block_->AddInstruction(if_inst);
+                current_block_->Append(if_inst);
 
                 current_block_ = if_inst->True();
                 SetBranch(builder_.ExitIf(if_inst));
@@ -783,7 +783,7 @@
             return;
         }
         auto* switch_inst = builder_.CreateSwitch(reg.Get());
-        current_block_->AddInstruction(switch_inst);
+        current_block_->Append(switch_inst);
 
         {
             ControlStackScope scope(this, switch_inst);
@@ -856,7 +856,7 @@
     // figuring out the multi-level exit that is triggered.
     void EmitDiscard(const ast::DiscardStatement*) {
         auto* inst = builder_.Discard();
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
     }
 
     void EmitBreakIf(const ast::BreakIfStatement* stmt) {
@@ -914,7 +914,7 @@
         // If this expression maps to sem::Load, insert a load instruction to get the result.
         if (result && sem->Is<sem::Load>()) {
             auto* load = builder_.Load(result.Get());
-            current_block_->AddInstruction(load);
+            current_block_->Append(load);
             return load;
         }
 
@@ -940,7 +940,7 @@
                     }
                     val->SetInitializer(init.Get());
                 }
-                current_block_->AddInstruction(val);
+                current_block_->Append(val);
 
                 if (auto* gv = sem->As<sem::GlobalVariable>(); gv && var->HasBindingPoint()) {
                     val->SetBindingPoint(gv->BindingPoint().value().group,
@@ -1012,7 +1012,7 @@
                 break;
         }
 
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
         return inst;
     }
 
@@ -1036,7 +1036,7 @@
         }
 
         auto* if_inst = builder_.CreateIf(lhs.Get());
-        current_block_->AddInstruction(if_inst);
+        current_block_->Append(if_inst);
 
         auto* result = builder_.BlockParam(builder_.ir.Types().bool_());
         if_inst->Merge()->SetParams(utils::Vector{result});
@@ -1157,7 +1157,7 @@
                 return utils::Failure;
         }
 
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
         return inst;
     }
 
@@ -1171,7 +1171,7 @@
         auto* ty = sem->Type()->Clone(clone_ctx_.type_ctx);
         auto* inst = builder_.Bitcast(ty, val.Get());
 
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
         return inst;
     }
 
@@ -1235,7 +1235,7 @@
         if (inst == nullptr) {
             return utils::Failure;
         }
-        current_block_->AddInstruction(inst);
+        current_block_->Append(inst);
         return inst;
     }
 
diff --git a/src/tint/ir/from_program_binary_test.cc b/src/tint/ir/from_program_binary_test.cc
index 5f7bcb2..2be72e1 100644
--- a/src/tint/ir/from_program_binary_test.cc
+++ b/src/tint/ir/from_program_binary_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramBinaryTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Add) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Add) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Add(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -49,7 +49,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Increment) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Increment) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = Increment("v1");
     WrapInFunction(expr);
@@ -73,7 +73,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundAdd) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundAdd) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kAdd);
     WrapInFunction(expr);
@@ -97,7 +97,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Subtract) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Subtract) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Sub(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -120,7 +120,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Decrement) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Decrement) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.i32());
     auto* expr = Decrement("v1");
     WrapInFunction(expr);
@@ -144,7 +144,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundSubtract) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundSubtract) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kSubtract);
     WrapInFunction(expr);
@@ -168,7 +168,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Multiply) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Multiply) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Mul(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -191,7 +191,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundMultiply) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundMultiply) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kMultiply);
     WrapInFunction(expr);
@@ -215,7 +215,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Div) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Div) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Div(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -238,7 +238,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundDiv) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundDiv) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kDivide);
     WrapInFunction(expr);
@@ -262,7 +262,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Modulo) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Modulo) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Mod(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -285,7 +285,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundModulo) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundModulo) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kModulo);
     WrapInFunction(expr);
@@ -309,7 +309,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_And) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_And) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = And(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -332,7 +332,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundAnd) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundAnd) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.bool_());
     auto* expr = CompoundAssign("v1", false, ast::BinaryOp::kAnd);
     WrapInFunction(expr);
@@ -356,7 +356,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Or) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Or) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Or(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -379,7 +379,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundOr) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundOr) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.bool_());
     auto* expr = CompoundAssign("v1", false, ast::BinaryOp::kOr);
     WrapInFunction(expr);
@@ -403,7 +403,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Xor) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Xor) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Xor(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -426,7 +426,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundXor) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundXor) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kXor);
     WrapInFunction(expr);
@@ -450,7 +450,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LogicalAnd) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_LogicalAnd) {
     Func("my_func", utils::Empty, ty.bool_(), utils::Vector{Return(true)});
     auto* expr = If(LogicalAnd(Call("my_func"), false), Block());
     WrapInFunction(expr);
@@ -502,7 +502,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LogicalOr) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_LogicalOr) {
     Func("my_func", utils::Empty, ty.bool_(), utils::Vector{Return(true)});
     auto* expr = If(LogicalOr(Call("my_func"), true), Block());
     WrapInFunction(expr);
@@ -554,7 +554,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Equal) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Equal) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Equal(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -577,7 +577,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_NotEqual) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_NotEqual) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = NotEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -600,7 +600,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LessThan) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_LessThan) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = LessThan(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -623,7 +623,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_GreaterThan) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_GreaterThan) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = GreaterThan(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -646,7 +646,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_LessThanEqual) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_LessThanEqual) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = LessThanEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -669,7 +669,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_GreaterThanEqual) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_GreaterThanEqual) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = GreaterThanEqual(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -692,7 +692,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_ShiftLeft) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_ShiftLeft) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Shl(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -715,7 +715,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundShiftLeft) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundShiftLeft) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kShiftLeft);
     WrapInFunction(expr);
@@ -739,7 +739,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_ShiftRight) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_ShiftRight) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(0_u)});
     auto* expr = Shr(Call("my_func"), 4_u);
     WrapInFunction(expr);
@@ -762,7 +762,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_CompoundShiftRight) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_CompoundShiftRight) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.u32());
     auto* expr = CompoundAssign("v1", 1_u, ast::BinaryOp::kShiftRight);
     WrapInFunction(expr);
@@ -786,7 +786,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Compound) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Compound) {
     Func("my_func", utils::Empty, ty.f32(), utils::Vector{Return(0_f)});
 
     auto* expr = LogicalAnd(LessThan(Call("my_func"), 2_f),
@@ -831,7 +831,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Binary_Compound_WithConstEval) {
+TEST_F(IR_FromProgramBinaryTest, EmitExpression_Binary_Compound_WithConstEval) {
     Func("my_func", utils::Vector{Param("p", ty.bool_())}, ty.bool_(), utils::Vector{Return(true)});
     auto* expr = Call("my_func", LogicalAnd(LessThan(2.4_f, 2_f),
                                             GreaterThan(2.5_f, Div(10_f, Mul(2.3_f, 9.4_f)))));
diff --git a/src/tint/ir/from_program_builtin_test.cc b/src/tint/ir/from_program_builtin_test.cc
index 4d21b48..7eafa17 100644
--- a/src/tint/ir/from_program_builtin_test.cc
+++ b/src/tint/ir/from_program_builtin_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramBuiltinTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Builtin) {
+TEST_F(IR_FromProgramBuiltinTest, EmitExpression_Builtin) {
     auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_f));
     auto* expr = Call("asin", i);
     WrapInFunction(expr);
diff --git a/src/tint/ir/from_program_call_test.cc b/src/tint/ir/from_program_call_test.cc
index d305855..1aa224c 100644
--- a/src/tint/ir/from_program_call_test.cc
+++ b/src/tint/ir/from_program_call_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramCallTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Bitcast) {
+TEST_F(IR_FromProgramCallTest, EmitExpression_Bitcast) {
     Func("my_func", utils::Empty, ty.f32(), utils::Vector{Return(0_f)});
 
     auto* expr = Bitcast<f32>(Call("my_func"));
@@ -50,7 +50,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitStatement_Discard) {
+TEST_F(IR_FromProgramCallTest, EmitStatement_Discard) {
     auto* expr = Discard();
     Func("test_function", {}, ty.void_(), expr,
          utils::Vector{
@@ -69,7 +69,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitStatement_UserFunction) {
+TEST_F(IR_FromProgramCallTest, EmitStatement_UserFunction) {
     Func("my_func", utils::Vector{Param("p", ty.f32())}, ty.void_(), utils::Empty);
 
     auto* stmt = CallStmt(Call("my_func", Mul(2_a, 3_a)));
@@ -91,7 +91,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Convert) {
+TEST_F(IR_FromProgramCallTest, EmitExpression_Convert) {
     auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_i));
     auto* expr = Call(ty.f32(), i);
     WrapInFunction(expr);
@@ -114,7 +114,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_ConstructEmpty) {
+TEST_F(IR_FromProgramCallTest, EmitExpression_ConstructEmpty) {
     auto* expr = vec3(ty.f32());
     GlobalVar("i", builtin::AddressSpace::kPrivate, expr);
 
@@ -129,7 +129,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Construct) {
+TEST_F(IR_FromProgramCallTest, EmitExpression_Construct) {
     auto i = GlobalVar("i", builtin::AddressSpace::kPrivate, Expr(1_f));
     auto* expr = vec3(ty.f32(), 2_f, 3_f, i);
     WrapInFunction(expr);
diff --git a/src/tint/ir/from_program_function_test.cc b/src/tint/ir/from_program_function_test.cc
index 57e78a3..a130281 100644
--- a/src/tint/ir/from_program_function_test.cc
+++ b/src/tint/ir/from_program_function_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramFunctionTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitFunction_Vertex) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_Vertex) {
     Func("test", utils::Empty, ty.vec4<f32>(), utils::Vector{Return(vec4<f32>(0_f, 0_f, 0_f, 0_f))},
          utils::Vector{Stage(ast::PipelineStage::kVertex)},
          utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
@@ -42,7 +42,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_Fragment) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_Fragment) {
     Func("test", utils::Empty, ty.void_(), utils::Empty,
          utils::Vector{Stage(ast::PipelineStage::kFragment)});
 
@@ -57,7 +57,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_Compute) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_Compute) {
     Func("test", utils::Empty, ty.void_(), utils::Empty,
          utils::Vector{Stage(ast::PipelineStage::kCompute), WorkgroupSize(8_i, 4_i, 2_i)});
 
@@ -73,7 +73,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_Return) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_Return) {
     Func("test", utils::Empty, ty.vec3<f32>(), utils::Vector{Return(vec3<f32>(0_f, 0_f, 0_f))},
          utils::Empty);
 
@@ -88,7 +88,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnPosition) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnPosition) {
     Func("test", utils::Empty, ty.vec4<f32>(), utils::Vector{Return(vec4<f32>(1_f, 2_f, 3_f, 4_f))},
          utils::Vector{Stage(ast::PipelineStage::kVertex)},
          utils::Vector{Builtin(builtin::BuiltinValue::kPosition)});
@@ -104,7 +104,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnPositionInvariant) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnPositionInvariant) {
     Func("test", utils::Empty, ty.vec4<f32>(), utils::Vector{Return(vec4<f32>(1_f, 2_f, 3_f, 4_f))},
          utils::Vector{Stage(ast::PipelineStage::kVertex)},
          utils::Vector{Builtin(builtin::BuiltinValue::kPosition), Invariant()});
@@ -121,7 +121,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnLocation) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnLocation) {
     Func("test", utils::Empty, ty.vec4<f32>(), utils::Vector{Return(vec4<f32>(1_f, 2_f, 3_f, 4_f))},
          utils::Vector{Stage(ast::PipelineStage::kFragment)}, utils::Vector{Location(1_i)});
 
@@ -137,7 +137,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnLocation_Interpolate) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnLocation_Interpolate) {
     Func("test", utils::Empty, ty.vec4<f32>(), utils::Vector{Return(vec4<f32>(1_f, 2_f, 3_f, 4_f))},
          utils::Vector{Stage(ast::PipelineStage::kFragment)},
          utils::Vector{Location(1_i), Interpolate(builtin::InterpolationType::kLinear,
@@ -156,7 +156,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnFragDepth) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnFragDepth) {
     Func("test", utils::Empty, ty.f32(), utils::Vector{Return(1_f)},
          utils::Vector{Stage(ast::PipelineStage::kFragment)},
          utils::Vector{Builtin(builtin::BuiltinValue::kFragDepth)});
@@ -172,7 +172,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitFunction_ReturnSampleMask) {
+TEST_F(IR_FromProgramFunctionTest, EmitFunction_ReturnSampleMask) {
     Func("test", utils::Empty, ty.u32(), utils::Vector{Return(1_u)},
          utils::Vector{Stage(ast::PipelineStage::kFragment)},
          utils::Vector{Builtin(builtin::BuiltinValue::kSampleMask)});
diff --git a/src/tint/ir/from_program_literal_test.cc b/src/tint/ir/from_program_literal_test.cc
index f746bc0..1ea9706 100644
--- a/src/tint/ir/from_program_literal_test.cc
+++ b/src/tint/ir/from_program_literal_test.cc
@@ -26,13 +26,13 @@
 namespace {
 
 const Value* GlobalVarInitializer(const Module& m) {
-    const auto instr = m.root_block->Instructions();
-
-    if (instr.Length() == 0u) {
+    if (m.root_block->Length() == 0u) {
         ADD_FAILURE() << "m.root_block has no instruction";
         return nullptr;
     }
-    auto* var = instr[0]->As<ir::Var>();
+
+    const auto instr = m.root_block->Instructions();
+    auto* var = instr->As<ir::Var>();
     if (!var) {
         ADD_FAILURE() << "m.root_block.instructions[0] was not a var";
         return nullptr;
@@ -42,9 +42,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramLiteralTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_True) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_Bool_True) {
     auto* expr = Expr(true);
     GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, expr);
 
@@ -58,7 +58,7 @@
     EXPECT_TRUE(val->As<constant::Scalar<bool>>()->ValueAs<bool>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_False) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_Bool_False) {
     auto* expr = Expr(false);
     GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, expr);
 
@@ -72,7 +72,7 @@
     EXPECT_FALSE(val->As<constant::Scalar<bool>>()->ValueAs<bool>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_Bool_Deduped) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_Bool_Deduped) {
     GlobalVar("a", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(true));
     GlobalVar("b", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(false));
     GlobalVar("c", ty.bool_(), builtin::AddressSpace::kPrivate, Expr(true));
@@ -81,14 +81,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    auto instr = m.Get().root_block->Instructions();
-    auto* var_a = instr[0]->As<ir::Var>();
+    auto itr = m.Get().root_block->begin();
+    auto* var_a = (*itr)->As<ir::Var>();
+    ++itr;
+
     ASSERT_NE(var_a, nullptr);
-    auto* var_b = instr[1]->As<ir::Var>();
+    auto* var_b = (*itr)->As<ir::Var>();
+    ++itr;
+
     ASSERT_NE(var_b, nullptr);
-    auto* var_c = instr[2]->As<ir::Var>();
+    auto* var_c = (*itr)->As<ir::Var>();
+    ++itr;
+
     ASSERT_NE(var_c, nullptr);
-    auto* var_d = instr[3]->As<ir::Var>();
+    auto* var_d = (*itr)->As<ir::Var>();
     ASSERT_NE(var_d, nullptr);
 
     ASSERT_EQ(var_a->Initializer(), var_c->Initializer());
@@ -96,7 +102,7 @@
     ASSERT_NE(var_a->Initializer(), var_b->Initializer());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_F32) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_F32) {
     auto* expr = Expr(1.2_f);
     GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, expr);
 
@@ -110,7 +116,7 @@
     EXPECT_EQ(1.2_f, val->As<constant::Scalar<f32>>()->ValueAs<f32>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_F32_Deduped) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_F32_Deduped) {
     GlobalVar("a", ty.f32(), builtin::AddressSpace::kPrivate, Expr(1.2_f));
     GlobalVar("b", ty.f32(), builtin::AddressSpace::kPrivate, Expr(1.25_f));
     GlobalVar("c", ty.f32(), builtin::AddressSpace::kPrivate, Expr(1.2_f));
@@ -118,19 +124,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    auto instr = m.Get().root_block->Instructions();
-    auto* var_a = instr[0]->As<ir::Var>();
+    auto itr = m.Get().root_block->begin();
+    auto* var_a = (*itr)->As<ir::Var>();
     ASSERT_NE(var_a, nullptr);
-    auto* var_b = instr[1]->As<ir::Var>();
+    ++itr;
+
+    auto* var_b = (*itr)->As<ir::Var>();
     ASSERT_NE(var_b, nullptr);
-    auto* var_c = instr[2]->As<ir::Var>();
+    ++itr;
+
+    auto* var_c = (*itr)->As<ir::Var>();
     ASSERT_NE(var_c, nullptr);
 
     ASSERT_EQ(var_a->Initializer(), var_c->Initializer());
     ASSERT_NE(var_a->Initializer(), var_b->Initializer());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_F16) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_F16) {
     Enable(builtin::Extension::kF16);
     auto* expr = Expr(1.2_h);
     GlobalVar("a", ty.f16(), builtin::AddressSpace::kPrivate, expr);
@@ -145,7 +155,7 @@
     EXPECT_EQ(1.2_h, val->As<constant::Scalar<f16>>()->ValueAs<f32>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_F16_Deduped) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_F16_Deduped) {
     Enable(builtin::Extension::kF16);
     GlobalVar("a", ty.f16(), builtin::AddressSpace::kPrivate, Expr(1.2_h));
     GlobalVar("b", ty.f16(), builtin::AddressSpace::kPrivate, Expr(1.25_h));
@@ -154,19 +164,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    auto instr = m.Get().root_block->Instructions();
-    auto* var_a = instr[0]->As<ir::Var>();
+    auto itr = m.Get().root_block->begin();
+    auto* var_a = (*itr)->As<ir::Var>();
     ASSERT_NE(var_a, nullptr);
-    auto* var_b = instr[1]->As<ir::Var>();
+    ++itr;
+
+    auto* var_b = (*itr)->As<ir::Var>();
     ASSERT_NE(var_b, nullptr);
-    auto* var_c = instr[2]->As<ir::Var>();
+    ++itr;
+
+    auto* var_c = (*itr)->As<ir::Var>();
     ASSERT_NE(var_c, nullptr);
 
     ASSERT_EQ(var_a->Initializer(), var_c->Initializer());
     ASSERT_NE(var_a->Initializer(), var_b->Initializer());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_I32) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_I32) {
     auto* expr = Expr(-2_i);
     GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate, expr);
 
@@ -180,7 +194,7 @@
     EXPECT_EQ(-2_i, val->As<constant::Scalar<i32>>()->ValueAs<f32>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_I32_Deduped) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_I32_Deduped) {
     GlobalVar("a", ty.i32(), builtin::AddressSpace::kPrivate, Expr(-2_i));
     GlobalVar("b", ty.i32(), builtin::AddressSpace::kPrivate, Expr(2_i));
     GlobalVar("c", ty.i32(), builtin::AddressSpace::kPrivate, Expr(-2_i));
@@ -188,19 +202,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    auto instr = m.Get().root_block->Instructions();
-    auto* var_a = instr[0]->As<ir::Var>();
+    auto itr = m.Get().root_block->begin();
+    auto* var_a = (*itr)->As<ir::Var>();
     ASSERT_NE(var_a, nullptr);
-    auto* var_b = instr[1]->As<ir::Var>();
+    ++itr;
+
+    auto* var_b = (*itr)->As<ir::Var>();
     ASSERT_NE(var_b, nullptr);
-    auto* var_c = instr[2]->As<ir::Var>();
+    ++itr;
+
+    auto* var_c = (*itr)->As<ir::Var>();
     ASSERT_NE(var_c, nullptr);
 
     ASSERT_EQ(var_a->Initializer(), var_c->Initializer());
     ASSERT_NE(var_a->Initializer(), var_b->Initializer());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_U32) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_U32) {
     auto* expr = Expr(2_u);
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate, expr);
 
@@ -214,7 +232,7 @@
     EXPECT_EQ(2_u, val->As<constant::Scalar<u32>>()->ValueAs<f32>());
 }
 
-TEST_F(IR_BuilderImplTest, EmitLiteral_U32_Deduped) {
+TEST_F(IR_FromProgramLiteralTest, EmitLiteral_U32_Deduped) {
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate, Expr(2_u));
     GlobalVar("b", ty.u32(), builtin::AddressSpace::kPrivate, Expr(3_u));
     GlobalVar("c", ty.u32(), builtin::AddressSpace::kPrivate, Expr(2_u));
@@ -222,12 +240,16 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    auto instr = m.Get().root_block->Instructions();
-    auto* var_a = instr[0]->As<ir::Var>();
+    auto itr = m.Get().root_block->begin();
+    auto* var_a = (*itr)->As<ir::Var>();
     ASSERT_NE(var_a, nullptr);
-    auto* var_b = instr[1]->As<ir::Var>();
+    ++itr;
+
+    auto* var_b = (*itr)->As<ir::Var>();
     ASSERT_NE(var_b, nullptr);
-    auto* var_c = instr[2]->As<ir::Var>();
+    ++itr;
+
+    auto* var_c = (*itr)->As<ir::Var>();
     ASSERT_NE(var_c, nullptr);
 
     ASSERT_EQ(var_a->Initializer(), var_c->Initializer());
diff --git a/src/tint/ir/from_program_materialize_test.cc b/src/tint/ir/from_program_materialize_test.cc
index 1262579..07b49c1 100644
--- a/src/tint/ir/from_program_materialize_test.cc
+++ b/src/tint/ir/from_program_materialize_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramMaterializeTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitExpression_MaterializedCall) {
+TEST_F(IR_FromProgramMaterializeTest, EmitExpression_MaterializedCall) {
     auto* expr = Return(Call("trunc", 2.5_f));
 
     Func("test_function", {}, ty.f32(), expr, utils::Empty);
diff --git a/src/tint/ir/from_program_store_test.cc b/src/tint/ir/from_program_store_test.cc
index 20ea290..daeed37 100644
--- a/src/tint/ir/from_program_store_test.cc
+++ b/src/tint/ir/from_program_store_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramStoreTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitStatement_Assign) {
+TEST_F(IR_FromProgramStoreTest, EmitStatement_Assign) {
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate);
 
     auto* expr = Assign("a", 4_u);
diff --git a/src/tint/ir/from_program_test.cc b/src/tint/ir/from_program_test.cc
index 404b6c3..d7825c5 100644
--- a/src/tint/ir/from_program_test.cc
+++ b/src/tint/ir/from_program_test.cc
@@ -51,9 +51,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, Func) {
+TEST_F(IR_FromProgramTest, Func) {
     Func("f", utils::Empty, ty.void_(), utils::Empty);
 
     auto m = Build();
@@ -74,7 +74,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithParam) {
+TEST_F(IR_FromProgramTest, Func_WithParam) {
     Func("f", utils::Vector{Param("a", ty.u32())}, ty.u32(), utils::Vector{Return("a")});
 
     auto m = Build();
@@ -95,7 +95,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithMultipleParam) {
+TEST_F(IR_FromProgramTest, Func_WithMultipleParam) {
     Func("f", utils::Vector{Param("a", ty.u32()), Param("b", ty.i32()), Param("c", ty.bool_())},
          ty.void_(), utils::Empty);
 
@@ -117,7 +117,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EntryPoint) {
+TEST_F(IR_FromProgramTest, EntryPoint) {
     Func("f", utils::Empty, ty.void_(), utils::Empty,
          utils::Vector{Stage(ast::PipelineStage::kFragment)});
 
@@ -127,7 +127,7 @@
     EXPECT_EQ(m->functions[0]->Stage(), Function::PipelineStage::kFragment);
 }
 
-TEST_F(IR_BuilderImplTest, IfStatement) {
+TEST_F(IR_FromProgramTest, IfStatement) {
     auto* ast_if = If(true, Block(), Else(Block()));
     WrapInFunction(ast_if);
 
@@ -167,7 +167,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, IfStatement_TrueReturns) {
+TEST_F(IR_FromProgramTest, IfStatement_TrueReturns) {
     auto* ast_if = If(true, Block(Return()));
     WrapInFunction(ast_if);
 
@@ -207,7 +207,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, IfStatement_FalseReturns) {
+TEST_F(IR_FromProgramTest, IfStatement_FalseReturns) {
     auto* ast_if = If(true, Block(), Else(Block(Return())));
     WrapInFunction(ast_if);
 
@@ -247,7 +247,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, IfStatement_BothReturn) {
+TEST_F(IR_FromProgramTest, IfStatement_BothReturn) {
     auto* ast_if = If(true, Block(Return()), Else(Block(Return())));
     WrapInFunction(ast_if);
 
@@ -282,7 +282,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, IfStatement_JumpChainToMerge) {
+TEST_F(IR_FromProgramTest, IfStatement_JumpChainToMerge) {
     auto* ast_loop = Loop(Block(Break()));
     auto* ast_if = If(true, Block(ast_loop));
     WrapInFunction(ast_if);
@@ -330,7 +330,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithBreak) {
+TEST_F(IR_FromProgramTest, Loop_WithBreak) {
     auto* ast_loop = Loop(Block(Break()));
     WrapInFunction(ast_loop);
 
@@ -342,7 +342,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
 
@@ -364,7 +364,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithContinue) {
+TEST_F(IR_FromProgramTest, Loop_WithContinue) {
     auto* ast_if = If(true, Block(Break()));
     auto* ast_loop = Loop(Block(ast_if, Continue()));
     WrapInFunction(ast_loop);
@@ -379,7 +379,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(2u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -424,7 +424,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithContinuing_BreakIf) {
+TEST_F(IR_FromProgramTest, Loop_WithContinuing_BreakIf) {
     auto* ast_break_if = BreakIf(true);
     auto* ast_loop = Loop(Block(), Block(ast_break_if));
     WrapInFunction(ast_loop);
@@ -437,7 +437,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(2u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -464,7 +464,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_Continuing_Body_Scope) {
+TEST_F(IR_FromProgramTest, Loop_Continuing_Body_Scope) {
     auto* a = Decl(Let("a", Expr(true)));
     auto* ast_break_if = BreakIf("a");
     auto* ast_loop = Loop(Block(a), Block(ast_break_if));
@@ -497,7 +497,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithReturn) {
+TEST_F(IR_FromProgramTest, Loop_WithReturn) {
     auto* ast_if = If(true, Block(Return()));
     auto* ast_loop = Loop(Block(ast_if, Continue()));
     WrapInFunction(ast_loop);
@@ -511,7 +511,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(2u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -551,7 +551,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithOnlyReturn) {
+TEST_F(IR_FromProgramTest, Loop_WithOnlyReturn) {
     auto* ast_loop = Loop(Block(Return(), Continue()));
     WrapInFunction(ast_loop, If(true, Block(Return())));
 
@@ -563,7 +563,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -580,7 +580,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithOnlyReturn_ContinuingBreakIf) {
+TEST_F(IR_FromProgramTest, Loop_WithOnlyReturn_ContinuingBreakIf) {
     // Note, even though there is code in the loop merge (specifically, the
     // `ast_if` below), it doesn't get emitted as there is no way to reach the
     // loop merge due to the loop itself doing a `return`. This is why the
@@ -601,7 +601,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -618,7 +618,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_WithIf_BothBranchesBreak) {
+TEST_F(IR_FromProgramTest, Loop_WithIf_BothBranchesBreak) {
     auto* ast_if = If(true, Block(Break()), Else(Block(Break())));
     auto* ast_loop = Loop(Block(ast_if, Continue()));
     WrapInFunction(ast_loop);
@@ -632,7 +632,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(2u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -667,7 +667,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Loop_Nested) {
+TEST_F(IR_FromProgramTest, Loop_Nested) {
     auto* ast_if_a = If(true, Block(Break()));
     auto* ast_if_b = If(true, Block(Continue()));
     auto* ast_if_c = BreakIf(true);
@@ -789,7 +789,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, While) {
+TEST_F(IR_FromProgramTest, While) {
     auto* ast_while = While(false, Block());
     WrapInFunction(ast_while);
 
@@ -805,7 +805,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(2u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -850,7 +850,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, While_Return) {
+TEST_F(IR_FromProgramTest, While_Return) {
     auto* ast_while = While(true, Block(Return()));
     WrapInFunction(ast_while);
 
@@ -866,7 +866,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(2u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -912,7 +912,7 @@
 }
 
 // TODO(dsinclair): Enable when variable declarations and increment are supported
-TEST_F(IR_BuilderImplTest, DISABLED_For) {
+TEST_F(IR_FromProgramTest, DISABLED_For) {
     // for(var i: 0; i < 10; i++) {
     // }
     //
@@ -950,7 +950,7 @@
     EXPECT_EQ(Disassemble(m), R"()");
 }
 
-TEST_F(IR_BuilderImplTest, For_NoInitCondOrContinuing) {
+TEST_F(IR_FromProgramTest, For_NoInitCondOrContinuing) {
     auto* ast_for = For(nullptr, nullptr, nullptr, Block(Break()));
     WrapInFunction(ast_for);
 
@@ -962,7 +962,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, flow->Body()->InboundBranches().Length());
+    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
 
@@ -984,7 +984,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Switch) {
+TEST_F(IR_FromProgramTest, Switch) {
     auto* ast_switch = Switch(
         1_i, utils::Vector{Case(utils::Vector{CaseSelector(0_i)}, Block()),
                            Case(utils::Vector{CaseSelector(1_i)}, Block()), DefaultCase(Block())});
@@ -1049,7 +1049,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Switch_MultiSelector) {
+TEST_F(IR_FromProgramTest, Switch_MultiSelector) {
     auto* ast_switch = Switch(
         1_i,
         utils::Vector{Case(
@@ -1100,7 +1100,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Switch_OnlyDefault) {
+TEST_F(IR_FromProgramTest, Switch_OnlyDefault) {
     auto* ast_switch = Switch(1_i, utils::Vector{DefaultCase(Block())});
     WrapInFunction(ast_switch);
 
@@ -1139,7 +1139,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Switch_WithBreak) {
+TEST_F(IR_FromProgramTest, Switch_WithBreak) {
     auto* ast_switch = Switch(1_i, utils::Vector{Case(utils::Vector{CaseSelector(0_i)},
                                                       Block(Break(), If(true, Block(Return())))),
                                                  DefaultCase(Block())});
@@ -1192,7 +1192,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Switch_AllReturn) {
+TEST_F(IR_FromProgramTest, Switch_AllReturn) {
     auto* ast_switch =
         Switch(1_i, utils::Vector{Case(utils::Vector{CaseSelector(0_i)}, Block(Return())),
                                   DefaultCase(Block(Return()))});
@@ -1242,7 +1242,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_Phony) {
+TEST_F(IR_FromProgramTest, Emit_Phony) {
     Func("b", utils::Empty, ty.i32(), Return(1_i));
     WrapInFunction(Ignore(Call("b")));
 
@@ -1264,7 +1264,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithParam_WithAttribute_Invariant) {
+TEST_F(IR_FromProgramTest, Func_WithParam_WithAttribute_Invariant) {
     Func(
         "f",
         utils::Vector{Param("a", ty.vec4<f32>(),
@@ -1284,7 +1284,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithParam_WithAttribute_Location) {
+TEST_F(IR_FromProgramTest, Func_WithParam_WithAttribute_Location) {
     Func("f", utils::Vector{Param("a", ty.f32(), utils::Vector{Location(2_i)})}, ty.f32(),
          utils::Vector{Return("a")}, utils::Vector{Stage(ast::PipelineStage::kFragment)},
          utils::Vector{Location(1_i)});
@@ -1301,7 +1301,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithParam_WithAttribute_Location_WithInterpolation_LinearCentroid) {
+TEST_F(IR_FromProgramTest, Func_WithParam_WithAttribute_Location_WithInterpolation_LinearCentroid) {
     Func("f",
          utils::Vector{Param(
              "a", ty.f32(),
@@ -1323,7 +1323,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Func_WithParam_WithAttribute_Location_WithInterpolation_Flat) {
+TEST_F(IR_FromProgramTest, Func_WithParam_WithAttribute_Location_WithInterpolation_Flat) {
     Func("f",
          utils::Vector{
              Param("a", ty.f32(),
diff --git a/src/tint/ir/from_program_unary_test.cc b/src/tint/ir/from_program_unary_test.cc
index b83e5d5..a7af3dd 100644
--- a/src/tint/ir/from_program_unary_test.cc
+++ b/src/tint/ir/from_program_unary_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramUnaryTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Unary_Not) {
+TEST_F(IR_FromProgramUnaryTest, EmitExpression_Unary_Not) {
     Func("my_func", utils::Empty, ty.bool_(), utils::Vector{Return(false)});
     auto* expr = Not(Call("my_func"));
     WrapInFunction(expr);
@@ -49,7 +49,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Unary_Complement) {
+TEST_F(IR_FromProgramUnaryTest, EmitExpression_Unary_Complement) {
     Func("my_func", utils::Empty, ty.u32(), utils::Vector{Return(1_u)});
     auto* expr = Complement(Call("my_func"));
     WrapInFunction(expr);
@@ -72,7 +72,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Unary_Negation) {
+TEST_F(IR_FromProgramUnaryTest, EmitExpression_Unary_Negation) {
     Func("my_func", utils::Empty, ty.i32(), utils::Vector{Return(1_i)});
     auto* expr = Negation(Call("my_func"));
     WrapInFunction(expr);
@@ -95,7 +95,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Unary_AddressOf) {
+TEST_F(IR_FromProgramUnaryTest, EmitExpression_Unary_AddressOf) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.i32());
 
     auto* expr = Decl(Let("v2", AddressOf("v1")));
@@ -117,7 +117,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, EmitExpression_Unary_Indirection) {
+TEST_F(IR_FromProgramUnaryTest, EmitExpression_Unary_Indirection) {
     GlobalVar("v1", builtin::AddressSpace::kPrivate, ty.i32());
     utils::Vector stmts = {
         Decl(Let("v3", AddressOf("v1"))),
diff --git a/src/tint/ir/from_program_var_test.cc b/src/tint/ir/from_program_var_test.cc
index 91b8b8f..5f6e78c 100644
--- a/src/tint/ir/from_program_var_test.cc
+++ b/src/tint/ir/from_program_var_test.cc
@@ -24,9 +24,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_BuilderImplTest = TestHelper;
+using IR_FromProgramVarTest = TestHelper;
 
-TEST_F(IR_BuilderImplTest, Emit_GlobalVar_NoInit) {
+TEST_F(IR_FromProgramVarTest, Emit_GlobalVar_NoInit) {
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate);
 
     auto m = Build();
@@ -40,7 +40,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_GlobalVar_Init) {
+TEST_F(IR_FromProgramVarTest, Emit_GlobalVar_Init) {
     auto* expr = Expr(2_u);
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kPrivate, expr);
 
@@ -55,7 +55,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_GlobalVar_GroupBinding) {
+TEST_F(IR_FromProgramVarTest, Emit_GlobalVar_GroupBinding) {
     GlobalVar("a", ty.u32(), builtin::AddressSpace::kStorage,
               utils::Vector{Group(2_u), Binding(3_u)});
 
@@ -70,7 +70,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_Var_NoInit) {
+TEST_F(IR_FromProgramVarTest, Emit_Var_NoInit) {
     auto* a = Var("a", ty.u32(), builtin::AddressSpace::kFunction);
     WrapInFunction(a);
 
@@ -87,7 +87,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_Var_Init_Constant) {
+TEST_F(IR_FromProgramVarTest, Emit_Var_Init_Constant) {
     auto* expr = Expr(2_u);
     auto* a = Var("a", ty.u32(), builtin::AddressSpace::kFunction, expr);
     WrapInFunction(a);
@@ -105,7 +105,7 @@
 )");
 }
 
-TEST_F(IR_BuilderImplTest, Emit_Var_Init_NonConstant) {
+TEST_F(IR_FromProgramVarTest, Emit_Var_Init_NonConstant) {
     auto* a = Var("a", ty.u32(), builtin::AddressSpace::kFunction);
     auto* b = Var("b", ty.u32(), builtin::AddressSpace::kFunction, Add("a", 2_u));
     WrapInFunction(a, b);
diff --git a/src/tint/ir/instruction.cc b/src/tint/ir/instruction.cc
index e54b13f..22e3904 100644
--- a/src/tint/ir/instruction.cc
+++ b/src/tint/ir/instruction.cc
@@ -14,6 +14,9 @@
 
 #include "src/tint/ir/instruction.h"
 
+#include "src/tint/debug.h"
+#include "src/tint/ir/block.h"
+
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Instruction);
 
 namespace tint::ir {
@@ -22,4 +25,27 @@
 
 Instruction::~Instruction() = default;
 
+void Instruction::InsertBefore(Instruction* before) {
+    TINT_ASSERT_OR_RETURN(IR, before);
+    TINT_ASSERT_OR_RETURN(IR, before->Block() != nullptr);
+    before->Block()->InsertBefore(before, this);
+}
+
+void Instruction::InsertAfter(Instruction* after) {
+    TINT_ASSERT_OR_RETURN(IR, after);
+    TINT_ASSERT_OR_RETURN(IR, after->Block() != nullptr);
+    after->Block()->InsertAfter(after, this);
+}
+
+void Instruction::Replace(Instruction* replacement) {
+    TINT_ASSERT_OR_RETURN(IR, replacement);
+    TINT_ASSERT_OR_RETURN(IR, Block() != nullptr);
+    Block()->Replace(this, replacement);
+}
+
+void Instruction::Remove() {
+    TINT_ASSERT_OR_RETURN(IR, Block() != nullptr);
+    Block()->Remove(this);
+}
+
 }  // namespace tint::ir
diff --git a/src/tint/ir/instruction.h b/src/tint/ir/instruction.h
index 13bcc00..a79b3da 100644
--- a/src/tint/ir/instruction.h
+++ b/src/tint/ir/instruction.h
@@ -37,10 +37,26 @@
 
     /// @returns the block that owns this instruction
     ir::Block* Block() { return block_; }
-
     /// @returns the block that owns this instruction
     const ir::Block* Block() const { return block_; }
 
+    /// Adds the new instruction before the given instruction in the owning block
+    /// @param before the instruction to insert before
+    void InsertBefore(Instruction* before);
+    /// Adds the new instruction after the given instruction in the owning block
+    /// @param after the instruction to insert after
+    void InsertAfter(Instruction* after);
+    /// Replaces this instruction with @p replacement in the owning block owning this instruction
+    /// @param replacement the instruction to replace with
+    void Replace(Instruction* replacement);
+    /// Removes this instruction from the owning block
+    void Remove();
+
+    /// Pointer to the next instruction in the list
+    Instruction* next = nullptr;
+    /// Pointer to the previous instruction in the list
+    Instruction* prev = nullptr;
+
   protected:
     /// Constructor
     Instruction();
diff --git a/src/tint/ir/instruction_test.cc b/src/tint/ir/instruction_test.cc
new file mode 100644
index 0000000..3fb8ab0
--- /dev/null
+++ b/src/tint/ir/instruction_test.cc
@@ -0,0 +1,162 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+#include "src/tint/ir/block.h"
+#include "src/tint/ir/builder.h"
+#include "src/tint/ir/module.h"
+
+namespace tint::ir {
+namespace {
+
+class IR_InstructionTest : public ::testing::Test {
+  public:
+    Module mod;
+    Builder b{mod};
+};
+
+TEST_F(IR_InstructionTest, InsertBefore) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* blk = b.CreateBlock();
+    blk->Append(inst2);
+    inst1->InsertBefore(inst2);
+    EXPECT_EQ(2u, blk->Length());
+    EXPECT_EQ(inst1->Block(), blk);
+}
+
+TEST_F(IR_InstructionTest, Fail_InsertBeforeNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            inst1->InsertBefore(nullptr);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, Fail_InsertBeforeNotInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            inst1->InsertBefore(inst2);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, InsertAfter) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* blk = b.CreateBlock();
+    blk->Append(inst2);
+    inst1->InsertAfter(inst2);
+    EXPECT_EQ(2u, blk->Length());
+    EXPECT_EQ(inst1->Block(), blk);
+}
+
+TEST_F(IR_InstructionTest, Fail_InsertAfterNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            inst1->InsertAfter(nullptr);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, Fail_InsertAfterNotInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            inst1->InsertAfter(inst2);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, Replace) {
+    auto* inst1 = b.CreateLoop();
+    auto* inst2 = b.CreateLoop();
+    auto* blk = b.CreateBlock();
+    blk->Append(inst2);
+    inst2->Replace(inst1);
+    EXPECT_EQ(1u, blk->Length());
+    EXPECT_EQ(inst1->Block(), blk);
+    EXPECT_EQ(inst2->Block(), nullptr);
+}
+
+TEST_F(IR_InstructionTest, Fail_ReplaceNullptr) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* blk = b.CreateBlock();
+            blk->Append(inst1);
+            inst1->Replace(nullptr);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, Fail_ReplaceNotInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            auto* inst2 = b.CreateLoop();
+            inst1->Replace(inst2);
+        },
+        "");
+}
+
+TEST_F(IR_InstructionTest, Remove) {
+    auto* inst1 = b.CreateLoop();
+    auto* blk = b.CreateBlock();
+    blk->Append(inst1);
+    EXPECT_EQ(1u, blk->Length());
+
+    inst1->Remove();
+    EXPECT_EQ(0u, blk->Length());
+    EXPECT_EQ(inst1->Block(), nullptr);
+}
+
+TEST_F(IR_InstructionTest, Fail_RemoveNotInserted) {
+    EXPECT_FATAL_FAILURE(
+        {
+            Module mod;
+            Builder b{mod};
+
+            auto* inst1 = b.CreateLoop();
+            inst1->Remove();
+        },
+        "");
+}
+
+}  // namespace
+}  // namespace tint::ir
diff --git a/src/tint/ir/load_test.cc b/src/tint/ir/load_test.cc
index 72359e7..02bc65b 100644
--- a/src/tint/ir/load_test.cc
+++ b/src/tint/ir/load_test.cc
@@ -21,9 +21,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_InstructionTest = TestHelper;
+using IR_LoadTest = TestHelper;
 
-TEST_F(IR_InstructionTest, CreateLoad) {
+TEST_F(IR_LoadTest, CreateLoad) {
     Module mod;
     Builder b{mod};
 
@@ -41,7 +41,7 @@
     EXPECT_EQ(inst->From(), var);
 }
 
-TEST_F(IR_InstructionTest, Load_Usage) {
+TEST_F(IR_LoadTest, Load_Usage) {
     Module mod;
     Builder b{mod};
 
diff --git a/src/tint/ir/loop.cc b/src/tint/ir/loop.cc
index 5b3e603..06764c8 100644
--- a/src/tint/ir/loop.cc
+++ b/src/tint/ir/loop.cc
@@ -28,6 +28,8 @@
     TINT_ASSERT(IR, body_);
     TINT_ASSERT(IR, continuing_);
     TINT_ASSERT(IR, merge_);
+
+    body_->AddInboundBranch(this);
 }
 
 Loop::~Loop() = default;
diff --git a/src/tint/ir/store_test.cc b/src/tint/ir/store_test.cc
index 1906cc6..bc68a98 100644
--- a/src/tint/ir/store_test.cc
+++ b/src/tint/ir/store_test.cc
@@ -21,9 +21,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_InstructionTest = TestHelper;
+using IR_StoreTest = TestHelper;
 
-TEST_F(IR_InstructionTest, CreateStore) {
+TEST_F(IR_StoreTest, CreateStore) {
     Module mod;
     Builder b{mod};
 
@@ -41,7 +41,7 @@
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, Store_Usage) {
+TEST_F(IR_StoreTest, Store_Usage) {
     Module mod;
     Builder b{mod};
 
diff --git a/src/tint/ir/to_program.cc b/src/tint/ir/to_program.cc
index 08436f3..33c9674 100644
--- a/src/tint/ir/to_program.cc
+++ b/src/tint/ir/to_program.cc
@@ -122,7 +122,7 @@
         while (block) {
             TINT_ASSERT(IR, block->HasBranchTarget());
 
-            for (auto* inst : block->Instructions()) {
+            for (auto* inst : *block) {
                 auto stmt = Stmt(inst);
                 if (TINT_UNLIKELY(!stmt)) {
                     return nullptr;
@@ -157,14 +157,14 @@
         }
 
         auto* false_blk = i->False();
-        if (false_blk->Instructions().Length() > 1 ||
-            (false_blk->Instructions().Length() == 1 && false_blk->HasBranchTarget() &&
-             !false_blk->Branch()->Is<ir::ExitIf>())) {
+        if (false_blk->Length() > 1 || (false_blk->Length() == 1 && false_blk->HasBranchTarget() &&
+                                        !false_blk->Branch()->Is<ir::ExitIf>())) {
             // If the else target is an `if` which has a merge target that just bounces to the outer
             // if merge target then emit an 'else if' instead of a block statement for the else.
-            if (auto* inst = i->False()->Instructions().Front()->As<ir::If>()) {
-                if (auto* br = inst->Merge()->Branch()->As<ir::ExitIf>(); br && br->If() == i) {
-                    auto* f = If(inst);
+            if (auto* inst = i->False()->Instructions(); inst && inst->As<ir::If>()) {
+                auto* if_ = inst->As<ir::If>();
+                if (auto* br = if_->Merge()->Branch()->As<ir::ExitIf>(); br && br->If() == i) {
+                    auto* f = If(if_);
                     if (!f) {
                         return nullptr;
                     }
diff --git a/src/tint/ir/unary_test.cc b/src/tint/ir/unary_test.cc
index 92ad24c..d6e5d50 100644
--- a/src/tint/ir/unary_test.cc
+++ b/src/tint/ir/unary_test.cc
@@ -21,9 +21,9 @@
 
 using namespace tint::number_suffixes;  // NOLINT
 
-using IR_InstructionTest = TestHelper;
+using IR_UnaryTest = TestHelper;
 
-TEST_F(IR_InstructionTest, CreateComplement) {
+TEST_F(IR_UnaryTest, CreateComplement) {
     Module mod;
     Builder b{mod};
     auto* inst = b.Complement(mod.Types().i32(), b.Constant(4_i));
@@ -37,7 +37,7 @@
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, CreateNegation) {
+TEST_F(IR_UnaryTest, CreateNegation) {
     Module mod;
     Builder b{mod};
     auto* inst = b.Negation(mod.Types().i32(), b.Constant(4_i));
@@ -51,7 +51,7 @@
     EXPECT_EQ(4_i, lhs->As<constant::Scalar<i32>>()->ValueAs<i32>());
 }
 
-TEST_F(IR_InstructionTest, Unary_Usage) {
+TEST_F(IR_UnaryTest, Unary_Usage) {
     Module mod;
     Builder b{mod};
     auto* inst = b.Negation(mod.Types().i32(), b.Constant(4_i));
diff --git a/src/tint/reader/wgsl/lexer.cc b/src/tint/reader/wgsl/lexer.cc
index 4ed4786..304a545 100644
--- a/src/tint/reader/wgsl/lexer.cc
+++ b/src/tint/reader/wgsl/lexer.cc
@@ -994,12 +994,11 @@
 
         // Consume continuing codepoint
         advance(n);
-    }
 
-    if (at(start) == '_') {
-        // Check for an underscore on its own (special token), or a
-        // double-underscore (not allowed).
-        if ((pos() == start + 1) || (at(start + 1) == '_')) {
+        if (pos() - start == 2 && substr(start, 2) == "__") {
+            // Identifiers prefixed with two or more underscores are not allowed.
+            // We check for these in the loop to bail early and prevent quadratic parse time for
+            // long sequences of ____.
             set_pos(start);
             return {};
         }
@@ -1008,8 +1007,8 @@
     auto str = substr(start, pos() - start);
     end_source(source);
 
-    if (auto t = check_keyword(source, str); t.has_value() && !t->IsUninitialized()) {
-        return t;
+    if (auto t = parse_keyword(str); t.has_value()) {
+        return Token{t.value(), source, str};
     }
 
     return Token{Token::Type::kIdentifier, source, str};
@@ -1194,92 +1193,95 @@
     return Token{type, source};
 }
 
-std::optional<Token> Lexer::check_keyword(const Source& source, std::string_view str) {
+std::optional<Token::Type> Lexer::parse_keyword(std::string_view str) {
     if (str == "alias") {
-        return Token{Token::Type::kAlias, source, "alias"};
+        return Token::Type::kAlias;
     }
     if (str == "bitcast") {
-        return Token{Token::Type::kBitcast, source, "bitcast"};
+        return Token::Type::kBitcast;
     }
     if (str == "break") {
-        return Token{Token::Type::kBreak, source, "break"};
+        return Token::Type::kBreak;
     }
     if (str == "case") {
-        return Token{Token::Type::kCase, source, "case"};
+        return Token::Type::kCase;
     }
     if (str == "const") {
-        return Token{Token::Type::kConst, source, "const"};
+        return Token::Type::kConst;
     }
     if (str == "const_assert") {
-        return Token{Token::Type::kConstAssert, source, "const_assert"};
+        return Token::Type::kConstAssert;
     }
     if (str == "continue") {
-        return Token{Token::Type::kContinue, source, "continue"};
+        return Token::Type::kContinue;
     }
     if (str == "continuing") {
-        return Token{Token::Type::kContinuing, source, "continuing"};
+        return Token::Type::kContinuing;
     }
     if (str == "diagnostic") {
-        return Token{Token::Type::kDiagnostic, source, "diagnostic"};
+        return Token::Type::kDiagnostic;
     }
     if (str == "discard") {
-        return Token{Token::Type::kDiscard, source, "discard"};
+        return Token::Type::kDiscard;
     }
     if (str == "default") {
-        return Token{Token::Type::kDefault, source, "default"};
+        return Token::Type::kDefault;
     }
     if (str == "else") {
-        return Token{Token::Type::kElse, source, "else"};
+        return Token::Type::kElse;
     }
     if (str == "enable") {
-        return Token{Token::Type::kEnable, source, "enable"};
+        return Token::Type::kEnable;
     }
     if (str == "fallthrough") {
-        return Token{Token::Type::kFallthrough, source, "fallthrough"};
+        return Token::Type::kFallthrough;
     }
     if (str == "false") {
-        return Token{Token::Type::kFalse, source, "false"};
+        return Token::Type::kFalse;
     }
     if (str == "fn") {
-        return Token{Token::Type::kFn, source, "fn"};
+        return Token::Type::kFn;
     }
     if (str == "for") {
-        return Token{Token::Type::kFor, source, "for"};
+        return Token::Type::kFor;
     }
     if (str == "if") {
-        return Token{Token::Type::kIf, source, "if"};
+        return Token::Type::kIf;
     }
     if (str == "let") {
-        return Token{Token::Type::kLet, source, "let"};
+        return Token::Type::kLet;
     }
     if (str == "loop") {
-        return Token{Token::Type::kLoop, source, "loop"};
+        return Token::Type::kLoop;
     }
     if (str == "override") {
-        return Token{Token::Type::kOverride, source, "override"};
+        return Token::Type::kOverride;
     }
     if (str == "return") {
-        return Token{Token::Type::kReturn, source, "return"};
+        return Token::Type::kReturn;
     }
     if (str == "requires") {
-        return Token{Token::Type::kRequires, source, "requires"};
+        return Token::Type::kRequires;
     }
     if (str == "struct") {
-        return Token{Token::Type::kStruct, source, "struct"};
+        return Token::Type::kStruct;
     }
     if (str == "switch") {
-        return Token{Token::Type::kSwitch, source, "switch"};
+        return Token::Type::kSwitch;
     }
     if (str == "true") {
-        return Token{Token::Type::kTrue, source, "true"};
+        return Token::Type::kTrue;
     }
     if (str == "var") {
-        return Token{Token::Type::kVar, source, "var"};
+        return Token::Type::kVar;
     }
     if (str == "while") {
-        return Token{Token::Type::kWhile, source, "while"};
+        return Token::Type::kWhile;
     }
-    return {};
+    if (str == "_") {
+        return Token::Type::kUnderscore;
+    }
+    return std::nullopt;
 }
 
 }  // namespace tint::reader::wgsl
diff --git a/src/tint/reader/wgsl/lexer.h b/src/tint/reader/wgsl/lexer.h
index e56a79a..e0231d8 100644
--- a/src/tint/reader/wgsl/lexer.h
+++ b/src/tint/reader/wgsl/lexer.h
@@ -53,7 +53,7 @@
                                            size_t prefix_count,
                                            int32_t base);
 
-    std::optional<Token> check_keyword(const Source&, std::string_view);
+    std::optional<Token::Type> parse_keyword(std::string_view);
 
     /// The try_* methods have the following in common:
     /// - They assume there is at least one character to be consumed,
diff --git a/src/tint/type/manager.cc b/src/tint/type/manager.cc
index 4a98045..136f910 100644
--- a/src/tint/type/manager.cc
+++ b/src/tint/type/manager.cc
@@ -128,15 +128,18 @@
 const type::Array* Manager::array(const type::Type* elem_ty,
                                   uint32_t count,
                                   uint32_t stride /* = 0*/) {
+    uint32_t implicit_stride = utils::RoundUp(elem_ty->Align(), elem_ty->Size());
     if (stride == 0) {
-        stride = elem_ty->Align();
+        stride = implicit_stride;
     }
+    TINT_ASSERT(Type, stride >= implicit_stride);
+
     return Get<type::Array>(/* element type */ elem_ty,
                             /* element count */ Get<ConstantArrayCount>(count),
                             /* array alignment */ elem_ty->Align(),
                             /* array size */ count * stride,
                             /* element stride */ stride,
-                            /* implicit stride */ elem_ty->Align());
+                            /* implicit stride */ implicit_stride);
 }
 
 const type::Array* Manager::runtime_array(const type::Type* elem_ty, uint32_t stride /* = 0 */) {
diff --git a/src/tint/writer/spirv/builder_assign_test.cc b/src/tint/writer/spirv/builder_assign_test.cc
index cab0ed4..e37563a 100644
--- a/src/tint/writer/spirv/builder_assign_test.cc
+++ b/src/tint/writer/spirv/builder_assign_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "src/tint/writer/spirv/spv_dump.h"
 #include "src/tint/writer/spirv/test_helper.h"
 
@@ -52,23 +53,23 @@
 }
 
 TEST_F(BuilderTest, Assign_Var_OutsideFunction_IsError) {
-    auto* v = GlobalVar("var", ty.f32(), builtin::AddressSpace::kPrivate);
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder pb;
 
-    auto* assign = Assign("var", Expr(1_f));
+            auto* v = pb.GlobalVar("var", pb.ty.f32(), builtin::AddressSpace::kPrivate);
 
-    WrapInFunction(assign);
+            auto* assign = pb.Assign("var", pb.Expr(1_f));
 
-    spirv::Builder& b = Build();
+            pb.WrapInFunction(assign);
 
-    EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.Diagnostics();
-    ASSERT_FALSE(b.has_error()) << b.Diagnostics();
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    tint::SetInternalCompilerErrorReporter(nullptr);
-
-    EXPECT_FALSE(b.GenerateAssignStatement(assign)) << b.Diagnostics();
-    EXPECT_TRUE(b.has_error());
-    EXPECT_THAT(b.Diagnostics().str(),
-                ::testing::HasSubstr("trying to add SPIR-V instruction 62 outside a function"));
+            b->GenerateGlobalVariable(v);
+            b->GenerateAssignStatement(assign);
+        },
+        "trying to add SPIR-V instruction 62 outside a function");
 }
 
 TEST_F(BuilderTest, Assign_Var_ZeroInitializer) {
diff --git a/src/tint/writer/spirv/builder_builtin_texture_test.cc b/src/tint/writer/spirv/builder_builtin_texture_test.cc
index 9d45519..6709f35 100644
--- a/src/tint/writer/spirv/builder_builtin_texture_test.cc
+++ b/src/tint/writer/spirv/builder_builtin_texture_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "src/tint/ast/builtin_texture_helper_test.h"
 #include "src/tint/ast/call_statement.h"
 #include "src/tint/ast/stage_attribute.h"
@@ -3761,34 +3762,38 @@
     Validate(b);
 }
 
-TEST_P(BuiltinTextureTest, OutsideFunction_IsError) {
-    auto param = GetParam();
+// TODO(dsinclair): This generates two fatal errors, but expect_fatal_failure can only handle 1
+TEST_P(BuiltinTextureTest, DISABLED_OutsideFunction_IsError) {
+    EXPECT_FATAL_FAILURE(
+        {
+            auto param = GetParam();
 
-    // The point of this test is to try to generate the texture
-    // builtin call outside a function.
+            // The point of this test is to try to generate the texture
+            // builtin call outside a function.
 
-    auto* texture = param.BuildTextureVariable(this);
-    auto* sampler = param.BuildSamplerVariable(this);
+            ProgramBuilder pb;
 
-    auto* call = Call(param.function, param.args(this));
-    auto* stmt = param.returns_value ? static_cast<const ast::Statement*>(Assign(Phony(), call))
-                                     : static_cast<const ast::Statement*>(CallStmt(call));
+            auto* texture = param.BuildTextureVariable(&pb);
+            auto* sampler = param.BuildSamplerVariable(&pb);
 
-    Func("func", utils::Empty, ty.void_(), utils::Vector{stmt},
-         utils::Vector{
-             Stage(ast::PipelineStage::kFragment),
-         });
+            auto* call = pb.Call(param.function, param.args(&pb));
+            auto* stmt = param.returns_value
+                             ? static_cast<const ast::Statement*>(pb.Assign(pb.Phony(), call))
+                             : static_cast<const ast::Statement*>(pb.CallStmt(call));
 
-    spirv::Builder& b = Build();
+            pb.Func("func", utils::Empty, pb.ty.void_(), utils::Vector{stmt},
+                    utils::Vector{
+                        pb.Stage(ast::PipelineStage::kFragment),
+                    });
 
-    tint::SetInternalCompilerErrorReporter(nullptr);
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    ASSERT_TRUE(b.GenerateGlobalVariable(texture)) << b.Diagnostics();
-    ASSERT_TRUE(b.GenerateGlobalVariable(sampler)) << b.Diagnostics();
-    EXPECT_EQ(b.GenerateExpression(call), 0u);
-    EXPECT_THAT(b.Diagnostics().str(),
-                ::testing::HasSubstr("Internal error: trying to add SPIR-V instruction "));
-    EXPECT_THAT(b.Diagnostics().str(), ::testing::HasSubstr(" outside a function"));
+            b->GenerateGlobalVariable(texture);
+            b->GenerateGlobalVariable(sampler);
+            b->GenerateExpression(call);
+        },
+        "Internal error: trying to add SPIR-V instruction ");
 }
 
 }  // namespace
diff --git a/src/tint/writer/spirv/builder_function_attribute_test.cc b/src/tint/writer/spirv/builder_function_attribute_test.cc
index c215f21..c47429b 100644
--- a/src/tint/writer/spirv/builder_function_attribute_test.cc
+++ b/src/tint/writer/spirv/builder_function_attribute_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "src/tint/ast/stage_attribute.h"
 #include "src/tint/ast/workgroup_attribute.h"
 #include "src/tint/writer/spirv/spv_dump.h"
@@ -151,44 +152,44 @@
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_OverridableConst) {
-    Override("width", ty.i32(), Call<i32>(2_i), Id(7_u));
-    Override("height", ty.i32(), Call<i32>(3_i), Id(8_u));
-    Override("depth", ty.i32(), Call<i32>(4_i), Id(9_u));
-    auto* func = Func("main", utils::Empty, ty.void_(), utils::Empty,
-                      utils::Vector{
-                          WorkgroupSize("width", "height", "depth"),
-                          Stage(ast::PipelineStage::kCompute),
-                      });
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder pb;
+            pb.Override("width", pb.ty.i32(), pb.Call<i32>(2_i), pb.Id(7_u));
+            pb.Override("height", pb.ty.i32(), pb.Call<i32>(3_i), pb.Id(8_u));
+            pb.Override("depth", pb.ty.i32(), pb.Call<i32>(4_i), pb.Id(9_u));
+            auto* func = pb.Func("main", utils::Empty, pb.ty.void_(), utils::Empty,
+                                 utils::Vector{
+                                     pb.WorkgroupSize("width", "height", "depth"),
+                                     pb.Stage(ast::PipelineStage::kCompute),
+                                 });
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    spirv::Builder& b = Build();
-
-    tint::SetInternalCompilerErrorReporter(nullptr);
-
-    EXPECT_FALSE(b.GenerateExecutionModes(func, 3)) << b.Diagnostics();
-    EXPECT_THAT(
-        b.Diagnostics().str(),
-        ::testing::HasSubstr(
-            "override-expressions should have been removed with the SubstituteOverride transform"));
+            b->GenerateExecutionModes(func, 3);
+        },
+        "override-expressions should have been removed with the SubstituteOverride transform");
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_WorkgroupSize_LiteralAndConst) {
-    Override("height", ty.i32(), Call<i32>(2_i), Id(7_u));
-    GlobalConst("depth", ty.i32(), Call<i32>(3_i));
-    auto* func = Func("main", utils::Empty, ty.void_(), utils::Empty,
-                      utils::Vector{
-                          WorkgroupSize(4_i, "height", "depth"),
-                          Stage(ast::PipelineStage::kCompute),
-                      });
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder pb;
 
-    spirv::Builder& b = Build();
+            pb.Override("height", pb.ty.i32(), pb.Call<i32>(2_i), pb.Id(7_u));
+            pb.GlobalConst("depth", pb.ty.i32(), pb.Call<i32>(3_i));
+            auto* func = pb.Func("main", utils::Empty, pb.ty.void_(), utils::Empty,
+                                 utils::Vector{
+                                     pb.WorkgroupSize(4_i, "height", "depth"),
+                                     pb.Stage(ast::PipelineStage::kCompute),
+                                 });
 
-    tint::SetInternalCompilerErrorReporter(nullptr);
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    EXPECT_FALSE(b.GenerateExecutionModes(func, 3)) << b.Diagnostics();
-    EXPECT_THAT(
-        b.Diagnostics().str(),
-        ::testing::HasSubstr(
-            "override-expressions should have been removed with the SubstituteOverride transform"));
+            b->GenerateExecutionModes(func, 3);
+        },
+        "override-expressions should have been removed with the SubstituteOverride transform");
 }
 
 TEST_F(BuilderTest, Decoration_ExecutionMode_MultipleFragment) {
diff --git a/src/tint/writer/spirv/builder_ident_expression_test.cc b/src/tint/writer/spirv/builder_ident_expression_test.cc
index 3917028..5ab7c19 100644
--- a/src/tint/writer/spirv/builder_ident_expression_test.cc
+++ b/src/tint/writer/spirv/builder_ident_expression_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "gtest/gtest-spi.h"
 #include "src/tint/writer/spirv/spv_dump.h"
 #include "src/tint/writer/spirv/test_helper.h"
 
@@ -23,21 +24,24 @@
 using BuilderTest = TestHelper;
 
 TEST_F(BuilderTest, IdentifierExpression_GlobalConst) {
-    auto* init = vec3<f32>(1_f, 1_f, 3_f);
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder pb;
 
-    auto* v = GlobalConst("c", ty.vec3<f32>(), init);
+            auto* init = pb.vec3<f32>(1_f, 1_f, 3_f);
 
-    auto* expr = Expr("c");
-    WrapInFunction(expr);
+            auto* v = pb.GlobalConst("c", pb.ty.vec3<f32>(), init);
 
-    spirv::Builder& b = Build();
+            auto* expr = pb.Expr("c");
+            pb.WrapInFunction(expr);
 
-    EXPECT_TRUE(b.GenerateGlobalVariable(v)) << b.Diagnostics();
-    ASSERT_FALSE(b.has_error()) << b.Diagnostics();
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    EXPECT_EQ(DumpInstructions(b.Module().Types()), R"()");
-
-    EXPECT_EQ(b.GenerateIdentifierExpression(expr), 0u);
+            b->GenerateGlobalVariable(v);
+            b->GenerateIdentifierExpression(expr);
+        },
+        "internal compiler error: unable to find ID for variable: c");
 }
 
 TEST_F(BuilderTest, IdentifierExpression_GlobalVar) {
diff --git a/src/tint/writer/spirv/builder_if_test.cc b/src/tint/writer/spirv/builder_if_test.cc
index 3bd4bb2..fb34a68 100644
--- a/src/tint/writer/spirv/builder_if_test.cc
+++ b/src/tint/writer/spirv/builder_if_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "gmock/gmock.h"
+#include "gtest/gtest-spi.h"
 #include "src/tint/writer/spirv/spv_dump.h"
 #include "src/tint/writer/spirv/test_helper.h"
 
@@ -51,19 +52,20 @@
     // if (true) {
     // }
 
-    auto* block = Block();
-    auto* expr = If(true, block);
-    WrapInFunction(expr);
+    EXPECT_FATAL_FAILURE(
+        {
+            ProgramBuilder pb;
 
-    spirv::Builder& b = Build();
+            auto* block = pb.Block();
+            auto* expr = pb.If(true, block);
+            pb.WrapInFunction(expr);
 
-    tint::SetInternalCompilerErrorReporter(nullptr);
+            auto program = std::make_unique<Program>(std::move(pb));
+            auto b = std::make_unique<spirv::Builder>(program.get());
 
-    EXPECT_FALSE(b.GenerateIfStatement(expr)) << b.Diagnostics();
-    EXPECT_TRUE(b.has_error());
-    EXPECT_THAT(b.Diagnostics().str(),
-                ::testing::HasSubstr(
-                    "Internal error: trying to add SPIR-V instruction 247 outside a function"));
+            b->GenerateIfStatement(expr);
+        },
+        "Internal error: trying to add SPIR-V instruction 247 outside a function");
 }
 
 TEST_F(BuilderTest, If_WithStatements) {
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.cc b/src/tint/writer/spirv/ir/generator_impl_ir.cc
index 8ae01c8..89e6a1f 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.cc
@@ -47,6 +47,7 @@
 #include "src/tint/type/i32.h"
 #include "src/tint/type/matrix.h"
 #include "src/tint/type/pointer.h"
+#include "src/tint/type/struct.h"
 #include "src/tint/type/type.h"
 #include "src/tint/type/u32.h"
 #include "src/tint/type/vector.h"
@@ -225,6 +226,7 @@
                     spv::Op::OpTypePointer,
                     {id, U32Operand(StorageClass(ptr->AddressSpace())), Type(ptr->StoreType())});
             },
+            [&](const type::Struct* str) { EmitStructType(id, str); },
             [&](Default) {
                 TINT_ICE(Writer, diagnostics_) << "unhandled type: " << ty->FriendlyName();
             });
@@ -237,12 +239,7 @@
         value,  //
         [&](const ir::Constant* constant) { return Constant(constant); },
         [&](const ir::Value*) {
-            auto id = values_.Find(value);
-            if (TINT_UNLIKELY(!id)) {
-                TINT_ICE(Writer, diagnostics_) << "missing result ID for value";
-                return 0u;
-            }
-            return *id;
+            return values_.GetOrCreate(value, [&] { return module_.NextId(); });
         });
 }
 
@@ -250,10 +247,49 @@
     return block_labels_.GetOrCreate(block, [&]() { return module_.NextId(); });
 }
 
+void GeneratorImplIr::EmitStructType(uint32_t id, const type::Struct* str) {
+    // Helper to return `type` or a potentially nested array element type within `type` as a matrix
+    // type, or nullptr if no such matrix type is present.
+    auto get_nested_matrix_type = [&](const type::Type* type) {
+        while (auto* arr = type->As<type::Array>()) {
+            type = arr->ElemType();
+        }
+        return type->As<type::Matrix>();
+    };
+
+    OperandList operands = {id};
+    for (auto* member : str->Members()) {
+        operands.push_back(Type(member->Type()));
+
+        // Generate struct member offset decoration.
+        module_.PushAnnot(
+            spv::Op::OpMemberDecorate,
+            {operands[0], member->Index(), U32Operand(SpvDecorationOffset), member->Offset()});
+
+        // Emit matrix layout decorations if necessary.
+        if (auto* matrix_type = get_nested_matrix_type(member->Type())) {
+            const uint32_t effective_row_count = (matrix_type->rows() == 2) ? 2 : 4;
+            module_.PushAnnot(spv::Op::OpMemberDecorate,
+                              {id, member->Index(), U32Operand(SpvDecorationColMajor)});
+            module_.PushAnnot(spv::Op::OpMemberDecorate,
+                              {id, member->Index(), U32Operand(SpvDecorationMatrixStride),
+                               Operand(effective_row_count * matrix_type->type()->Size())});
+        }
+
+        if (member->Name().IsValid()) {
+            module_.PushDebug(spv::Op::OpMemberName,
+                              {operands[0], member->Index(), Operand(member->Name().Name())});
+        }
+    }
+    module_.PushType(spv::Op::OpTypeStruct, std::move(operands));
+
+    if (str->Name().IsValid()) {
+        module_.PushDebug(spv::Op::OpName, {operands[0], Operand(str->Name().Name())});
+    }
+}
+
 void GeneratorImplIr::EmitFunction(const ir::Function* func) {
-    // Make an ID for the function.
-    auto id = module_.NextId();
-    values_.Add(func, id);
+    auto id = Value(func);
 
     // Emit the function name.
     module_.PushDebug(spv::Op::OpName, {id, Operand(ir_->NameOf(func).Name())});
@@ -272,9 +308,8 @@
     // Generate function parameter declarations and add their type IDs to the function signature.
     for (auto* param : func->Params()) {
         auto param_type_id = Type(param->Type());
-        auto param_id = module_.NextId();
+        auto param_id = Value(param);
         params.push_back(Instruction(spv::Op::OpFunctionParameter, {param_type_id, param_id}));
-        values_.Add(param, param_id);
         function_type.param_type_ids.Push(param_type_id);
         if (auto name = ir_->NameOf(param)) {
             module_.PushDebug(spv::Op::OpName, {param_id, Operand(name.Name())});
@@ -341,16 +376,14 @@
 }
 
 void GeneratorImplIr::EmitRootBlock(const ir::Block* root_block) {
-    for (auto* inst : root_block->Instructions()) {
-        auto result = Switch(
+    for (auto* inst : *root_block) {
+        Switch(
             inst,  //
             [&](const ir::Var* v) { return EmitVar(v); },
             [&](Default) {
                 TINT_ICE(Writer, diagnostics_)
                     << "unimplemented root block instruction: " << inst->TypeInfo().name;
-                return 0u;
             });
-        values_.Add(inst, result);
     }
 }
 
@@ -363,7 +396,7 @@
 
     // If there are no instructions in the block, it's a dead end, so we shouldn't be able to get
     // here to begin with.
-    if (block->Instructions().IsEmpty()) {
+    if (block->IsEmpty()) {
         current_function_.push_inst(spv::Op::OpUnreachable, {});
         return;
     }
@@ -371,9 +404,7 @@
     // Emit Phi nodes for all the incoming block parameters
     for (size_t param_idx = 0; param_idx < block->Params().Length(); param_idx++) {
         auto* param = block->Params()[param_idx];
-        auto id = module_.NextId();
-        values_.Add(param, id);
-        OperandList ops{Type(param->Type()), id};
+        OperandList ops{Type(param->Type()), Value(param)};
 
         for (auto* incoming : block->InboundBranches()) {
             auto* arg = incoming->Args()[param_idx];
@@ -385,40 +416,23 @@
     }
 
     // Emit the instructions.
-    for (auto* inst : block->Instructions()) {
-        auto result = Switch(
-            inst,  //
-            [&](const ir::Binary* b) { return EmitBinary(b); },
-            [&](const ir::Builtin* b) { return EmitBuiltin(b); },
-            [&](const ir::Load* l) { return EmitLoad(l); },
-            [&](const ir::Loop* l) {
-                EmitLoop(l);
-                return 0u;
-            },
-            [&](const ir::Switch* sw) {
-                EmitSwitch(sw);
-                return 0u;
-            },
-            [&](const ir::Store* s) {
-                EmitStore(s);
-                return 0u;
-            },
-            [&](const ir::UserCall* c) { return EmitUserCall(c); },
-            [&](const ir::Var* v) { return EmitVar(v); },
-            [&](const ir::If* i) {
-                EmitIf(i);
-                return 0u;
-            },
-            [&](const ir::Branch* b) {
-                EmitBranch(b);
-                return 0u;
-            },
+    for (auto* inst : *block) {
+        Switch(
+            inst,                                             //
+            [&](const ir::Binary* b) { EmitBinary(b); },      //
+            [&](const ir::Builtin* b) { EmitBuiltin(b); },    //
+            [&](const ir::Load* l) { EmitLoad(l); },          //
+            [&](const ir::Loop* l) { EmitLoop(l); },          //
+            [&](const ir::Switch* sw) { EmitSwitch(sw); },    //
+            [&](const ir::Store* s) { EmitStore(s); },        //
+            [&](const ir::UserCall* c) { EmitUserCall(c); },  //
+            [&](const ir::Var* v) { EmitVar(v); },            //
+            [&](const ir::If* i) { EmitIf(i); },              //
+            [&](const ir::Branch* b) { EmitBranch(b); },      //
             [&](Default) {
                 TINT_ICE(Writer, diagnostics_)
                     << "unimplemented instruction: " << inst->TypeInfo().name;
-                return 0u;
             });
-        values_.Add(inst, result);
     }
 }
 
@@ -477,11 +491,11 @@
     uint32_t merge_label = Label(merge_block);
     uint32_t true_label = merge_label;
     uint32_t false_label = merge_label;
-    if (true_block->Instructions().Length() > 1 || !merge_block->Params().IsEmpty() ||
+    if (true_block->Length() > 1 || !merge_block->Params().IsEmpty() ||
         (true_block->HasBranchTarget() && !true_block->Branch()->Is<ir::ExitIf>())) {
         true_label = Label(true_block);
     }
-    if (false_block->Instructions().Length() > 1 || !merge_block->Params().IsEmpty() ||
+    if (false_block->Length() > 1 || !merge_block->Params().IsEmpty() ||
         (false_block->HasBranchTarget() && !false_block->Branch()->Is<ir::ExitIf>())) {
         false_label = Label(false_block);
     }
@@ -504,8 +518,8 @@
     EmitBlock(merge_block);
 }
 
-uint32_t GeneratorImplIr::EmitBinary(const ir::Binary* binary) {
-    auto id = module_.NextId();
+void GeneratorImplIr::EmitBinary(const ir::Binary* binary) {
+    auto id = Value(binary);
     auto* lhs_ty = binary->LHS()->Type();
 
     // Determine the opcode.
@@ -603,14 +617,20 @@
     // Emit the instruction.
     current_function_.push_inst(
         op, {Type(binary->Type()), id, Value(binary->LHS()), Value(binary->RHS())});
-
-    return id;
 }
 
-uint32_t GeneratorImplIr::EmitBuiltin(const ir::Builtin* builtin) {
-    auto id = module_.NextId();
+void GeneratorImplIr::EmitBuiltin(const ir::Builtin* builtin) {
     auto* result_ty = builtin->Type();
 
+    if (builtin->Func() == builtin::Function::kAbs &&
+        result_ty->is_unsigned_integer_scalar_or_vector()) {
+        // abs() is a no-op for unsigned integers.
+        values_.Add(builtin, Value(builtin->Args()[0]));
+        return;
+    }
+
+    auto id = Value(builtin);
+
     spv::Op op = spv::Op::Max;
     OperandList operands = {Type(result_ty), id};
 
@@ -634,9 +654,6 @@
                 glsl_ext_inst(GLSLstd450FAbs);
             } else if (result_ty->is_signed_integer_scalar_or_vector()) {
                 glsl_ext_inst(GLSLstd450SAbs);
-            } else if (result_ty->is_unsigned_integer_scalar_or_vector()) {
-                // abs() is a no-op for unsigned integers.
-                return Value(builtin->Args()[0]);
             }
             break;
         case builtin::Function::kMax:
@@ -659,7 +676,6 @@
             break;
         default:
             TINT_ICE(Writer, diagnostics_) << "unimplemented builtin function: " << builtin->Func();
-            return 0u;
     }
     TINT_ASSERT(Writer, op != spv::Op::Max);
 
@@ -670,14 +686,11 @@
 
     // Emit the instruction.
     current_function_.push_inst(op, operands);
-
-    return id;
 }
 
-uint32_t GeneratorImplIr::EmitLoad(const ir::Load* load) {
-    auto id = module_.NextId();
-    current_function_.push_inst(spv::Op::OpLoad, {Type(load->Type()), id, Value(load->From())});
-    return id;
+void GeneratorImplIr::EmitLoad(const ir::Load* load) {
+    current_function_.push_inst(spv::Op::OpLoad,
+                                {Type(load->Type()), Value(load), Value(load->From())});
 }
 
 void GeneratorImplIr::EmitLoop(const ir::Loop* loop) {
@@ -754,18 +767,17 @@
     current_function_.push_inst(spv::Op::OpStore, {Value(store->To()), Value(store->From())});
 }
 
-uint32_t GeneratorImplIr::EmitUserCall(const ir::UserCall* call) {
-    auto id = module_.NextId();
-    OperandList operands = {Type(call->Type()), id, values_.Get(call->Func()).value()};
+void GeneratorImplIr::EmitUserCall(const ir::UserCall* call) {
+    auto id = Value(call);
+    OperandList operands = {Type(call->Type()), id, Value(call->Func())};
     for (auto* arg : call->Args()) {
         operands.push_back(Value(arg));
     }
     current_function_.push_inst(spv::Op::OpFunctionCall, operands);
-    return id;
 }
 
-uint32_t GeneratorImplIr::EmitVar(const ir::Var* var) {
-    auto id = module_.NextId();
+void GeneratorImplIr::EmitVar(const ir::Var* var) {
+    auto id = Value(var);
     auto* ptr = var->Type()->As<type::Pointer>();
     TINT_ASSERT(Writer, ptr);
     auto ty = Type(ptr);
@@ -803,7 +815,6 @@
         default: {
             TINT_ICE(Writer, diagnostics_)
                 << "unimplemented variable address space " << ptr->AddressSpace();
-            return 0u;
         }
     }
 
@@ -811,8 +822,6 @@
     if (auto name = ir_->NameOf(var)) {
         module_.PushDebug(spv::Op::OpName, {id, Operand(name.Name())});
     }
-
-    return id;
 }
 
 }  // namespace tint::writer::spirv
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.h b/src/tint/writer/spirv/ir/generator_impl_ir.h
index 5793325..7c3105b 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.h
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.h
@@ -31,6 +31,7 @@
 namespace tint::ir {
 class Binary;
 class Block;
+class BlockParam;
 class Branch;
 class Builtin;
 class If;
@@ -45,6 +46,7 @@
 class Var;
 }  // namespace tint::ir
 namespace tint::type {
+class Struct;
 class Type;
 }  // namespace tint::type
 
@@ -96,6 +98,11 @@
     /// @returns the ID of the block's label
     uint32_t Label(const ir::Block* block);
 
+    /// Emit a struct type.
+    /// @param id the result ID to use
+    /// @param str the struct type to emit
+    void EmitStructType(uint32_t id, const type::Struct* str);
+
     /// Emit a function.
     /// @param func the function to emit
     void EmitFunction(const ir::Function* func);
@@ -119,18 +126,15 @@
 
     /// Emit a binary instruction.
     /// @param binary the binary instruction to emit
-    /// @returns the result ID of the instruction
-    uint32_t EmitBinary(const ir::Binary* binary);
+    void EmitBinary(const ir::Binary* binary);
 
     /// Emit a builtin function call instruction.
     /// @param call the builtin call instruction to emit
-    /// @returns the result ID of the instruction
-    uint32_t EmitBuiltin(const ir::Builtin* call);
+    void EmitBuiltin(const ir::Builtin* call);
 
     /// Emit a load instruction.
     /// @param load the load instruction to emit
-    /// @returns the result ID of the instruction
-    uint32_t EmitLoad(const ir::Load* load);
+    void EmitLoad(const ir::Load* load);
 
     /// Emit a loop instruction.
     /// @param loop the loop instruction to emit
@@ -146,13 +150,11 @@
 
     /// Emit a user call instruction.
     /// @param call the user call instruction to emit
-    /// @returns the result ID of the instruction
-    uint32_t EmitUserCall(const ir::UserCall* call);
+    void EmitUserCall(const ir::UserCall* call);
 
     /// Emit a var instruction.
     /// @param var the var instruction to emit
-    /// @returns the result ID of the instruction
-    uint32_t EmitVar(const ir::Var* var);
+    void EmitVar(const ir::Var* var);
 
     /// Emit a branch instruction.
     /// @param b the branch instruction to emit
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
index f62848e..3bc06c1 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
@@ -76,10 +76,10 @@
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
 %2 = OpTypeInt 32 0
 %3 = OpTypeFunction %2
-%6 = OpConstant %2 1
+%5 = OpConstant %2 1
 %1 = OpFunction %2 None %3
 %4 = OpLabel
-OpReturnValue %6
+OpReturnValue %5
 OpFunctionEnd
 )");
 }
@@ -95,12 +95,12 @@
 %3 = OpTypeInt 32 0
 %2 = OpTypeVector %3 2
 %4 = OpTypeFunction %2
-%8 = OpConstant %3 42
-%9 = OpConstant %3 10
-%7 = OpConstantComposite %2 %8 %9
+%7 = OpConstant %3 42
+%8 = OpConstant %3 10
+%6 = OpConstantComposite %2 %7 %8
 %1 = OpFunction %2 None %4
 %5 = OpLabel
-OpReturnValue %7
+OpReturnValue %6
 OpFunctionEnd
 )");
 }
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
index 1c9b9ac..8d88852 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
@@ -161,9 +161,9 @@
 %3 = OpTypeFunction %2
 %9 = OpTypeBool
 %8 = OpConstantTrue %9
-%11 = OpTypeInt 32 1
-%12 = OpConstant %11 10
-%13 = OpConstant %11 20
+%10 = OpTypeInt 32 1
+%12 = OpConstant %10 10
+%13 = OpConstant %10 20
 %1 = OpFunction %2 None %3
 %4 = OpLabel
 OpSelectionMerge %5 None
@@ -173,8 +173,8 @@
 %7 = OpLabel
 OpBranch %5
 %5 = OpLabel
-%10 = OpPhi %11 %12 %6 %13 %7
-OpReturnValue %10
+%11 = OpPhi %10 %12 %6 %13 %7
+OpReturnValue %11
 OpFunctionEnd
 )");
 }
@@ -277,9 +277,9 @@
 %3 = OpTypeFunction %2
 %9 = OpTypeBool
 %8 = OpConstantTrue %9
-%11 = OpTypeInt 32 1
-%12 = OpConstant %11 10
-%13 = OpConstant %11 20
+%10 = OpTypeInt 32 1
+%12 = OpConstant %10 10
+%13 = OpConstant %10 20
 %15 = OpConstantFalse %9
 %1 = OpFunction %2 None %3
 %4 = OpLabel
@@ -290,9 +290,9 @@
 %7 = OpLabel
 OpBranch %5
 %5 = OpLabel
-%10 = OpPhi %11 %12 %6 %13 %7
+%11 = OpPhi %10 %12 %6 %13 %7
 %14 = OpPhi %9 %8 %6 %15 %7
-OpReturnValue %10
+OpReturnValue %11
 OpFunctionEnd
 )");
 }
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc
index a32a751..577d9d2 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc
@@ -24,11 +24,11 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Body()->AddInstruction(b.Continue(loop));
-    loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), loop));
-    loop->Merge()->AddInstruction(b.Return(func));
+    loop->Body()->Append(b.Continue(loop));
+    loop->Continuing()->Append(b.BreakIf(b.Constant(true), loop));
+    loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -58,10 +58,10 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Body()->AddInstruction(b.ExitLoop(loop));
-    loop->Merge()->AddInstruction(b.Return(func));
+    loop->Body()->Append(b.ExitLoop(loop));
+    loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -89,15 +89,15 @@
     auto* loop = b.CreateLoop();
 
     auto* cond_break = b.CreateIf(b.Constant(true));
-    cond_break->True()->AddInstruction(b.ExitLoop(loop));
-    cond_break->False()->AddInstruction(b.ExitIf(cond_break));
-    cond_break->Merge()->AddInstruction(b.Continue(loop));
+    cond_break->True()->Append(b.ExitLoop(loop));
+    cond_break->False()->Append(b.ExitIf(cond_break));
+    cond_break->Merge()->Append(b.Continue(loop));
 
-    loop->Body()->AddInstruction(cond_break);
-    loop->Continuing()->AddInstruction(b.NextIteration(loop));
-    loop->Merge()->AddInstruction(b.Return(func));
+    loop->Body()->Append(cond_break);
+    loop->Continuing()->Append(b.NextIteration(loop));
+    loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -132,15 +132,15 @@
     auto* loop = b.CreateLoop();
 
     auto* cond_break = b.CreateIf(b.Constant(true));
-    cond_break->True()->AddInstruction(b.Continue(loop));
-    cond_break->False()->AddInstruction(b.ExitIf(cond_break));
-    cond_break->Merge()->AddInstruction(b.ExitLoop(loop));
+    cond_break->True()->Append(b.Continue(loop));
+    cond_break->False()->Append(b.ExitIf(cond_break));
+    cond_break->Merge()->Append(b.ExitLoop(loop));
 
-    loop->Body()->AddInstruction(cond_break);
-    loop->Continuing()->AddInstruction(b.NextIteration(loop));
-    loop->Merge()->AddInstruction(b.Return(func));
+    loop->Body()->Append(cond_break);
+    loop->Continuing()->Append(b.NextIteration(loop));
+    loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -176,9 +176,9 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Body()->AddInstruction(b.Return(func));
+    loop->Body()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -207,11 +207,11 @@
 
     auto* result = b.Equal(mod.Types().i32(), b.Constant(1_i), b.Constant(2_i));
 
-    loop->Body()->AddInstruction(result);
-    loop->Continuing()->AddInstruction(b.BreakIf(result, loop));
-    loop->Merge()->AddInstruction(b.Return(func));
+    loop->Body()->Append(result);
+    loop->Continuing()->Append(b.BreakIf(result, loop));
+    loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(loop);
+    func->StartTarget()->Append(loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -242,15 +242,15 @@
     auto* outer_loop = b.CreateLoop();
     auto* inner_loop = b.CreateLoop();
 
-    inner_loop->Body()->AddInstruction(b.ExitLoop(inner_loop));
-    inner_loop->Continuing()->AddInstruction(b.NextIteration(inner_loop));
-    inner_loop->Merge()->AddInstruction(b.Continue(outer_loop));
+    inner_loop->Body()->Append(b.ExitLoop(inner_loop));
+    inner_loop->Continuing()->Append(b.NextIteration(inner_loop));
+    inner_loop->Merge()->Append(b.Continue(outer_loop));
 
-    outer_loop->Body()->AddInstruction(inner_loop);
-    outer_loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), outer_loop));
-    outer_loop->Merge()->AddInstruction(b.Return(func));
+    outer_loop->Body()->Append(inner_loop);
+    outer_loop->Continuing()->Append(b.BreakIf(b.Constant(true), outer_loop));
+    outer_loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(outer_loop);
+    func->StartTarget()->Append(outer_loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -289,15 +289,15 @@
     auto* outer_loop = b.CreateLoop();
     auto* inner_loop = b.CreateLoop();
 
-    inner_loop->Body()->AddInstruction(b.Continue(inner_loop));
-    inner_loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), inner_loop));
-    inner_loop->Merge()->AddInstruction(b.BreakIf(b.Constant(true), outer_loop));
+    inner_loop->Body()->Append(b.Continue(inner_loop));
+    inner_loop->Continuing()->Append(b.BreakIf(b.Constant(true), inner_loop));
+    inner_loop->Merge()->Append(b.BreakIf(b.Constant(true), outer_loop));
 
-    outer_loop->Body()->AddInstruction(b.Continue(outer_loop));
-    outer_loop->Continuing()->AddInstruction(inner_loop);
-    outer_loop->Merge()->AddInstruction(b.Return(func));
+    outer_loop->Body()->Append(b.Continue(outer_loop));
+    outer_loop->Continuing()->Append(inner_loop);
+    outer_loop->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(outer_loop);
+    func->StartTarget()->Append(outer_loop);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -330,5 +330,105 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, Loop_Phi_SingleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* l = b.CreateLoop(utils::Vector{b.Constant(1_i)});
+    func->StartTarget()->Append(l);
+
+    auto* loop_param = b.BlockParam(b.ir.Types().i32());
+    l->Body()->SetParams(utils::Vector{loop_param});
+    auto* inc = b.Add(b.ir.Types().i32(), loop_param, b.Constant(1_i));
+    l->Body()->Append(inc);
+    l->Body()->Append(b.Continue(l, utils::Vector{inc}));
+
+    auto* cont_param = b.BlockParam(b.ir.Types().i32());
+    l->Continuing()->SetParams(utils::Vector{cont_param});
+    auto* cmp = b.GreaterThan(b.ir.Types().bool_(), cont_param, b.Constant(5_i));
+    l->Continuing()->Append(cmp);
+    l->Continuing()->Append(b.BreakIf(cmp, l, utils::Vector{cont_param}));
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeInt 32 1
+%11 = OpConstant %9 1
+%16 = OpTypeBool
+%17 = OpConstant %9 5
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpBranch %5
+%5 = OpLabel
+OpLoopMerge %8 %7 None
+OpBranch %6
+%6 = OpLabel
+%10 = OpPhi %9 %11 %12 %13 %7
+%14 = OpIAdd %9 %10 %11
+OpBranch %7
+%7 = OpLabel
+%13 = OpPhi %9 %14 %5
+%15 = OpSGreaterThan %16 %13 %17
+OpBranchConditional %15 %8 %5
+%8 = OpLabel
+OpUnreachable
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Loop_Phi_MultipleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* l = b.CreateLoop(utils::Vector{b.Constant(1_i), b.Constant(false)});
+    func->StartTarget()->Append(l);
+
+    auto* loop_param_a = b.BlockParam(b.ir.Types().i32());
+    auto* loop_param_b = b.BlockParam(b.ir.Types().bool_());
+    l->Body()->SetParams(utils::Vector{loop_param_a, loop_param_b});
+    auto* inc = b.Add(b.ir.Types().i32(), loop_param_a, b.Constant(1_i));
+    l->Body()->Append(inc);
+    l->Body()->Append(b.Continue(l, utils::Vector{inc, loop_param_b}));
+
+    auto* cont_param_a = b.BlockParam(b.ir.Types().i32());
+    auto* cont_param_b = b.BlockParam(b.ir.Types().bool_());
+    l->Continuing()->SetParams(utils::Vector{cont_param_a, cont_param_b});
+    auto* cmp = b.GreaterThan(b.ir.Types().bool_(), cont_param_a, b.Constant(5_i));
+    l->Continuing()->Append(cmp);
+    auto* not_b = b.Not(b.ir.Types().bool_(), cont_param_b);
+    l->Continuing()->Append(not_b);
+    l->Continuing()->Append(b.BreakIf(cmp, l, utils::Vector{cont_param_a, not_b}));
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeInt 32 1
+%11 = OpConstant %9 1
+%14 = OpTypeBool
+%16 = OpConstantFalse %14
+%21 = OpConstant %9 5
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpBranch %5
+%5 = OpLabel
+OpLoopMerge %8 %7 None
+OpBranch %6
+%6 = OpLabel
+%10 = OpPhi %9 %11 %12 %13 %7
+%15 = OpPhi %14 %16 %12 %17 %7
+%18 = OpIAdd %9 %10 %11
+OpBranch %7
+%7 = OpLabel
+%13 = OpPhi %9 %18 %5
+%19 = OpPhi %14 %15 %5
+%20 = OpSGreaterThan %14 %13 %21
+%17 = OpLogicalEqual %14 %19 %16
+OpBranchConditional %20 %8 %5
+%8 = OpLabel
+OpUnreachable
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace tint::writer::spirv
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
index 1c4d5d0..2773ae0 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
@@ -25,11 +25,11 @@
     auto* swtch = b.CreateSwitch(b.Constant(42_i));
 
     auto* def_case = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector()});
-    def_case->AddInstruction(b.ExitSwitch(swtch));
+    def_case->Append(b.ExitSwitch(swtch));
 
-    swtch->Merge()->AddInstruction(b.Return(func));
+    swtch->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(swtch);
+    func->StartTarget()->Append(swtch);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -55,17 +55,17 @@
     auto* swtch = b.CreateSwitch(b.Constant(42_i));
 
     auto* case_a = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)}});
-    case_a->AddInstruction(b.ExitSwitch(swtch));
+    case_a->Append(b.ExitSwitch(swtch));
 
     auto* case_b = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
-    case_b->AddInstruction(b.ExitSwitch(swtch));
+    case_b->Append(b.ExitSwitch(swtch));
 
     auto* def_case = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector()});
-    def_case->AddInstruction(b.ExitSwitch(swtch));
+    def_case->Append(b.ExitSwitch(swtch));
 
-    swtch->Merge()->AddInstruction(b.Return(func));
+    swtch->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(swtch);
+    func->StartTarget()->Append(swtch);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -96,19 +96,19 @@
 
     auto* case_a = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
                                                      ir::Switch::CaseSelector{b.Constant(3_i)}});
-    case_a->AddInstruction(b.ExitSwitch(swtch));
+    case_a->Append(b.ExitSwitch(swtch));
 
     auto* case_b = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)},
                                                      ir::Switch::CaseSelector{b.Constant(4_i)}});
-    case_b->AddInstruction(b.ExitSwitch(swtch));
+    case_b->Append(b.ExitSwitch(swtch));
 
     auto* def_case = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(5_i)},
                                                        ir::Switch::CaseSelector()});
-    def_case->AddInstruction(b.ExitSwitch(swtch));
+    def_case->Append(b.ExitSwitch(swtch));
 
-    swtch->Merge()->AddInstruction(b.Return(func));
+    swtch->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(swtch);
+    func->StartTarget()->Append(swtch);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -138,15 +138,15 @@
     auto* swtch = b.CreateSwitch(b.Constant(42_i));
 
     auto* case_a = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)}});
-    case_a->AddInstruction(b.Return(func));
+    case_a->Append(b.Return(func));
 
     auto* case_b = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
-    case_b->AddInstruction(b.Return(func));
+    case_b->Append(b.Return(func));
 
     auto* def_case = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector()});
-    def_case->AddInstruction(b.Return(func));
+    def_case->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(swtch);
+    func->StartTarget()->Append(swtch);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -176,19 +176,19 @@
     auto* swtch = b.CreateSwitch(b.Constant(42_i));
 
     auto* cond_break = b.CreateIf(b.Constant(true));
-    cond_break->True()->AddInstruction(b.ExitSwitch(swtch));
-    cond_break->False()->AddInstruction(b.ExitIf(cond_break));
-    cond_break->Merge()->AddInstruction(b.Return(func));
+    cond_break->True()->Append(b.ExitSwitch(swtch));
+    cond_break->False()->Append(b.ExitIf(cond_break));
+    cond_break->Merge()->Append(b.Return(func));
 
     auto* case_a = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)}});
-    case_a->AddInstruction(cond_break);
+    case_a->Append(cond_break);
 
     auto* def_case = b.CreateCase(swtch, utils::Vector{ir::Switch::CaseSelector()});
-    def_case->AddInstruction(b.ExitSwitch(swtch));
+    def_case->Append(b.ExitSwitch(swtch));
 
-    swtch->Merge()->AddInstruction(b.Return(func));
+    swtch->Merge()->Append(b.Return(func));
 
-    func->StartTarget()->AddInstruction(swtch);
+    func->StartTarget()->Append(swtch);
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
@@ -225,13 +225,13 @@
     auto* s = b.CreateSwitch(b.Constant(42_i));
     auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
                                                  ir::Switch::CaseSelector{nullptr}});
-    case_a->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(10_i)}));
+    case_a->Append(b.ExitSwitch(s, utils::Vector{b.Constant(10_i)}));
 
     auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
-    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
+    case_b->Append(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
 
     s->Merge()->SetParams(utils::Vector{merge_param});
-    s->Merge()->AddInstruction(b.Return(func));
+    s->Merge()->Append(b.Return(func));
 
     func->StartTarget()->SetInstructions(utils::Vector{s});
 
@@ -264,13 +264,13 @@
     auto* s = b.CreateSwitch(b.Constant(42_i));
     auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
                                                  ir::Switch::CaseSelector{nullptr}});
-    case_a->AddInstruction(b.Return(func, utils::Vector{b.Constant(10_i)}));
+    case_a->Append(b.Return(func, utils::Vector{b.Constant(10_i)}));
 
     auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
-    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
+    case_b->Append(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
 
     s->Merge()->SetParams(utils::Vector{b.BlockParam(b.ir.Types().i32())});
-    s->Merge()->AddInstruction(b.Return(func));
+    s->Merge()->Append(b.Return(func));
 
     func->StartTarget()->SetInstructions(utils::Vector{s});
 
@@ -306,13 +306,13 @@
     auto* s = b.CreateSwitch(b.Constant(42_i));
     auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
                                                  ir::Switch::CaseSelector{nullptr}});
-    case_a->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(10_i), b.Constant(true)}));
+    case_a->Append(b.ExitSwitch(s, utils::Vector{b.Constant(10_i), b.Constant(true)}));
 
     auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
-    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i), b.Constant(false)}));
+    case_b->Append(b.ExitSwitch(s, utils::Vector{b.Constant(20_i), b.Constant(false)}));
 
     s->Merge()->SetParams(utils::Vector{merge_param_0, merge_param_1});
-    s->Merge()->AddInstruction(b.Return(func, utils::Vector{merge_param_0}));
+    s->Merge()->Append(b.Return(func, utils::Vector{merge_param_0}));
 
     func->StartTarget()->SetInstructions(utils::Vector{s});
 
@@ -324,9 +324,9 @@
 %6 = OpConstant %7 42
 %11 = OpConstant %7 10
 %12 = OpConstant %7 20
-%14 = OpTypeBool
-%15 = OpConstantTrue %14
-%16 = OpConstantFalse %14
+%13 = OpTypeBool
+%15 = OpConstantTrue %13
+%16 = OpConstantFalse %13
 %1 = OpFunction %2 None %3
 %4 = OpLabel
 OpSelectionMerge %9 None
@@ -337,7 +337,7 @@
 OpBranch %9
 %9 = OpLabel
 %10 = OpPhi %7 %11 %5 %12 %8
-%13 = OpPhi %14 %15 %5 %16 %8
+%14 = OpPhi %13 %15 %5 %16 %8
 OpReturnValue %10
 OpFunctionEnd
 )");
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
index 7b2142c..d6c654f 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
@@ -149,6 +149,22 @@
     EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 16\n");
 }
 
+TEST_F(SpvGeneratorImplTest, Type_Array_NestedArray) {
+    auto* arr = mod.Types().array(mod.Types().array(mod.Types().f32(), 64u), 4u);
+    auto id = generator_.Type(arr);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%3 = OpTypeFloat 32\n"
+              "%5 = OpTypeInt 32 0\n"
+              "%4 = OpConstant %5 64\n"
+              "%2 = OpTypeArray %3 %4\n"
+              "%6 = OpConstant %5 4\n"
+              "%1 = OpTypeArray %2 %6\n");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()),
+              "OpDecorate %2 ArrayStride 4\n"
+              "OpDecorate %1 ArrayStride 256\n");
+}
+
 TEST_F(SpvGeneratorImplTest, Type_RuntimeArray_DefaultStride) {
     auto* arr = mod.Types().runtime_array(mod.Types().f32());
     auto id = generator_.Type(arr);
@@ -169,6 +185,76 @@
     EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 16\n");
 }
 
+TEST_F(SpvGeneratorImplTest, Type_Struct) {
+    auto* str = mod.Types().Get<type::Struct>(
+        mod.symbols.Register("MyStruct"),
+        utils::Vector{
+            mod.Types().Get<type::StructMember>(mod.symbols.Register("a"), mod.Types().f32(), 0u,
+                                                0u, 4u, 4u, type::StructMemberAttributes{}),
+            mod.Types().Get<type::StructMember>(mod.symbols.Register("b"),
+                                                mod.Types().vec4(mod.Types().i32()), 1u, 16u, 16u,
+                                                16u, type::StructMemberAttributes{}),
+        },
+        16u, 32u, 32u);
+    auto id = generator_.Type(str);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(), R"(%2 = OpTypeFloat 32
+%4 = OpTypeInt 32 1
+%3 = OpTypeVector %4 4
+%1 = OpTypeStruct %2 %3
+)");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), R"(OpMemberDecorate %1 0 Offset 0
+OpMemberDecorate %1 1 Offset 16
+)");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Debug()), R"(OpMemberName %1 0 "a"
+OpMemberName %1 1 "b"
+OpName %1 "MyStruct"
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Type_Struct_MatrixLayout) {
+    auto* str = mod.Types().Get<type::Struct>(
+        mod.symbols.Register("MyStruct"),
+        utils::Vector{
+            mod.Types().Get<type::StructMember>(mod.symbols.Register("m"),
+                                                mod.Types().mat3x3(mod.Types().f32()), 0u, 0u, 16u,
+                                                48u, type::StructMemberAttributes{}),
+            // Matrices nested inside arrays need layout decorations on the struct member too.
+            mod.Types().Get<type::StructMember>(
+                mod.symbols.Register("arr"),
+                mod.Types().array(mod.Types().array(mod.Types().mat2x4(mod.Types().f16()), 4), 4),
+                1u, 64u, 8u, 64u, type::StructMemberAttributes{}),
+        },
+        16u, 128u, 128u);
+    auto id = generator_.Type(str);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(), R"(%4 = OpTypeFloat 32
+%3 = OpTypeVector %4 3
+%2 = OpTypeMatrix %3 3
+%9 = OpTypeFloat 16
+%8 = OpTypeVector %9 4
+%7 = OpTypeMatrix %8 2
+%11 = OpTypeInt 32 0
+%10 = OpConstant %11 4
+%6 = OpTypeArray %7 %10
+%5 = OpTypeArray %6 %10
+%1 = OpTypeStruct %2 %5
+)");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), R"(OpMemberDecorate %1 0 Offset 0
+OpMemberDecorate %1 0 ColMajor
+OpMemberDecorate %1 0 MatrixStride 16
+OpDecorate %6 ArrayStride 16
+OpDecorate %5 ArrayStride 64
+OpMemberDecorate %1 1 Offset 64
+OpMemberDecorate %1 1 ColMajor
+OpMemberDecorate %1 1 MatrixStride 8
+)");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Debug()), R"(OpMemberName %1 0 "m"
+OpMemberName %1 1 "arr"
+OpName %1 "MyStruct"
+)");
+}
+
 // Test that we can emit multiple types.
 // Includes types with the same opcode but different parameters.
 TEST_F(SpvGeneratorImplTest, Type_Multiple) {