diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 83d7421..a315fd4 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -523,6 +523,10 @@
       "ir/transform/block_decorated_structs.h",
       "ir/transform/merge_return.cc",
       "ir/transform/merge_return.h",
+      "ir/transform/shader_io.cc",
+      "ir/transform/shader_io.h",
+      "ir/transform/shader_io_spirv.cc",
+      "ir/transform/shader_io_spirv.h",
       "ir/transform/var_for_dynamic_index.cc",
       "ir/transform/var_for_dynamic_index.h",
     ]
@@ -1866,6 +1870,7 @@
         "ir/transform/add_empty_entry_point_test.cc",
         "ir/transform/block_decorated_structs_test.cc",
         "ir/transform/merge_return_test.cc",
+        "ir/transform/shader_io_test.cc",
         "ir/transform/test_helper.h",
         "ir/transform/var_for_dynamic_index_test.cc",
       ]
@@ -2398,6 +2403,7 @@
         "ir/store_test.cc",
         "ir/switch_test.cc",
         "ir/swizzle_test.cc",
+        "ir/to_program_inlining_test.cc",
         "ir/to_program_roundtrip_test.cc",
         "ir/to_program_test.cc",
         "ir/unary_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 0ddae38..967cef2 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -832,6 +832,10 @@
     ir/transform/block_decorated_structs.h
     ir/transform/merge_return.cc
     ir/transform/merge_return.h
+    ir/transform/shader_io.cc
+    ir/transform/shader_io.h
+    ir/transform/shader_io_spirv.cc
+    ir/transform/shader_io_spirv.h
     ir/transform/transform.cc
     ir/transform/transform.h
     ir/transform/var_for_dynamic_index.cc
@@ -1586,6 +1590,7 @@
       ir/transform/add_empty_entry_point_test.cc
       ir/transform/block_decorated_structs_test.cc
       ir/transform/merge_return_test.cc
+      ir/transform/shader_io_test.cc
       ir/transform/var_for_dynamic_index_test.cc
       ir/unary_test.cc
       ir/user_call_test.cc
@@ -1603,6 +1608,7 @@
 
   if (${TINT_BUILD_IR} AND ${TINT_BUILD_WGSL_WRITER})
     list(APPEND TINT_TEST_SRCS
+      ir/to_program_inlining_test.cc
       ir/to_program_test.cc
     )
   endif()
diff --git a/src/tint/ir/block_test.cc b/src/tint/ir/block_test.cc
index 9f5fbfa..79ae399 100644
--- a/src/tint/ir/block_test.cc
+++ b/src/tint/ir/block_test.cc
@@ -36,7 +36,7 @@
 TEST_F(IR_BlockTest, HasTerminator_BreakIf) {
     auto* blk = b.Block();
     auto* loop = b.Loop();
-    blk->Append(b.BreakIf(true, loop));
+    blk->Append(b.BreakIf(loop, true));
     EXPECT_TRUE(blk->HasTerminator());
 }
 
diff --git a/src/tint/ir/break_if_test.cc b/src/tint/ir/break_if_test.cc
index 2ce17ae..506d93f 100644
--- a/src/tint/ir/break_if_test.cc
+++ b/src/tint/ir/break_if_test.cc
@@ -30,7 +30,7 @@
     auto* arg1 = b.Constant(1_u);
     auto* arg2 = b.Constant(2_u);
 
-    auto* brk = b.BreakIf(cond, loop, arg1, arg2);
+    auto* brk = b.BreakIf(loop, cond, arg1, arg2);
 
     EXPECT_THAT(cond->Usages(), testing::UnorderedElementsAre(Usage{brk, 0u}));
     EXPECT_THAT(arg1->Usages(), testing::UnorderedElementsAre(Usage{brk, 1u}));
@@ -43,7 +43,7 @@
     auto* arg1 = b.Constant(1_u);
     auto* arg2 = b.Constant(2_u);
 
-    auto* brk = b.BreakIf(cond, loop, arg1, arg2);
+    auto* brk = b.BreakIf(loop, cond, arg1, arg2);
     EXPECT_FALSE(brk->HasResults());
     EXPECT_FALSE(brk->HasMultiResults());
 }
@@ -53,7 +53,7 @@
         {
             Module mod;
             Builder b{mod};
-            b.BreakIf(true, nullptr);
+            b.BreakIf(nullptr, true);
         },
         "");
 }
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 2b3c9a4..6049a85 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -50,6 +50,7 @@
     auto* ir_func = ir.values.Create<ir::Function>(return_type, stage, wg_size);
     ir_func->SetBlock(Block());
     ir.SetName(ir_func, name);
+    ir.functions.Push(ir_func);
     return ir_func;
 }
 
@@ -76,6 +77,12 @@
     return Append(ir.instructions.Create<ir::Var>(InstructionResult(type)));
 }
 
+ir::Var* Builder::Var(std::string_view name, const type::Pointer* type) {
+    auto* var = Var(type);
+    ir.SetName(var, name);
+    return var;
+}
+
 ir::BlockParam* Builder::BlockParam(const type::Type* type) {
     return ir.values.Create<ir::BlockParam>(type);
 }
@@ -84,6 +91,12 @@
     return ir.values.Create<ir::FunctionParam>(type);
 }
 
+ir::FunctionParam* Builder::FunctionParam(std::string_view name, const type::Type* type) {
+    auto* param = ir.values.Create<ir::FunctionParam>(type);
+    ir.SetName(param, name);
+    return param;
+}
+
 ir::Unreachable* Builder::Unreachable() {
     return Append(ir.instructions.Create<ir::Unreachable>());
 }
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 3ad87a6..95c6df0 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -17,7 +17,9 @@
 
 #include <utility>
 
+#include "src/tint/constant/composite.h"
 #include "src/tint/constant/scalar.h"
+#include "src/tint/constant/splat.h"
 #include "src/tint/ir/access.h"
 #include "src/tint/ir/binary.h"
 #include "src/tint/ir/bitcast.h"
@@ -559,6 +561,12 @@
     /// @returns the instruction
     ir::Var* Var(const type::Pointer* type);
 
+    /// Creates a new `var` declaration with a name
+    /// @param name the var name
+    /// @param type the var type
+    /// @returns the instruction
+    ir::Var* Var(std::string_view name, const type::Pointer* type);
+
     /// Creates a return instruction
     /// @param func the function being returned
     /// @returns the instruction
@@ -572,6 +580,11 @@
     /// @returns the instruction
     template <typename ARG>
     ir::Return* Return(ir::Function* func, ARG&& value) {
+        if constexpr (std::is_same_v<std::decay_t<ARG>, ir::Value*>) {
+            if (value == nullptr) {
+                return Append(ir.instructions.Create<ir::Return>(func));
+            }
+        }
         return Append(ir.instructions.Create<ir::Return>(func, Value(std::forward<ARG>(value))));
     }
 
@@ -591,7 +604,7 @@
     /// @param args the arguments for the target MultiInBlock
     /// @returns the instruction
     template <typename CONDITION, typename... ARGS>
-    ir::BreakIf* BreakIf(CONDITION&& condition, ir::Loop* loop, ARGS&&... args) {
+    ir::BreakIf* BreakIf(ir::Loop* loop, CONDITION&& condition, ARGS&&... args) {
         return Append(ir.instructions.Create<ir::BreakIf>(
             Value(std::forward<CONDITION>(condition)), loop, Values(std::forward<ARGS>(args)...)));
     }
@@ -658,6 +671,12 @@
     /// @returns the value
     ir::FunctionParam* FunctionParam(const type::Type* type);
 
+    /// Creates a new `FunctionParam` with a name.
+    /// @param name the parameter name
+    /// @param type the parameter type
+    /// @returns the value
+    ir::FunctionParam* FunctionParam(std::string_view name, const type::Type* type);
+
     /// Creates a new `Access`
     /// @param type the return type
     /// @param object the object being accessed
diff --git a/src/tint/ir/call.cc b/src/tint/ir/call.cc
index ead6124..cacdaa4 100644
--- a/src/tint/ir/call.cc
+++ b/src/tint/ir/call.cc
@@ -20,7 +20,9 @@
 
 namespace tint::ir {
 
-Call::Call() = default;
+Call::Call() {
+    flags_.Add(Flag::kSequenced);
+}
 
 Call::~Call() = default;
 
diff --git a/src/tint/ir/control_instruction.cc b/src/tint/ir/control_instruction.cc
index 6451622..a5c3f0f 100644
--- a/src/tint/ir/control_instruction.cc
+++ b/src/tint/ir/control_instruction.cc
@@ -18,6 +18,10 @@
 
 namespace tint::ir {
 
+ControlInstruction::ControlInstruction() {
+    flags_.Add(Flag::kSequenced);
+}
+
 ControlInstruction::~ControlInstruction() = default;
 
 void ControlInstruction::AddExit(Exit* exit) {
diff --git a/src/tint/ir/control_instruction.h b/src/tint/ir/control_instruction.h
index 701e032..30fbf4d 100644
--- a/src/tint/ir/control_instruction.h
+++ b/src/tint/ir/control_instruction.h
@@ -31,6 +31,9 @@
 /// ControlInstruction.
 class ControlInstruction : public utils::Castable<ControlInstruction, OperandInstruction<1, 1>> {
   public:
+    /// Constructor
+    ControlInstruction();
+
     /// Destructor
     ~ControlInstruction() override;
 
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index f8e301f..38e9be4 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -294,11 +294,13 @@
 }
 
 void Disassembler::EmitValueWithType(Instruction* val) {
+    SourceMarker sm(this);
     if (val->Result()) {
         EmitValueWithType(val->Result());
     } else {
         out_ << "undef";
     }
+    sm.StoreResult(Usage{val, 0});
 }
 
 void Disassembler::EmitValueWithType(Value* val) {
@@ -371,6 +373,13 @@
 }
 
 void Disassembler::EmitInstruction(Instruction* inst) {
+    if (!inst->Alive()) {
+        SourceMarker sm(this);
+        out_ << "<destroyed " << inst->TypeInfo().name << " " << utils::ToString(inst) << ">";
+        sm.Store(inst);
+        EmitLine();
+        return;
+    }
     tint::Switch(
         inst,                               //
         [&](Switch* s) { EmitSwitch(s); },  //
@@ -512,46 +521,54 @@
     }
 }
 
-void Disassembler::EmitIf(If* i) {
+void Disassembler::EmitIf(If* if_) {
     SourceMarker sm(this);
-    if (i->Result()) {
-        EmitValueWithType(i->Result());
+    if (if_->HasResults()) {
+        auto res = if_->Results();
+        for (size_t i = 0; i < res.Length(); ++i) {
+            if (i > 0) {
+                out_ << ", ";
+            }
+            SourceMarker rs(this);
+            EmitValueWithType(res[i]);
+            rs.StoreResult(Usage{if_, i});
+        }
         out_ << " = ";
     }
     out_ << "if ";
-    EmitOperand(i, i->Condition(), If::kConditionOperandOffset);
+    EmitOperand(if_, if_->Condition(), If::kConditionOperandOffset);
 
-    bool has_true = !i->True()->IsEmpty();
-    bool has_false = !i->False()->IsEmpty();
+    bool has_true = !if_->True()->IsEmpty();
+    bool has_false = !if_->False()->IsEmpty();
 
     out_ << " [";
     if (has_true) {
-        out_ << "t: %b" << IdOf(i->True());
+        out_ << "t: %b" << IdOf(if_->True());
     }
     if (has_false) {
         if (has_true) {
             out_ << ", ";
         }
-        out_ << "f: %b" << IdOf(i->False());
+        out_ << "f: %b" << IdOf(if_->False());
     }
     out_ << "]";
-    sm.Store(i);
+    sm.Store(if_);
 
-    out_ << " {  # " << NameOf(i);
+    out_ << " {  # " << NameOf(if_);
     EmitLine();
 
     if (has_true) {
         ScopedIndent si(indent_size_);
-        EmitBlock(i->True(), "true");
+        EmitBlock(if_->True(), "true");
     }
     if (has_false) {
         ScopedIndent si(indent_size_);
-        EmitBlock(i->False(), "false");
-    } else if (i->HasResults()) {
+        EmitBlock(if_->False(), "false");
+    } else if (if_->HasResults()) {
         ScopedIndent si(indent_size_);
         Indent();
         out_ << "# implicit false block: exit_if undef";
-        for (size_t v = 1; v < i->Results().Length(); v++) {
+        for (size_t v = 1; v < if_->Results().Length(); v++) {
             out_ << ", undef";
         }
         EmitLine();
@@ -738,9 +755,9 @@
             break;
     }
     out_ << " ";
-    EmitValue(b->LHS());
+    EmitOperand(b, b->LHS(), Binary::kLhsOperandOffset);
     out_ << ", ";
-    EmitValue(b->RHS());
+    EmitOperand(b, b->RHS(), Binary::kRhsOperandOffset);
 
     sm.Store(b);
     EmitLine();
@@ -759,7 +776,7 @@
             break;
     }
     out_ << " ";
-    EmitValue(u->Val());
+    EmitOperand(u, u->Val(), Unary::kValueOperandOffset);
 
     sm.Store(u);
     EmitLine();
diff --git a/src/tint/ir/disassembler.h b/src/tint/ir/disassembler.h
index 940f7f6..4a0e495 100644
--- a/src/tint/ir/disassembler.h
+++ b/src/tint/ir/disassembler.h
@@ -61,6 +61,10 @@
     /// @returns the source for the operand
     Source OperandSource(Usage operand) { return operand_to_src_.Get(operand).value_or(Source{}); }
 
+    /// @param result the result to retrieve
+    /// @returns the source for the result
+    Source ResultSource(Usage result) { return result_to_src_.Get(result).value_or(Source{}); }
+
     /// @param blk teh block to retrieve
     /// @returns the source for the block
     Source BlockSource(Block* blk) { return block_to_src_.Get(blk).value_or(Source{}); }
@@ -80,6 +84,11 @@
     /// @param src the source location
     void SetSource(Usage op, Source src) { operand_to_src_.Add(op, src); }
 
+    /// Stores the given @p src location for @p result
+    /// @param result the result to store
+    /// @param src the source location
+    void SetResultSource(Usage result, Source src) { result_to_src_.Add(result, src); }
+
     /// @returns the source location for the current emission location
     Source::Location MakeCurrentLocation();
 
@@ -95,6 +104,8 @@
 
         void Store(Usage operand) { dis_->SetSource(operand, MakeSource()); }
 
+        void StoreResult(Usage result) { dis_->SetResultSource(result, MakeSource()); }
+
         Source MakeSource() const {
             return Source(Source::Range(begin_, dis_->MakeCurrentLocation()));
         }
@@ -151,6 +162,7 @@
     utils::Hashmap<Block*, Source, 8> block_to_src_;
     utils::Hashmap<Instruction*, Source, 8> instruction_to_src_;
     utils::Hashmap<Usage, Source, 8, Usage::Hasher> operand_to_src_;
+    utils::Hashmap<Usage, Source, 8, Usage::Hasher> result_to_src_;
     utils::Hashmap<If*, std::string, 8> if_names_;
     utils::Hashmap<Loop*, std::string, 8> loop_names_;
     utils::Hashmap<Switch*, std::string, 8> switch_names_;
diff --git a/src/tint/ir/from_program.cc b/src/tint/ir/from_program.cc
index b6c6586..69b80ea 100644
--- a/src/tint/ir/from_program.cc
+++ b/src/tint/ir/from_program.cc
@@ -263,7 +263,6 @@
         auto* ir_func = builder_.Function(ast_func->name->symbol.NameView(),
                                           sem->ReturnType()->Clone(clone_ctx_.type_ctx));
         current_function_ = ir_func;
-        builder_.ir.functions.Push(ir_func);
 
         scopes_.Set(ast_func->name->symbol, ir_func);
 
@@ -338,7 +337,7 @@
         for (auto* p : ast_func->params) {
             const auto* param_sem = program_->Sem().Get(p)->As<sem::Parameter>();
             auto* ty = param_sem->Type()->Clone(clone_ctx_.type_ctx);
-            auto* param = builder_.FunctionParam(ty);
+            auto* param = builder_.FunctionParam(p->name->symbol.NameView(), ty);
 
             // Note, interpolated is only valid when paired with Location, so it will only be set
             // when the location is set.
@@ -412,7 +411,6 @@
             }
 
             scopes_.Set(p->name->symbol, param);
-            builder_.ir.SetName(param, p->name->symbol.NameView());
             params.Push(param);
         }
         ir_func->SetParams(params);
@@ -855,7 +853,7 @@
         if (!cond) {
             return;
         }
-        SetTerminator(builder_.BreakIf(cond.Get(), current_control->As<ir::Loop>()));
+        SetTerminator(builder_.BreakIf(current_control->As<ir::Loop>(), cond.Get()));
     }
 
     struct AccessorInfo {
diff --git a/src/tint/ir/function.h b/src/tint/ir/function.h
index 0aadc64..4310bc6 100644
--- a/src/tint/ir/function.h
+++ b/src/tint/ir/function.h
@@ -79,6 +79,9 @@
     /// @param z the z size
     void SetWorkgroupSize(uint32_t x, uint32_t y, uint32_t z) { workgroup_size_ = {x, y, z}; }
 
+    /// Clears the workgroup size.
+    void ClearWorkgroupSize() { workgroup_size_ = {}; }
+
     /// @returns the workgroup size information
     std::optional<std::array<uint32_t, 3>> WorkgroupSize() { return workgroup_size_; }
 
@@ -93,6 +96,8 @@
     }
     /// @returns the return builtin attribute
     std::optional<enum ReturnBuiltin> ReturnBuiltin() { return return_.builtin; }
+    /// Clears the return builtin attribute.
+    void ClearReturnBuiltin() { return_.builtin = {}; }
 
     /// Sets the return location
     /// @param loc the location to set
@@ -102,6 +107,8 @@
     }
     /// @returns the return location
     std::optional<Location> ReturnLocation() { return return_.location; }
+    /// Clears the return location attribute.
+    void ClearReturnLocation() { return_.location = {}; }
 
     /// Sets the return as invariant
     /// @param val the invariant value to set
diff --git a/src/tint/ir/function_param.h b/src/tint/ir/function_param.h
index 6a1e8ca..0c138bc 100644
--- a/src/tint/ir/function_param.h
+++ b/src/tint/ir/function_param.h
@@ -70,6 +70,8 @@
     }
     /// @returns the builtin set for the parameter
     std::optional<FunctionParam::Builtin> Builtin() { return builtin_; }
+    /// Clears the builtin attribute.
+    void ClearBuiltin() { builtin_ = {}; }
 
     /// Sets the parameter as invariant
     /// @param val the value to set for invariant
@@ -85,13 +87,15 @@
     }
     /// @returns the location if `Attributes` contains `kLocation`
     std::optional<struct Location> Location() { return location_; }
+    /// Clears the location attribute.
+    void ClearLocation() { location_ = {}; }
 
     /// Sets the binding point
     /// @param group the group
     /// @param binding the binding
     void SetBindingPoint(uint32_t group, uint32_t binding) { binding_point_ = {group, binding}; }
     /// @returns the binding points if `Attributes` contains `kBindingPoint`
-    std::optional<struct BindingPoint> BindingPoint() { return binding_point_; }
+    std::optional<struct BindingPoint>& BindingPoint() { return binding_point_; }
 
   private:
     const type::Type* type_ = nullptr;
diff --git a/src/tint/ir/instruction.cc b/src/tint/ir/instruction.cc
index e8bc12c..635302f 100644
--- a/src/tint/ir/instruction.cc
+++ b/src/tint/ir/instruction.cc
@@ -34,7 +34,7 @@
         result->SetSource(nullptr);
         result->Destroy();
     }
-    alive_ = false;
+    flags_.Add(Flag::kDead);
 }
 
 void Instruction::InsertBefore(Instruction* before) {
diff --git a/src/tint/ir/instruction.h b/src/tint/ir/instruction.h
index 8145258..5b6a940 100644
--- a/src/tint/ir/instruction.h
+++ b/src/tint/ir/instruction.h
@@ -18,6 +18,7 @@
 #include "src/tint/ir/instruction_result.h"
 #include "src/tint/ir/value.h"
 #include "src/tint/utils/castable.h"
+#include "src/tint/utils/enum_set.h"
 
 // Forward declarations
 namespace tint::ir {
@@ -57,7 +58,11 @@
     virtual void Destroy();
 
     /// @returns true if the Instruction has not been destroyed with Destroy()
-    bool Alive() const { return alive_; }
+    bool Alive() const { return !flags_.Contains(Flag::kDead); }
+
+    /// @returns true if the Instruction is sequenced. Sequenced instructions cannot be implicitly
+    /// reordered with other sequenced instructions.
+    bool Sequenced() const { return flags_.Contains(Flag::kSequenced); }
 
     /// Sets the block that owns this instruction
     /// @param block the new owner block
@@ -92,14 +97,22 @@
     Instruction* prev = nullptr;
 
   protected:
+    /// Flags applied to an Instruction
+    enum class Flag {
+        /// The instruction has been destroyed
+        kDead,
+        /// The instruction must not be reordered with another sequenced instruction
+        kSequenced,
+    };
+
     /// Constructor
     Instruction();
 
     /// The block that owns this instruction
     ir::Block* block_ = nullptr;
 
-  private:
-    bool alive_ = true;
+    /// Bitset of instruction flags
+    utils::EnumSet<Flag> flags_;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/load.cc b/src/tint/ir/load.cc
index 0918398..ac62f46 100644
--- a/src/tint/ir/load.cc
+++ b/src/tint/ir/load.cc
@@ -22,6 +22,8 @@
 namespace tint::ir {
 
 Load::Load(InstructionResult* result, Value* from) {
+    flags_.Add(Flag::kSequenced);
+
     TINT_ASSERT(IR, from->Type()->Is<type::Pointer>());
     TINT_ASSERT(IR, from && from->Type()->UnwrapPtr() == result->Type());
 
diff --git a/src/tint/ir/store.cc b/src/tint/ir/store.cc
index d1ea611..23b5f83 100644
--- a/src/tint/ir/store.cc
+++ b/src/tint/ir/store.cc
@@ -20,6 +20,8 @@
 namespace tint::ir {
 
 Store::Store(Value* to, Value* from) {
+    flags_.Add(Flag::kSequenced);
+
     AddOperand(Store::kToOperandOffset, to);
     AddOperand(Store::kFromOperandOffset, from);
 }
diff --git a/src/tint/ir/to_program.cc b/src/tint/ir/to_program.cc
index e3a9604..3ca56a6 100644
--- a/src/tint/ir/to_program.cc
+++ b/src/tint/ir/to_program.cc
@@ -21,6 +21,7 @@
 #include "src/tint/ir/access.h"
 #include "src/tint/ir/binary.h"
 #include "src/tint/ir/block.h"
+#include "src/tint/ir/break_if.h"
 #include "src/tint/ir/call.h"
 #include "src/tint/ir/constant.h"
 #include "src/tint/ir/continue.h"
@@ -118,6 +119,9 @@
     /// The current switch case block
     ir::Block* current_switch_case_ = nullptr;
 
+    // Values that can be inlined.
+    utils::Hashset<ir::Value*, 64> can_inline_;
+
     const ast::Function* Fn(ir::Function* fn) {
         SCOPED_NESTING();
 
@@ -146,6 +150,7 @@
     StatementList Statements(ir::Block* block) {
         StatementList stmts;
         if (block) {
+            MarkInlinable(block);
             TINT_SCOPED_ASSIGNMENT(statements_, &stmts);
             for (auto* inst : *block) {
                 Instruction(inst);
@@ -154,12 +159,80 @@
         return stmts;
     }
 
+    void MarkInlinable(ir::Block* block) {
+        // An ordered list of possibly-inlinable values returned by sequenced instructions that have
+        // not yet been marked-for or ruled-out-for inlining.
+        utils::UniqueVector<ir::Value*, 32> pending_resolution;
+
+        // Walk the instructions of the block starting with the first.
+        for (auto* inst : *block) {
+            // Is the instruction sequenced?
+            bool sequenced = inst->Sequenced();
+
+            // Walk the instruction's operands starting with the right-most.
+            auto operands = inst->Operands();
+            for (auto* operand : utils::Reverse(operands)) {
+                if (!pending_resolution.Contains(operand)) {
+                    continue;
+                }
+                // Operand is in 'pending_resolution'
+
+                if (pending_resolution.TryPop(operand)) {
+                    // Operand was the last sequenced value to be added to 'pending_resolution'
+                    // This operand can be inlined as it does not change the sequencing order.
+                    can_inline_.Add(operand);
+                    sequenced = true;  // Inherit the 'sequenced' flag from the inlined value
+                } else {
+                    // Operand was in 'pending_resolution', but was not the last sequenced value to
+                    // be added. Inlining this operand would break the sequencing order, so must be
+                    // emitted as a let. All preceding pending values must also be emitted as a
+                    // let to prevent them being inlined and breaking the sequencing order.
+                    // Remove all the values in pending upto and including 'operand'.
+                    for (size_t i = 0; i < pending_resolution.Length(); i++) {
+                        if (pending_resolution[i] == operand) {
+                            pending_resolution.Erase(0, i + 1);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (inst->Results().Length() == 1) {
+                // Instruction has a single result value.
+                // Check to see if the result of this instruction is a candidate for inlining.
+                auto* result = inst->Result();
+                // Only values with a single usage can be inlined.
+                // Named values are not inlined, as we want to emit the name for a let.
+                if (result->Usages().Count() == 1 && !mod.NameOf(result).IsValid()) {
+                    if (sequenced) {
+                        // The value comes from a sequenced instruction. We need to ensure
+                        // instruction ordering so add it to 'pending_resolution'.
+                        pending_resolution.Add(result);
+                    } else {
+                        // The value comes from an unsequenced instruction. Just inline.
+                        can_inline_.Add(result);
+                    }
+                    continue;
+                }
+            }
+
+            // At this point the value has been ruled out for inlining.
+
+            if (sequenced) {
+                // A sequenced instruction with zero or multiple return values cannot be inlined.
+                // All preceding sequenced instructions cannot be inlined past this point.
+                pending_resolution.Clear();
+            }
+        }
+    }
+
     void Append(const ast::Statement* inst) { statements_->Push(inst); }
 
     void Instruction(ir::Instruction* inst) {
         tint::Switch(
             inst,                                       //
-            [&](ir::Binary* u) { Binary(u); },          //
+            [&](ir::Binary* i) { Binary(i); },          //
+            [&](ir::BreakIf* i) { BreakIf(i); },        //
             [&](ir::Call* i) { Call(i); },              //
             [&](ir::ExitIf*) {},                        //
             [&](ir::ExitSwitch* i) { ExitSwitch(i); },  //
@@ -214,6 +287,7 @@
 
         StatementList body_stmts;
         {
+            MarkInlinable(l->Body());
             TINT_SCOPED_ASSIGNMENT(statements_, &body_stmts);
             for (auto* inst : *l->Body()) {
                 if (body_stmts.IsEmpty()) {
@@ -293,6 +367,8 @@
 
     void ExitLoop(const ir::ExitLoop*) { Append(b.Break()); }
 
+    void BreakIf(ir::BreakIf* i) { Append(b.BreakIf(Expr(i->Condition()))); }
+
     void Return(ir::Return* ret) {
         if (ret->Args().IsEmpty()) {
             // Return has no arguments.
@@ -615,7 +691,7 @@
     template <typename T>
     void Bind(ir::Value* value, const T* expr) {
         TINT_ASSERT(IR, value);
-        if (CanInline(value)) {
+        if (can_inline_.Remove(value)) {
             // Value will be inlined at its place of usage.
             bool added = bindings_.Add(value, expr);
             if (TINT_UNLIKELY(!added)) {
@@ -627,12 +703,6 @@
         }
     }
 
-    /// @returns true if the if the value can be inlined into its single place
-    /// of usage. Currently a value is inlined if it has a single usage and is unnamed.
-    /// TODO(crbug.com/tint/1902): This logic needs to check that the sequence of side-effecting
-    /// expressions is not changed by inlining the expression. This needs fixing.
-    bool CanInline(Value* val) { return val->Usages().Count() == 1 && !mod.NameOf(val).IsValid(); }
-
     ////////////////////////////////////////////////////////////////////////////////////////////////
     // Helpers
     ////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/tint/ir/to_program_inlining_test.cc b/src/tint/ir/to_program_inlining_test.cc
new file mode 100644
index 0000000..72b9d39
--- /dev/null
+++ b/src/tint/ir/to_program_inlining_test.cc
@@ -0,0 +1,1155 @@
+// 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 <string>
+
+#include "src/tint/ir/disassembler.h"
+#include "src/tint/ir/to_program.h"
+#include "src/tint/ir/to_program_test.h"
+#include "src/tint/utils/string.h"
+#include "src/tint/writer/wgsl/generator.h"
+
+namespace tint::ir::test {
+namespace {
+
+using namespace tint::number_suffixes;        // NOLINT
+using namespace tint::builtin::fluent_types;  // NOLINT
+
+using IRToProgramInliningTest = IRToProgramTest;
+
+////////////////////////////////////////////////////////////////////////////////
+// Load / Store
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, LoadVar_ThenStoreVar_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        b.Store(var, 2_i);
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  v = 2i;
+  return v_1;
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Binary op
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, BinaryOpUnsequencedLHSThenUnsequencedRHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* lhs = b.Add(ty.i32(), 1_i, 2_i);
+        auto* rhs = b.Add(ty.i32(), 3_i, 4_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return ((1i + 2i) + (3i + 4i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpSequencedLHSThenUnsequencedRHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* lhs = b.Call(ty.i32(), fn_a, 1_i);
+        auto* rhs = b.Add(ty.i32(), 2_i, 3_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return (a(1i) + (2i + 3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpUnsequencedLHSThenSequencedRHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* lhs = b.Add(ty.i32(), 1_i, 2_i);
+        auto* rhs = b.Call(ty.i32(), fn_a, 3_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return ((1i + 2i) + a(3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpSequencedLHSThenSequencedRHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* lhs = b.Call(ty.i32(), fn_a, 1_i);
+        auto* rhs = b.Call(ty.i32(), fn_a, 2_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return (a(1i) + a(2i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpUnsequencedRHSThenUnsequencedLHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* rhs = b.Add(ty.i32(), 3_i, 4_i);
+        auto* lhs = b.Add(ty.i32(), 1_i, 2_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return ((1i + 2i) + (3i + 4i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpUnsequencedRHSThenSequencedLHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* rhs = b.Add(ty.i32(), 2_i, 3_i);
+        auto* lhs = b.Call(ty.i32(), fn_a, 1_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return (a(1i) + (2i + 3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpSequencedRHSThenUnsequencedLHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* rhs = b.Call(ty.i32(), fn_a, 3_i);
+        auto* lhs = b.Add(ty.i32(), 1_i, 2_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  return ((1i + 2i) + a(3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, BinaryOpSequencedRHSThenSequencedLHS) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] {
+        auto* rhs = b.Call(ty.i32(), fn_a, 2_i);
+        auto* lhs = b.Call(ty.i32(), fn_a, 1_i);
+        auto* bin = b.Add(ty.i32(), lhs, rhs);
+        b.Return(fn_b, bin);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b() -> i32 {
+  let v_1 = a(2i);
+  return (a(1i) + v_1);
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Call
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, CallSequencedXYZ) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  return b(a(1i), a(2i), a(3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, CallSequencedYXZ) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  let v_4 = a(2i);
+  return b(a(1i), v_4, a(3i));
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, CallSequencedXZY) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  let v_4 = a(1i);
+  let v_5 = a(3i);
+  return b(v_4, a(2i), v_5);
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, CallSequencedZXY) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  let v_4 = a(3i);
+  return b(a(1i), a(2i), v_4);
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, CallSequencedYZX) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  let v_4 = a(2i);
+  let v_5 = a(3i);
+  return b(a(1i), v_4, v_5);
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, CallSequencedZYX) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 0_i); });
+    fn_a->SetParams({b.FunctionParam(ty.i32())});
+
+    auto* fn_b = b.Function("b", ty.i32());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, 0_i); });
+    fn_b->SetParams(
+        {b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32()), b.FunctionParam(ty.i32())});
+
+    auto* fn_c = b.Function("c", ty.i32());
+    b.With(fn_c->Block(), [&] {
+        auto* z = b.Call(ty.i32(), fn_a, 3_i);
+        auto* y = b.Call(ty.i32(), fn_a, 2_i);
+        auto* x = b.Call(ty.i32(), fn_a, 1_i);
+        auto* call = b.Call(ty.i32(), fn_b, x, y, z);
+        b.Return(fn_c, call);
+    });
+
+    EXPECT_WGSL(R"(
+fn a(v : i32) -> i32 {
+  return 0i;
+}
+
+fn b(v_1 : i32, v_2 : i32, v_3 : i32) -> i32 {
+  return 0i;
+}
+
+fn c() -> i32 {
+  let v_4 = a(3i);
+  let v_5 = a(2i);
+  return b(a(1i), v_5, v_4);
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenCallVoidFn_ThenUseLoad) {
+    auto* fn_a = b.Function("a", ty.void_());
+
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        b.Call(ty.void_(), fn_a);
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn a() {
+}
+
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  a();
+  return v_1;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenCallUnusedi32Fn_ThenUseLoad) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 1_i); });
+
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        b.Call(ty.i32(), fn_a);
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn a() -> i32 {
+  return 1i;
+}
+
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  a();
+  return v_1;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenCalli32Fn_ThenUseLoadBeforeCall) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 1_i); });
+
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* call = b.Call(ty.i32(), fn_a);
+        b.Return(fn, b.Add(ty.i32(), load, call));
+    });
+
+    EXPECT_WGSL(R"(
+fn a() -> i32 {
+  return 1i;
+}
+
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  return (v + a());
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenCalli32Fn_ThenUseCallBeforeLoad) {
+    auto* fn_a = b.Function("a", ty.i32());
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, 1_i); });
+
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* call = b.Call(ty.i32(), fn_a);
+        b.Return(fn, b.Add(ty.i32(), call, load));
+    });
+
+    EXPECT_WGSL(R"(
+fn a() -> i32 {
+  return 1i;
+}
+
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  return (a() + v_1);
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// If
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, UnsequencedOutsideIf) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* if_ = b.If(true);
+        b.With(if_->True(), [&] { b.Return(fn, v); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  if (true) {
+    return (1i + 2i);
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedOutsideIf) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        var->SetInitializer(b.Constant(1_i));
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Add(ty.i32(), v_1, 2_i);
+        auto* if_ = b.If(true);
+        b.With(if_->True(), [&] { b.Return(fn, v_2); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32 = 1i;
+  let v_1 = (v + 2i);
+  if (true) {
+    return v_1;
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, UnsequencedUsedByIfCondition) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Equal(ty.bool_(), 1_i, 2_i);
+        auto* if_ = b.If(v);
+        b.With(if_->True(), [&] { b.Return(fn, 3_i); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  if ((1i == 2i)) {
+    return 3i;
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedUsedByIfCondition) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        var->SetInitializer(b.Constant(1_i));
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Equal(ty.bool_(), v_1, 2_i);
+        auto* if_ = b.If(v_2);
+        b.With(if_->True(), [&] { b.Return(fn, 3_i); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32 = 1i;
+  if ((v == 2i)) {
+    return 3i;
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenWriteToVarInIf_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* if_ = b.If(true);
+        b.With(if_->True(), [&] { b.Store(var, 2_i); });
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  if (true) {
+    v = 2i;
+  }
+  return v_1;
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Switch
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, UnsequencedOutsideSwitch) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* switch_ = b.Switch(3_i);
+        auto* case_ = b.Case(switch_, {Switch::CaseSelector{}});
+        b.With(case_, [&] { b.Return(fn, v); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  switch(3i) {
+    default: {
+      return (1i + 2i);
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedOutsideSwitch) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        var->SetInitializer(b.Constant(1_i));
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Add(ty.i32(), v_1, 2_i);
+        auto* switch_ = b.Switch(3_i);
+        auto* case_ = b.Case(switch_, {Switch::CaseSelector{}});
+        b.With(case_, [&] { b.Return(fn, v_2); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32 = 1i;
+  let v_1 = (v + 2i);
+  switch(3i) {
+    default: {
+      return v_1;
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, UnsequencedUsedBySwitchCondition) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* switch_ = b.Switch(v);
+        auto* case_ = b.Case(switch_, {Switch::CaseSelector{}});
+        b.With(case_, [&] { b.Return(fn, 3_i); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  switch((1i + 2i)) {
+    default: {
+      return 3i;
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedUsedBySwitchCondition) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        var->SetInitializer(b.Constant(1_i));
+        auto* v_1 = b.Load(var);
+        auto* switch_ = b.Switch(v_1);
+        auto* case_ = b.Case(switch_, {Switch::CaseSelector{}});
+        b.With(case_, [&] { b.Return(fn, 3_i); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32 = 1i;
+  switch(v) {
+    default: {
+      return 3i;
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenWriteToVarInSwitch_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* switch_ = b.Switch(1_i);
+        auto* case_ = b.Case(switch_, {Switch::CaseSelector{}});
+        b.With(case_, [&] { b.Store(var, 2_i); });
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  switch(1i) {
+    default: {
+      v = 2i;
+    }
+  }
+  return v_1;
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Loop
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramInliningTest, UnsequencedOutsideLoopInitializer) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Initializer(), [&] { b.Store(var, v); });
+        b.With(loop->Body(), [&] { b.ExitLoop(loop); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  {
+    v = (1i + 2i);
+    loop {
+      break;
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedOutsideLoopInitializer) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Add(ty.i32(), v_1, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Initializer(), [&] { b.Store(var, v_2); });
+        b.With(loop->Body(), [&] { b.ExitLoop(loop); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  let v_1 = (v + 2i);
+  {
+    v = v_1;
+    loop {
+      break;
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenWriteToVarInLoopInitializer_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* loop = b.Loop();
+        b.With(loop->Initializer(), [&] { b.Store(var, 2_i); });
+        b.With(loop->Body(), [&] { b.ExitLoop(loop); });
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  {
+    v = 2i;
+    loop {
+      break;
+    }
+  }
+  return v_1;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, UnsequencedOutsideLoopBody) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] { b.Return(fn, v); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  loop {
+    return (1i + 2i);
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedOutsideLoopBody) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Add(ty.i32(), v_1, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] { b.Return(fn, v_2); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  let v_1 = (v + 2i);
+  loop {
+    return v_1;
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenWriteToVarInLoopBody_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] {
+            b.Store(var, 2_i);
+            b.ExitLoop(loop);
+        });
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  loop {
+    v = 2i;
+    break;
+  }
+  return v_1;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, UnsequencedOutsideLoopContinuing) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* v = b.Add(ty.i32(), 1_i, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] { b.Continue(loop); });
+        b.With(loop->Continuing(), [&] { b.BreakIf(loop, b.Equal(ty.bool_(), v, 3_i)); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  loop {
+
+    continuing {
+      break if ((1i + 2i) == 3i);
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, SequencedOutsideLoopContinuing) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        auto* v_1 = b.Load(var);
+        auto* v_2 = b.Add(ty.i32(), v_1, 2_i);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] { b.Continue(loop); });
+        b.With(loop->Continuing(), [&] { b.BreakIf(loop, b.Equal(ty.bool_(), v_2, 3_i)); });
+        b.Return(fn, 0_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  let v_1 = (v + 2i);
+  loop {
+
+    continuing {
+      break if (v_1 == 3i);
+    }
+  }
+  return 0i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVar_ThenWriteToVarInLoopContinuing_ThenUseLoad) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* load = b.Load(var);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] { b.Continue(loop); });
+        b.With(loop->Continuing(), [&] {
+            b.Store(var, 2_i);
+            b.NextIteration(loop);
+        });
+        b.With(loop->Body(), [&] {
+            b.Store(var, 2_i);
+            b.ExitLoop(loop);
+        });
+        b.Return(fn, load);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  let v_1 = v;
+  loop {
+    v = 2i;
+    break;
+
+    continuing {
+      v = 2i;
+    }
+  }
+  return v_1;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVarInLoopInitializer_ThenReadAndWriteToVarInLoopBody) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* loop = b.Loop();
+        b.With(loop->Initializer(), [&] {
+            auto* load = b.Load(var);
+            b.With(loop->Body(), [&] {
+                b.Store(var, b.Add(ty.i32(), load, 1_i));
+                b.ExitLoop(loop);
+            });
+        });
+        b.Return(fn, 3_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  {
+    let v_1 = v;
+    loop {
+      v = (v_1 + 1i);
+      break;
+    }
+  }
+  return 3i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVarInLoopInitializer_ThenReadAndWriteToVarInLoopContinuing) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* loop = b.Loop();
+        b.With(loop->Initializer(), [&] {
+            auto* load = b.Load(var);
+            b.With(loop->Body(), [&] { b.Continue(loop); });
+            b.With(loop->Continuing(), [&] {
+                b.Store(var, b.Add(ty.i32(), load, 1_i));
+                b.BreakIf(loop, true);
+            });
+        });
+        b.Return(fn, 3_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  {
+    let v_1 = v;
+    loop {
+
+      continuing {
+        v = (v_1 + 1i);
+        break if true;
+      }
+    }
+  }
+  return 3i;
+}
+)");
+}
+
+TEST_F(IRToProgramInliningTest, LoadVarInLoopBody_ThenReadAndWriteToVarInLoopContinuing) {
+    auto* fn = b.Function("f", ty.i32());
+    b.With(fn->Block(), [&] {
+        auto* var = b.Var(ty.ptr<function, i32>());
+        b.Store(var, 1_i);
+        auto* loop = b.Loop();
+        b.With(loop->Body(), [&] {
+            auto* load = b.Load(var);
+            b.Continue(loop);
+
+            b.With(loop->Continuing(), [&] {
+                b.Store(var, b.Add(ty.i32(), load, 1_i));
+                b.BreakIf(loop, true);
+            });
+        });
+        b.Return(fn, 3_i);
+    });
+
+    EXPECT_WGSL(R"(
+fn f() -> i32 {
+  var v : i32;
+  v = 1i;
+  loop {
+    let v_1 = v;
+
+    continuing {
+      v = (v_1 + 1i);
+      break if true;
+    }
+  }
+  return 3i;
+}
+)");
+}
+
+}  // namespace
+}  // namespace tint::ir::test
diff --git a/src/tint/ir/to_program_roundtrip_test.cc b/src/tint/ir/to_program_roundtrip_test.cc
index c8552bc..c5b482a 100644
--- a/src/tint/ir/to_program_roundtrip_test.cc
+++ b/src/tint/ir/to_program_roundtrip_test.cc
@@ -264,7 +264,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Short-circuiting binary ops
 ////////////////////////////////////////////////////////////////////////////////
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Param_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_2) {
     Test(R"(
 fn f(a : bool, b : bool) -> bool {
   return (a && b);
@@ -272,7 +272,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Param_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_3_ab_c) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return ((a && b) && c);
@@ -280,7 +280,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Param_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Param_3_a_bc) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return ((a && b) && c);
@@ -288,7 +288,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Let_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_2) {
     Test(R"(
 fn f(a : bool, b : bool) -> bool {
   let l = (a && b);
@@ -297,7 +297,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Let_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_3_ab_c) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = ((a && b) && c);
@@ -306,7 +306,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Let_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Let_3_a_bc) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = (a && (b && c));
@@ -315,7 +315,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Call_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_2) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -331,7 +331,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Call_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_3_ab_c) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -351,7 +351,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalAnd_Call_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_And_Call_3_a_bc) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -371,7 +371,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Param_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_2) {
     Test(R"(
 fn f(a : bool, b : bool) -> bool {
   return (a || b);
@@ -379,7 +379,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Param_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_3_ab_c) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return ((a || b) || c);
@@ -387,7 +387,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Param_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Param_3_a_bc) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return (a || (b || c));
@@ -395,7 +395,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Let_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_2) {
     Test(R"(
 fn f(a : bool, b : bool) -> bool {
   let l = (a || b);
@@ -404,7 +404,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Let_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_3_ab_c) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = ((a || b) || c);
@@ -413,7 +413,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Let_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Let_3_a_bc) {
     Test(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = (a || (b || c));
@@ -422,7 +422,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Call_2) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_2) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -438,7 +438,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Call_3_ab_c) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_3_ab_c) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -458,7 +458,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalOr_Call_3_a_bc) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Or_Call_3_a_bc) {
     Test(R"(
 fn a() -> bool {
   return true;
@@ -478,7 +478,7 @@
 )");
 }
 
-TEST_F(IRToProgramRoundtripTest, BinaryOp_LogicalMixed) {
+TEST_F(IRToProgramRoundtripTest, ShortCircuit_Mixed) {
     Test(R"(
 fn b() -> bool {
   return true;
diff --git a/src/tint/ir/to_program_test.cc b/src/tint/ir/to_program_test.cc
index 8cfae5c..00b5681 100644
--- a/src/tint/ir/to_program_test.cc
+++ b/src/tint/ir/to_program_test.cc
@@ -12,65 +12,59 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <sstream>
 #include <string>
 
 #include "src/tint/ir/disassembler.h"
-#include "src/tint/ir/ir_test_helper.h"
 #include "src/tint/ir/to_program.h"
+#include "src/tint/ir/to_program_test.h"
 #include "src/tint/utils/string.h"
 #include "src/tint/writer/wgsl/generator.h"
 
-#if !TINT_BUILD_WGSL_WRITER
-#error "to_program_test.cc requires both the WGSL writer to be enabled"
-#endif
-
-namespace tint::ir {
-namespace {
+namespace tint::ir::test {
 
 using namespace tint::number_suffixes;        // NOLINT
 using namespace tint::builtin::fluent_types;  // NOLINT
 
-class IRToProgramTest : public IRTestHelper {
-  public:
-    void Test(std::string_view expected_wgsl) {
-        tint::ir::Disassembler d{mod};
-        auto disassembly = d.Disassemble();
+IRToProgramTest::Result IRToProgramTest::Run() {
+    Result result;
 
-        auto output_program = ToProgram(mod);
-        if (!output_program.IsValid()) {
-            FAIL() << output_program.Diagnostics().str() << std::endl  //
-                   << "IR:" << std::endl                               //
-                   << disassembly << std::endl                         //
-                   << "AST:" << std::endl                              //
-                   << Program::printer(&output_program) << std::endl;
-        }
+    tint::ir::Disassembler d{mod};
+    result.ir = d.Disassemble();
 
-        ASSERT_TRUE(output_program.IsValid()) << output_program.Diagnostics().str();
-
-        auto output = writer::wgsl::Generate(&output_program, {});
-        ASSERT_TRUE(output.success) << output.error;
-
-        auto expected = std::string(utils::TrimSpace(expected_wgsl));
-        if (!expected.empty()) {
-            expected = "\n" + expected + "\n";
-        }
-        auto got = std::string(utils::TrimSpace(output.wgsl));
-        if (!got.empty()) {
-            got = "\n" + got + "\n";
-        }
-        EXPECT_EQ(expected, got) << "IR:" << std::endl << disassembly;
+    auto output_program = ToProgram(mod);
+    if (!output_program.IsValid()) {
+        result.err = output_program.Diagnostics().str();
+        result.ast = Program::printer(&output_program);
+        return result;
     }
-};
+
+    auto output = writer::wgsl::Generate(&output_program, {});
+    if (!output.success) {
+        std::stringstream ss;
+        ss << "wgsl::Generate() errored: " << output.error;
+        result.err = ss.str();
+        return result;
+    }
+
+    result.wgsl = std::string(utils::TrimSpace(output.wgsl));
+    if (!result.wgsl.empty()) {
+        result.wgsl = "\n" + result.wgsl + "\n";
+    }
+
+    return result;
+}
+
+namespace {
 
 TEST_F(IRToProgramTest, EmptyModule) {
-    Test("");
+    EXPECT_WGSL("");
 }
 
 TEST_F(IRToProgramTest, SingleFunction_Empty) {
-    auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
+    b.Function("f", ty.void_());
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
 }
 )");
@@ -78,11 +72,10 @@
 
 TEST_F(IRToProgramTest, SingleFunction_Return) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     fn->Block()->Append(b.Return(fn));
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
 }
 )");
@@ -90,11 +83,10 @@
 
 TEST_F(IRToProgramTest, SingleFunction_Return_i32) {
     auto* fn = b.Function("f", ty.i32());
-    mod.functions.Push(fn);
 
     fn->Block()->Append(b.Return(fn, 42_i));
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() -> i32 {
   return 42i;
 }
@@ -103,16 +95,13 @@
 
 TEST_F(IRToProgramTest, SingleFunction_Parameters) {
     auto* fn = b.Function("f", ty.i32());
-    auto* i = b.FunctionParam(ty.i32());
-    auto* u = b.FunctionParam(ty.u32());
-    mod.SetName(i, "i");
-    mod.SetName(u, "u");
+    auto* i = b.FunctionParam("i", ty.i32());
+    auto* u = b.FunctionParam("u", ty.u32());
     fn->SetParams({i, u});
-    mod.functions.Push(fn);
 
     fn->Block()->Append(b.Return(fn, i));
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(i : i32, u : u32) -> i32 {
   return i;
 }
@@ -124,14 +113,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, UnaryOp_Negate) {
     auto* fn = b.Function("f", ty.i32());
-    auto* i = b.FunctionParam(ty.i32());
-    mod.SetName(i, "i");
+    auto* i = b.FunctionParam("i", ty.i32());
     fn->SetParams({i});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Negation(ty.i32(), i)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(i : i32) -> i32 {
   return -(i);
 }
@@ -140,14 +127,12 @@
 
 TEST_F(IRToProgramTest, UnaryOp_Complement) {
     auto* fn = b.Function("f", ty.u32());
-    auto* i = b.FunctionParam(ty.u32());
-    mod.SetName(i, "i");
+    auto* i = b.FunctionParam("i", ty.u32());
     fn->SetParams({i});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Complement(ty.u32(), i)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(i : u32) -> u32 {
   return ~(i);
 }
@@ -156,14 +141,12 @@
 
 TEST_F(IRToProgramTest, UnaryOp_Not) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* i = b.FunctionParam(ty.bool_());
-    mod.SetName(i, "b");
+    auto* i = b.FunctionParam("b", ty.bool_());
     fn->SetParams({i});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Not(ty.bool_(), i)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(b : bool) -> bool {
   return !(b);
 }
@@ -175,16 +158,13 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, BinaryOp_Add) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Add(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a + b);
 }
@@ -193,16 +173,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Subtract) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Subtract(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a - b);
 }
@@ -211,16 +188,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Multiply) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Multiply(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a * b);
 }
@@ -229,16 +203,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Divide) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Divide(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a / b);
 }
@@ -247,16 +218,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Modulo) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Modulo(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a % b);
 }
@@ -265,16 +233,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_And) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.And(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a & b);
 }
@@ -283,16 +248,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Or) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Or(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a | b);
 }
@@ -301,16 +263,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Xor) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Xor(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> i32 {
   return (a ^ b);
 }
@@ -319,16 +278,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_Equal) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.Equal(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a == b);
 }
@@ -337,16 +293,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_NotEqual) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.NotEqual(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a != b);
 }
@@ -355,16 +308,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_LessThan) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.LessThan(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a < b);
 }
@@ -373,16 +323,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_GreaterThan) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.GreaterThan(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a > b);
 }
@@ -391,16 +338,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_LessThanEqual) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.LessThanEqual(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a <= b);
 }
@@ -409,16 +353,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_GreaterThanEqual) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.i32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.i32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.GreaterThanEqual(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : i32) -> bool {
   return (a >= b);
 }
@@ -427,16 +368,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_ShiftLeft) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.u32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.u32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.ShiftLeft(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : u32) -> i32 {
   return (a << b);
 }
@@ -445,16 +383,13 @@
 
 TEST_F(IRToProgramTest, BinaryOp_ShiftRight) {
     auto* fn = b.Function("f", ty.i32());
-    auto* pa = b.FunctionParam(ty.i32());
-    auto* pb = b.FunctionParam(ty.u32());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.i32());
+    auto* pb = b.FunctionParam("b", ty.u32());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] { b.Return(fn, b.ShiftRight(ty.i32(), pa, pb)); });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : i32, b : u32) -> i32 {
   return (a >> b);
 }
@@ -464,14 +399,11 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Short-circuiting binary ops
 ////////////////////////////////////////////////////////////////////////////////
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Param_2) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Param_2) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(pa);
@@ -482,23 +414,19 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool) -> bool {
   return (a && b);
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Param_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Param_3_ab_c) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(pa);
@@ -514,52 +442,47 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return ((a && b) && c);
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Param_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Param_3_a_bc) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(pb);
+        auto* if1 = b.If(pa);
         if1->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if1->True(), [&] { b.ExitIf(if1, pc); });
-        b.With(if1->False(), [&] { b.ExitIf(if1, false); });
+        b.With(if1->True(), [&] {
+            auto* if2 = b.If(pb);
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, pc); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, false); });
 
-        auto* if2 = b.If(pa);
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
-        b.Return(fn, if2->Result(0));
+            b.ExitIf(if1, if2->Result(0));
+        });
+        b.With(if1->False(), [&] { b.ExitIf(if1, false); });
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return (a && (b && c));
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Let_2) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Let_2) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(pa);
@@ -571,7 +494,7 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool) -> bool {
   let l = (a && b);
   return l;
@@ -579,16 +502,12 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Let_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Let_3_ab_c) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(pa);
@@ -605,7 +524,7 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = ((a && b) && c);
   return l;
@@ -613,33 +532,31 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Let_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Let_3_a_bc) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(pb);
+        auto* if1 = b.If(pa);
         if1->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if1->True(), [&] { b.ExitIf(if1, pc); });
+        b.With(if1->True(), [&] {
+            auto* if2 = b.If(pb);
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, pc); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, false); });
+
+            b.ExitIf(if1, if2->Result(0));
+        });
         b.With(if1->False(), [&] { b.ExitIf(if1, false); });
 
-        auto* if2 = b.If(pa);
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
-
-        mod.SetName(if2->Result(0), "l");
-        b.Return(fn, if2->Result(0));
+        mod.SetName(if1->Result(0), "l");
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = (a && (b && c));
   return l;
@@ -647,17 +564,14 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Call_2) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Call_2) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(b.Call(ty.bool_(), fn_a));
@@ -668,7 +582,7 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -683,21 +597,17 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Call_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Call_3_ab_c) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn_c = b.Function("c", ty.bool_());
-    mod.functions.Push(fn_c);
     b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(b.Call(ty.bool_(), fn_a));
@@ -713,7 +623,7 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -732,37 +642,35 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalAnd_Call_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_And_Call_3_a_bc) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn_c = b.Function("c", ty.bool_());
-    mod.functions.Push(fn_c);
     b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_a));
         if1->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if1->True(), [&] { b.ExitIf(if1, b.Call(ty.bool_(), fn_c)); });
+        b.With(if1->True(), [&] {
+            auto* if2 = b.If(b.Call(ty.bool_(), fn_b));
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, b.Call(ty.bool_(), fn_c)); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, false); });
+
+            b.ExitIf(if1, if2->Result(0));
+        });
         b.With(if1->False(), [&] { b.ExitIf(if1, false); });
 
-        auto* if2 = b.If(b.Call(ty.bool_(), fn_a));
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
-
-        b.Return(fn, if2->Result(0));
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -781,14 +689,11 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Param_2) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Param_2) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(pa);
@@ -799,23 +704,19 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool) -> bool {
   return (a || b);
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Param_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Param_3_ab_c) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(pa);
@@ -831,53 +732,48 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return ((a || b) || c);
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Param_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Param_3_a_bc) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(pb);
+        auto* if1 = b.If(pa);
         if1->SetResults(b.InstructionResult(ty.bool_()));
         b.With(if1->True(), [&] { b.ExitIf(if1, true); });
-        b.With(if1->False(), [&] { b.ExitIf(if1, pc); });
+        b.With(if1->False(), [&] {
+            auto* if2 = b.If(pb);
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, pc); });
 
-        auto* if2 = b.If(pa);
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+            b.ExitIf(if1, if2->Result(0));
+        });
 
-        b.Return(fn, if2->Result(0));
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   return (a || (b || c));
 }
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Let_2) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Let_2) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
     fn->SetParams({pa, pb});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(pa);
@@ -889,7 +785,7 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool) -> bool {
   let l = (a || b);
   return l;
@@ -897,16 +793,12 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Let_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Let_3_ab_c) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(pa);
@@ -923,7 +815,7 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = ((a || b) || c);
   return l;
@@ -931,33 +823,31 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Let_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Let_3_a_bc) {
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pb, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(pb);
+        auto* if1 = b.If(pa);
         if1->SetResults(b.InstructionResult(ty.bool_()));
         b.With(if1->True(), [&] { b.ExitIf(if1, true); });
-        b.With(if1->False(), [&] { b.ExitIf(if1, pc); });
+        b.With(if1->False(), [&] {
+            auto* if2 = b.If(pb);
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, pc); });
 
-        auto* if2 = b.If(pa);
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+            b.ExitIf(if1, if2->Result(0));
+        });
 
-        mod.SetName(if2->Result(0), "l");
-        b.Return(fn, if2->Result(0));
+        mod.SetName(if1->Result(0), "l");
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(a : bool, b : bool, c : bool) -> bool {
   let l = (a || (b || c));
   return l;
@@ -965,17 +855,14 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Call_2) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Call_2) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(b.Call(ty.bool_(), fn_a));
@@ -986,7 +873,7 @@
         b.Return(fn, if_->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -1001,21 +888,17 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Call_3_ab_c) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Call_3_ab_c) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn_c = b.Function("c", ty.bool_());
-    mod.functions.Push(fn_c);
     b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(b.Call(ty.bool_(), fn_a));
@@ -1031,7 +914,7 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -1050,37 +933,35 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalOr_Call_3_a_bc) {
+TEST_F(IRToProgramTest, ShortCircuit_Or_Call_3_a_bc) {
     auto* fn_a = b.Function("a", ty.bool_());
-    mod.functions.Push(fn_a);
     b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
 
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn_c = b.Function("c", ty.bool_());
-    mod.functions.Push(fn_c);
     b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_a));
         if1->SetResults(b.InstructionResult(ty.bool_()));
         b.With(if1->True(), [&] { b.ExitIf(if1, true); });
-        b.With(if1->False(), [&] { b.ExitIf(if1, b.Call(ty.bool_(), fn_c)); });
+        b.With(if1->False(), [&] {
+            auto* if2 = b.If(b.Call(ty.bool_(), fn_b));
+            if2->SetResults(b.InstructionResult(ty.bool_()));
+            b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+            b.With(if2->False(), [&] { b.ExitIf(if2, b.Call(ty.bool_(), fn_c)); });
 
-        auto* if2 = b.If(b.Call(ty.bool_(), fn_a));
-        if2->SetResults(b.InstructionResult(ty.bool_()));
-        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
-        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+            b.ExitIf(if1, if2->Result(0));
+        });
 
-        b.Return(fn, if2->Result(0));
+        b.Return(fn, if1->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() -> bool {
   return true;
 }
@@ -1099,22 +980,17 @@
 )");
 }
 
-TEST_F(IRToProgramTest, BinaryOp_LogicalMixed) {
+TEST_F(IRToProgramTest, ShortCircuit_Mixed) {
     auto* fn_b = b.Function("b", ty.bool_());
-    mod.functions.Push(fn_b);
     b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
 
     auto* fn_d = b.Function("d", ty.bool_());
-    mod.functions.Push(fn_d);
     b.With(fn_d->Block(), [&] { b.Return(fn_d, true); });
 
     auto* fn = b.Function("f", ty.bool_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pc, "c");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
     fn->SetParams({pa, pc});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if1 = b.If(pa);
@@ -1138,7 +1014,7 @@
         b.Return(fn, if2->Result(0));
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn b() -> bool {
   return true;
 }
@@ -1155,19 +1031,266 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Non short-circuiting binary ops
+// Similar to the above, but cannot be short-circuited as the RHS is evaluated
+// outside of the if block.
+////////////////////////////////////////////////////////////////////////////////
+TEST_F(IRToProgramTest, NonShortCircuit_And_ParamCallParam_a_bc) {
+    auto* fn_b = b.Function("b", ty.bool_());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
+
+    auto* fn = b.Function("f", ty.bool_());
+    auto* pa = b.FunctionParam(ty.bool_());
+    auto* pc = b.FunctionParam(ty.bool_());
+    mod.SetName(pa, "a");
+    mod.SetName(pc, "c");
+    fn->SetParams({pa, pc});
+
+    b.With(fn->Block(), [&] {
+        // 'b() && c' is evaluated before 'a'.
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, pc); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, false); });
+
+        auto* if2 = b.If(pa);
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn b() -> bool {
+  return true;
+}
+
+fn f(a : bool, c : bool) -> bool {
+  let v = (b() && c);
+  return (a && v);
+}
+)");
+}
+
+TEST_F(IRToProgramTest, NonShortCircuit_And_Call_3_a_bc) {
+    auto* fn_a = b.Function("a", ty.bool_());
+
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
+
+    auto* fn_b = b.Function("b", ty.bool_());
+
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
+
+    auto* fn_c = b.Function("c", ty.bool_());
+
+    b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
+
+    auto* fn = b.Function("f", ty.bool_());
+
+    b.With(fn->Block(), [&] {
+        // 'b() && c()' is evaluated before 'a()'.
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, b.Call(ty.bool_(), fn_c)); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, false); });
+
+        auto* if2 = b.If(b.Call(ty.bool_(), fn_a));
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
+
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn a() -> bool {
+  return true;
+}
+
+fn b() -> bool {
+  return true;
+}
+
+fn c() -> bool {
+  return true;
+}
+
+fn f() -> bool {
+  let v = (b() && c());
+  return (a() && v);
+}
+)");
+}
+
+TEST_F(IRToProgramTest, NonShortCircuit_And_Param_3_a_bc_EarlyEval) {
+    auto* fn = b.Function("f", ty.bool_());
+    auto* pa = b.FunctionParam(ty.bool_());
+    auto* pb = b.FunctionParam(ty.bool_());
+    auto* pc = b.FunctionParam(ty.bool_());
+    mod.SetName(pa, "a");
+    mod.SetName(pb, "b");
+    mod.SetName(pc, "c");
+    fn->SetParams({pa, pb, pc});
+
+    b.With(fn->Block(), [&] {
+        // 'b && c' is evaluated outside the true block of if2, but these can be moved to the RHS
+        // of the 'a &&' as the 'b && c' is not sequenced.
+        auto* if1 = b.If(pb);
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, pc); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, false); });
+
+        auto* if2 = b.If(pa);
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, if1->Result(0)); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, false); });
+
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn f(a : bool, b : bool, c : bool) -> bool {
+  let v = (b && c);
+  return (a && v);
+}
+)");
+}
+
+TEST_F(IRToProgramTest, NonShortCircuit_Or_ParamCallParam_a_bc) {
+    auto* fn_b = b.Function("b", ty.bool_());
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
+
+    auto* fn = b.Function("f", ty.bool_());
+    auto* pa = b.FunctionParam(ty.bool_());
+    auto* pc = b.FunctionParam(ty.bool_());
+    mod.SetName(pa, "a");
+    mod.SetName(pc, "c");
+    fn->SetParams({pa, pc});
+
+    b.With(fn->Block(), [&] {
+        // 'b() && c' is evaluated before 'a'.
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, true); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, pc); });
+
+        auto* if2 = b.If(pa);
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+
+        mod.SetName(if2->Result(0), "l");
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn b() -> bool {
+  return true;
+}
+
+fn f(a : bool, c : bool) -> bool {
+  let v = (b() || c);
+  let l = (a || v);
+  return l;
+}
+)");
+}
+
+TEST_F(IRToProgramTest, NonShortCircuit_Or_Call_3_a_bc) {
+    auto* fn_a = b.Function("a", ty.bool_());
+
+    b.With(fn_a->Block(), [&] { b.Return(fn_a, true); });
+
+    auto* fn_b = b.Function("b", ty.bool_());
+
+    b.With(fn_b->Block(), [&] { b.Return(fn_b, true); });
+
+    auto* fn_c = b.Function("c", ty.bool_());
+
+    b.With(fn_c->Block(), [&] { b.Return(fn_c, true); });
+
+    auto* fn = b.Function("f", ty.bool_());
+
+    b.With(fn->Block(), [&] {
+        auto* if1 = b.If(b.Call(ty.bool_(), fn_b));
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, true); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, b.Call(ty.bool_(), fn_c)); });
+
+        auto* if2 = b.If(b.Call(ty.bool_(), fn_a));
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn a() -> bool {
+  return true;
+}
+
+fn b() -> bool {
+  return true;
+}
+
+fn c() -> bool {
+  return true;
+}
+
+fn f() -> bool {
+  let v = (b() || c());
+  return (a() || v);
+}
+)");
+}
+
+TEST_F(IRToProgramTest, NonShortCircuit_Or_Param_3_a_bc_EarlyEval) {
+    auto* fn = b.Function("f", ty.bool_());
+    auto* pa = b.FunctionParam(ty.bool_());
+    auto* pb = b.FunctionParam(ty.bool_());
+    auto* pc = b.FunctionParam(ty.bool_());
+    mod.SetName(pa, "a");
+    mod.SetName(pb, "b");
+    mod.SetName(pc, "c");
+    fn->SetParams({pa, pb, pc});
+
+    b.With(fn->Block(), [&] {
+        // 'b || c' is evaluated outside the true block of if2, but these can be moved to the RHS
+        // of the 'a ||' as the 'b || c' is not sequenced.
+        auto* if1 = b.If(pb);
+        if1->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if1->True(), [&] { b.ExitIf(if1, true); });
+        b.With(if1->False(), [&] { b.ExitIf(if1, pc); });
+
+        auto* if2 = b.If(pa);
+        if2->SetResults(b.InstructionResult(ty.bool_()));
+        b.With(if2->True(), [&] { b.ExitIf(if2, true); });
+        b.With(if2->False(), [&] { b.ExitIf(if2, if1->Result(0)); });
+
+        b.Return(fn, if2->Result(0));
+    });
+
+    EXPECT_WGSL(R"(
+fn f(a : bool, b : bool, c : bool) -> bool {
+  let v = (b || c);
+  return (a || v);
+}
+)");
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Compound assignment
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, CompoundAssign_Increment) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Add(ty.i32(), b.Load(v), 1_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v + 1i);
@@ -1177,15 +1300,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Decrement) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Subtract(ty.i32(), b.Load(v), 1_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v - 1i);
@@ -1195,15 +1316,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Add) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Add(ty.i32(), b.Load(v), 8_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v + 8i);
@@ -1213,15 +1332,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Subtract) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Subtract(ty.i32(), b.Load(v), 8_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v - 8i);
@@ -1231,15 +1348,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Multiply) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Multiply(ty.i32(), b.Load(v), 8_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v * 8i);
@@ -1249,15 +1364,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Divide) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Divide(ty.i32(), b.Load(v), 8_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v / 8i);
@@ -1267,15 +1380,13 @@
 
 TEST_F(IRToProgramTest, CompoundAssign_Xor) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         b.Store(v, b.Xor(ty.i32(), b.Load(v), 8_i));
-        mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var v : i32;
   v = (v ^ 8i);
@@ -1288,10 +1399,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, LetUsedOnce) {
     auto* fn = b.Function("f", ty.u32());
-    auto* i = b.FunctionParam(ty.u32());
-    mod.SetName(i, "i");
+    auto* i = b.FunctionParam("i", ty.u32());
     fn->SetParams({i});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* v = b.Complement(ty.u32(), i);
@@ -1299,7 +1408,7 @@
         mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(i : u32) -> u32 {
   let v = ~(i);
   return v;
@@ -1309,10 +1418,8 @@
 
 TEST_F(IRToProgramTest, LetUsedTwice) {
     auto* fn = b.Function("f", ty.i32());
-    auto* i = b.FunctionParam(ty.i32());
-    mod.SetName(i, "i");
+    auto* i = b.FunctionParam("i", ty.i32());
     fn->SetParams({i});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* v = b.Multiply(ty.i32(), i, 2_i);
@@ -1320,7 +1427,7 @@
         mod.SetName(v, "v");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(i : i32) -> i32 {
   let v = (i * 2i);
   return (v + v);
@@ -1333,14 +1440,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, FunctionScopeVar_i32) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
-    b.With(fn->Block(), [&] {
-        auto* i = b.Var(ty.ptr<function, i32>());
-        mod.SetName(i, "i");
+    b.With(fn->Block(), [&] {  //
+        b.Var("i", ty.ptr<function, i32>());
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var i : i32;
 }
@@ -1349,15 +1454,13 @@
 
 TEST_F(IRToProgramTest, FunctionScopeVar_i32_InitLiteral) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* i = b.Var(ty.ptr<function, i32>());
+        auto* i = b.Var("i", ty.ptr<function, i32>());
         i->SetInitializer(b.Constant(42_i));
-        mod.SetName(i, "i");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var i : i32 = 42i;
 }
@@ -1366,26 +1469,21 @@
 
 TEST_F(IRToProgramTest, FunctionScopeVar_Chained) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* va = b.Var(ty.ptr<function, i32>());
+        auto* va = b.Var("a", ty.ptr<function, i32>());
         va->SetInitializer(b.Constant(42_i));
 
         auto* la = b.Load(va)->Result();
-        auto* vb = b.Var(ty.ptr<function, i32>());
+        auto* vb = b.Var("b", ty.ptr<function, i32>());
         vb->SetInitializer(la);
 
         auto* lb = b.Load(vb)->Result();
-        auto* vc = b.Var(ty.ptr<function, i32>());
+        auto* vc = b.Var("c", ty.ptr<function, i32>());
         vc->SetInitializer(lb);
-
-        mod.SetName(va, "a");
-        mod.SetName(vb, "b");
-        mod.SetName(vc, "c");
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var a : i32 = 42i;
   var b : i32 = a;
@@ -1399,13 +1497,10 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, If_CallFn) {
     auto* a = b.Function("a", ty.void_());
-    mod.functions.Push(a);
 
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* if_ = b.If(cond);
@@ -1415,7 +1510,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1429,17 +1524,15 @@
 
 TEST_F(IRToProgramTest, If_Return) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto if_ = b.If(cond);
         b.With(if_->True(), [&] { b.Return(fn); });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   if (cond) {
     return;
@@ -1450,18 +1543,16 @@
 
 TEST_F(IRToProgramTest, If_Return_i32) {
     auto* fn = b.Function("f", ty.i32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* cond = b.Var(ty.ptr<function, bool>());
-        mod.SetName(cond, "cond");
+        auto* cond = b.Var("cond", ty.ptr<function, bool>());
         cond->SetInitializer(b.Constant(true));
         auto if_ = b.If(b.Load(cond));
         b.With(if_->True(), [&] { b.Return(fn, 42_i); });
         b.Return(fn, 10_i);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() -> i32 {
   var cond : bool = true;
   if (cond) {
@@ -1474,16 +1565,12 @@
 
 TEST_F(IRToProgramTest, If_CallFn_Else_CallFn) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn_b = b.Function("b", ty.void_());
-    mod.functions.Push(fn_b);
 
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto if_ = b.If(cond);
@@ -1497,7 +1584,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1516,18 +1603,16 @@
 
 TEST_F(IRToProgramTest, If_Return_f32_Else_Return_f32) {
     auto* fn = b.Function("f", ty.f32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* cond = b.Var(ty.ptr<function, bool>());
-        mod.SetName(cond, "cond");
+        auto* cond = b.Var("cond", ty.ptr<function, bool>());
         cond->SetInitializer(b.Constant(true));
         auto if_ = b.If(b.Load(cond));
         b.With(if_->True(), [&] { b.Return(fn, 1.0_f); });
         b.With(if_->False(), [&] { b.Return(fn, 2.0_f); });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() -> f32 {
   var cond : bool = true;
   if (cond) {
@@ -1541,17 +1626,13 @@
 
 TEST_F(IRToProgramTest, If_Return_u32_Else_CallFn) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn_b = b.Function("b", ty.void_());
-    mod.functions.Push(fn_b);
 
     auto* fn = b.Function("f", ty.u32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* cond = b.Var(ty.ptr<function, bool>());
-        mod.SetName(cond, "cond");
+        auto* cond = b.Var("cond", ty.ptr<function, bool>());
         cond->SetInitializer(b.Constant(true));
         auto if_ = b.If(b.Load(cond));
         b.With(if_->True(), [&] { b.Return(fn, 1_u); });
@@ -1563,7 +1644,7 @@
         b.Return(fn, 2_u);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1585,20 +1666,15 @@
 
 TEST_F(IRToProgramTest, If_CallFn_ElseIf_CallFn) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn_b = b.Function("b", ty.void_());
-    mod.functions.Push(fn_b);
 
     auto* fn_c = b.Function("c", ty.void_());
-    mod.functions.Push(fn_c);
 
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* cond = b.Var(ty.ptr<function, bool>());
-        mod.SetName(cond, "cond");
+        auto* cond = b.Var("cond", ty.ptr<function, bool>());
         cond->SetInitializer(b.Constant(true));
         auto if1 = b.If(b.Load(cond));
         b.With(if1->True(), [&] {
@@ -1616,7 +1692,7 @@
         b.Call(ty.void_(), fn_c);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1640,23 +1716,16 @@
 
 TEST_F(IRToProgramTest, If_Else_Chain) {
     auto* x = b.Function("x", ty.bool_());
-    auto* i = b.FunctionParam(ty.i32());
-    mod.SetName(i, "i");
+    auto* i = b.FunctionParam("i", ty.i32());
     x->SetParams({i});
-    mod.functions.Push(x);
     b.With(x->Block(), [&] { b.Return(x, true); });
 
     auto* fn = b.Function("f", ty.void_());
-    auto* pa = b.FunctionParam(ty.bool_());
-    auto* pb = b.FunctionParam(ty.bool_());
-    auto* pc = b.FunctionParam(ty.bool_());
-    auto* pd = b.FunctionParam(ty.bool_());
-    mod.SetName(pa, "a");
-    mod.SetName(pb, "b");
-    mod.SetName(pc, "c");
-    mod.SetName(pd, "d");
+    auto* pa = b.FunctionParam("a", ty.bool_());
+    auto* pb = b.FunctionParam("b", ty.bool_());
+    auto* pc = b.FunctionParam("c", ty.bool_());
+    auto* pd = b.FunctionParam("d", ty.bool_());
     fn->SetParams({pa, pb, pc, pd});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto if1 = b.If(pa);
@@ -1683,7 +1752,7 @@
             });
         });
     });
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn x(i : i32) -> bool {
   return true;
 }
@@ -1707,14 +1776,11 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, Switch_Default) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
-        mod.SetName(v, "v");
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         v->SetInitializer(b.Constant(42_i));
 
         auto s = b.Switch(b.Load(v));
@@ -1724,7 +1790,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1741,20 +1807,15 @@
 
 TEST_F(IRToProgramTest, Switch_3_Cases) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn_b = b.Function("b", ty.void_());
-    mod.functions.Push(fn_b);
 
     auto* fn_c = b.Function("c", ty.void_());
-    mod.functions.Push(fn_c);
 
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
-        mod.SetName(v, "v");
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         v->SetInitializer(b.Constant(42_i));
 
         auto s = b.Switch(b.Load(v));
@@ -1777,7 +1838,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1806,14 +1867,11 @@
 
 TEST_F(IRToProgramTest, Switch_3_Cases_AllReturn) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
-        mod.SetName(v, "v");
+        auto* v = b.Var("v", ty.ptr<function, i32>());
         v->SetInitializer(b.Constant(42_i));
 
         auto s = b.Switch(b.Load(v));
@@ -1830,7 +1888,7 @@
         b.Return(fn);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1854,24 +1912,18 @@
 
 TEST_F(IRToProgramTest, Switch_Nested) {
     auto* fn_a = b.Function("a", ty.void_());
-    mod.functions.Push(fn_a);
 
-    auto* fn_b = b.Function("b", ty.void_());
-    mod.functions.Push(fn_b);
+    b.Function("b", ty.void_());
 
     auto* fn_c = b.Function("c", ty.void_());
-    mod.functions.Push(fn_c);
 
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* v1 = b.Var(ty.ptr<function, i32>());
-        mod.SetName(v1, "v1");
+        auto* v1 = b.Var("v1", ty.ptr<function, i32>());
         v1->SetInitializer(b.Constant(42_i));
 
-        auto* v2 = b.Var(ty.ptr<function, i32>());
-        mod.SetName(v2, "v2");
+        auto* v2 = b.Var("v2", ty.ptr<function, i32>());
         v2->SetInitializer(b.Constant(24_i));
 
         auto s1 = b.Switch(b.Load(v1));
@@ -1900,7 +1952,7 @@
             b.ExitSwitch(s1);
         });
     });
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a() {
 }
 
@@ -1939,14 +1991,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, For_Empty) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
 
         b.With(loop->Initializer(), [&] {
-            auto* i = b.Var(ty.ptr<function, i32>());
-            mod.SetName(i, "i");
+            auto* i = b.Var("i", ty.ptr<function, i32>());
             i->SetInitializer(b.Constant(0_i));
 
             b.With(loop->Body(), [&] {
@@ -1959,7 +2009,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   for(var i : i32 = 0i; (i < 5i); i = (i + 1i)) {
   }
@@ -1969,11 +2019,9 @@
 
 TEST_F(IRToProgramTest, For_Empty_NoInit) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* i = b.Var(ty.ptr<function, i32>());
-        mod.SetName(i, "i");
+        auto* i = b.Var("i", ty.ptr<function, i32>());
         i->SetInitializer(b.Constant(0_i));
 
         auto* loop = b.Loop();
@@ -1987,7 +2035,7 @@
         b.With(loop->Continuing(), [&] { b.Store(i, b.Add(ty.i32(), b.Load(i), 1_i)); });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var i : i32 = 0i;
   for(; (i < 5i); i = (i + 1i)) {
@@ -1998,14 +2046,12 @@
 
 TEST_F(IRToProgramTest, For_Empty_NoCont) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
 
         b.With(loop->Initializer(), [&] {
-            auto* i = b.Var(ty.ptr<function, i32>());
-            mod.SetName(i, "i");
+            auto* i = b.Var("i", ty.ptr<function, i32>());
             i->SetInitializer(b.Constant(0_i));
 
             b.With(loop->Body(), [&] {
@@ -2016,7 +2062,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   for(var i : i32 = 0i; (i < 5i); ) {
   }
@@ -2026,21 +2072,17 @@
 
 TEST_F(IRToProgramTest, For_ComplexBody) {
     auto* a = b.Function("a", ty.bool_());
-    auto* v = b.FunctionParam(ty.i32());
-    mod.SetName(v, "v");
+    auto* v = b.FunctionParam("v", ty.i32());
     a->SetParams({v});
     b.With(a->Block(), [&] { b.Return(a, b.Equal(ty.bool_(), v, 1_i)); });
-    mod.functions.Push(a);
 
     auto* fn = b.Function("f", ty.i32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
 
         b.With(loop->Initializer(), [&] {
-            auto* i = b.Var(ty.ptr<function, i32>());
-            mod.SetName(i, "i");
+            auto* i = b.Var("i", ty.ptr<function, i32>());
             i->SetInitializer(b.Constant(0_i));
 
             b.With(loop->Body(), [&] {
@@ -2059,7 +2101,7 @@
         b.Return(fn, 3_i);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a(v : i32) -> bool {
   return (v == 1i);
 }
@@ -2079,18 +2121,14 @@
 
 TEST_F(IRToProgramTest, For_ComplexBody_NoInit) {
     auto* a = b.Function("a", ty.bool_());
-    auto* v = b.FunctionParam(ty.i32());
-    mod.SetName(v, "v");
+    auto* v = b.FunctionParam("v", ty.i32());
     a->SetParams({v});
     b.With(a->Block(), [&] { b.Return(a, b.Equal(ty.bool_(), v, 1_i)); });
-    mod.functions.Push(a);
 
     auto* fn = b.Function("f", ty.i32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* i = b.Var(ty.ptr<function, i32>());
-        mod.SetName(i, "i");
+        auto* i = b.Var("i", ty.ptr<function, i32>());
         i->SetInitializer(b.Constant(0_i));
 
         auto* loop = b.Loop();
@@ -2110,7 +2148,7 @@
         b.Return(fn, 3_i);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a(v : i32) -> bool {
   return (v == 1i);
 }
@@ -2131,21 +2169,17 @@
 
 TEST_F(IRToProgramTest, For_ComplexBody_NoCont) {
     auto* a = b.Function("a", ty.bool_());
-    auto* v = b.FunctionParam(ty.i32());
-    mod.SetName(v, "v");
+    auto* v = b.FunctionParam("v", ty.i32());
     a->SetParams({v});
     b.With(a->Block(), [&] { b.Return(a, b.Equal(ty.bool_(), v, 1_i)); });
-    mod.functions.Push(a);
 
     auto* fn = b.Function("f", ty.i32());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
 
         b.With(loop->Initializer(), [&] {
-            auto* i = b.Var(ty.ptr<function, i32>());
-            mod.SetName(i, "i");
+            auto* i = b.Var("i", ty.ptr<function, i32>());
             i->SetInitializer(b.Constant(0_i));
 
             b.With(loop->Body(), [&] {
@@ -2161,7 +2195,7 @@
         b.Return(fn, 3_i);
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn a(v : i32) -> bool {
   return (v == 1i);
 }
@@ -2181,26 +2215,24 @@
 
 TEST_F(IRToProgramTest, For_CallInInitCondCont) {
     auto* fn_n = b.Function("n", ty.i32());
-    auto* v = b.FunctionParam(ty.i32());
-    mod.SetName(v, "v");
+    auto* v = b.FunctionParam("v", ty.i32());
     fn_n->SetParams({v});
     b.With(fn_n->Block(), [&] { b.Return(fn_n, b.Add(ty.i32(), v, 1_i)); });
-    mod.functions.Push(fn_n);
 
     auto* fn_f = b.Function("f", ty.void_());
-    mod.functions.Push(fn_f);
 
     b.With(fn_f->Block(), [&] {
         auto* loop = b.Loop();
 
         b.With(loop->Initializer(), [&] {
             auto* n_0 = b.Call(ty.i32(), fn_n, 0_i)->Result();
-            auto* i = b.Var(ty.ptr<function, i32>());
-            mod.SetName(i, "i");
+            auto* i = b.Var("i", ty.ptr<function, i32>());
             i->SetInitializer(n_0);
 
             b.With(loop->Body(), [&] {
-                auto* if_ = b.If(b.LessThan(ty.bool_(), b.Load(i), b.Call(ty.i32(), fn_n, 1_i)));
+                auto* load = b.Load(i);
+                auto* call = b.Call(ty.i32(), fn_n, 1_i);
+                auto* if_ = b.If(b.LessThan(ty.bool_(), load, call));
                 b.With(if_->True(), [&] { b.ExitIf(if_); });
                 b.With(if_->False(), [&] { b.ExitLoop(loop); });
             });
@@ -2209,7 +2241,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn n(v : i32) -> i32 {
   return (v + 1i);
 }
@@ -2226,7 +2258,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, While_Empty) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2238,7 +2269,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   while(true) {
   }
@@ -2248,10 +2279,8 @@
 
 TEST_F(IRToProgramTest, While_Cond) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2263,7 +2292,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   while(cond) {
   }
@@ -2273,7 +2302,6 @@
 
 TEST_F(IRToProgramTest, While_Break) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2286,7 +2314,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   while(true) {
     break;
@@ -2297,10 +2325,8 @@
 
 TEST_F(IRToProgramTest, While_IfBreak) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2315,7 +2341,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   while(true) {
     if (cond) {
@@ -2328,10 +2354,8 @@
 
 TEST_F(IRToProgramTest, While_IfReturn) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2346,7 +2370,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   while(true) {
     if (cond) {
@@ -2362,7 +2386,6 @@
 ////////////////////////////////////////////////////////////////////////////////
 TEST_F(IRToProgramTest, Loop_Break) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2370,7 +2393,7 @@
         b.With(loop->Body(), [&] { b.ExitLoop(loop); });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   loop {
     break;
@@ -2381,10 +2404,8 @@
 
 TEST_F(IRToProgramTest, Loop_IfBreak) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2394,7 +2415,7 @@
             b.With(if_->True(), [&] { b.ExitLoop(loop); });
         });
     });
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   loop {
     if (cond) {
@@ -2407,10 +2428,8 @@
 
 TEST_F(IRToProgramTest, Loop_IfReturn) {
     auto* fn = b.Function("f", ty.void_());
-    auto* cond = b.FunctionParam(ty.bool_());
-    mod.SetName(cond, "cond");
+    auto* cond = b.FunctionParam("cond", ty.bool_());
     fn->SetParams({cond});
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
         auto* loop = b.Loop();
@@ -2421,7 +2440,7 @@
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f(cond : bool) {
   loop {
     if (cond) {
@@ -2434,12 +2453,10 @@
 
 TEST_F(IRToProgramTest, Loop_IfContinuing) {
     auto* fn = b.Function("f", ty.void_());
-    mod.functions.Push(fn);
 
     b.With(fn->Block(), [&] {
-        auto* cond = b.Var(ty.ptr<function, bool>());
+        auto* cond = b.Var("cond", ty.ptr<function, bool>());
         cond->SetInitializer(b.Constant(false));
-        mod.SetName(cond, "cond");
 
         auto* loop = b.Loop();
 
@@ -2451,7 +2468,7 @@
         b.With(loop->Continuing(), [&] { b.Store(cond, true); });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var cond : bool = false;
   loop {
@@ -2469,30 +2486,32 @@
 
 TEST_F(IRToProgramTest, Loop_VarsDeclaredOutsideAndInside) {
     auto* f = b.Function("f", ty.void_());
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
-        auto* var_b = b.Var(ty.ptr<function, i32>());
+        auto* var_b = b.Var("b", ty.ptr<function, i32>());
         var_b->SetInitializer(b.Constant(1_i));
-        mod.SetName(var_b, "b");
 
         auto* loop = b.Loop();
 
         b.With(loop->Body(), [&] {
-            auto* var_a = b.Var(ty.ptr<function, i32>());
+            auto* var_a = b.Var("a", ty.ptr<function, i32>());
             var_a->SetInitializer(b.Constant(2_i));
-            mod.SetName(var_a, "a");
 
-            auto* if_ = b.If(b.Equal(ty.bool_(), b.Load(var_a), b.Load(var_b)));
+            auto* body_load_a = b.Load(var_a);
+            auto* body_load_b = b.Load(var_b);
+            auto* if_ = b.If(b.Equal(ty.bool_(), body_load_a, body_load_b));
             b.With(if_->True(), [&] { b.Return(f); });
             b.With(if_->False(), [&] { b.ExitIf(if_); });
 
-            b.With(loop->Continuing(),
-                   [&] { b.Store(var_b, b.Add(ty.i32(), b.Load(var_a), b.Load(var_b))); });
+            b.With(loop->Continuing(), [&] {
+                auto* cont_load_a = b.Load(var_a);
+                auto* cont_load_b = b.Load(var_b);
+                b.Store(var_b, b.Add(ty.i32(), cont_load_a, cont_load_b));
+            });
         });
     });
 
-    Test(R"(
+    EXPECT_WGSL(R"(
 fn f() {
   var b : i32 = 1i;
   loop {
@@ -2510,4 +2529,4 @@
 }
 
 }  // namespace
-}  // namespace tint::ir
+}  // namespace tint::ir::test
diff --git a/src/tint/ir/to_program_test.h b/src/tint/ir/to_program_test.h
new file mode 100644
index 0000000..ccf13ce
--- /dev/null
+++ b/src/tint/ir/to_program_test.h
@@ -0,0 +1,61 @@
+// 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.
+
+#ifndef SRC_TINT_IR_TO_PROGRAM_TEST_H_
+#define SRC_TINT_IR_TO_PROGRAM_TEST_H_
+
+#include <string>
+
+#include "src/tint/ir/ir_test_helper.h"
+
+#if !TINT_BUILD_WGSL_WRITER
+#error "to_program_test.h requires the WGSL writer to be enabled"
+#endif
+
+namespace tint::ir::test {
+
+/// Class used for IR to Program tests
+class IRToProgramTest : public IRTestHelper {
+  public:
+    /// The result of Run()
+    struct Result {
+        /// The resulting WGSL
+        std::string wgsl;
+        /// The resulting AST
+        std::string ast;
+        /// The resulting IR
+        std::string ir;
+        /// The resulting error
+        std::string err;
+    };
+    /// @returns the WGSL generated from the IR
+    Result Run();
+};
+
+#define EXPECT_WGSL(expected_wgsl)                                                     \
+    do {                                                                               \
+        if (auto got = Run(); got.err.empty()) {                                       \
+            auto expected = std::string(utils::TrimSpace(expected_wgsl));              \
+            if (!expected.empty()) {                                                   \
+                expected = "\n" + expected + "\n";                                     \
+            }                                                                          \
+            EXPECT_EQ(expected, got.wgsl) << "IR: " << got.ir;                         \
+        } else {                                                                       \
+            FAIL() << got.err << std::endl << "IR: " << got.ir << "AST:" << std::endl; \
+        }                                                                              \
+    } while (false)
+
+}  // namespace tint::ir::test
+
+#endif  // SRC_TINT_IR_TO_PROGRAM_TEST_H_
diff --git a/src/tint/ir/transform/add_empty_entry_point.cc b/src/tint/ir/transform/add_empty_entry_point.cc
index 5781e93..985c2ff 100644
--- a/src/tint/ir/transform/add_empty_entry_point.cc
+++ b/src/tint/ir/transform/add_empty_entry_point.cc
@@ -38,7 +38,6 @@
     auto* ep = builder.Function("unused_entry_point", ir->Types().void_(),
                                 Function::PipelineStage::kCompute, std::array{1u, 1u, 1u});
     ep->Block()->Append(builder.Return(ep));
-    ir->functions.Push(ep);
 }
 
 }  // namespace tint::ir::transform
diff --git a/src/tint/ir/transform/add_empty_entry_point_test.cc b/src/tint/ir/transform/add_empty_entry_point_test.cc
index 567feae..d74ed0e 100644
--- a/src/tint/ir/transform/add_empty_entry_point_test.cc
+++ b/src/tint/ir/transform/add_empty_entry_point_test.cc
@@ -40,7 +40,6 @@
 TEST_F(IR_AddEmptyEntryPointTest, ExistingEntryPoint) {
     auto* ep = b.Function("main", mod.Types().void_(), Function::PipelineStage::kFragment);
     ep->Block()->Append(b.Return(ep));
-    mod.functions.Push(ep);
 
     auto* expect = R"(
 %main = @fragment func():void -> %b1 {
diff --git a/src/tint/ir/transform/block_decorated_structs_test.cc b/src/tint/ir/transform/block_decorated_structs_test.cc
index 2d2a856..2d93a2d 100644
--- a/src/tint/ir/transform/block_decorated_structs_test.cc
+++ b/src/tint/ir/transform/block_decorated_structs_test.cc
@@ -32,7 +32,6 @@
 TEST_F(IR_BlockDecoratedStructsTest, NoRootBlock) {
     auto* func = b.Function("foo", ty.void_());
     func->Block()->Append(b.Return(func));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func():void -> %b1 {
@@ -57,7 +56,6 @@
     auto* block = func->Block();
     auto* load = block->Append(b.Load(buffer));
     block->Append(b.Return(func, load));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 tint_symbol_1 = struct @align(4), @block {
@@ -90,7 +88,6 @@
     auto* func = b.Function("foo", ty.void_());
     func->Block()->Append(b.Store(buffer, 42_i));
     func->Block()->Append(b.Return(func));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 tint_symbol_1 = struct @align(4), @block {
@@ -128,8 +125,6 @@
         b.Return(func);
     });
 
-    mod.functions.Push(func);
-
     auto* expect = R"(
 tint_symbol_1 = struct @align(4), @block {
   tint_symbol:array<i32> @offset(0)
@@ -177,8 +172,6 @@
         b.Return(func);
     });
 
-    mod.functions.Push(func);
-
     auto* expect = R"(
 MyStruct = struct @align(4) {
   i:i32 @offset(0)
@@ -226,7 +219,6 @@
     auto* func = b.Function("foo", ty.void_());
     func->Block()->Append(b.Store(buffer, private_var));
     func->Block()->Append(b.Return(func));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 MyStruct = struct @align(4) {
@@ -275,7 +267,6 @@
     auto* load_c = block->Append(b.Load(buffer_c));
     block->Append(b.Store(buffer_a, b.Add(ty.i32(), load_b, load_c)));
     block->Append(b.Return(func));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 tint_symbol_1 = struct @align(4), @block {
diff --git a/src/tint/ir/transform/merge_return.cc b/src/tint/ir/transform/merge_return.cc
index d2d4259..af42ab9 100644
--- a/src/tint/ir/transform/merge_return.cc
+++ b/src/tint/ir/transform/merge_return.cc
@@ -78,16 +78,14 @@
         }
 
         // Create a boolean variable that can be used to check whether the function is returning.
-        continue_execution = b.Var(ty.ptr<function, bool>());
+        continue_execution = b.Var("continue_execution", ty.ptr<function, bool>());
         continue_execution->SetInitializer(b.Constant(true));
         fn->Block()->Prepend(continue_execution);
-        ir->SetName(continue_execution, "continue_execution");
 
         // Create a variable to hold the return value if needed.
         if (!fn->ReturnType()->Is<type::Void>()) {
-            return_val = b.Var(ty.ptr(function, fn->ReturnType()));
+            return_val = b.Var("return_value", ty.ptr(function, fn->ReturnType()));
             fn->Block()->Prepend(return_val);
-            ir->SetName(return_val, "return_value");
         }
 
         // Look to see if the function ends with a return
diff --git a/src/tint/ir/transform/merge_return_test.cc b/src/tint/ir/transform/merge_return_test.cc
index c54f809..0991bb5 100644
--- a/src/tint/ir/transform/merge_return_test.cc
+++ b/src/tint/ir/transform/merge_return_test.cc
@@ -30,7 +30,6 @@
     auto* in = b.FunctionParam(ty.i32());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({in});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] { b.Return(func, b.Add(ty.i32(), in, 1_i)); });
 
@@ -56,7 +55,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({in});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -97,7 +95,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({in});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* swtch = b.Switch(in);
@@ -150,7 +147,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -204,7 +200,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -256,7 +251,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -320,7 +314,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -385,7 +378,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -450,7 +442,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -506,7 +497,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -583,7 +573,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse = b.If(cond);
@@ -656,14 +645,10 @@
     b.RootBlock()->Append(global);
 
     auto* func = b.Function("foo", ty.i32());
-    auto* condA = b.FunctionParam(ty.bool_());
-    auto* condB = b.FunctionParam(ty.bool_());
-    auto* condC = b.FunctionParam(ty.bool_());
-    mod.SetName(condA, "condA");
-    mod.SetName(condB, "condB");
-    mod.SetName(condC, "condC");
+    auto* condA = b.FunctionParam("condA", ty.bool_());
+    auto* condB = b.FunctionParam("condB", ty.bool_());
+    auto* condC = b.FunctionParam("condC", ty.bool_());
     func->SetParams({condA, condB, condC});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse_outer = b.If(condA);
@@ -806,14 +791,10 @@
     b.RootBlock()->Append(global);
 
     auto* func = b.Function("foo", ty.i32());
-    auto* condA = b.FunctionParam(ty.bool_());
-    auto* condB = b.FunctionParam(ty.bool_());
-    auto* condC = b.FunctionParam(ty.bool_());
-    mod.SetName(condA, "condA");
-    mod.SetName(condB, "condB");
-    mod.SetName(condC, "condC");
+    auto* condA = b.FunctionParam("condA", ty.bool_());
+    auto* condB = b.FunctionParam("condB", ty.bool_());
+    auto* condC = b.FunctionParam("condC", ty.bool_());
     func->SetParams({condA, condB, condC});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse_outer = b.If(condA);
@@ -931,14 +912,10 @@
     b.RootBlock()->Append(global);
 
     auto* func = b.Function("foo", ty.i32());
-    auto* condA = b.FunctionParam(ty.bool_());
-    auto* condB = b.FunctionParam(ty.bool_());
-    auto* condC = b.FunctionParam(ty.bool_());
-    mod.SetName(condA, "condA");
-    mod.SetName(condB, "condB");
-    mod.SetName(condC, "condC");
+    auto* condA = b.FunctionParam("condA", ty.bool_());
+    auto* condB = b.FunctionParam("condB", ty.bool_());
+    auto* condC = b.FunctionParam("condC", ty.bool_());
     func->SetParams({condA, condB, condC});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* ifelse_outer = b.If(condA);
@@ -1080,7 +1057,6 @@
 
 TEST_F(IR_MergeReturnTest, Loop_UnconditionalReturnInBody) {
     auto* func = b.Function("foo", ty.i32());
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -1130,7 +1106,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -1145,7 +1120,7 @@
 
         b.With(loop->Continuing(), [&] {
             b.Store(global, 1_i);
-            b.BreakIf(true, loop);
+            b.BreakIf(loop, true);
         });
 
         b.Store(global, 3_i);
@@ -1245,7 +1220,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -1351,7 +1325,6 @@
     auto* cond = b.FunctionParam(ty.bool_());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -1367,7 +1340,7 @@
 
         b.With(loop->Continuing(), [&] {
             b.Store(global, 1_i);
-            b.BreakIf(true, loop, 4_i);
+            b.BreakIf(loop, true, 4_i);
         });
 
         b.Store(global, 3_i);
@@ -1463,7 +1436,6 @@
     auto* cond = b.FunctionParam(ty.i32());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* sw = b.Switch(cond);
@@ -1530,7 +1502,6 @@
     auto* cond = b.FunctionParam(ty.i32());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* sw = b.Switch(cond);
@@ -1634,7 +1605,6 @@
     auto* cond = b.FunctionParam(ty.i32());
     auto* func = b.Function("foo", ty.i32());
     func->SetParams({cond});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* sw = b.Switch(cond);
@@ -1713,7 +1683,6 @@
 
 TEST_F(IR_MergeReturnTest, LoopIfReturnThenContinue) {
     auto* func = b.Function("foo", ty.void_());
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         auto* loop = b.Loop();
@@ -1776,7 +1745,6 @@
 
 TEST_F(IR_MergeReturnTest, NestedIfsWithReturns) {
     auto* func = b.Function("foo", ty.i32());
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         b.With(b.If(true)->True(), [&] {
diff --git a/src/tint/ir/transform/shader_io.cc b/src/tint/ir/transform/shader_io.cc
new file mode 100644
index 0000000..6456710
--- /dev/null
+++ b/src/tint/ir/transform/shader_io.cc
@@ -0,0 +1,279 @@
+// 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/transform/shader_io.h"
+
+#include <memory>
+#include <utility>
+
+#include "src/tint/ir/builder.h"
+#include "src/tint/ir/module.h"
+#include "src/tint/type/struct.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::ShaderIO);
+TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::ShaderIO::Config);
+
+using namespace tint::builtin::fluent_types;  // NOLINT
+using namespace tint::number_suffixes;        // NOLINT
+
+namespace tint::ir::transform {
+
+namespace {
+
+builtin::BuiltinValue FunctionParamBuiltin(enum FunctionParam::Builtin builtin) {
+    switch (builtin) {
+        case FunctionParam::Builtin::kVertexIndex:
+            return builtin::BuiltinValue::kVertexIndex;
+        case FunctionParam::Builtin::kInstanceIndex:
+            return builtin::BuiltinValue::kInstanceIndex;
+        case FunctionParam::Builtin::kPosition:
+            return builtin::BuiltinValue::kPosition;
+        case FunctionParam::Builtin::kFrontFacing:
+            return builtin::BuiltinValue::kFrontFacing;
+        case FunctionParam::Builtin::kLocalInvocationId:
+            return builtin::BuiltinValue::kLocalInvocationId;
+        case FunctionParam::Builtin::kLocalInvocationIndex:
+            return builtin::BuiltinValue::kLocalInvocationIndex;
+        case FunctionParam::Builtin::kGlobalInvocationId:
+            return builtin::BuiltinValue::kGlobalInvocationId;
+        case FunctionParam::Builtin::kWorkgroupId:
+            return builtin::BuiltinValue::kWorkgroupId;
+        case FunctionParam::Builtin::kNumWorkgroups:
+            return builtin::BuiltinValue::kNumWorkgroups;
+        case FunctionParam::Builtin::kSampleIndex:
+            return builtin::BuiltinValue::kSampleIndex;
+        case FunctionParam::Builtin::kSampleMask:
+            return builtin::BuiltinValue::kSampleMask;
+    }
+    return builtin::BuiltinValue::kUndefined;
+}
+
+builtin::BuiltinValue ReturnBuiltin(enum Function::ReturnBuiltin builtin) {
+    switch (builtin) {
+        case Function::ReturnBuiltin::kPosition:
+            return builtin::BuiltinValue::kPosition;
+        case Function::ReturnBuiltin::kFragDepth:
+            return builtin::BuiltinValue::kFragDepth;
+        case Function::ReturnBuiltin::kSampleMask:
+            return builtin::BuiltinValue::kSampleMask;
+    }
+    return builtin::BuiltinValue::kUndefined;
+}
+
+}  // namespace
+
+ShaderIO::ShaderIO() = default;
+
+ShaderIO::~ShaderIO() = default;
+
+/// PIMPL state for the transform, for a single entry point function.
+struct ShaderIO::State {
+    /// The configuration data.
+    const ShaderIO::Config& config;
+    /// The IR module.
+    Module* ir = nullptr;
+    /// The IR builder.
+    Builder b{*ir};
+    /// The type manager.
+    type::Manager& ty{ir->Types()};
+    /// The set of struct members that need to have their IO attributes stripped.
+    utils::Hashset<const type::StructMember*, 8> members_to_strip;
+
+    /// The entry point currently being processed.
+    Function* func = nullptr;
+
+    /// The backend state object for the current entry point.
+    std::unique_ptr<ShaderIO::BackendState> backend;
+
+    /// Constructor
+    /// @param cfg the transform config
+    /// @param mod the module
+    State(const ShaderIO::Config& cfg, Module* mod) : config(cfg), ir(mod) {}
+
+    /// Process an entry point.
+    /// @param f the original entry point function
+    /// @param bs the backend state object
+    void Process(Function* f, std::unique_ptr<ShaderIO::BackendState> bs) {
+        TINT_SCOPED_ASSIGNMENT(func, f);
+        backend = std::move(bs);
+        TINT_DEFER(backend = nullptr);
+
+        // Process the parameters and return value to prepare for building a wrapper function.
+        GatherInputs();
+        GatherOutput();
+        auto new_params = backend->FinalizeInputs();
+        auto* new_ret_val = backend->FinalizeOutputs();
+
+        // Rename the old function and remove its pipeline stage and workgroup size, as we will be
+        // wrapping it with a new entry point.
+        auto name = ir->NameOf(func).Name();
+        auto stage = func->Stage();
+        auto wgsize = func->WorkgroupSize();
+        ir->SetName(func, name + "_inner");
+        func->SetStage(Function::PipelineStage::kUndefined);
+        func->ClearWorkgroupSize();
+
+        // Create the entry point wrapper function.
+        auto* ep = b.Function(name, new_ret_val ? new_ret_val->Type() : ty.void_());
+        ep->SetStage(stage);
+        if (wgsize) {
+            ep->SetWorkgroupSize((*wgsize)[0], (*wgsize)[1], (*wgsize)[2]);
+        }
+        auto wrapper = b.With(ep->Block());
+
+        // Call the original function, passing it the inputs and capturing its return value.
+        auto inner_call_args = BuildInnerCallArgs(wrapper);
+        auto* inner_result = wrapper.Call(func->ReturnType(), func, std::move(inner_call_args));
+        SetOutputs(wrapper, inner_result->Result());
+
+        // Return the new result.
+        wrapper.Return(ep, new_ret_val);
+    }
+
+    /// Gather the shader inputs.
+    void GatherInputs() {
+        for (auto* param : func->Params()) {
+            if (auto* str = param->Type()->As<type::Struct>()) {
+                for (auto* member : str->Members()) {
+                    auto name = str->Name().Name() + "_" + member->Name().Name();
+                    backend->AddInput(ir->symbols.Register(name), member->Type(),
+                                      member->Attributes());
+                    members_to_strip.Add(member);
+                }
+            } else {
+                // Pull out the IO attributes and remove them from the parameter.
+                type::StructMemberAttributes attributes;
+                if (auto loc = param->Location()) {
+                    attributes.location = loc->value;
+                    if (loc->interpolation) {
+                        attributes.interpolation = *loc->interpolation;
+                    }
+                    param->ClearLocation();
+                } else if (auto builtin = param->Builtin()) {
+                    attributes.builtin = FunctionParamBuiltin(*builtin);
+                    param->ClearBuiltin();
+                }
+                attributes.invariant = param->Invariant();
+                param->SetInvariant(false);
+
+                auto name = ir->NameOf(param);
+                backend->AddInput(name, param->Type(), std::move(attributes));
+            }
+        }
+    }
+
+    /// Gather the shader outputs.
+    void GatherOutput() {
+        if (func->ReturnType()->Is<type::Void>()) {
+            return;
+        }
+
+        if (auto* str = func->ReturnType()->As<type::Struct>()) {
+            for (auto* member : str->Members()) {
+                auto name = str->Name().Name() + "_" + member->Name().Name();
+                backend->AddOutput(ir->symbols.Register(name), member->Type(),
+                                   member->Attributes());
+                members_to_strip.Add(member);
+            }
+        } else {
+            // Pull out the IO attributes and remove them from the original function.
+            type::StructMemberAttributes attributes;
+            if (auto loc = func->ReturnLocation()) {
+                attributes.location = loc->value;
+                func->ClearReturnLocation();
+            } else if (auto builtin = func->ReturnBuiltin()) {
+                attributes.builtin = ReturnBuiltin(*builtin);
+                func->ClearReturnBuiltin();
+            }
+            attributes.invariant = func->ReturnInvariant();
+            func->SetReturnInvariant(false);
+
+            backend->AddOutput(ir->symbols.New(), func->ReturnType(), std::move(attributes));
+        }
+    }
+
+    /// Build the argument list to call the original entry point function.
+    /// @param builder the IR builder for new instructions
+    /// @returns the argument list
+    utils::Vector<Value*, 4> BuildInnerCallArgs(Builder& builder) {
+        uint32_t input_idx = 0;
+        utils::Vector<Value*, 4> args;
+        for (auto* param : func->Params()) {
+            if (auto* str = param->Type()->As<type::Struct>()) {
+                utils::Vector<Value*, 4> construct_args;
+                for (uint32_t i = 0; i < str->Members().Length(); i++) {
+                    construct_args.Push(backend->GetInput(builder, input_idx++));
+                }
+                args.Push(builder.Construct(param->Type(), construct_args)->Result());
+            } else {
+                args.Push(backend->GetInput(builder, input_idx++));
+            }
+        }
+
+        return args;
+    }
+
+    /// Propagate outputs from the inner function call to their final destination.
+    /// @param builder the IR builder for new instructions
+    /// @param inner_result the return value from calling the original entry point function
+    void SetOutputs(Builder& builder, Value* inner_result) {
+        if (auto* str = inner_result->Type()->As<type::Struct>()) {
+            for (auto* member : str->Members()) {
+                Value* from =
+                    builder.Access(member->Type(), inner_result, u32(member->Index()))->Result();
+                backend->SetOutput(builder, member->Index(), from);
+            }
+        } else if (!inner_result->Type()->Is<type::Void>()) {
+            backend->SetOutput(builder, 0u, inner_result);
+        }
+    }
+
+    /// Finalize any state needed to complete the transform.
+    void Finalize() {
+        // Remove IO attributes from all structure members that had them prior to this transform.
+        for (auto* member : members_to_strip) {
+            // TODO(crbug.com/tint/745): Remove the const_cast.
+            const_cast<type::StructMember*>(member)->SetAttributes({});
+        }
+    }
+};
+
+void ShaderIO::Run(Module* ir, const DataMap& inputs, DataMap&) const {
+    auto* cfg = inputs.Get<Config>();
+    TINT_ASSERT(Transform, cfg);
+
+    ShaderIO::State state(*cfg, ir);
+    for (auto* func : ir->functions) {
+        // Only process entry points.
+        if (func->Stage() == Function::PipelineStage::kUndefined) {
+            continue;
+        }
+
+        // Skip entry points with no inputs or outputs.
+        if (func->Params().IsEmpty() && func->ReturnType()->Is<type::Void>()) {
+            continue;
+        }
+
+        state.Process(func, MakeBackendState(ir, func));
+    }
+    state.Finalize();
+}
+
+ShaderIO::Config::Config() = default;
+
+ShaderIO::Config::~Config() = default;
+
+ShaderIO::BackendState::~BackendState() = default;
+
+}  // namespace tint::ir::transform
diff --git a/src/tint/ir/transform/shader_io.h b/src/tint/ir/transform/shader_io.h
new file mode 100644
index 0000000..1f80811
--- /dev/null
+++ b/src/tint/ir/transform/shader_io.h
@@ -0,0 +1,134 @@
+// 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.
+
+#ifndef SRC_TINT_IR_TRANSFORM_SHADER_IO_H_
+#define SRC_TINT_IR_TRANSFORM_SHADER_IO_H_
+
+#include <memory>
+#include <utility>
+
+#include "src/tint/ir/builder.h"
+#include "src/tint/ir/transform/transform.h"
+#include "src/tint/type/manager.h"
+
+namespace tint::ir::transform {
+
+/// ShaderIO is a transform that modifies an entry point function's parameters and return value to
+/// prepare them for backend codegen.
+class ShaderIO : public utils::Castable<ShaderIO, Transform> {
+  public:
+    /// Configuration options for the transform.
+    struct Config final : public utils::Castable<Config, Data> {
+        /// Constructor
+        Config();
+
+        /// Copy constructor
+        Config(const Config&) = default;
+
+        /// Destructor
+        ~Config() override;
+    };
+
+    /// Constructor
+    ShaderIO();
+    /// Destructor
+    ~ShaderIO() override;
+
+    /// @copydoc Transform::Run
+    void Run(ir::Module* module, const DataMap& inputs, DataMap& outputs) const override;
+
+    /// Abstract base class for the state needed to handle IO for a particular backend target.
+    struct BackendState {
+        /// Constructor
+        /// @param mod the IR module
+        /// @param f the entry point function
+        BackendState(Module* mod, Function* f) : ir(mod), func(f) {}
+
+        /// Destructor
+        virtual ~BackendState();
+
+        /// Add an input.
+        /// @param name the name of the input
+        /// @param type the type of the input
+        /// @param attributes the IO attributes
+        virtual void AddInput(Symbol name,
+                              const type::Type* type,
+                              type::StructMemberAttributes attributes) {
+            inputs.Push({name, type, std::move(attributes)});
+        }
+
+        /// Add an output.
+        /// @param name the name of the output
+        /// @param type the type of the output
+        /// @param attributes the IO attributes
+        virtual void AddOutput(Symbol name,
+                               const type::Type* type,
+                               type::StructMemberAttributes attributes) {
+            outputs.Push({name, type, std::move(attributes)});
+        }
+
+        /// Finalize the shader inputs and create any state needed for the new entry point function.
+        /// @returns the list of function parameters for the new entry point
+        virtual utils::Vector<FunctionParam*, 4> FinalizeInputs() = 0;
+
+        /// Finalize the shader outputs and create state needed for the new entry point function.
+        /// @returns the return value for the new entry point
+        virtual Value* FinalizeOutputs() = 0;
+
+        /// Get the value of the input at index @p idx
+        /// @param builder the IR builder for new instructions
+        /// @param idx the index of the input
+        /// @returns the value of the input
+        virtual Value* GetInput(Builder& builder, uint32_t idx) = 0;
+
+        /// Set the value of the output at index @p idx
+        /// @param builder the IR builder for new instructions
+        /// @param idx the index of the output
+        /// @param value the value to set
+        virtual void SetOutput(Builder& builder, uint32_t idx, Value* value) = 0;
+
+      protected:
+        /// The IR module.
+        Module* ir = nullptr;
+
+        /// The IR builder.
+        Builder b{*ir};
+
+        /// The type manager.
+        type::Manager& ty{ir->Types()};
+
+        /// The original entry point function.
+        Function* func = nullptr;
+
+        /// The list of shader inputs.
+        utils::Vector<type::Manager::StructMemberDesc, 4> inputs;
+
+        /// The list of shader outputs.
+        utils::Vector<type::Manager::StructMemberDesc, 4> outputs;
+    };
+
+  protected:
+    struct State;
+
+    /// Create a backend state object.
+    /// @param mod the IR module
+    /// @param func the entry point function
+    /// @returns the backend state object
+    virtual std::unique_ptr<ShaderIO::BackendState> MakeBackendState(Module* mod,
+                                                                     Function* func) const = 0;
+};
+
+}  // namespace tint::ir::transform
+
+#endif  // SRC_TINT_IR_TRANSFORM_SHADER_IO_H_
diff --git a/src/tint/ir/transform/shader_io_spirv.cc b/src/tint/ir/transform/shader_io_spirv.cc
new file mode 100644
index 0000000..4a2400e
--- /dev/null
+++ b/src/tint/ir/transform/shader_io_spirv.cc
@@ -0,0 +1,172 @@
+// 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/transform/shader_io_spirv.h"
+
+#include <memory>
+#include <utility>
+
+#include "src/tint/ir/builder.h"
+#include "src/tint/ir/module.h"
+#include "src/tint/type/array.h"
+#include "src/tint/type/struct.h"
+
+TINT_INSTANTIATE_TYPEINFO(tint::ir::transform::ShaderIOSpirv);
+
+using namespace tint::builtin::fluent_types;  // NOLINT
+using namespace tint::number_suffixes;        // NOLINT
+
+namespace tint::ir::transform {
+
+ShaderIOSpirv::ShaderIOSpirv() = default;
+
+ShaderIOSpirv::~ShaderIOSpirv() = default;
+
+namespace {
+
+/// PIMPL state for the parts of the shader IO transform specific to SPIR-V.
+/// For SPIR-V, we split builtins and locations into two separate structures each for input and
+/// output, and declare global variables for them. The wrapper entry point then loads from and
+/// stores to these variables.
+/// We also modify the type of the SampleMask builtin to be an array, as required by Vulkan.
+struct StateImpl : ShaderIO::BackendState {
+    /// The global variable for input builtins.
+    Var* builtin_input_var = nullptr;
+    /// The global variable for input locations.
+    Var* location_input_var = nullptr;
+    /// The global variable for output builtins.
+    Var* builtin_output_var = nullptr;
+    /// The global variable for output locations.
+    Var* location_output_var = nullptr;
+    /// The member indices for inputs.
+    utils::Vector<uint32_t, 4> input_indices;
+    /// The member indices for outputs.
+    utils::Vector<uint32_t, 4> output_indices;
+
+    /// Constructor
+    /// @copydoc ShaderIO::BackendState::BackendState
+    using ShaderIO::BackendState::BackendState;
+    /// Destructor
+    ~StateImpl() override {}
+
+    /// Split the members listed in @p entries into two separate structures for builtins and
+    /// locations, and make global variables for them. Record the new member indices in @p indices.
+    /// @param builtin_var the generated global variable for builtins
+    /// @param location_var the generated global variable for locations
+    /// @param indices the new member indices
+    /// @param entries the entries to split
+    /// @param addrspace the address to use for the global variables
+    /// @param access the access mode to use for the global variables
+    /// @param name_suffix the suffix to add to struct and variable names
+    void MakeStructs(Var*& builtin_var,
+                     Var*& location_var,
+                     utils::Vector<uint32_t, 4>* indices,
+                     utils::Vector<type::Manager::StructMemberDesc, 4>& entries,
+                     builtin::AddressSpace addrspace,
+                     builtin::Access access,
+                     const char* name_suffix) {
+        // Build separate lists of builtin and location entries and record their new indices.
+        uint32_t next_builtin_idx = 0;
+        uint32_t next_location_idx = 0;
+        utils::Vector<type::Manager::StructMemberDesc, 4> builtin_members;
+        utils::Vector<type::Manager::StructMemberDesc, 4> location_members;
+        for (auto io : entries) {
+            if (io.attributes.builtin) {
+                // SampleMask must be an array for Vulkan.
+                if (io.attributes.builtin.value() == builtin::BuiltinValue::kSampleMask) {
+                    io.type = ty.array<u32, 1>();
+                }
+                builtin_members.Push(io);
+                indices->Push(next_builtin_idx++);
+            } else {
+                location_members.Push(io);
+                indices->Push(next_location_idx++);
+            }
+        }
+
+        // Declare the structs and variables if needed.
+        auto make_struct = [&](auto& members, const char* iotype) {
+            auto name = ir->NameOf(func).Name() + iotype + name_suffix;
+            auto* str = ty.Struct(ir->symbols.New(name + "Struct"), std::move(members));
+            auto* var = b.Var(name, ty.ptr(addrspace, str, access));
+            str->SetStructFlag(type::kBlock);
+            b.RootBlock()->Append(var);
+            return var;
+        };
+        if (!builtin_members.IsEmpty()) {
+            builtin_var = make_struct(builtin_members, "_Builtin");
+        }
+        if (!location_members.IsEmpty()) {
+            location_var = make_struct(location_members, "_Location");
+        }
+    }
+
+    /// @copydoc ShaderIO::BackendState::FinalizeInputs
+    utils::Vector<FunctionParam*, 4> FinalizeInputs() override {
+        MakeStructs(builtin_input_var, location_input_var, &input_indices, inputs,
+                    builtin::AddressSpace::kIn, builtin::Access::kRead, "Inputs");
+        return utils::Empty;
+    }
+
+    /// @copydoc ShaderIO::BackendState::FinalizeOutputs
+    Value* FinalizeOutputs() override {
+        MakeStructs(builtin_output_var, location_output_var, &output_indices, outputs,
+                    builtin::AddressSpace::kOut, builtin::Access::kWrite, "Outputs");
+        return nullptr;
+    }
+
+    /// @copydoc ShaderIO::BackendState::GetInput
+    Value* GetInput(Builder& builder, uint32_t idx) override {
+        // Load the input from the global variable declared earlier.
+        auto* ptr = ty.ptr(builtin::AddressSpace::kIn, inputs[idx].type, builtin::Access::kRead);
+        Access* from = nullptr;
+        if (inputs[idx].attributes.builtin) {
+            if (inputs[idx].attributes.builtin.value() == builtin::BuiltinValue::kSampleMask) {
+                // SampleMask becomes an array for SPIR-V, so load from the first element.
+                from = builder.Access(ptr, builtin_input_var, u32(input_indices[idx]), 0_u);
+            } else {
+                from = builder.Access(ptr, builtin_input_var, u32(input_indices[idx]));
+            }
+        } else {
+            from = builder.Access(ptr, location_input_var, u32(input_indices[idx]));
+        }
+        return builder.Load(from)->Result();
+    }
+
+    /// @copydoc ShaderIO::BackendState::SetOutput
+    void SetOutput(Builder& builder, uint32_t idx, Value* value) override {
+        // Store the output to the global variable declared earlier.
+        auto* ptr = ty.ptr(builtin::AddressSpace::kOut, outputs[idx].type, builtin::Access::kWrite);
+        Access* to = nullptr;
+        if (outputs[idx].attributes.builtin) {
+            if (outputs[idx].attributes.builtin.value() == builtin::BuiltinValue::kSampleMask) {
+                // SampleMask becomes an array for SPIR-V, so store to the first element.
+                to = builder.Access(ptr, builtin_output_var, u32(output_indices[idx]), 0_u);
+            } else {
+                to = builder.Access(ptr, builtin_output_var, u32(output_indices[idx]));
+            }
+        } else {
+            to = builder.Access(ptr, location_output_var, u32(output_indices[idx]));
+        }
+        builder.Store(to, value);
+    }
+};
+}  // namespace
+
+std::unique_ptr<ShaderIO::BackendState> ShaderIOSpirv::MakeBackendState(Module* mod,
+                                                                        Function* func) const {
+    return std::make_unique<StateImpl>(mod, func);
+}
+
+}  // namespace tint::ir::transform
diff --git a/src/tint/ir/transform/shader_io_spirv.h b/src/tint/ir/transform/shader_io_spirv.h
new file mode 100644
index 0000000..f374e9c
--- /dev/null
+++ b/src/tint/ir/transform/shader_io_spirv.h
@@ -0,0 +1,39 @@
+// 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.
+
+#ifndef SRC_TINT_IR_TRANSFORM_SHADER_IO_SPIRV_H_
+#define SRC_TINT_IR_TRANSFORM_SHADER_IO_SPIRV_H_
+
+#include "src/tint/ir/transform/shader_io.h"
+
+#include <memory>
+
+namespace tint::ir::transform {
+
+/// ShaderIOSpirv is the subclass of the ShaderIO transform used for the SPIR-V backend.
+class ShaderIOSpirv final : public utils::Castable<ShaderIOSpirv, ShaderIO> {
+  public:
+    /// Constructor
+    ShaderIOSpirv();
+    /// Destructor
+    ~ShaderIOSpirv() override;
+
+    /// @copydoc ShaderIO::MakeBackendState
+    std::unique_ptr<ShaderIO::BackendState> MakeBackendState(Module* mod,
+                                                             Function* func) const override;
+};
+
+}  // namespace tint::ir::transform
+
+#endif  // SRC_TINT_IR_TRANSFORM_SHADER_IO_SPIRV_H_
diff --git a/src/tint/ir/transform/shader_io_test.cc b/src/tint/ir/transform/shader_io_test.cc
new file mode 100644
index 0000000..7f18722
--- /dev/null
+++ b/src/tint/ir/transform/shader_io_test.cc
@@ -0,0 +1,948 @@
+// 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 <utility>
+
+#include "src/tint/ir/transform/shader_io.h"
+#include "src/tint/ir/transform/shader_io_spirv.h"
+#include "src/tint/ir/transform/test_helper.h"
+#include "src/tint/type/struct.h"
+
+namespace tint::ir::transform {
+namespace {
+
+using namespace tint::builtin::fluent_types;  // NOLINT
+using namespace tint::number_suffixes;        // NOLINT
+
+using IR_ShaderIOTest = TransformTest;
+
+TEST_F(IR_ShaderIOTest, NoInputsOrOutputs) {
+    auto* ep = b.Function("foo", ty.void_());
+    ep->SetStage(Function::PipelineStage::kCompute);
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep);
+    });
+
+    auto* src = R"(
+%foo = @compute func():void -> %b1 {
+  %b1 = block {
+    ret
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = src;
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, Parameters_NonStruct_Spirv) {
+    auto* ep = b.Function("foo", ty.void_());
+    auto* front_facing = b.FunctionParam("front_facing", ty.bool_());
+    front_facing->SetBuiltin(FunctionParam::Builtin::kFrontFacing);
+    auto* position = b.FunctionParam("position", ty.vec4<f32>());
+    position->SetBuiltin(FunctionParam::Builtin::kPosition);
+    position->SetInvariant(true);
+    auto* color1 = b.FunctionParam("color1", ty.f32());
+    color1->SetLocation(0, {});
+    auto* color2 = b.FunctionParam("color2", ty.f32());
+    color2->SetLocation(1, builtin::Interpolation{builtin::InterpolationType::kLinear,
+                                                  builtin::InterpolationSampling::kSample});
+
+    ep->SetParams({front_facing, position, color1, color2});
+    ep->SetStage(Function::PipelineStage::kFragment);
+
+    b.With(ep->Block(), [&] {
+        auto* ifelse = b.If(front_facing);
+        b.With(ifelse->True(), [&] {
+            b.Multiply(ty.vec4<f32>(), position, b.Add(ty.f32(), color1, color2));
+            b.ExitIf(ifelse);
+        });
+        b.Return(ep);
+    });
+
+    auto* src = R"(
+%foo = @fragment func(%front_facing:bool [@front_facing], %position:vec4<f32> [@invariant, @position], %color1:f32 [@location(0)], %color2:f32 [@location(1), @interpolate(linear, sample)]):void -> %b1 {
+  %b1 = block {
+    if %front_facing [t: %b2] {  # if_1
+      %b2 = block {  # true
+        %6:f32 = add %color1, %color2
+        %7:vec4<f32> = mul %position, %6
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+foo_BuiltinInputsStruct = struct @align(16), @block {
+  front_facing:bool @offset(0), @builtin(front_facing)
+  position:vec4<f32> @offset(16), @invariant, @builtin(position)
+}
+
+foo_LocationInputsStruct = struct @align(4), @block {
+  color1:f32 @offset(0), @location(0)
+  color2:f32 @offset(4), @location(1), @interpolate(linear, sample)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinInputs:ptr<__in, foo_BuiltinInputsStruct, read> = var
+  %foo_LocationInputs:ptr<__in, foo_LocationInputsStruct, read> = var
+}
+
+%foo_inner = func(%front_facing:bool, %position:vec4<f32>, %color1:f32, %color2:f32):void -> %b2 {
+  %b2 = block {
+    if %front_facing [t: %b3] {  # if_1
+      %b3 = block {  # true
+        %8:f32 = add %color1, %color2
+        %9:vec4<f32> = mul %position, %8
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+%foo = @fragment func():void -> %b4 {
+  %b4 = block {
+    %11:ptr<__in, bool, read> = access %foo_BuiltinInputs, 0u
+    %12:bool = load %11
+    %13:ptr<__in, vec4<f32>, read> = access %foo_BuiltinInputs, 1u
+    %14:vec4<f32> = load %13
+    %15:ptr<__in, f32, read> = access %foo_LocationInputs, 0u
+    %16:f32 = load %15
+    %17:ptr<__in, f32, read> = access %foo_LocationInputs, 1u
+    %18:f32 = load %17
+    %19:void = call %foo_inner, %12, %14, %16, %18
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, Parameters_Struct_Spirv) {
+    auto* str_ty =
+        ty.Struct(mod.symbols.New("Inputs"),
+                  {
+                      {
+                          mod.symbols.New("front_facing"),
+                          ty.bool_(),
+                          {{}, {}, builtin::BuiltinValue::kFrontFacing, {}, false},
+                      },
+                      {
+                          mod.symbols.New("position"),
+                          ty.vec4<f32>(),
+                          {{}, {}, builtin::BuiltinValue::kPosition, {}, true},
+                      },
+                      {
+                          mod.symbols.New("color1"),
+                          ty.f32(),
+                          {0u, {}, {}, {}, false},
+                      },
+                      {
+                          mod.symbols.New("color2"),
+                          ty.f32(),
+                          {1u,
+                           {},
+                           {},
+                           builtin::Interpolation{builtin::InterpolationType::kLinear,
+                                                  builtin::InterpolationSampling::kSample},
+                           false},
+                      },
+                  });
+
+    auto* ep = b.Function("foo", ty.void_());
+    auto* str_param = b.FunctionParam("inputs", str_ty);
+    ep->SetParams({str_param});
+    ep->SetStage(Function::PipelineStage::kFragment);
+
+    b.With(ep->Block(), [&] {
+        auto* ifelse = b.If(b.Access(ty.bool_(), str_param, 0_i));
+        b.With(ifelse->True(), [&] {
+            auto* position = b.Access(ty.vec4<f32>(), str_param, 1_i);
+            auto* color1 = b.Access(ty.f32(), str_param, 2_i);
+            auto* color2 = b.Access(ty.f32(), str_param, 3_i);
+            b.Multiply(ty.vec4<f32>(), position, b.Add(ty.f32(), color1, color2));
+            b.ExitIf(ifelse);
+        });
+        b.Return(ep);
+    });
+
+    auto* src = R"(
+Inputs = struct @align(16) {
+  front_facing:bool @offset(0), @builtin(front_facing)
+  position:vec4<f32> @offset(16), @invariant, @builtin(position)
+  color1:f32 @offset(32), @location(0)
+  color2:f32 @offset(36), @location(1), @interpolate(linear, sample)
+}
+
+%foo = @fragment func(%inputs:Inputs):void -> %b1 {
+  %b1 = block {
+    %3:bool = access %inputs, 0i
+    if %3 [t: %b2] {  # if_1
+      %b2 = block {  # true
+        %4:vec4<f32> = access %inputs, 1i
+        %5:f32 = access %inputs, 2i
+        %6:f32 = access %inputs, 3i
+        %7:f32 = add %5, %6
+        %8:vec4<f32> = mul %4, %7
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Inputs = struct @align(16) {
+  front_facing:bool @offset(0)
+  position:vec4<f32> @offset(16)
+  color1:f32 @offset(32)
+  color2:f32 @offset(36)
+}
+
+foo_BuiltinInputsStruct = struct @align(16), @block {
+  Inputs_front_facing:bool @offset(0), @builtin(front_facing)
+  Inputs_position:vec4<f32> @offset(16), @invariant, @builtin(position)
+}
+
+foo_LocationInputsStruct = struct @align(4), @block {
+  Inputs_color1:f32 @offset(0), @location(0)
+  Inputs_color2:f32 @offset(4), @location(1), @interpolate(linear, sample)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinInputs:ptr<__in, foo_BuiltinInputsStruct, read> = var
+  %foo_LocationInputs:ptr<__in, foo_LocationInputsStruct, read> = var
+}
+
+%foo_inner = func(%inputs:Inputs):void -> %b2 {
+  %b2 = block {
+    %5:bool = access %inputs, 0i
+    if %5 [t: %b3] {  # if_1
+      %b3 = block {  # true
+        %6:vec4<f32> = access %inputs, 1i
+        %7:f32 = access %inputs, 2i
+        %8:f32 = access %inputs, 3i
+        %9:f32 = add %7, %8
+        %10:vec4<f32> = mul %6, %9
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+%foo = @fragment func():void -> %b4 {
+  %b4 = block {
+    %12:ptr<__in, bool, read> = access %foo_BuiltinInputs, 0u
+    %13:bool = load %12
+    %14:ptr<__in, vec4<f32>, read> = access %foo_BuiltinInputs, 1u
+    %15:vec4<f32> = load %14
+    %16:ptr<__in, f32, read> = access %foo_LocationInputs, 0u
+    %17:f32 = load %16
+    %18:ptr<__in, f32, read> = access %foo_LocationInputs, 1u
+    %19:f32 = load %18
+    %20:Inputs = construct %13, %15, %17, %19
+    %21:void = call %foo_inner, %20
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, Parameters_Mixed_Spirv) {
+    auto* str_ty = ty.Struct(mod.symbols.New("Inputs"),
+                             {
+                                 {
+                                     mod.symbols.New("position"),
+                                     ty.vec4<f32>(),
+                                     {{}, {}, builtin::BuiltinValue::kPosition, {}, true},
+                                 },
+                                 {
+                                     mod.symbols.New("color1"),
+                                     ty.f32(),
+                                     {0u, {}, {}, {}, false},
+                                 },
+                             });
+
+    auto* ep = b.Function("foo", ty.void_());
+    auto* front_facing = b.FunctionParam("front_facing", ty.bool_());
+    front_facing->SetBuiltin(FunctionParam::Builtin::kFrontFacing);
+    auto* str_param = b.FunctionParam("inputs", str_ty);
+    auto* color2 = b.FunctionParam("color2", ty.f32());
+    color2->SetLocation(1, builtin::Interpolation{builtin::InterpolationType::kLinear,
+                                                  builtin::InterpolationSampling::kSample});
+
+    ep->SetParams({front_facing, str_param, color2});
+    ep->SetStage(Function::PipelineStage::kFragment);
+
+    b.With(ep->Block(), [&] {
+        auto* ifelse = b.If(front_facing);
+        b.With(ifelse->True(), [&] {
+            auto* position = b.Access(ty.vec4<f32>(), str_param, 0_i);
+            auto* color1 = b.Access(ty.f32(), str_param, 1_i);
+            b.Multiply(ty.vec4<f32>(), position, b.Add(ty.f32(), color1, color2));
+            b.ExitIf(ifelse);
+        });
+        b.Return(ep);
+    });
+
+    auto* src = R"(
+Inputs = struct @align(16) {
+  position:vec4<f32> @offset(0), @invariant, @builtin(position)
+  color1:f32 @offset(16), @location(0)
+}
+
+%foo = @fragment func(%front_facing:bool [@front_facing], %inputs:Inputs, %color2:f32 [@location(1), @interpolate(linear, sample)]):void -> %b1 {
+  %b1 = block {
+    if %front_facing [t: %b2] {  # if_1
+      %b2 = block {  # true
+        %5:vec4<f32> = access %inputs, 0i
+        %6:f32 = access %inputs, 1i
+        %7:f32 = add %6, %color2
+        %8:vec4<f32> = mul %5, %7
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Inputs = struct @align(16) {
+  position:vec4<f32> @offset(0)
+  color1:f32 @offset(16)
+}
+
+foo_BuiltinInputsStruct = struct @align(16), @block {
+  front_facing:bool @offset(0), @builtin(front_facing)
+  Inputs_position:vec4<f32> @offset(16), @invariant, @builtin(position)
+}
+
+foo_LocationInputsStruct = struct @align(4), @block {
+  Inputs_color1:f32 @offset(0), @location(0)
+  color2:f32 @offset(4), @location(1), @interpolate(linear, sample)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinInputs:ptr<__in, foo_BuiltinInputsStruct, read> = var
+  %foo_LocationInputs:ptr<__in, foo_LocationInputsStruct, read> = var
+}
+
+%foo_inner = func(%front_facing:bool, %inputs:Inputs, %color2:f32):void -> %b2 {
+  %b2 = block {
+    if %front_facing [t: %b3] {  # if_1
+      %b3 = block {  # true
+        %7:vec4<f32> = access %inputs, 0i
+        %8:f32 = access %inputs, 1i
+        %9:f32 = add %8, %color2
+        %10:vec4<f32> = mul %7, %9
+        exit_if  # if_1
+      }
+    }
+    ret
+  }
+}
+%foo = @fragment func():void -> %b4 {
+  %b4 = block {
+    %12:ptr<__in, bool, read> = access %foo_BuiltinInputs, 0u
+    %13:bool = load %12
+    %14:ptr<__in, vec4<f32>, read> = access %foo_BuiltinInputs, 1u
+    %15:vec4<f32> = load %14
+    %16:ptr<__in, f32, read> = access %foo_LocationInputs, 0u
+    %17:f32 = load %16
+    %18:Inputs = construct %15, %17
+    %19:ptr<__in, f32, read> = access %foo_LocationInputs, 1u
+    %20:f32 = load %19
+    %21:void = call %foo_inner, %13, %18, %20
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, ReturnValue_NonStructBuiltin_Spirv) {
+    auto* ep = b.Function("foo", ty.vec4<f32>());
+    ep->SetReturnBuiltin(Function::ReturnBuiltin::kPosition);
+    ep->SetReturnInvariant(true);
+    ep->SetStage(Function::PipelineStage::kVertex);
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep, b.Construct(ty.vec4<f32>(), 0.5_f));
+    });
+
+    auto* src = R"(
+%foo = @vertex func():vec4<f32> [@invariant, @position] -> %b1 {
+  %b1 = block {
+    %2:vec4<f32> = construct 0.5f
+    ret %2
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+foo_BuiltinOutputsStruct = struct @align(16), @block {
+  tint_symbol:vec4<f32> @offset(0), @invariant, @builtin(position)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinOutputs:ptr<__out, foo_BuiltinOutputsStruct, write> = var
+}
+
+%foo_inner = func():vec4<f32> -> %b2 {
+  %b2 = block {
+    %3:vec4<f32> = construct 0.5f
+    ret %3
+  }
+}
+%foo = @vertex func():void -> %b3 {
+  %b3 = block {
+    %5:vec4<f32> = call %foo_inner
+    %6:ptr<__out, vec4<f32>, write> = access %foo_BuiltinOutputs, 0u
+    store %6, %5
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, ReturnValue_NonStructLocation_Spirv) {
+    auto* ep = b.Function("foo", ty.vec4<f32>());
+    ep->SetReturnLocation(1u, {});
+    ep->SetStage(Function::PipelineStage::kFragment);
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep, b.Construct(ty.vec4<f32>(), 0.5_f));
+    });
+
+    auto* src = R"(
+%foo = @fragment func():vec4<f32> [@location(1)] -> %b1 {
+  %b1 = block {
+    %2:vec4<f32> = construct 0.5f
+    ret %2
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+foo_LocationOutputsStruct = struct @align(16), @block {
+  tint_symbol:vec4<f32> @offset(0), @location(1)
+}
+
+%b1 = block {  # root
+  %foo_LocationOutputs:ptr<__out, foo_LocationOutputsStruct, write> = var
+}
+
+%foo_inner = func():vec4<f32> -> %b2 {
+  %b2 = block {
+    %3:vec4<f32> = construct 0.5f
+    ret %3
+  }
+}
+%foo = @fragment func():void -> %b3 {
+  %b3 = block {
+    %5:vec4<f32> = call %foo_inner
+    %6:ptr<__out, vec4<f32>, write> = access %foo_LocationOutputs, 0u
+    store %6, %5
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, ReturnValue_Struct_Spirv) {
+    auto* str_ty =
+        ty.Struct(mod.symbols.New("Outputs"),
+                  {
+                      {
+                          mod.symbols.New("position"),
+                          ty.vec4<f32>(),
+                          {{}, {}, builtin::BuiltinValue::kPosition, {}, true},
+                      },
+                      {
+                          mod.symbols.New("color1"),
+                          ty.f32(),
+                          {0u, {}, {}, {}, false},
+                      },
+                      {
+                          mod.symbols.New("color2"),
+                          ty.f32(),
+                          {1u,
+                           {},
+                           {},
+                           builtin::Interpolation{builtin::InterpolationType::kLinear,
+                                                  builtin::InterpolationSampling::kSample},
+                           false},
+                      },
+                  });
+
+    auto* ep = b.Function("foo", str_ty);
+    ep->SetStage(Function::PipelineStage::kVertex);
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep, b.Construct(str_ty, b.Construct(ty.vec4<f32>(), 0_f), 0.25_f, 0.75_f));
+    });
+
+    auto* src = R"(
+Outputs = struct @align(16) {
+  position:vec4<f32> @offset(0), @invariant, @builtin(position)
+  color1:f32 @offset(16), @location(0)
+  color2:f32 @offset(20), @location(1), @interpolate(linear, sample)
+}
+
+%foo = @vertex func():Outputs -> %b1 {
+  %b1 = block {
+    %2:vec4<f32> = construct 0.0f
+    %3:Outputs = construct %2, 0.25f, 0.75f
+    ret %3
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Outputs = struct @align(16) {
+  position:vec4<f32> @offset(0)
+  color1:f32 @offset(16)
+  color2:f32 @offset(20)
+}
+
+foo_BuiltinOutputsStruct = struct @align(16), @block {
+  Outputs_position:vec4<f32> @offset(0), @invariant, @builtin(position)
+}
+
+foo_LocationOutputsStruct = struct @align(4), @block {
+  Outputs_color1:f32 @offset(0), @location(0)
+  Outputs_color2:f32 @offset(4), @location(1), @interpolate(linear, sample)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinOutputs:ptr<__out, foo_BuiltinOutputsStruct, write> = var
+  %foo_LocationOutputs:ptr<__out, foo_LocationOutputsStruct, write> = var
+}
+
+%foo_inner = func():Outputs -> %b2 {
+  %b2 = block {
+    %4:vec4<f32> = construct 0.0f
+    %5:Outputs = construct %4, 0.25f, 0.75f
+    ret %5
+  }
+}
+%foo = @vertex func():void -> %b3 {
+  %b3 = block {
+    %7:Outputs = call %foo_inner
+    %8:vec4<f32> = access %7, 0u
+    %9:ptr<__out, vec4<f32>, write> = access %foo_BuiltinOutputs, 0u
+    store %9, %8
+    %10:f32 = access %7, 1u
+    %11:ptr<__out, f32, write> = access %foo_LocationOutputs, 0u
+    store %11, %10
+    %12:f32 = access %7, 2u
+    %13:ptr<__out, f32, write> = access %foo_LocationOutputs, 1u
+    store %13, %12
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, Struct_SharedByVertexAndFragment_Spirv) {
+    auto* vec4f = ty.vec4<f32>();
+    auto* str_ty = ty.Struct(mod.symbols.New("Interface"),
+                             {
+                                 {
+                                     mod.symbols.New("position"),
+                                     vec4f,
+                                     {{}, {}, builtin::BuiltinValue::kPosition, {}, false},
+                                 },
+                                 {
+                                     mod.symbols.New("color"),
+                                     vec4f,
+                                     {0u, {}, {}, {}, false},
+                                 },
+                             });
+
+    // Vertex shader.
+    {
+        auto* ep = b.Function("vert", str_ty);
+        ep->SetStage(Function::PipelineStage::kVertex);
+
+        b.With(ep->Block(), [&] {  //
+            auto* position = b.Construct(vec4f, 0_f);
+            auto* color = b.Construct(vec4f, 1_f);
+            b.Return(ep, b.Construct(str_ty, position, color));
+        });
+    }
+
+    // Fragment shader.
+    {
+        auto* ep = b.Function("frag", vec4f);
+        auto* inputs = b.FunctionParam("inputs", str_ty);
+        ep->SetStage(Function::PipelineStage::kFragment);
+        ep->SetParams({inputs});
+
+        b.With(ep->Block(), [&] {  //
+            auto* position = b.Access(vec4f, inputs, 0_u);
+            auto* color = b.Access(vec4f, inputs, 1_u);
+            b.Return(ep, b.Add(vec4f, position, color));
+        });
+    }
+
+    auto* src = R"(
+Interface = struct @align(16) {
+  position:vec4<f32> @offset(0), @builtin(position)
+  color:vec4<f32> @offset(16), @location(0)
+}
+
+%vert = @vertex func():Interface -> %b1 {
+  %b1 = block {
+    %2:vec4<f32> = construct 0.0f
+    %3:vec4<f32> = construct 1.0f
+    %4:Interface = construct %2, %3
+    ret %4
+  }
+}
+%frag = @fragment func(%inputs:Interface):vec4<f32> -> %b2 {
+  %b2 = block {
+    %7:vec4<f32> = access %inputs, 0u
+    %8:vec4<f32> = access %inputs, 1u
+    %9:vec4<f32> = add %7, %8
+    ret %9
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Interface = struct @align(16) {
+  position:vec4<f32> @offset(0)
+  color:vec4<f32> @offset(16)
+}
+
+vert_BuiltinOutputsStruct = struct @align(16), @block {
+  Interface_position:vec4<f32> @offset(0), @builtin(position)
+}
+
+vert_LocationOutputsStruct = struct @align(16), @block {
+  Interface_color:vec4<f32> @offset(0), @location(0)
+}
+
+frag_BuiltinInputsStruct = struct @align(16), @block {
+  Interface_position:vec4<f32> @offset(0), @builtin(position)
+}
+
+frag_LocationInputsStruct = struct @align(16), @block {
+  Interface_color:vec4<f32> @offset(0), @location(0)
+}
+
+frag_LocationOutputsStruct = struct @align(16), @block {
+  tint_symbol:vec4<f32> @offset(0)
+}
+
+%b1 = block {  # root
+  %vert_BuiltinOutputs:ptr<__out, vert_BuiltinOutputsStruct, write> = var
+  %vert_LocationOutputs:ptr<__out, vert_LocationOutputsStruct, write> = var
+  %frag_BuiltinInputs:ptr<__in, frag_BuiltinInputsStruct, read> = var
+  %frag_LocationInputs:ptr<__in, frag_LocationInputsStruct, read> = var
+  %frag_LocationOutputs:ptr<__out, frag_LocationOutputsStruct, write> = var
+}
+
+%vert_inner = func():Interface -> %b2 {
+  %b2 = block {
+    %7:vec4<f32> = construct 0.0f
+    %8:vec4<f32> = construct 1.0f
+    %9:Interface = construct %7, %8
+    ret %9
+  }
+}
+%frag_inner = func(%inputs:Interface):vec4<f32> -> %b3 {
+  %b3 = block {
+    %12:vec4<f32> = access %inputs, 0u
+    %13:vec4<f32> = access %inputs, 1u
+    %14:vec4<f32> = add %12, %13
+    ret %14
+  }
+}
+%vert = @vertex func():void -> %b4 {
+  %b4 = block {
+    %16:Interface = call %vert_inner
+    %17:vec4<f32> = access %16, 0u
+    %18:ptr<__out, vec4<f32>, write> = access %vert_BuiltinOutputs, 0u
+    store %18, %17
+    %19:vec4<f32> = access %16, 1u
+    %20:ptr<__out, vec4<f32>, write> = access %vert_LocationOutputs, 0u
+    store %20, %19
+    ret
+  }
+}
+%frag = @fragment func():void -> %b5 {
+  %b5 = block {
+    %22:ptr<__in, vec4<f32>, read> = access %frag_BuiltinInputs, 0u
+    %23:vec4<f32> = load %22
+    %24:ptr<__in, vec4<f32>, read> = access %frag_LocationInputs, 0u
+    %25:vec4<f32> = load %24
+    %26:Interface = construct %23, %25
+    %27:vec4<f32> = call %frag_inner, %26
+    %28:ptr<__out, vec4<f32>, write> = access %frag_LocationOutputs, 0u
+    store %28, %27
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(IR_ShaderIOTest, Struct_SharedWithBuffer_Spirv) {
+    auto* vec4f = ty.vec4<f32>();
+    auto* str_ty = ty.Struct(mod.symbols.New("Outputs"),
+                             {
+                                 {
+                                     mod.symbols.New("position"),
+                                     vec4f,
+                                     {{}, {}, builtin::BuiltinValue::kPosition, {}, false},
+                                 },
+                                 {
+                                     mod.symbols.New("color"),
+                                     vec4f,
+                                     {0u, {}, {}, {}, false},
+                                 },
+                             });
+
+    auto* buffer = b.RootBlock()->Append(b.Var(ty.ptr(storage, str_ty, read)));
+
+    auto* ep = b.Function("vert", str_ty);
+    ep->SetStage(Function::PipelineStage::kVertex);
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep, b.Load(buffer));
+    });
+
+    auto* src = R"(
+Outputs = struct @align(16) {
+  position:vec4<f32> @offset(0), @builtin(position)
+  color:vec4<f32> @offset(16), @location(0)
+}
+
+%b1 = block {  # root
+  %1:ptr<storage, Outputs, read> = var
+}
+
+%vert = @vertex func():Outputs -> %b2 {
+  %b2 = block {
+    %3:Outputs = load %1
+    ret %3
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Outputs = struct @align(16) {
+  position:vec4<f32> @offset(0)
+  color:vec4<f32> @offset(16)
+}
+
+vert_BuiltinOutputsStruct = struct @align(16), @block {
+  Outputs_position:vec4<f32> @offset(0), @builtin(position)
+}
+
+vert_LocationOutputsStruct = struct @align(16), @block {
+  Outputs_color:vec4<f32> @offset(0), @location(0)
+}
+
+%b1 = block {  # root
+  %1:ptr<storage, Outputs, read> = var
+  %vert_BuiltinOutputs:ptr<__out, vert_BuiltinOutputsStruct, write> = var
+  %vert_LocationOutputs:ptr<__out, vert_LocationOutputsStruct, write> = var
+}
+
+%vert_inner = func():Outputs -> %b2 {
+  %b2 = block {
+    %5:Outputs = load %1
+    ret %5
+  }
+}
+%vert = @vertex func():void -> %b3 {
+  %b3 = block {
+    %7:Outputs = call %vert_inner
+    %8:vec4<f32> = access %7, 0u
+    %9:ptr<__out, vec4<f32>, write> = access %vert_BuiltinOutputs, 0u
+    store %9, %8
+    %10:vec4<f32> = access %7, 1u
+    %11:ptr<__out, vec4<f32>, write> = access %vert_LocationOutputs, 0u
+    store %11, %10
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+// Test that we change the type of the sample mask builtin to an array for SPIR-V.
+TEST_F(IR_ShaderIOTest, SampleMask_Spirv) {
+    auto* str_ty = ty.Struct(mod.symbols.New("Outputs"),
+                             {
+                                 {
+                                     mod.symbols.New("color"),
+                                     ty.f32(),
+                                     {0u, {}, {}, {}, false},
+                                 },
+                                 {
+                                     mod.symbols.New("mask"),
+                                     ty.u32(),
+                                     {{}, {}, builtin::BuiltinValue::kSampleMask, {}, false},
+                                 },
+                             });
+
+    auto* mask_in = b.FunctionParam("mask_in", ty.u32());
+    mask_in->SetBuiltin(FunctionParam::Builtin::kSampleMask);
+
+    auto* ep = b.Function("foo", str_ty);
+    ep->SetStage(Function::PipelineStage::kFragment);
+    ep->SetParams({mask_in});
+
+    b.With(ep->Block(), [&] {  //
+        b.Return(ep, b.Construct(str_ty, 0.5_f, mask_in));
+    });
+
+    auto* src = R"(
+Outputs = struct @align(4) {
+  color:f32 @offset(0), @location(0)
+  mask:u32 @offset(4), @builtin(sample_mask)
+}
+
+%foo = @fragment func(%mask_in:u32 [@sample_mask]):Outputs -> %b1 {
+  %b1 = block {
+    %3:Outputs = construct 0.5f, %mask_in
+    ret %3
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Outputs = struct @align(4) {
+  color:f32 @offset(0)
+  mask:u32 @offset(4)
+}
+
+foo_BuiltinInputsStruct = struct @align(4), @block {
+  mask_in:array<u32, 1> @offset(0), @builtin(sample_mask)
+}
+
+foo_BuiltinOutputsStruct = struct @align(4), @block {
+  Outputs_mask:array<u32, 1> @offset(0), @builtin(sample_mask)
+}
+
+foo_LocationOutputsStruct = struct @align(4), @block {
+  Outputs_color:f32 @offset(0), @location(0)
+}
+
+%b1 = block {  # root
+  %foo_BuiltinInputs:ptr<__in, foo_BuiltinInputsStruct, read> = var
+  %foo_BuiltinOutputs:ptr<__out, foo_BuiltinOutputsStruct, write> = var
+  %foo_LocationOutputs:ptr<__out, foo_LocationOutputsStruct, write> = var
+}
+
+%foo_inner = func(%mask_in:u32):Outputs -> %b2 {
+  %b2 = block {
+    %6:Outputs = construct 0.5f, %mask_in
+    ret %6
+  }
+}
+%foo = @fragment func():void -> %b3 {
+  %b3 = block {
+    %8:ptr<__in, u32, read> = access %foo_BuiltinInputs, 0u, 0u
+    %9:u32 = load %8
+    %10:Outputs = call %foo_inner, %9
+    %11:f32 = access %10, 0u
+    %12:ptr<__out, f32, write> = access %foo_LocationOutputs, 0u
+    store %12, %11
+    %13:u32 = access %10, 1u
+    %14:ptr<__out, u32, write> = access %foo_BuiltinOutputs, 0u, 0u
+    store %14, %13
+    ret
+  }
+}
+)";
+
+    Transform::DataMap data;
+    data.Add<ShaderIO::Config>();
+    Run<ShaderIOSpirv>(data);
+
+    EXPECT_EQ(expect, str());
+}
+
+}  // namespace
+}  // namespace tint::ir::transform
diff --git a/src/tint/ir/transform/var_for_dynamic_index_test.cc b/src/tint/ir/transform/var_for_dynamic_index_test.cc
index ce0d691..7848174 100644
--- a/src/tint/ir/transform/var_for_dynamic_index_test.cc
+++ b/src/tint/ir/transform/var_for_dynamic_index_test.cc
@@ -37,7 +37,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.i32(), arr, 1_i));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<i32, 4>):i32 -> %b1 {
@@ -61,7 +60,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.f32(), mat, 1_i, 0_i));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:mat2x2<f32>):f32 -> %b1 {
@@ -87,7 +85,6 @@
     auto* access = block->Append(b.Access(ty.ptr<function, i32>(), arr, idx));
     auto* load = block->Append(b.Load(access));
     block->Append(b.Return(func, load));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:ptr<function, array<i32, 4>, read_write>, %3:i32):i32 -> %b1 {
@@ -114,7 +111,6 @@
     auto* access = block->Append(b.Access(ty.ptr<function, f32>(), mat, idx, idx));
     auto* load = block->Append(b.Load(access));
     block->Append(b.Return(func, load));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:ptr<function, mat2x2<f32>, read_write>, %3:i32):f32 -> %b1 {
@@ -140,7 +136,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.f32(), vec, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:vec4<f32>, %3:i32):f32 -> %b1 {
@@ -165,7 +160,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.i32(), arr, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<i32, 4>, %3:i32):i32 -> %b1 {
@@ -192,7 +186,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.vec2<f32>(), mat, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:mat2x2<f32>, %3:i32):vec2<f32> -> %b1 {
@@ -219,7 +212,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.i32(), arr, idx, 1_u, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
@@ -246,7 +238,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.i32(), arr, 1_u, 2_u, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
@@ -274,7 +265,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.i32(), arr, 1_u, idx, 2_u, idx));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<array<array<array<i32, 4>, 4>, 4>, 4>, %3:i32):i32 -> %b1 {
@@ -308,7 +298,6 @@
     auto* block = func->Block();
     auto* access = block->Append(b.Access(ty.f32(), str_val, 1_u, idx, 0_u));
     block->Append(b.Return(func, access));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 MyStruct = struct @align(16) {
@@ -346,7 +335,6 @@
     block->Append(b.Access(ty.i32(), arr, idx_b));
     auto* access_c = block->Append(b.Access(ty.i32(), arr, idx_c));
     block->Append(b.Return(func, access_c));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<i32, 4>, %3:i32, %4:i32, %5:i32):i32 -> %b1 {
@@ -381,7 +369,6 @@
     block->Append(b.Access(ty.i32(), arr, 1_u, 2_u, idx_b));
     auto* access_c = block->Append(b.Access(ty.i32(), arr, 1_u, 2_u, idx_c));
     block->Append(b.Return(func, access_c));
-    mod.functions.Push(func);
 
     auto* expect = R"(
 %foo = func(%2:array<array<array<i32, 4>, 4>, 4>, %3:i32, %4:i32, %5:i32):i32 -> %b1 {
diff --git a/src/tint/ir/validate.cc b/src/tint/ir/validate.cc
index d8871b9..a743786 100644
--- a/src/tint/ir/validate.cc
+++ b/src/tint/ir/validate.cc
@@ -66,12 +66,9 @@
         }
 
         if (diagnostics_.contains_errors()) {
-            // If a diassembly file was generated then one of the diagnostics referenced the
-            // disasembly. Emit the entire disassembly file at the end of the messages.
-            if (mod_.disassembly_file) {
-                diagnostics_.add_note(tint::diag::System::IR,
-                                      "# Disassembly\n" + mod_.disassembly_file->content.data, {});
-            }
+            DisassembleIfNeeded();
+            diagnostics_.add_note(tint::diag::System::IR,
+                                  "# Disassembly\n" + mod_.disassembly_file->content.data, {});
             return std::move(diagnostics_);
         }
         return Success{};
@@ -83,6 +80,7 @@
     Disassembler dis_{mod_};
 
     Block* current_block_ = nullptr;
+    utils::Hashset<Function*, 4> seen_functions_;
 
     void DisassembleIfNeeded() {
         if (mod_.disassembly_file) {
@@ -113,6 +111,17 @@
         }
     }
 
+    void AddResultError(Instruction* inst, size_t idx, std::string err) {
+        DisassembleIfNeeded();
+        auto src = dis_.ResultSource(Usage{inst, static_cast<uint32_t>(idx)});
+        src.file = mod_.disassembly_file.get();
+        AddError(std::move(err), src);
+
+        if (current_block_) {
+            AddNote(current_block_, "In block");
+        }
+    }
+
     void AddError(Block* blk, std::string err) {
         DisassembleIfNeeded();
         auto src = dis_.BlockSource(blk);
@@ -142,7 +151,30 @@
         diagnostics_.add_note(tint::diag::System::IR, std::move(note), src);
     }
 
-    // std::string Name(Value* v) { return mod_.NameOf(v).Name(); }
+    std::string Name(Value* v) { return mod_.NameOf(v).Name(); }
+
+    template <typename FUNC>
+    void CheckOperandNotNull(ir::Instruction* inst,
+                             ir::Value* operand,
+                             size_t idx,
+                             std::string_view name,
+                             FUNC&& cb) {
+        if (operand == nullptr) {
+            AddError(inst, idx, std::string(name) + ": " + cb(idx) + " operand is undefined");
+        }
+    }
+
+    template <typename FUNC>
+    void CheckOperandsNotNull(ir::Instruction* inst,
+                              size_t start_operand,
+                              size_t end_operand,
+                              std::string_view name,
+                              FUNC&& cb) {
+        auto operands = inst->Operands();
+        for (size_t i = start_operand; i <= end_operand; i++) {
+            CheckOperandNotNull(inst, operands[i], i, name, cb);
+        }
+    }
 
     void CheckRootBlock(Block* blk) {
         if (!blk) {
@@ -158,11 +190,17 @@
                          std::string("root block: invalid instruction: ") + inst->TypeInfo().name);
                 continue;
             }
-            CheckVar(var);
+            CheckInstruction(var);
         }
     }
 
-    void CheckFunction(Function* func) { CheckBlock(func->Block()); }
+    void CheckFunction(Function* func) {
+        if (!seen_functions_.Add(func)) {
+            AddError("function '" + Name(func) + "' added to module multiple times");
+        }
+
+        CheckBlock(func->Block());
+    }
 
     void CheckBlock(Block* blk) {
         TINT_SCOPED_ASSIGNMENT(current_block_, blk);
@@ -184,12 +222,22 @@
     void CheckInstruction(Instruction* inst) {
         if (!inst->Alive()) {
             AddError(inst, "destroyed instruction found in instruction list");
+            return;
         }
-        if (inst->Result()) {
-            if (inst->Result()->Source() == nullptr) {
-                AddError(inst, "instruction result source is undefined");
-            } else if (inst->Result()->Source() != inst) {
-                AddError(inst, "instruction result source has wrong instruction");
+        if (inst->HasResults()) {
+            auto results = inst->Results();
+            for (size_t i = 0; i < results.Length(); ++i) {
+                auto* res = results[i];
+                if (!res) {
+                    AddResultError(inst, i, "instruction result is undefined");
+                    continue;
+                }
+
+                if (res->Source() == nullptr) {
+                    AddResultError(inst, i, "instruction result source is undefined");
+                } else if (res->Source() != inst) {
+                    AddResultError(inst, i, "instruction result source has wrong instruction");
+                }
             }
         }
 
@@ -203,7 +251,7 @@
             // Note, a `nullptr` is a valid operand in some cases, like `var` so we can't just check
             // for `nullptr` here.
             if (!op->Alive()) {
-                AddError(inst, "instruction has undefined operand");
+                AddError(inst, i, "instruction has operand which is not alive");
             }
 
             if (!op->Usages().Contains({inst, i})) {
@@ -223,7 +271,7 @@
             [&](Switch*) {},                             //
             [&](Swizzle*) {},                            //
             [&](Terminator* b) { CheckTerminator(b); },  //
-            [&](Unary*) {},                              //
+            [&](Unary* u) { CheckUnary(u); },            //
             [&](Var* var) { CheckVar(var); },            //
             [&](Default) {
                 AddError(std::string("missing validation of: ") + inst->TypeInfo().name);
@@ -313,14 +361,20 @@
     }
 
     void CheckBinary(ir::Binary* b) {
-        if (b->LHS() == nullptr) {
-            AddError(b, "binary: left operand is undefined");
-        }
-        if (b->RHS() == nullptr) {
-            AddError(b, "binary: right operand is undefined");
-        }
-        if (b->Result() == nullptr) {
-            AddError(b, "binary: result is undefined");
+        CheckOperandsNotNull(b, Binary::kLhsOperandOffset, Binary::kRhsOperandOffset, "binary",
+                             [](size_t err_idx) {
+                                 return (err_idx == Binary::kLhsOperandOffset) ? "left" : "right";
+                             });
+    }
+
+    void CheckUnary(ir::Unary* u) {
+        CheckOperandNotNull(u, u->Val(), Unary::kValueOperandOffset, "unary",
+                            [](size_t) { return "value"; });
+
+        if (u->Result() && u->Val()) {
+            if (u->Result()->Type() != u->Val()->Type()) {
+                AddError(u, "unary: result type must match value type");
+            }
         }
     }
 
@@ -345,19 +399,15 @@
     }
 
     void CheckIf(If* if_) {
-        if (!if_->Condition()) {
-            AddError(if_, "if: condition is undefined");
-        }
+        CheckOperandNotNull(if_, if_->Condition(), If::kConditionOperandOffset, "if",
+                            [](size_t) { return "condition"; });
+
         if (if_->Condition() && !if_->Condition()->Type()->Is<type::Bool>()) {
             AddError(if_, If::kConditionOperandOffset, "if: condition must be a `bool` type");
         }
     }
 
     void CheckVar(Var* var) {
-        if (var->Result() == nullptr) {
-            AddError(var, "var: result is undefined");
-        }
-
         if (var->Result() && var->Initializer()) {
             if (var->Initializer()->Type() != var->Result()->Type()->UnwrapPtr()) {
                 AddError(var, "var initializer has incorrect type");
diff --git a/src/tint/ir/validate_test.cc b/src/tint/ir/validate_test.cc
index 8d696e1..723c3fc 100644
--- a/src/tint/ir/validate_test.cc
+++ b/src/tint/ir/validate_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <string>
 #include <utility>
 
 #include "gmock/gmock.h"
@@ -21,6 +22,7 @@
 #include "src/tint/type/matrix.h"
 #include "src/tint/type/pointer.h"
 #include "src/tint/type/struct.h"
+#include "src/tint/utils/string.h"
 
 namespace tint::ir {
 namespace {
@@ -68,7 +70,6 @@
 
 TEST_F(IR_ValidateTest, Function) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     f->SetParams({b.FunctionParam(ty.i32()), b.FunctionParam(ty.f32())});
     f->Block()->Append(b.Return(f));
@@ -77,10 +78,34 @@
     EXPECT_TRUE(res) << res.Failure().str();
 }
 
-TEST_F(IR_ValidateTest, Block_NoTerminator) {
+TEST_F(IR_ValidateTest, Function_Duplicate) {
     auto* f = b.Function("my_func", ty.void_());
+    // Function would auto-push by the builder, so this adds a duplicate
     mod.functions.Push(f);
 
+    f->SetParams({b.FunctionParam(ty.i32()), b.FunctionParam(ty.f32())});
+    f->Block()->Append(b.Return(f));
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(error: function 'my_func' added to module multiple times
+note: # Disassembly
+%my_func = func(%2:i32, %3:f32):void -> %b1 {
+  %b1 = block {
+    ret
+  }
+}
+%my_func = func(%2:i32, %3:f32):void -> %b1 {
+  %b1 = block {
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Block_NoTerminator) {
+    b.Function("my_func", ty.void_());
+
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
     EXPECT_EQ(res.Failure().str(), R"(:2:3 error: block: does not end in a terminator instruction
@@ -99,7 +124,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.mat3x2<f32>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.f32(), obj, 1_u, 0_u);
@@ -114,7 +138,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.ptr<private_, f32>(), obj, 1_u, 0_u);
@@ -129,7 +152,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.vec3<f32>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.f32(), obj, -1_i);
@@ -160,7 +182,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.mat3x2<f32>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.f32(), obj, 1_u, 3_u);
@@ -195,7 +216,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.ptr<private_, f32>(), obj, 1_u, 3_u);
@@ -231,7 +251,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.f32());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.f32(), obj, 1_u);
@@ -262,7 +281,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.ptr<private_, f32>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.ptr<private_, f32>(), obj, 1_u);
@@ -299,7 +317,6 @@
     auto* obj = b.FunctionParam(str_ty);
     auto* idx = b.FunctionParam(ty.i32());
     f->SetParams({obj, idx});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.i32(), obj, idx);
@@ -342,7 +359,6 @@
     auto* obj = b.FunctionParam(ty.ptr<private_, read_write>(str_ty));
     auto* idx = b.FunctionParam(ty.i32());
     f->SetParams({obj, idx});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.i32(), obj, idx);
@@ -379,7 +395,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.mat3x2<f32>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.i32(), obj, 1_u, 1_u);
@@ -411,7 +426,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.ptr<private_, i32>(), obj, 1_u, 1_u);
@@ -444,7 +458,6 @@
     auto* f = b.Function("my_func", ty.void_());
     auto* obj = b.FunctionParam(ty.ptr<private_, mat3x2<f32>>());
     f->SetParams({obj});
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Access(ty.f32(), obj, 1_u, 1_u);
@@ -475,7 +488,6 @@
 
 TEST_F(IR_ValidateTest, Block_TerminatorInMiddle) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     b.With(f->Block(), [&] {
         b.Return(f);
@@ -505,7 +517,6 @@
 
 TEST_F(IR_ValidateTest, If_ConditionIsBool) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto* if_ = b.If(1_i);
     if_->True()->Append(b.Return(f));
@@ -541,15 +552,52 @@
 )");
 }
 
+TEST_F(IR_ValidateTest, If_ConditionIsNullptr) {
+    auto* f = b.Function("my_func", ty.void_());
+
+    auto* if_ = b.If(nullptr);
+    if_->True()->Append(b.Return(f));
+    if_->False()->Append(b.Return(f));
+
+    f->Block()->Append(if_);
+    f->Block()->Append(b.Return(f));
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:8 error: if: condition operand is undefined
+    if undef [t: %b2, f: %b3] {  # if_1
+       ^^^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    if undef [t: %b2, f: %b3] {  # if_1
+      %b2 = block {  # true
+        ret
+      }
+      %b3 = block {  # false
+        ret
+      }
+    }
+    ret
+  }
+}
+)");
+}
+
 TEST_F(IR_ValidateTest, Var_RootBlock_NullResult) {
     auto* v = mod.instructions.Create<ir::Var>(nullptr);
     b.RootBlock()->Append(v);
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:2:11 error: var: result is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:2:3 error: instruction result is undefined
   undef = var
-          ^^^
+  ^^^^^
 
 :1:1 note: In block
 %b1 = block {  # root
@@ -567,7 +615,6 @@
     auto* v = mod.instructions.Create<ir::Var>(nullptr);
 
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     sb.Append(v);
@@ -575,9 +622,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:13 error: var: result is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: instruction result is undefined
     undef = var
-            ^^^
+    ^^^^^
 
 :2:3 note: In block
   %b1 = block {
@@ -595,7 +642,6 @@
 
 TEST_F(IR_ValidateTest, Var_Init_WrongType) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     auto* v = sb.Var(ty.ptr<function, f32>());
@@ -626,7 +672,6 @@
 
 TEST_F(IR_ValidateTest, Instruction_AppendedDead) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     auto* v = sb.Var(ty.ptr<function, f32>());
@@ -635,19 +680,12 @@
     v->Destroy();
     v->InsertBefore(ret);
 
-    auto res = ir::Validate(mod);
-    ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: destroyed instruction found in instruction list
-    %2:ptr<function, f32, read_write> = var
-                                        ^^^
+    auto addr = utils::ToString(v);
+    auto arrows = std::string(addr.length(), '^');
 
-:2:3 note: In block
-  %b1 = block {
-  ^^^^^^^^^^^
-
-:3:41 error: instruction result source is undefined
-    %2:ptr<function, f32, read_write> = var
-                                        ^^^
+    std::string expected = R"(:3:5 error: destroyed instruction found in instruction list
+    <destroyed tint::ir::Var $ADDRESS>
+    ^^^^^^^^^^^^^^^^^^^^^^^^^$ARROWS^
 
 :2:3 note: In block
   %b1 = block {
@@ -656,16 +694,22 @@
 note: # Disassembly
 %my_func = func():void -> %b1 {
   %b1 = block {
-    %2:ptr<function, f32, read_write> = var
+    <destroyed tint::ir::Var $ADDRESS>
     ret
   }
 }
-)");
+)";
+
+    expected = utils::ReplaceAll(expected, "$ADDRESS", addr);
+    expected = utils::ReplaceAll(expected, "$ARROWS", arrows);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), expected);
 }
 
 TEST_F(IR_ValidateTest, Instruction_NullSource) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     auto* v = sb.Var(ty.ptr<function, f32>());
@@ -675,9 +719,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: instruction result source is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: instruction result source is undefined
     %2:ptr<function, f32, read_write> = var
-                                        ^^^
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 :2:3 note: In block
   %b1 = block {
@@ -695,7 +739,6 @@
 
 TEST_F(IR_ValidateTest, Instruction_DeadOperand) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     auto* v = sb.Var(ty.ptr<function, f32>());
@@ -707,9 +750,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:41 error: instruction has undefined operand
+    EXPECT_EQ(res.Failure().str(), R"(:3:46 error: instruction has operand which is not alive
     %2:ptr<function, f32, read_write> = var, %3
-                                        ^^^
+                                             ^^
 
 :2:3 note: In block
   %b1 = block {
@@ -727,7 +770,6 @@
 
 TEST_F(IR_ValidateTest, Instruction_OperandUsageRemoved) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     auto* v = sb.Var(ty.ptr<function, f32>());
@@ -759,7 +801,6 @@
 
 TEST_F(IR_ValidateTest, Binary_LHS_Nullptr) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     sb.Add(ty.i32(), nullptr, sb.Constant(2_i));
@@ -767,9 +808,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: binary: left operand is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:3:18 error: binary: left operand is undefined
     %2:i32 = add undef, 2i
-    ^^^^^^^^^^^^^^^^^^^^^^
+                 ^^^^^
 
 :2:3 note: In block
   %b1 = block {
@@ -787,7 +828,6 @@
 
 TEST_F(IR_ValidateTest, Binary_RHS_Nullptr) {
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     sb.Add(ty.i32(), sb.Constant(2_i), nullptr);
@@ -795,9 +835,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: binary: right operand is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:3:22 error: binary: right operand is undefined
     %2:i32 = add 2i, undef
-    ^^^^^^^^^^^^^^^^^^^^^^
+                     ^^^^^
 
 :2:3 note: In block
   %b1 = block {
@@ -818,7 +858,6 @@
                                                     b.Constant(3_i), b.Constant(2_i));
 
     auto* f = b.Function("my_func", ty.void_());
-    mod.functions.Push(f);
 
     auto sb = b.With(f->Block());
     sb.Append(bin);
@@ -826,9 +865,9 @@
 
     auto res = ir::Validate(mod);
     ASSERT_FALSE(res);
-    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: binary: result is undefined
+    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: instruction result is undefined
     undef = add 3i, 2i
-    ^^^^^^^^^^^^^^^^^^
+    ^^^^^
 
 :2:3 note: In block
   %b1 = block {
@@ -844,5 +883,91 @@
 )");
 }
 
+TEST_F(IR_ValidateTest, Unary_Value_Nullptr) {
+    auto* f = b.Function("my_func", ty.void_());
+
+    auto sb = b.With(f->Block());
+    sb.Negation(ty.i32(), nullptr);
+    sb.Return(f);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:23 error: unary: value operand is undefined
+    %2:i32 = negation undef
+                      ^^^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:i32 = negation undef
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Unary_Result_Nullptr) {
+    auto* bin =
+        mod.instructions.Create<ir::Unary>(nullptr, ir::Unary::Kind::kNegation, b.Constant(2_i));
+
+    auto* f = b.Function("my_func", ty.void_());
+
+    auto sb = b.With(f->Block());
+    sb.Append(bin);
+    sb.Return(f);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: instruction result is undefined
+    undef = negation 2i
+    ^^^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    undef = negation 2i
+    ret
+  }
+}
+)");
+}
+
+TEST_F(IR_ValidateTest, Unary_ResultTypeNotMatchValueType) {
+    auto* bin = b.Complement(ty.f32(), 2_i);
+
+    auto* f = b.Function("my_func", ty.void_());
+
+    auto sb = b.With(f->Block());
+    sb.Append(bin);
+    sb.Return(f);
+
+    auto res = ir::Validate(mod);
+    ASSERT_FALSE(res);
+    EXPECT_EQ(res.Failure().str(), R"(:3:5 error: unary: result type must match value type
+    %2:f32 = complement 2i
+    ^^^^^^^^^^^^^^^^^^^^^^
+
+:2:3 note: In block
+  %b1 = block {
+  ^^^^^^^^^^^
+
+note: # Disassembly
+%my_func = func():void -> %b1 {
+  %b1 = block {
+    %2:f32 = complement 2i
+    ret
+  }
+}
+)");
+}
+
 }  // namespace
 }  // namespace tint::ir
diff --git a/src/tint/ir/value.cc b/src/tint/ir/value.cc
index 1471681..dd93f4b 100644
--- a/src/tint/ir/value.cc
+++ b/src/tint/ir/value.cc
@@ -28,7 +28,7 @@
 void Value::Destroy() {
     TINT_ASSERT(IR, Alive());
     TINT_ASSERT(IR, Usages().Count() == 0);
-    alive_ = false;
+    flags_.Add(Flag::kDead);
 }
 
 void Value::ReplaceAllUsesWith(std::function<Value*(Usage use)> replacer) {
diff --git a/src/tint/ir/value.h b/src/tint/ir/value.h
index 0efa6d0..1f7f3b5 100644
--- a/src/tint/ir/value.h
+++ b/src/tint/ir/value.h
@@ -64,7 +64,7 @@
     virtual void Destroy();
 
     /// @returns true if the Value has not been destroyed with Destroy()
-    bool Alive() const { return alive_; }
+    bool Alive() const { return !flags_.Contains(Flag::kDead); }
 
     /// Adds a usage of this value.
     /// @param u the usage
@@ -91,8 +91,16 @@
     Value();
 
   private:
+    /// Flags applied to an Value
+    enum class Flag {
+        /// The value has been destroyed
+        kDead,
+    };
+
     utils::Hashset<Usage, 4, Usage::Hasher> uses_;
-    bool alive_ = true;
+
+    /// Bitset of value flags
+    utils::EnumSet<Flag> flags_;
 };
 }  // namespace tint::ir
 
diff --git a/src/tint/reader/wgsl/parser_impl.cc b/src/tint/reader/wgsl/parser_impl.cc
index 5b5c684..352fd47 100644
--- a/src/tint/reader/wgsl/parser_impl.cc
+++ b/src/tint/reader/wgsl/parser_impl.cc
@@ -3067,6 +3067,8 @@
             return create<ast::GroupAttribute>(t.source(), args[0]);
         case builtin::Attribute::kId:
             return create<ast::IdAttribute>(t.source(), args[0]);
+        case builtin::Attribute::kIndex:
+            return create<ast::IndexAttribute>(t.source(), args[0]);
         case builtin::Attribute::kInterpolate:
             return create<ast::InterpolateAttribute>(t.source(), args[0],
                                                      args.Length() == 2 ? args[1] : nullptr);
diff --git a/src/tint/reader/wgsl/parser_impl_struct_member_attribute_test.cc b/src/tint/reader/wgsl/parser_impl_struct_member_attribute_test.cc
index 30834ad..0cc1138 100644
--- a/src/tint/reader/wgsl/parser_impl_struct_member_attribute_test.cc
+++ b/src/tint/reader/wgsl/parser_impl_struct_member_attribute_test.cc
@@ -223,5 +223,22 @@
     EXPECT_EQ(p->error(), "1:9: mixing '+' and '<<' requires parenthesis");
 }
 
+TEST_F(ParserImplTest, Attribute_Index) {
+    auto p = parser("index(1)");
+    auto attr = p->attribute();
+    EXPECT_TRUE(attr.matched);
+    EXPECT_FALSE(attr.errored);
+    ASSERT_NE(attr.value, nullptr);
+    ASSERT_FALSE(p->has_error()) << p->error();
+
+    auto* member_attr = attr.value->As<ast::Attribute>();
+    ASSERT_NE(member_attr, nullptr);
+    ASSERT_TRUE(member_attr->Is<ast::IndexAttribute>());
+
+    auto* o = member_attr->As<ast::IndexAttribute>();
+    ASSERT_TRUE(o->expr->Is<ast::IntLiteralExpression>());
+    EXPECT_EQ(o->expr->As<ast::IntLiteralExpression>()->value, 1);
+}
+
 }  // namespace
 }  // namespace tint::reader::wgsl
diff --git a/src/tint/resolver/dual_source_blending_extension_test.cc b/src/tint/resolver/dual_source_blending_extension_test.cc
index 4974940..fe8ed1d 100644
--- a/src/tint/resolver/dual_source_blending_extension_test.cc
+++ b/src/tint/resolver/dual_source_blending_extension_test.cc
@@ -120,5 +120,17 @@
     EXPECT_TRUE(r()->Resolve()) << r()->error();
 }
 
+// Using an index attribute on a global variable should pass. This is needed internally when using
+// @index with the canonicalize_entry_point transform. This test uses an internal attribute to
+// ignore address space, which is how it is used with the canonicalize_entry_point transform.
+TEST_F(DualSourceBlendingExtensionTests, GlobalVariableIndexAttribute) {
+    GlobalVar("var", ty.vec4<f32>(),
+              utils::Vector{Location(0_a), Index(0_a),
+                            Disable(ast::DisabledValidation::kIgnoreAddressSpace)},
+              builtin::AddressSpace::kOut);
+
+    EXPECT_TRUE(r()->Resolve()) << r()->error();
+}
+
 }  // namespace
 }  // namespace tint::resolver
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 254c969..6e960ec 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -572,7 +572,7 @@
         bool has_io_address_space = address_space == builtin::AddressSpace::kIn ||
                                     address_space == builtin::AddressSpace::kOut;
 
-        std::optional<uint32_t> group, binding, location;
+        std::optional<uint32_t> group, binding, location, index;
         for (auto* attribute : var->attributes) {
             Mark(attribute);
             enum Status { kSuccess, kErrored, kInvalid };
@@ -605,6 +605,17 @@
                     location = value.Get();
                     return kSuccess;
                 },
+                [&](const ast::IndexAttribute* attr) {
+                    if (!has_io_address_space) {
+                        return kInvalid;
+                    }
+                    auto value = IndexAttribute(attr);
+                    if (!value) {
+                        return kErrored;
+                    }
+                    index = value.Get();
+                    return kSuccess;
+                },
                 [&](const ast::BuiltinAttribute* attr) {
                     if (!has_io_address_space) {
                         return kInvalid;
@@ -645,7 +656,7 @@
         }
         sem = builder_->create<sem::GlobalVariable>(
             var, var_ty, sem::EvaluationStage::kRuntime, address_space, access,
-            /* constant_value */ nullptr, binding_point, location);
+            /* constant_value */ nullptr, binding_point, location, index);
 
     } else {
         for (auto* attribute : var->attributes) {
diff --git a/src/tint/sem/variable.cc b/src/tint/sem/variable.cc
index a220a80..95c4236 100644
--- a/src/tint/sem/variable.cc
+++ b/src/tint/sem/variable.cc
@@ -62,10 +62,12 @@
                                builtin::Access access,
                                const constant::Value* constant_value,
                                std::optional<sem::BindingPoint> binding_point,
-                               std::optional<uint32_t> location)
+                               std::optional<uint32_t> location,
+                               std::optional<uint32_t> index)
     : Base(declaration, type, stage, address_space, access, constant_value),
       binding_point_(binding_point),
-      location_(location) {}
+      location_(location),
+      index_(index) {}
 
 GlobalVariable::~GlobalVariable() = default;
 
diff --git a/src/tint/sem/variable.h b/src/tint/sem/variable.h
index 7660df3..cc8b661 100644
--- a/src/tint/sem/variable.h
+++ b/src/tint/sem/variable.h
@@ -156,6 +156,7 @@
     /// @param constant_value the constant value for the variable. May be null
     /// @param binding_point the optional resource binding point of the variable
     /// @param location the location value if provided
+    /// @param index the index value if provided
     ///
     /// Note, a GlobalVariable generally doesn't have a `location` in WGSL, as it isn't allowed by
     /// the spec. The location maybe attached by transforms such as CanonicalizeEntryPointIO.
@@ -166,7 +167,8 @@
                    builtin::Access access,
                    const constant::Value* constant_value,
                    std::optional<sem::BindingPoint> binding_point = std::nullopt,
-                   std::optional<uint32_t> location = std::nullopt);
+                   std::optional<uint32_t> location = std::nullopt,
+                   std::optional<uint32_t> index = std::nullopt);
 
     /// Destructor
     ~GlobalVariable() override;
@@ -188,6 +190,7 @@
 
     tint::OverrideId override_id_;
     std::optional<uint32_t> location_;
+    std::optional<uint32_t> index_;
 };
 
 /// Parameter is a function parameter
diff --git a/src/tint/transform/manager_test.cc b/src/tint/transform/manager_test.cc
index e578766..f8f8e0b 100644
--- a/src/tint/transform/manager_test.cc
+++ b/src/tint/transform/manager_test.cc
@@ -52,7 +52,6 @@
         ir::Builder builder(*mod);
         auto* func = builder.Function("ir_func", mod->Types().Get<type::Void>());
         func->Block()->Append(builder.Return(func));
-        mod->functions.Push(func);
     }
 };
 #endif  // TINT_BUILD_IR
@@ -69,7 +68,6 @@
     ir::Builder builder(mod);
     auto* func = builder.Function("main", mod.Types().Get<type::Void>());
     func->Block()->Append(builder.Return(func));
-    builder.ir.functions.Push(func);
     return mod;
 }
 #endif  // TINT_BUILD_IR
diff --git a/src/tint/type/manager.cc b/src/tint/type/manager.cc
index 17a3011..33bed10 100644
--- a/src/tint/type/manager.cc
+++ b/src/tint/type/manager.cc
@@ -172,7 +172,7 @@
     return Get<type::Pointer>(address_space, subtype, access);
 }
 
-const type::Struct* Manager::Struct(Symbol name, utils::VectorRef<StructMemberDesc> md) {
+type::Struct* Manager::Struct(Symbol name, utils::VectorRef<StructMemberDesc> md) {
     utils::Vector<const type::StructMember*, 4> members;
     uint32_t current_size = 0u;
     uint32_t max_align = 0u;
diff --git a/src/tint/type/manager.h b/src/tint/type/manager.h
index 63e02e3..76cf959 100644
--- a/src/tint/type/manager.h
+++ b/src/tint/type/manager.h
@@ -429,13 +429,13 @@
     /// @param name the name of the structure
     /// @param members the list of structure member descriptors
     /// @returns the structure type
-    const type::Struct* Struct(Symbol name, utils::VectorRef<StructMemberDesc> members);
+    type::Struct* Struct(Symbol name, utils::VectorRef<StructMemberDesc> members);
 
     /// Create a new structure declaration.
     /// @param name the name of the structure
     /// @param members the list of structure member descriptors
     /// @returns the structure type
-    const type::Struct* Struct(Symbol name, std::initializer_list<StructMemberDesc> members) {
+    type::Struct* Struct(Symbol name, std::initializer_list<StructMemberDesc> members) {
         return Struct(name, utils::Vector<StructMemberDesc, 4>(members));
     }
 
diff --git a/src/tint/type/struct.h b/src/tint/type/struct.h
index 907485c..5a6c4dd 100644
--- a/src/tint/type/struct.h
+++ b/src/tint/type/struct.h
@@ -15,11 +15,11 @@
 #ifndef SRC_TINT_TYPE_STRUCT_H_
 #define SRC_TINT_TYPE_STRUCT_H_
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <optional>
 #include <string>
 #include <unordered_set>
+#include <utility>
 
 #include "src/tint/builtin/address_space.h"
 #include "src/tint/builtin/interpolation.h"
@@ -245,6 +245,10 @@
     /// @returns the optional attributes
     const StructMemberAttributes& Attributes() const { return attributes_; }
 
+    /// Set the attributes of the struct member.
+    /// @param attributes the new attributes
+    void SetAttributes(StructMemberAttributes&& attributes) { attributes_ = std::move(attributes); }
+
     /// @param ctx the clone context
     /// @returns a clone of this struct member
     StructMember* Clone(CloneContext& ctx) const;
@@ -257,7 +261,7 @@
     const uint32_t offset_;
     const uint32_t align_;
     const uint32_t size_;
-    const StructMemberAttributes attributes_;
+    StructMemberAttributes attributes_;
 };
 
 }  // namespace tint::type
diff --git a/src/tint/utils/enum_set.h b/src/tint/utils/enum_set.h
index 575868b..c156d50 100644
--- a/src/tint/utils/enum_set.h
+++ b/src/tint/utils/enum_set.h
@@ -37,27 +37,27 @@
     constexpr EnumSet() = default;
 
     /// Copy constructor.
-    /// @param s the set to copy
+    /// @param s the EnumSet to copy
     constexpr EnumSet(const EnumSet& s) = default;
 
     /// Constructor. Initializes the EnumSet with the given values.
-    /// @param values the enumerator values to construct the set with
+    /// @param values the enumerator values to construct the EnumSet with
     template <typename... VALUES>
     explicit constexpr EnumSet(VALUES... values) : set(Union(values...)) {}
 
     /// Copy assignment operator.
-    /// @param set the set to assign to this set
-    /// @return this set so calls can be chained
+    /// @param set the EnumSet to assign to this set
+    /// @returns this EnumSet so calls can be chained
     inline EnumSet& operator=(const EnumSet& set) = default;
 
     /// Copy assignment operator.
     /// @param e the enum value
-    /// @return this set so calls can be chained
+    /// @returns this EnumSet so calls can be chained
     inline EnumSet& operator=(Enum e) { return *this = EnumSet{e}; }
 
     /// Adds all the given values to this set
     /// @param values the values to add
-    /// @return this set so calls can be chained
+    /// @returns this EnumSet so calls can be chained
     template <typename... VALUES>
     inline EnumSet& Add(VALUES... values) {
         return Add(EnumSet(std::forward<VALUES>(values)...));
@@ -65,24 +65,30 @@
 
     /// Removes all the given values from this set
     /// @param values the values to remove
-    /// @return this set so calls can be chained
+    /// @returns this EnumSet so calls can be chained
     template <typename... VALUES>
     inline EnumSet& Remove(VALUES... values) {
         return Remove(EnumSet(std::forward<VALUES>(values)...));
     }
 
-    /// Adds all of s to this set
+    /// Adds all of @p s to this set
     /// @param s the enum value
-    /// @return this set so calls can be chained
+    /// @returns this EnumSet so calls can be chained
     inline EnumSet& Add(EnumSet s) { return (*this = *this + s); }
 
-    /// Removes all of s from this set
+    /// Removes all of @p s from this set
     /// @param s the enum value
-    /// @return this set so calls can be chained
+    /// @returns this EnumSet so calls can be chained
     inline EnumSet& Remove(EnumSet s) { return (*this = *this - s); }
 
+    /// Adds or removes @p e to the set
     /// @param e the enum value
-    /// @returns a copy of this set with e added
+    /// @param add if true the enum value is added, otherwise removed
+    /// @returns this EnumSet so calls can be chained
+    inline EnumSet& Set(Enum e, bool add = true) { return add ? Add(e) : Remove(e); }
+
+    /// @param e the enum value
+    /// @returns a copy of this EnumSet with @p e added
     inline EnumSet operator+(Enum e) const {
         EnumSet out;
         out.set = set | Bit(e);
@@ -90,7 +96,7 @@
     }
 
     /// @param e the enum value
-    /// @returns a copy of this set with e removed
+    /// @returns a copy of this EnumSet with @p e removed
     inline EnumSet operator-(Enum e) const {
         EnumSet out;
         out.set = set & ~Bit(e);
@@ -98,7 +104,7 @@
     }
 
     /// @param s the other set
-    /// @returns the union of this set with s (this ∪ rhs)
+    /// @returns the union of this EnumSet with @p s (`this` ∪ @p s)
     inline EnumSet operator+(EnumSet s) const {
         EnumSet out;
         out.set = set | s.set;
@@ -106,7 +112,7 @@
     }
 
     /// @param s the other set
-    /// @returns the set of entries found in this but not in s (this \ s)
+    /// @returns the set of entries found in this but not in s (`this` \ @p s)
     inline EnumSet operator-(EnumSet s) const {
         EnumSet out;
         out.set = set & ~s.set;
@@ -114,7 +120,7 @@
     }
 
     /// @param s the other set
-    /// @returns the intersection of this set with s (this ∩ rhs)
+    /// @returns the intersection of this EnumSet with s (`this` ∩ @p s)
     inline EnumSet operator&(EnumSet s) const {
         EnumSet out;
         out.set = set & s.set;
@@ -122,7 +128,7 @@
     }
 
     /// @param e the enum value
-    /// @return true if the set contains `e`
+    /// @return true if the set contains @p e
     inline bool Contains(Enum e) const { return (set & Bit(e)) != 0; }
 
     /// @return true if the set is empty
@@ -130,22 +136,22 @@
 
     /// Equality operator
     /// @param rhs the other EnumSet to compare this to
-    /// @return true if this EnumSet is equal to rhs
+    /// @return true if this EnumSet is equal to @p rhs
     inline bool operator==(EnumSet rhs) const { return set == rhs.set; }
 
     /// Inequality operator
     /// @param rhs the other EnumSet to compare this to
-    /// @return true if this EnumSet is not equal to rhs
+    /// @return true if this EnumSet is not equal to @p rhs
     inline bool operator!=(EnumSet rhs) const { return set != rhs.set; }
 
     /// Equality operator
     /// @param rhs the enum to compare this to
-    /// @return true if this EnumSet only contains `rhs`
+    /// @return true if this EnumSet only contains @p rhs
     inline bool operator==(Enum rhs) const { return set == Bit(rhs); }
 
     /// Inequality operator
     /// @param rhs the enum to compare this to
-    /// @return false if this EnumSet only contains `rhs`
+    /// @return false if this EnumSet only contains @p rhs
     inline bool operator!=(Enum rhs) const { return set != Bit(rhs); }
 
     /// @return the underlying value for the EnumSet
diff --git a/src/tint/utils/enum_set_test.cc b/src/tint/utils/enum_set_test.cc
index 6e9b59c..cf0496a 100644
--- a/src/tint/utils/enum_set_test.cc
+++ b/src/tint/utils/enum_set_test.cc
@@ -126,6 +126,19 @@
     EXPECT_FALSE(set.Contains(E::C));
 }
 
+TEST(EnumSetTest, Set) {
+    EnumSet<E> set;
+    set.Set(E::B);
+    EXPECT_FALSE(set.Contains(E::A));
+    EXPECT_TRUE(set.Contains(E::B));
+    EXPECT_FALSE(set.Contains(E::C));
+
+    set.Set(E::B, false);
+    EXPECT_FALSE(set.Contains(E::A));
+    EXPECT_FALSE(set.Contains(E::B));
+    EXPECT_FALSE(set.Contains(E::C));
+}
+
 TEST(EnumSetTest, OperatorPlusEnum) {
     EnumSet<E> set = EnumSet<E>{E::B} + E::C;
     EXPECT_FALSE(set.Contains(E::A));
diff --git a/src/tint/utils/slice.h b/src/tint/utils/slice.h
index 49483ec..efe2ac4 100644
--- a/src/tint/utils/slice.h
+++ b/src/tint/utils/slice.h
@@ -18,6 +18,7 @@
 #include <cstdint>
 #include <iterator>
 
+#include "src/tint/debug.h"
 #include "src/tint/utils/bitcast.h"
 #include "src/tint/utils/castable.h"
 #include "src/tint/utils/traits.h"
@@ -186,24 +187,42 @@
     /// Index operator
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
-    T& operator[](size_t i) { return data[i]; }
+    T& operator[](size_t i) {
+        TINT_ASSERT(Utils, i < Length());
+        return data[i];
+    }
 
     /// Index operator
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
-    const T& operator[](size_t i) const { return data[i]; }
+    const T& operator[](size_t i) const {
+        TINT_ASSERT(Utils, i < Length());
+        return data[i];
+    }
 
     /// @returns a reference to the first element in the vector
-    T& Front() { return data[0]; }
+    T& Front() {
+        TINT_ASSERT(Utils, !IsEmpty());
+        return data[0];
+    }
 
     /// @returns a reference to the first element in the vector
-    const T& Front() const { return data[0]; }
+    const T& Front() const {
+        TINT_ASSERT(Utils, !IsEmpty());
+        return data[0];
+    }
 
     /// @returns a reference to the last element in the vector
-    T& Back() { return data[len - 1]; }
+    T& Back() {
+        TINT_ASSERT(Utils, !IsEmpty());
+        return data[len - 1];
+    }
 
     /// @returns a reference to the last element in the vector
-    const T& Back() const { return data[len - 1]; }
+    const T& Back() const {
+        TINT_ASSERT(Utils, !IsEmpty());
+        return data[len - 1];
+    }
 
     /// @returns a pointer to the first element in the vector
     T* begin() { return data; }
diff --git a/src/tint/utils/string.cc b/src/tint/utils/string.cc
index 00b51a8..320335d 100644
--- a/src/tint/utils/string.cc
+++ b/src/tint/utils/string.cc
@@ -25,7 +25,7 @@
     const auto len_b = str_b.size();
 
     Vector<size_t, 64> mat;
-    mat.Reserve((len_a + 1) * (len_b + 1));
+    mat.Resize((len_a + 1) * (len_b + 1));
 
     auto at = [&](size_t a, size_t b) -> size_t& { return mat[a + b * (len_a + 1)]; };
 
diff --git a/src/tint/utils/string_stream.h b/src/tint/utils/string_stream.h
index 2ab62a2..7485a9f 100644
--- a/src/tint/utils/string_stream.h
+++ b/src/tint/utils/string_stream.h
@@ -24,7 +24,6 @@
 #include <utility>
 
 #include "src/tint/utils/unicode.h"
-#include "src/tint/utils/vector.h"
 
 namespace tint::utils {
 
@@ -193,44 +192,6 @@
 /// @returns out so calls can be chained
 utils::StringStream& operator<<(utils::StringStream& out, CodePoint codepoint);
 
-/// Prints the vector @p vec to @p o
-/// @param o the stream to write to
-/// @param vec the vector
-/// @return the stream so calls can be chained
-template <typename T, size_t N>
-inline utils::StringStream& operator<<(utils::StringStream& o, const utils::Vector<T, N>& vec) {
-    o << "[";
-    bool first = true;
-    for (auto& el : vec) {
-        if (!first) {
-            o << ", ";
-        }
-        first = false;
-        o << el;
-    }
-    o << "]";
-    return o;
-}
-
-/// Prints the vector @p vec to @p o
-/// @param o the stream to write to
-/// @param vec the vector reference
-/// @return the stream so calls can be chained
-template <typename T>
-inline utils::StringStream& operator<<(utils::StringStream& o, utils::VectorRef<T> vec) {
-    o << "[";
-    bool first = true;
-    for (auto& el : vec) {
-        if (!first) {
-            o << ", ";
-        }
-        first = false;
-        o << el;
-    }
-    o << "]";
-    return o;
-}
-
 }  // namespace tint::utils
 
 #endif  // SRC_TINT_UTILS_STRING_STREAM_H_
diff --git a/src/tint/utils/unique_vector.h b/src/tint/utils/unique_vector.h
index eca0d4c..22df7ec 100644
--- a/src/tint/utils/unique_vector.h
+++ b/src/tint/utils/unique_vector.h
@@ -45,7 +45,7 @@
         }
     }
 
-    /// add appends the item to the end of the vector, if the vector does not
+    /// Add appends the item to the end of the vector, if the vector does not
     /// already contain the given item.
     /// @param item the item to append to the end of the vector
     /// @returns true if the item was added, otherwise false.
@@ -57,6 +57,16 @@
         return false;
     }
 
+    /// Removes @p count elements from the vector
+    /// @param start the index of the first element to remove
+    /// @param count the number of elements to remove
+    void Erase(size_t start, size_t count = 1) {
+        for (size_t i = 0; i < count; i++) {
+            set.Remove(vector[start + i]);
+        }
+        vector.Erase(start, count);
+    }
+
     /// @returns true if the vector contains `item`
     /// @param item the item
     bool Contains(const T& item) const { return set.Contains(item); }
@@ -72,6 +82,12 @@
     /// @returns true if the vector is empty
     bool IsEmpty() const { return vector.IsEmpty(); }
 
+    /// Removes all elements from the vector
+    void Clear() {
+        vector.Clear();
+        set.Clear();
+    }
+
     /// @returns the number of items in the vector
     size_t Length() const { return vector.Length(); }
 
@@ -111,6 +127,18 @@
         return vector.Pop();
     }
 
+    /// Removes the last element from the vector if it is equal to @p value
+    /// @param value the value to pop if it is at the back of the vector
+    /// @returns true if the value was popped, otherwise false
+    bool TryPop(T value) {
+        if (!vector.IsEmpty() && vector.Back() == value) {
+            set.Remove(vector.Back());
+            vector.Pop();
+            return true;
+        }
+        return false;
+    }
+
   private:
     Vector<T, N> vector;
     Hashset<T, N, HASH, EQUAL> set;
diff --git a/src/tint/utils/unique_vector_test.cc b/src/tint/utils/unique_vector_test.cc
index c198615..1d8b2f8 100644
--- a/src/tint/utils/unique_vector_test.cc
+++ b/src/tint/utils/unique_vector_test.cc
@@ -25,14 +25,14 @@
 
 TEST(UniqueVectorTest, Empty) {
     UniqueVector<int, 4> unique_vec;
-    EXPECT_EQ(unique_vec.Length(), 0u);
+    ASSERT_EQ(unique_vec.Length(), 0u);
     EXPECT_EQ(unique_vec.IsEmpty(), true);
     EXPECT_EQ(unique_vec.begin(), unique_vec.end());
 }
 
 TEST(UniqueVectorTest, MoveConstructor) {
     UniqueVector<int, 4> unique_vec(std::vector<int>{0, 3, 2, 1, 2});
-    EXPECT_EQ(unique_vec.Length(), 4u);
+    ASSERT_EQ(unique_vec.Length(), 4u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     EXPECT_EQ(unique_vec[0], 0);
     EXPECT_EQ(unique_vec[1], 3);
@@ -45,7 +45,7 @@
     unique_vec.Add(0);
     unique_vec.Add(1);
     unique_vec.Add(2);
-    EXPECT_EQ(unique_vec.Length(), 3u);
+    ASSERT_EQ(unique_vec.Length(), 3u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     int i = 0;
     for (auto n : unique_vec) {
@@ -69,7 +69,7 @@
     unique_vec.Add(1);
     unique_vec.Add(1);
     unique_vec.Add(2);
-    EXPECT_EQ(unique_vec.Length(), 3u);
+    ASSERT_EQ(unique_vec.Length(), 3u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     int i = 0;
     for (auto n : unique_vec) {
@@ -85,6 +85,87 @@
     EXPECT_EQ(unique_vec[2], 2);
 }
 
+TEST(UniqueVectorTest, Erase) {
+    UniqueVector<int, 4> unique_vec;
+    unique_vec.Add(0);
+    unique_vec.Add(3);
+    unique_vec.Add(2);
+    unique_vec.Add(5);
+    unique_vec.Add(1);
+    unique_vec.Add(6);
+    EXPECT_EQ(unique_vec.Length(), 6u);
+    EXPECT_EQ(unique_vec.IsEmpty(), false);
+
+    unique_vec.Erase(2, 2);
+
+    ASSERT_EQ(unique_vec.Length(), 4u);
+    EXPECT_EQ(unique_vec[0], 0);
+    EXPECT_EQ(unique_vec[1], 3);
+    EXPECT_EQ(unique_vec[2], 1);
+    EXPECT_EQ(unique_vec[3], 6);
+    EXPECT_TRUE(unique_vec.Contains(0));
+    EXPECT_TRUE(unique_vec.Contains(3));
+    EXPECT_FALSE(unique_vec.Contains(2));
+    EXPECT_FALSE(unique_vec.Contains(5));
+    EXPECT_TRUE(unique_vec.Contains(1));
+    EXPECT_TRUE(unique_vec.Contains(6));
+    EXPECT_EQ(unique_vec.IsEmpty(), false);
+
+    unique_vec.Erase(1);
+
+    ASSERT_EQ(unique_vec.Length(), 3u);
+    EXPECT_EQ(unique_vec[0], 0);
+    EXPECT_EQ(unique_vec[1], 1);
+    EXPECT_EQ(unique_vec[2], 6);
+    EXPECT_TRUE(unique_vec.Contains(0));
+    EXPECT_FALSE(unique_vec.Contains(3));
+    EXPECT_FALSE(unique_vec.Contains(2));
+    EXPECT_FALSE(unique_vec.Contains(5));
+    EXPECT_TRUE(unique_vec.Contains(1));
+    EXPECT_TRUE(unique_vec.Contains(6));
+    EXPECT_EQ(unique_vec.IsEmpty(), false);
+
+    unique_vec.Erase(2);
+
+    ASSERT_EQ(unique_vec.Length(), 2u);
+    EXPECT_EQ(unique_vec[0], 0);
+    EXPECT_EQ(unique_vec[1], 1);
+    EXPECT_TRUE(unique_vec.Contains(0));
+    EXPECT_FALSE(unique_vec.Contains(3));
+    EXPECT_FALSE(unique_vec.Contains(2));
+    EXPECT_FALSE(unique_vec.Contains(5));
+    EXPECT_TRUE(unique_vec.Contains(1));
+    EXPECT_FALSE(unique_vec.Contains(6));
+    EXPECT_EQ(unique_vec.IsEmpty(), false);
+
+    unique_vec.Erase(0, 2);
+
+    ASSERT_EQ(unique_vec.Length(), 0u);
+    EXPECT_FALSE(unique_vec.Contains(0));
+    EXPECT_FALSE(unique_vec.Contains(3));
+    EXPECT_FALSE(unique_vec.Contains(2));
+    EXPECT_FALSE(unique_vec.Contains(5));
+    EXPECT_FALSE(unique_vec.Contains(1));
+    EXPECT_FALSE(unique_vec.Contains(6));
+    EXPECT_EQ(unique_vec.IsEmpty(), true);
+
+    unique_vec.Add(6);
+    unique_vec.Add(0);
+    unique_vec.Add(2);
+
+    ASSERT_EQ(unique_vec.Length(), 3u);
+    EXPECT_EQ(unique_vec[0], 6);
+    EXPECT_EQ(unique_vec[1], 0);
+    EXPECT_EQ(unique_vec[2], 2);
+    EXPECT_TRUE(unique_vec.Contains(0));
+    EXPECT_FALSE(unique_vec.Contains(3));
+    EXPECT_TRUE(unique_vec.Contains(2));
+    EXPECT_FALSE(unique_vec.Contains(5));
+    EXPECT_FALSE(unique_vec.Contains(1));
+    EXPECT_TRUE(unique_vec.Contains(6));
+    EXPECT_EQ(unique_vec.IsEmpty(), false);
+}
+
 TEST(UniqueVectorTest, AsVector) {
     UniqueVector<int, 4> unique_vec;
     unique_vec.Add(0);
@@ -115,25 +196,25 @@
     unique_vec.Add(1);
 
     EXPECT_EQ(unique_vec.Pop(), 1);
-    EXPECT_EQ(unique_vec.Length(), 2u);
+    ASSERT_EQ(unique_vec.Length(), 2u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     EXPECT_EQ(unique_vec[0], 0);
     EXPECT_EQ(unique_vec[1], 2);
 
     EXPECT_EQ(unique_vec.Pop(), 2);
-    EXPECT_EQ(unique_vec.Length(), 1u);
+    ASSERT_EQ(unique_vec.Length(), 1u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     EXPECT_EQ(unique_vec[0], 0);
 
     unique_vec.Add(1);
 
-    EXPECT_EQ(unique_vec.Length(), 2u);
+    ASSERT_EQ(unique_vec.Length(), 2u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     EXPECT_EQ(unique_vec[0], 0);
     EXPECT_EQ(unique_vec[1], 1);
 
     EXPECT_EQ(unique_vec.Pop(), 1);
-    EXPECT_EQ(unique_vec.Length(), 1u);
+    ASSERT_EQ(unique_vec.Length(), 1u);
     EXPECT_EQ(unique_vec.IsEmpty(), false);
     EXPECT_EQ(unique_vec[0], 0);
 
diff --git a/src/tint/utils/vector.h b/src/tint/utils/vector.h
index 78cddbd..aa17a9f 100644
--- a/src/tint/utils/vector.h
+++ b/src/tint/utils/vector.h
@@ -23,9 +23,11 @@
 #include <utility>
 #include <vector>
 
+#include "src/tint/debug.h"
 #include "src/tint/utils/bitcast.h"
 #include "src/tint/utils/compiler_macros.h"
 #include "src/tint/utils/slice.h"
+#include "src/tint/utils/string_stream.h"
 
 namespace tint::utils {
 
@@ -209,12 +211,18 @@
     /// Index operator
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
-    T& operator[](size_t i) { return impl_.slice[i]; }
+    T& operator[](size_t i) {
+        TINT_ASSERT(Utils, i < Length());
+        return impl_.slice[i];
+    }
 
     /// Index operator
     /// @param i the element index. Must be less than `len`.
     /// @returns a reference to the i'th element.
-    const T& operator[](size_t i) const { return impl_.slice[i]; }
+    const T& operator[](size_t i) const {
+        TINT_ASSERT(Utils, i < Length());
+        return impl_.slice[i];
+    }
 
     /// @return the number of elements in the vector
     size_t Length() const { return impl_.slice.len; }
@@ -313,12 +321,32 @@
     /// Removes and returns the last element from the vector.
     /// @returns the popped element
     T Pop() {
+        TINT_ASSERT(Utils, !IsEmpty());
         auto& el = impl_.slice.data[--impl_.slice.len];
         auto val = std::move(el);
         el.~T();
         return val;
     }
 
+    /// Removes @p count elements from the vector
+    /// @param start the index of the first element to remove
+    /// @param count the number of elements to remove
+    void Erase(size_t start, size_t count = 1) {
+        TINT_ASSERT(Utils, start < Length());
+        TINT_ASSERT(Utils, (start + count) <= Length());
+        // Shuffle
+        for (size_t i = start + count; i < impl_.slice.len; i++) {
+            auto& src = impl_.slice.data[i];
+            auto& dst = impl_.slice.data[i - count];
+            dst = std::move(src);
+        }
+        // Pop
+        for (size_t i = 0; i < count; i++) {
+            auto& el = impl_.slice.data[--impl_.slice.len];
+            el.~T();
+        }
+    }
+
     /// Sort sorts the vector in-place using the predicate function @p pred
     /// @param pred a function that has the signature `bool(const T& a, const T& b)` which returns
     /// true if `a` is ordered before `b`.
@@ -766,6 +794,44 @@
     return out;
 }
 
+/// Prints the vector @p vec to @p o
+/// @param o the stream to write to
+/// @param vec the vector
+/// @return the stream so calls can be chained
+template <typename T, size_t N>
+inline StringStream& operator<<(StringStream& o, const Vector<T, N>& vec) {
+    o << "[";
+    bool first = true;
+    for (auto& el : vec) {
+        if (!first) {
+            o << ", ";
+        }
+        first = false;
+        o << el;
+    }
+    o << "]";
+    return o;
+}
+
+/// Prints the vector @p vec to @p o
+/// @param o the stream to write to
+/// @param vec the vector reference
+/// @return the stream so calls can be chained
+template <typename T>
+inline StringStream& operator<<(StringStream& o, VectorRef<T> vec) {
+    o << "[";
+    bool first = true;
+    for (auto& el : vec) {
+        if (!first) {
+            o << ", ";
+        }
+        first = false;
+        o << el;
+    }
+    o << "]";
+    return o;
+}
+
 namespace detail {
 
 /// IsVectorLike<T>::value is true if T is a utils::Vector or utils::VectorRef.
diff --git a/src/tint/utils/vector_test.cc b/src/tint/utils/vector_test.cc
index d65f570..91f7166 100644
--- a/src/tint/utils/vector_test.cc
+++ b/src/tint/utils/vector_test.cc
@@ -151,6 +151,70 @@
     EXPECT_TRUE(AllExternallyHeld(vec));
 }
 
+TEST(TintVectorTest, Erase_Front) {
+    Vector<std::string, 3> vec;
+    vec.Push("one");
+    vec.Push("two");
+    vec.Push("three");
+    vec.Push("four");
+    EXPECT_EQ(vec.Length(), 4u);
+
+    vec.Erase(0);
+    EXPECT_EQ(vec.Length(), 3u);
+    EXPECT_EQ(vec[0], "two");
+    EXPECT_EQ(vec[1], "three");
+    EXPECT_EQ(vec[2], "four");
+
+    vec.Erase(0, 1);
+    EXPECT_EQ(vec.Length(), 2u);
+    EXPECT_EQ(vec[0], "three");
+    EXPECT_EQ(vec[1], "four");
+
+    vec.Erase(0, 2);
+    EXPECT_EQ(vec.Length(), 0u);
+}
+
+TEST(TintVectorTest, Erase_Mid) {
+    Vector<std::string, 5> vec;
+    vec.Push("one");
+    vec.Push("two");
+    vec.Push("three");
+    vec.Push("four");
+    vec.Push("five");
+    EXPECT_EQ(vec.Length(), 5u);
+
+    vec.Erase(1);
+    EXPECT_EQ(vec.Length(), 4u);
+    EXPECT_EQ(vec[0], "one");
+    EXPECT_EQ(vec[1], "three");
+    EXPECT_EQ(vec[2], "four");
+    EXPECT_EQ(vec[3], "five");
+
+    vec.Erase(1, 2);
+    EXPECT_EQ(vec.Length(), 2u);
+    EXPECT_EQ(vec[0], "one");
+    EXPECT_EQ(vec[1], "five");
+}
+
+TEST(TintVectorTest, Erase_Back) {
+    Vector<std::string, 3> vec;
+    vec.Push("one");
+    vec.Push("two");
+    vec.Push("three");
+    vec.Push("four");
+    EXPECT_EQ(vec.Length(), 4u);
+
+    vec.Erase(3);
+    EXPECT_EQ(vec.Length(), 3u);
+    EXPECT_EQ(vec[0], "one");
+    EXPECT_EQ(vec[1], "two");
+    EXPECT_EQ(vec[2], "three");
+
+    vec.Erase(1, 2);
+    EXPECT_EQ(vec.Length(), 1u);
+    EXPECT_EQ(vec[0], "one");
+}
+
 TEST(TintVectorTest, InferTN_1CString) {
     auto vec = Vector{"one"};
     static_assert(std::is_same_v<decltype(vec)::value_type, const char*>);
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index a00c31a..357dd3a 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -1444,7 +1444,7 @@
     const ast::transform::DecomposeMemoryAccess::Intrinsic* intrinsic) {
     auto const buffer = intrinsic->Buffer()->identifier->symbol.Name();
     auto* const offset = expr->args[0];
-    auto* const value = expr->args[1];
+    auto* const value = expr->args.Length() > 1 ? expr->args[1] : nullptr;
 
     using Op = ast::transform::DecomposeMemoryAccess::Intrinsic::Op;
     using DataType = ast::transform::DecomposeMemoryAccess::Intrinsic::DataType;
diff --git a/src/tint/writer/msl/ir/generator_impl_ir.cc b/src/tint/writer/msl/ir/generator_impl_ir.cc
index 3209562..5c47493 100644
--- a/src/tint/writer/msl/ir/generator_impl_ir.cc
+++ b/src/tint/writer/msl/ir/generator_impl_ir.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/writer/msl/ir/generator_impl_ir.h"
 
+#include "src/tint/constant/composite.h"
+#include "src/tint/constant/splat.h"
 #include "src/tint/ir/constant.h"
 #include "src/tint/ir/validate.h"
 #include "src/tint/switch.h"
@@ -162,129 +164,13 @@
         [&](const type::F16*) { out << "half"; },   //
         [&](const type::I32*) { out << "int"; },    //
         [&](const type::U32*) { out << "uint"; },   //
-        [&](const type::Array* arr) {
-            out << ArrayTemplateName() << "<";
-            EmitType(out, arr->ElemType());
-            out << ", ";
-            if (arr->Count()->Is<type::RuntimeArrayCount>()) {
-                out << "1";
-            } else {
-                auto count = arr->ConstantCount();
-                if (!count) {
-                    diagnostics_.add_error(diag::System::Writer,
-                                           type::Array::kErrExpectedConstantCount);
-                    return;
-                }
-                out << count.value();
-            }
-            out << ">";
-        },
-        [&](const type::Vector* vec) {
-            if (vec->Packed()) {
-                out << "packed_";
-            }
-            EmitType(out, vec->type());
-            out << vec->Width();
-        },
-        [&](const type::Matrix* mat) {
-            EmitType(out, mat->type());
-            out << mat->columns() << "x" << mat->rows();
-        },
-        [&](const type::Atomic* atomic) {
-            if (atomic->Type()->Is<type::I32>()) {
-                out << "atomic_int";
-                return;
-            }
-            if (TINT_LIKELY(atomic->Type()->Is<type::U32>())) {
-                out << "atomic_uint";
-                return;
-            }
-            TINT_ICE(Writer, diagnostics_)
-                << "unhandled atomic type " << atomic->Type()->FriendlyName();
-        },
-        [&](const type::Pointer* ptr) {
-            if (ptr->Access() == builtin::Access::kRead) {
-                out << "const ";
-            }
-            EmitAddressSpace(out, ptr->AddressSpace());
-            out << " ";
-            EmitType(out, ptr->StoreType());
-            out << "*";
-        },
+        [&](const type::Array* arr) { EmitArrayType(out, arr); },
+        [&](const type::Vector* vec) { EmitVectorType(out, vec); },
+        [&](const type::Matrix* mat) { EmitMatrixType(out, mat); },
+        [&](const type::Atomic* atomic) { EmitAtomicType(out, atomic); },
+        [&](const type::Pointer* ptr) { EmitPointerType(out, ptr); },
         [&](const type::Sampler*) { out << "sampler"; },  //
-        [&](const type::Texture* tex) {
-            if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
-                TINT_ICE(Writer, diagnostics_)
-                    << "Multiplanar external texture transform was not run.";
-                return;
-            }
-
-            if (tex->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
-                out << "depth";
-            } else {
-                out << "texture";
-            }
-
-            switch (tex->dim()) {
-                case type::TextureDimension::k1d:
-                    out << "1d";
-                    break;
-                case type::TextureDimension::k2d:
-                    out << "2d";
-                    break;
-                case type::TextureDimension::k2dArray:
-                    out << "2d_array";
-                    break;
-                case type::TextureDimension::k3d:
-                    out << "3d";
-                    break;
-                case type::TextureDimension::kCube:
-                    out << "cube";
-                    break;
-                case type::TextureDimension::kCubeArray:
-                    out << "cube_array";
-                    break;
-                default:
-                    diagnostics_.add_error(diag::System::Writer, "Invalid texture dimensions");
-                    return;
-            }
-            if (tex->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
-                out << "_ms";
-            }
-            out << "<";
-            TINT_DEFER(out << ">");
-
-            tint::Switch(
-                tex,  //
-                [&](const type::DepthTexture*) { out << "float, access::sample"; },
-                [&](const type::DepthMultisampledTexture*) { out << "float, access::read"; },
-                [&](const type::StorageTexture* storage) {
-                    EmitType(out, storage->type());
-                    out << ", ";
-
-                    std::string access_str;
-                    if (storage->access() == builtin::Access::kRead) {
-                        out << "access::read";
-                    } else if (storage->access() == builtin::Access::kWrite) {
-                        out << "access::write";
-                    } else {
-                        diagnostics_.add_error(diag::System::Writer,
-                                               "Invalid access control for storage texture");
-                        return;
-                    }
-                },
-                [&](const type::MultisampledTexture* ms) {
-                    EmitType(out, ms->type());
-                    out << ", access::read";
-                },
-                [&](const type::SampledTexture* sampled) {
-                    EmitType(out, sampled->type());
-                    out << ", access::sample";
-                },
-                [&](Default) {
-                    diagnostics_.add_error(diag::System::Writer, "invalid texture type");
-                });
-        },
+        [&](const type::Texture* tex) { EmitTextureType(out, tex); },
         [&](const type::Struct* str) {
             out << StructName(str);
 
@@ -294,6 +180,129 @@
         [&](Default) { UNHANDLED_CASE(ty); });
 }
 
+void GeneratorImplIr::EmitPointerType(utils::StringStream& out, const type::Pointer* ptr) {
+    if (ptr->Access() == builtin::Access::kRead) {
+        out << "const ";
+    }
+    EmitAddressSpace(out, ptr->AddressSpace());
+    out << " ";
+    EmitType(out, ptr->StoreType());
+    out << "*";
+}
+
+void GeneratorImplIr::EmitAtomicType(utils::StringStream& out, const type::Atomic* atomic) {
+    if (atomic->Type()->Is<type::I32>()) {
+        out << "atomic_int";
+        return;
+    }
+    if (TINT_LIKELY(atomic->Type()->Is<type::U32>())) {
+        out << "atomic_uint";
+        return;
+    }
+    TINT_ICE(Writer, diagnostics_) << "unhandled atomic type " << atomic->Type()->FriendlyName();
+}
+
+void GeneratorImplIr::EmitArrayType(utils::StringStream& out, const type::Array* arr) {
+    out << ArrayTemplateName() << "<";
+    EmitType(out, arr->ElemType());
+    out << ", ";
+    if (arr->Count()->Is<type::RuntimeArrayCount>()) {
+        out << "1";
+    } else {
+        auto count = arr->ConstantCount();
+        if (!count) {
+            diagnostics_.add_error(diag::System::Writer, type::Array::kErrExpectedConstantCount);
+            return;
+        }
+        out << count.value();
+    }
+    out << ">";
+}
+
+void GeneratorImplIr::EmitVectorType(utils::StringStream& out, const type::Vector* vec) {
+    if (vec->Packed()) {
+        out << "packed_";
+    }
+    EmitType(out, vec->type());
+    out << vec->Width();
+}
+
+void GeneratorImplIr::EmitMatrixType(utils::StringStream& out, const type::Matrix* mat) {
+    EmitType(out, mat->type());
+    out << mat->columns() << "x" << mat->rows();
+}
+
+void GeneratorImplIr::EmitTextureType(utils::StringStream& out, const type::Texture* tex) {
+    if (TINT_UNLIKELY(tex->Is<type::ExternalTexture>())) {
+        TINT_ICE(Writer, diagnostics_) << "Multiplanar external texture transform was not run.";
+        return;
+    }
+
+    if (tex->IsAnyOf<type::DepthTexture, type::DepthMultisampledTexture>()) {
+        out << "depth";
+    } else {
+        out << "texture";
+    }
+
+    switch (tex->dim()) {
+        case type::TextureDimension::k1d:
+            out << "1d";
+            break;
+        case type::TextureDimension::k2d:
+            out << "2d";
+            break;
+        case type::TextureDimension::k2dArray:
+            out << "2d_array";
+            break;
+        case type::TextureDimension::k3d:
+            out << "3d";
+            break;
+        case type::TextureDimension::kCube:
+            out << "cube";
+            break;
+        case type::TextureDimension::kCubeArray:
+            out << "cube_array";
+            break;
+        default:
+            diagnostics_.add_error(diag::System::Writer, "Invalid texture dimensions");
+            return;
+    }
+    if (tex->IsAnyOf<type::MultisampledTexture, type::DepthMultisampledTexture>()) {
+        out << "_ms";
+    }
+    out << "<";
+    TINT_DEFER(out << ">");
+
+    tint::Switch(
+        tex,  //
+        [&](const type::DepthTexture*) { out << "float, access::sample"; },
+        [&](const type::DepthMultisampledTexture*) { out << "float, access::read"; },
+        [&](const type::StorageTexture* storage) {
+            EmitType(out, storage->type());
+            out << ", ";
+
+            std::string access_str;
+            if (storage->access() == builtin::Access::kRead) {
+                out << "access::read";
+            } else if (storage->access() == builtin::Access::kWrite) {
+                out << "access::write";
+            } else {
+                diagnostics_.add_error(diag::System::Writer,
+                                       "Invalid access control for storage texture");
+                return;
+            }
+        },
+        [&](const type::MultisampledTexture* ms) {
+            EmitType(out, ms->type());
+            out << ", access::read";
+        },
+        [&](const type::SampledTexture* sampled) {
+            EmitType(out, sampled->type());
+            out << ", access::sample";
+        },
+        [&](Default) { diagnostics_.add_error(diag::System::Writer, "invalid texture type"); });
+}
+
 void GeneratorImplIr::EmitStructType(const type::Struct* str) {
     auto it = emitted_structs_.emplace(str);
     if (!it.second) {
@@ -431,14 +440,77 @@
 }
 
 void GeneratorImplIr::EmitConstant(utils::StringStream& out, ir::Constant* c) {
-    return tint::Switch(
+    EmitConstant(out, c->Value());
+}
+
+void GeneratorImplIr::EmitConstant(utils::StringStream& out, const constant::Value* c) {
+    auto emit_values = [&](uint32_t count) {
+        for (size_t i = 0; i < count; i++) {
+            if (i > 0) {
+                out << ", ";
+            }
+            EmitConstant(out, c->Index(i));
+        }
+    };
+
+    tint::Switch(
         c->Type(),  //
-        [&](const type::Bool*) { out << (c->Value()->ValueAs<bool>() ? "true" : "false"); },
-        [&](const type::I32*) { PrintI32(out, c->Value()->ValueAs<i32>()); },
-        [&](const type::U32*) { out << c->Value()->ValueAs<u32>() << "u"; },
-        [&](const type::F32*) { PrintF32(out, c->Value()->ValueAs<f32>()); },
-        [&](const type::F16*) { PrintF16(out, c->Value()->ValueAs<f16>()); },
-        [&](Default) { UNHANDLED_CASE(c); });
+        [&](const type::Bool*) { out << (c->ValueAs<bool>() ? "true" : "false"); },
+        [&](const type::I32*) { PrintI32(out, c->ValueAs<i32>()); },
+        [&](const type::U32*) { out << c->ValueAs<u32>() << "u"; },
+        [&](const type::F32*) { PrintF32(out, c->ValueAs<f32>()); },
+        [&](const type::F16*) { PrintF16(out, c->ValueAs<f16>()); },
+        [&](const type::Vector* v) {
+            EmitType(out, v);
+
+            ScopedParen sp(out);
+            if (auto* splat = c->As<constant::Splat>()) {
+                EmitConstant(out, splat->el);
+                return;
+            }
+            emit_values(v->Width());
+        },
+        [&](const type::Matrix* m) {
+            EmitType(out, m);
+            ScopedParen sp(out);
+            emit_values(m->columns());
+        },
+        [&](const type::Array* a) {
+            EmitType(out, a);
+            out << "{";
+            TINT_DEFER(out << "}");
+
+            if (c->AllZero()) {
+                return;
+            }
+
+            auto count = a->ConstantCount();
+            if (!count) {
+                diagnostics_.add_error(diag::System::Writer,
+                                       type::Array::kErrExpectedConstantCount);
+                return;
+            }
+            emit_values(*count);
+        },
+        [&](const type::Struct* s) {
+            EmitStructType(s);
+            out << StructName(s) << "{";
+            TINT_DEFER(out << "}");
+
+            if (c->AllZero()) {
+                return;
+            }
+
+            auto members = s->Members();
+            for (size_t i = 0; i < members.Length(); i++) {
+                if (i > 0) {
+                    out << ", ";
+                }
+                out << "." << members[i]->Name().Name() << "=";
+                EmitConstant(out, c->Index(i));
+            }
+        },
+        [&](Default) { UNHANDLED_CASE(c->Type()); });
 }
 
 }  // namespace tint::writer::msl
diff --git a/src/tint/writer/msl/ir/generator_impl_ir.h b/src/tint/writer/msl/ir/generator_impl_ir.h
index 89ec1a1..80f0cb2 100644
--- a/src/tint/writer/msl/ir/generator_impl_ir.h
+++ b/src/tint/writer/msl/ir/generator_impl_ir.h
@@ -20,6 +20,7 @@
 
 #include "src/tint/diagnostic/diagnostic.h"
 #include "src/tint/ir/module.h"
+#include "src/tint/type/texture.h"
 #include "src/tint/utils/string_stream.h"
 #include "src/tint/writer/ir_text_generator.h"
 
@@ -45,6 +46,30 @@
     /// @param ty the type to emit
     void EmitType(utils::StringStream& out, const type::Type* ty);
 
+    /// Handles generating an array declaration
+    /// @param out the output stream
+    /// @param arr the array to emit
+    void EmitArrayType(utils::StringStream& out, const type::Array* arr);
+    /// Handles generating an atomic declaration
+    /// @param out the output stream
+    /// @param atomic the atomic to emit
+    void EmitAtomicType(utils::StringStream& out, const type::Atomic* atomic);
+    /// Handles generating a pointer declaration
+    /// @param out the output stream
+    /// @param ptr the pointer to emit
+    void EmitPointerType(utils::StringStream& out, const type::Pointer* ptr);
+    /// Handles generating a vector declaration
+    /// @param out the output stream
+    /// @param vec the vector to emit
+    void EmitVectorType(utils::StringStream& out, const type::Vector* vec);
+    /// Handles generating a matrix declaration
+    /// @param out the output stream
+    /// @param mat the matrix to emit
+    void EmitMatrixType(utils::StringStream& out, const type::Matrix* mat);
+    /// Handles generating a texture declaration
+    /// @param out the output stream
+    /// @param tex the texture to emit
+    void EmitTextureType(utils::StringStream& out, const type::Texture* tex);
     /// Handles generating a struct declaration. If the structure has already been emitted, then
     /// this function will simply return without emitting anything.
     /// @param str the struct to generate
@@ -59,6 +84,10 @@
     /// @param out the stream to write the constant too
     /// @param c the constant to emit
     void EmitConstant(utils::StringStream& out, ir::Constant* c);
+    /// Handles constant::Value values
+    /// @param out the stream to write the constant too
+    /// @param c the constant to emit
+    void EmitConstant(utils::StringStream& out, const constant::Value* c);
 
     /// @returns the name of the templated `tint_array` helper type, generating it if needed
     const std::string& ArrayTemplateName();
diff --git a/src/tint/writer/msl/ir/generator_impl_ir_constant_test.cc b/src/tint/writer/msl/ir/generator_impl_ir_constant_test.cc
index 41a6139..9cdd570 100644
--- a/src/tint/writer/msl/ir/generator_impl_ir_constant_test.cc
+++ b/src/tint/writer/msl/ir/generator_impl_ir_constant_test.cc
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "src/tint/type/array.h"
+#include "src/tint/type/matrix.h"
 #include "src/tint/utils/string.h"
 #include "src/tint/writer/msl/ir/test_helper_ir.h"
 
@@ -62,5 +64,251 @@
     EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("32752.0h"));
 }
 
+TEST_F(MslGeneratorImplIrTest, Constant_Vector_Splat) {
+    auto* c = b.Constant(mod.constant_values.Splat(ty.vec3<f32>(), b.Constant(1.5_f)->Value(), 3));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("float3(1.5f)"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Vector_Composite) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.vec3<f32>(), utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(1.0_f)->Value(),
+                                      b.Constant(1.5_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("float3(1.5f, 1.0f, 1.5f)"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Vector_Composite_AnyZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.vec3<f32>(), utils::Vector{b.Constant(1.0_f)->Value(), b.Constant(0.0_f)->Value(),
+                                      b.Constant(1.5_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("float3(1.0f, 0.0f, 1.5f)"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Vector_Composite_AllZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.vec3<f32>(), utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value(),
+                                      b.Constant(0.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("float3(0.0f)"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Matrix_Splat) {
+    auto* c =
+        b.Constant(mod.constant_values.Splat(ty.mat3x2<f32>(), b.Constant(1.5_f)->Value(), 3));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string("float3x2(1.5f, 1.5f, 1.5f)"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Matrix_Composite) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.mat3x2<f32>(),
+        utils::Vector{mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(1.0_f)->Value()}),
+                      mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(2.0_f)->Value()}),
+                      mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(2.5_f)->Value(), b.Constant(3.5_f)->Value()})}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()),
+              std::string("float3x2(float2(1.5f, 1.0f), float2(1.5f, 2.0f), float2(2.5f, 3.5f))"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Matrix_Composite_AnyZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.mat2x2<f32>(),
+        utils::Vector{mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(1.0_f)->Value(), b.Constant(0.0_f)->Value()}),
+                      mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(2.5_f)->Value()})}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()),
+              std::string("float2x2(float2(1.0f, 0.0f), float2(1.5f, 2.5f))"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Matrix_Composite_AllZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.mat3x2<f32>(),
+        utils::Vector{mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value()}),
+                      mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value()}),
+                      mod.constant_values.Composite(
+                          ty.vec2<f32>(),
+                          utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value()})}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()),
+              std::string("float3x2(float2(0.0f), float2(0.0f), float2(0.0f))"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Array_Splat) {
+    auto* c =
+        b.Constant(mod.constant_values.Splat(ty.array<f32, 3>(), b.Constant(1.5_f)->Value(), 3));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), R"(template<typename T, size_t N>
+struct tint_array {
+  const constant T& operator[](size_t i) const constant { return elements[i]; }
+  device T& operator[](size_t i) device { return elements[i]; }
+  const device T& operator[](size_t i) const device { return elements[i]; }
+  thread T& operator[](size_t i) thread { return elements[i]; }
+  const thread T& operator[](size_t i) const thread { return elements[i]; }
+  threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+  const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+  T elements[N];
+};
+
+
+tint_array<float, 3>{1.5f, 1.5f, 1.5f})");
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Array_Composite) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.array<f32, 3>(), utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(1.0_f)->Value(),
+                                          b.Constant(2.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string(R"(template<typename T, size_t N>
+struct tint_array {
+  const constant T& operator[](size_t i) const constant { return elements[i]; }
+  device T& operator[](size_t i) device { return elements[i]; }
+  const device T& operator[](size_t i) const device { return elements[i]; }
+  thread T& operator[](size_t i) thread { return elements[i]; }
+  const thread T& operator[](size_t i) const thread { return elements[i]; }
+  threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+  const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+  T elements[N];
+};
+
+
+tint_array<float, 3>{1.5f, 1.0f, 2.0f})"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Array_Composite_AnyZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.array<f32, 2>(), utils::Vector{b.Constant(1.0_f)->Value(), b.Constant(0.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), R"(template<typename T, size_t N>
+struct tint_array {
+  const constant T& operator[](size_t i) const constant { return elements[i]; }
+  device T& operator[](size_t i) device { return elements[i]; }
+  const device T& operator[](size_t i) const device { return elements[i]; }
+  thread T& operator[](size_t i) thread { return elements[i]; }
+  const thread T& operator[](size_t i) const thread { return elements[i]; }
+  threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+  const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+  T elements[N];
+};
+
+
+tint_array<float, 2>{1.0f, 0.0f})");
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Array_Composite_AllZero) {
+    auto* c = b.Constant(mod.constant_values.Composite(
+        ty.array<f32, 3>(), utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value(),
+                                          b.Constant(0.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), R"(template<typename T, size_t N>
+struct tint_array {
+  const constant T& operator[](size_t i) const constant { return elements[i]; }
+  device T& operator[](size_t i) device { return elements[i]; }
+  const device T& operator[](size_t i) const device { return elements[i]; }
+  thread T& operator[](size_t i) thread { return elements[i]; }
+  const thread T& operator[](size_t i) const thread { return elements[i]; }
+  threadgroup T& operator[](size_t i) threadgroup { return elements[i]; }
+  const threadgroup T& operator[](size_t i) const threadgroup { return elements[i]; }
+  T elements[N];
+};
+
+
+tint_array<float, 3>{})");
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Struct_Splat) {
+    auto* s = ty.Struct(mod.symbols.New("S"), {
+                                                  {mod.symbols.Register("a"), ty.f32()},
+                                                  {mod.symbols.Register("b"), ty.f32()},
+                                              });
+    auto* c = b.Constant(mod.constant_values.Splat(s, b.Constant(1.5_f)->Value(), 2));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string(R"(struct S {
+  float a;
+  float b;
+};
+
+S{.a=1.5f, .b=1.5f})"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Struct_Composite) {
+    auto* s = ty.Struct(mod.symbols.New("S"), {
+                                                  {mod.symbols.Register("a"), ty.f32()},
+                                                  {mod.symbols.Register("b"), ty.f32()},
+                                              });
+    auto* c = b.Constant(mod.constant_values.Composite(
+        s, utils::Vector{b.Constant(1.5_f)->Value(), b.Constant(1.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string(R"(struct S {
+  float a;
+  float b;
+};
+
+S{.a=1.5f, .b=1.0f})"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Struct_Composite_AnyZero) {
+    auto* s = ty.Struct(mod.symbols.New("S"), {
+                                                  {mod.symbols.Register("a"), ty.f32()},
+                                                  {mod.symbols.Register("b"), ty.f32()},
+                                              });
+    auto* c = b.Constant(mod.constant_values.Composite(
+        s, utils::Vector{b.Constant(1.0_f)->Value(), b.Constant(0.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string(R"(struct S {
+  float a;
+  float b;
+};
+
+S{.a=1.0f, .b=0.0f})"));
+}
+
+TEST_F(MslGeneratorImplIrTest, Constant_Struct_Composite_AllZero) {
+    auto* s = ty.Struct(mod.symbols.New("S"), {
+                                                  {mod.symbols.Register("a"), ty.f32()},
+                                                  {mod.symbols.Register("b"), ty.f32()},
+                                              });
+    auto* c = b.Constant(mod.constant_values.Composite(
+        s, utils::Vector{b.Constant(0.0_f)->Value(), b.Constant(0.0_f)->Value()}));
+    generator_.EmitConstant(generator_.Line(), c);
+    ASSERT_TRUE(generator_.Diagnostics().empty()) << generator_.Diagnostics().str();
+    EXPECT_EQ(utils::TrimSpace(generator_.Result()), std::string(R"(struct S {
+  float a;
+  float b;
+};
+
+S{})"));
+}
+
 }  // namespace
 }  // namespace tint::writer::msl
diff --git a/src/tint/writer/msl/ir/test_helper_ir.h b/src/tint/writer/msl/ir/test_helper_ir.h
index 38bbf9b..cf74688 100644
--- a/src/tint/writer/msl/ir/test_helper_ir.h
+++ b/src/tint/writer/msl/ir/test_helper_ir.h
@@ -15,6 +15,7 @@
 #ifndef SRC_TINT_WRITER_MSL_IR_TEST_HELPER_IR_H_
 #define SRC_TINT_WRITER_MSL_IR_TEST_HELPER_IR_H_
 
+#include <iostream>
 #include <string>
 
 #include "gtest/gtest.h"
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.cc b/src/tint/writer/spirv/ir/generator_impl_ir.cc
index 4f07640..1fd5db9 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.cc
@@ -43,6 +43,7 @@
 #include "src/tint/ir/transform/add_empty_entry_point.h"
 #include "src/tint/ir/transform/block_decorated_structs.h"
 #include "src/tint/ir/transform/merge_return.h"
+#include "src/tint/ir/transform/shader_io_spirv.h"
 #include "src/tint/ir/transform/var_for_dynamic_index.h"
 #include "src/tint/ir/unreachable.h"
 #include "src/tint/ir/user_call.h"
@@ -77,8 +78,11 @@
     manager.Add<ir::transform::AddEmptyEntryPoint>();
     manager.Add<ir::transform::BlockDecoratedStructs>();
     manager.Add<ir::transform::MergeReturn>();
+    manager.Add<ir::transform::ShaderIOSpirv>();
     manager.Add<ir::transform::VarForDynamicIndex>();
 
+    data.Add<ir::transform::ShaderIO::Config>(ir::transform::ShaderIO::Config());
+
     transform::DataMap outputs;
     manager.Run(module, data, outputs);
 }
@@ -87,8 +91,12 @@
     switch (addrspace) {
         case builtin::AddressSpace::kFunction:
             return SpvStorageClassFunction;
+        case builtin::AddressSpace::kIn:
+            return SpvStorageClassInput;
         case builtin::AddressSpace::kPrivate:
             return SpvStorageClassPrivate;
+        case builtin::AddressSpace::kOut:
+            return SpvStorageClassOutput;
         case builtin::AddressSpace::kStorage:
             return SpvStorageClassStorageBuffer;
         case builtin::AddressSpace::kUniform:
@@ -144,6 +152,47 @@
     return true;
 }
 
+uint32_t GeneratorImplIr::Builtin(builtin::BuiltinValue builtin, builtin::AddressSpace addrspace) {
+    switch (builtin) {
+        case builtin::BuiltinValue::kPointSize:
+            return SpvBuiltInPointSize;
+        case builtin::BuiltinValue::kFragDepth:
+            return SpvBuiltInFragDepth;
+        case builtin::BuiltinValue::kFrontFacing:
+            return SpvBuiltInFrontFacing;
+        case builtin::BuiltinValue::kGlobalInvocationId:
+            return SpvBuiltInGlobalInvocationId;
+        case builtin::BuiltinValue::kInstanceIndex:
+            return SpvBuiltInInstanceIndex;
+        case builtin::BuiltinValue::kLocalInvocationId:
+            return SpvBuiltInLocalInvocationId;
+        case builtin::BuiltinValue::kLocalInvocationIndex:
+            return SpvBuiltInLocalInvocationIndex;
+        case builtin::BuiltinValue::kNumWorkgroups:
+            return SpvBuiltInNumWorkgroups;
+        case builtin::BuiltinValue::kPosition:
+            if (addrspace == builtin::AddressSpace::kOut) {
+                // Vertex output.
+                return SpvBuiltInPosition;
+            } else {
+                // Fragment input.
+                return SpvBuiltInFragCoord;
+            }
+        case builtin::BuiltinValue::kSampleIndex:
+            module_.PushCapability(SpvCapabilitySampleRateShading);
+            return SpvBuiltInSampleId;
+        case builtin::BuiltinValue::kSampleMask:
+            return SpvBuiltInSampleMask;
+        case builtin::BuiltinValue::kVertexIndex:
+            return SpvBuiltInVertexIndex;
+        case builtin::BuiltinValue::kWorkgroupId:
+            return SpvBuiltInWorkgroupId;
+        case builtin::BuiltinValue::kUndefined:
+            return SpvBuiltInMax;
+    }
+    return SpvBuiltInMax;
+}
+
 uint32_t GeneratorImplIr::Constant(ir::Constant* constant) {
     return Constant(constant->Value());
 }
@@ -218,7 +267,8 @@
     });
 }
 
-uint32_t GeneratorImplIr::Type(const type::Type* ty) {
+uint32_t GeneratorImplIr::Type(const type::Type* ty,
+                               builtin::AddressSpace addrspace /* = kUndefined */) {
     return types_.GetOrCreate(ty, [&] {
         auto id = module_.NextId();
         Switch(
@@ -261,11 +311,11 @@
                                   {id, U32Operand(SpvDecorationArrayStride), arr->Stride()});
             },
             [&](const type::Pointer* ptr) {
-                module_.PushType(
-                    spv::Op::OpTypePointer,
-                    {id, U32Operand(StorageClass(ptr->AddressSpace())), Type(ptr->StoreType())});
+                module_.PushType(spv::Op::OpTypePointer,
+                                 {id, U32Operand(StorageClass(ptr->AddressSpace())),
+                                  Type(ptr->StoreType(), ptr->AddressSpace())});
             },
-            [&](const type::Struct* str) { EmitStructType(id, str); },
+            [&](const type::Struct* str) { EmitStructType(id, str, addrspace); },
             [&](Default) {
                 TINT_ICE(Writer, diagnostics_) << "unhandled type: " << ty->FriendlyName();
             });
@@ -288,7 +338,9 @@
     return block_labels_.GetOrCreate(block, [&] { return module_.NextId(); });
 }
 
-void GeneratorImplIr::EmitStructType(uint32_t id, const type::Struct* str) {
+void GeneratorImplIr::EmitStructType(uint32_t id,
+                                     const type::Struct* str,
+                                     builtin::AddressSpace addrspace /* = kUndefined */) {
     // 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) {
@@ -307,6 +359,56 @@
             spv::Op::OpMemberDecorate,
             {operands[0], member->Index(), U32Operand(SpvDecorationOffset), member->Offset()});
 
+        // Generate shader IO decorations.
+        const auto& attrs = member->Attributes();
+        if (attrs.location) {
+            module_.PushAnnot(
+                spv::Op::OpMemberDecorate,
+                {operands[0], member->Index(), U32Operand(SpvDecorationLocation), *attrs.location});
+            if (attrs.interpolation) {
+                switch (attrs.interpolation->type) {
+                    case builtin::InterpolationType::kLinear:
+                        module_.PushAnnot(
+                            spv::Op::OpMemberDecorate,
+                            {operands[0], member->Index(), U32Operand(SpvDecorationNoPerspective)});
+                        break;
+                    case builtin::InterpolationType::kFlat:
+                        module_.PushAnnot(
+                            spv::Op::OpMemberDecorate,
+                            {operands[0], member->Index(), U32Operand(SpvDecorationFlat)});
+                        break;
+                    case builtin::InterpolationType::kPerspective:
+                    case builtin::InterpolationType::kUndefined:
+                        break;
+                }
+                switch (attrs.interpolation->sampling) {
+                    case builtin::InterpolationSampling::kCentroid:
+                        module_.PushAnnot(
+                            spv::Op::OpMemberDecorate,
+                            {operands[0], member->Index(), U32Operand(SpvDecorationCentroid)});
+                        break;
+                    case builtin::InterpolationSampling::kSample:
+                        module_.PushCapability(SpvCapabilitySampleRateShading);
+                        module_.PushAnnot(
+                            spv::Op::OpMemberDecorate,
+                            {operands[0], member->Index(), U32Operand(SpvDecorationSample)});
+                        break;
+                    case builtin::InterpolationSampling::kCenter:
+                    case builtin::InterpolationSampling::kUndefined:
+                        break;
+                }
+            }
+        }
+        if (attrs.builtin) {
+            module_.PushAnnot(spv::Op::OpMemberDecorate,
+                              {operands[0], member->Index(), U32Operand(SpvDecorationBuiltIn),
+                               Builtin(*attrs.builtin, addrspace)});
+        }
+        if (attrs.invariant) {
+            module_.PushAnnot(spv::Op::OpMemberDecorate,
+                              {operands[0], member->Index(), U32Operand(SpvDecorationInvariant)});
+        }
+
         // 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;
@@ -404,7 +506,6 @@
             stage = SpvExecutionModelFragment;
             module_.PushExecutionMode(spv::Op::OpExecutionMode,
                                       {id, U32Operand(SpvExecutionModeOriginUpperLeft)});
-            // TODO(jrprice): Add DepthReplacing execution mode if FragDepth is used.
             break;
         }
         case ir::Function::PipelineStage::kVertex: {
@@ -416,9 +517,52 @@
             return;
     }
 
-    // TODO(jrprice): Add the interface list of all referenced global variables.
-    module_.PushEntryPoint(spv::Op::OpEntryPoint,
-                           {U32Operand(stage), id, ir_->NameOf(func).Name()});
+    OperandList operands = {U32Operand(stage), id, ir_->NameOf(func).Name()};
+
+    // Add the list of all referenced shader IO variables.
+    if (ir_->root_block) {
+        for (auto* global : *ir_->root_block) {
+            auto* var = global->As<ir::Var>();
+            if (!var) {
+                continue;
+            }
+
+            auto* ptr = var->Result()->Type()->As<type::Pointer>();
+            if (!(ptr->AddressSpace() == builtin::AddressSpace::kIn ||
+                  ptr->AddressSpace() == builtin::AddressSpace::kOut)) {
+                continue;
+            }
+
+            // Determine if this IO variable is used by the entry point.
+            bool used = false;
+            for (const auto& use : var->Result()->Usages()) {
+                auto* block = use.instruction->Block();
+                while (block->Parent()) {
+                    block = block->Parent()->Block();
+                }
+                if (block == func->Block()) {
+                    used = true;
+                    break;
+                }
+            }
+            if (!used) {
+                continue;
+            }
+            operands.push_back(Value(var));
+
+            // Add the `DepthReplacing` execution mode if `frag_depth` is used.
+            if (auto* str = ptr->StoreType()->As<type::Struct>()) {
+                for (auto* member : str->Members()) {
+                    if (member->Attributes().builtin == builtin::BuiltinValue::kFragDepth) {
+                        module_.PushExecutionMode(spv::Op::OpExecutionMode,
+                                                  {id, U32Operand(SpvExecutionModeDepthReplacing)});
+                    }
+                }
+            }
+        }
+    }
+
+    module_.PushEntryPoint(spv::Op::OpEntryPoint, operands);
 }
 
 void GeneratorImplIr::EmitRootBlock(ir::Block* root_block) {
@@ -492,6 +636,13 @@
                 TINT_ICE(Writer, diagnostics_)
                     << "unimplemented instruction: " << inst->TypeInfo().name;
             });
+
+        // Set the name for the SPIR-V result ID if provided in the module.
+        if (inst->Result() && !inst->Is<ir::Var>()) {
+            if (auto name = ir_->NameOf(inst)) {
+                module_.PushDebug(spv::Op::OpName, {Value(inst), Operand(name.Name())});
+            }
+        }
     }
 
     if (block->IsEmpty()) {
@@ -932,6 +1083,11 @@
             }
             break;
         }
+        case builtin::AddressSpace::kIn: {
+            TINT_ASSERT(Writer, !current_function_);
+            module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassInput)});
+            break;
+        }
         case builtin::AddressSpace::kPrivate: {
             TINT_ASSERT(Writer, !current_function_);
             OperandList operands = {ty, id, U32Operand(SpvStorageClassPrivate)};
@@ -942,6 +1098,11 @@
             module_.PushType(spv::Op::OpVariable, operands);
             break;
         }
+        case builtin::AddressSpace::kOut: {
+            TINT_ASSERT(Writer, !current_function_);
+            module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassOutput)});
+            break;
+        }
         case builtin::AddressSpace::kStorage:
         case builtin::AddressSpace::kUniform: {
             TINT_ASSERT(Writer, !current_function_);
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.h b/src/tint/writer/spirv/ir/generator_impl_ir.h
index d0dc4bd..ae1bc95 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.h
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.h
@@ -92,8 +92,10 @@
 
     /// Get the result ID of the type `ty`, emitting a type declaration instruction if necessary.
     /// @param ty the type to get the ID for
+    /// @param addrspace the optional address space that this type is being used for
     /// @returns the result ID of the type
-    uint32_t Type(const type::Type* ty);
+    uint32_t Type(const type::Type* ty,
+                  builtin::AddressSpace addrspace = builtin::AddressSpace::kUndefined);
 
     /// Get the result ID of the value `value`, emitting its instruction if necessary.
     /// @param value the value to get the ID for
@@ -112,8 +114,11 @@
 
     /// Emit a struct type.
     /// @param id the result ID to use
+    /// @param addrspace the optional address space that this type is being used for
     /// @param str the struct type to emit
-    void EmitStructType(uint32_t id, const type::Struct* str);
+    void EmitStructType(uint32_t id,
+                        const type::Struct* str,
+                        builtin::AddressSpace addrspace = builtin::AddressSpace::kUndefined);
 
     /// Emit a function.
     /// @param func the function to emit
@@ -193,6 +198,13 @@
     void EmitExitPhis(ir::ControlInstruction* inst);
 
   private:
+    /// Convert a builtin to the corresponding SPIR-V enum value, taking into account the target
+    /// address space. Adds any capabilities needed for the builtin.
+    /// @param builtin the builtin to convert
+    /// @param addrspace the address space the builtin is being used in
+    /// @returns the enum value of the corresponding SPIR-V builtin
+    uint32_t Builtin(builtin::BuiltinValue builtin, builtin::AddressSpace addrspace);
+
     /// Get the result ID of the constant `constant`, emitting its instruction if necessary.
     /// @param constant the constant to get the ID for
     /// @returns the result ID of the constant
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_access_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_access_test.cc
index 40f4d4d..df494fb 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_access_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_access_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "gmock/gmock.h"
 #include "src/tint/writer/spirv/ir/test_helper_ir.h"
 
 namespace tint::writer::spirv {
@@ -20,452 +21,213 @@
 using namespace tint::builtin::fluent_types;  // NOLINT
 using namespace tint::number_suffixes;        // NOLINT
 
-using SpvGeneratorImplTest_Access = SpvGeneratorImplTest;
-
-TEST_F(SpvGeneratorImplTest_Access, Array_Value_ConstantIndex) {
-    auto* arr_val = b.FunctionParam(ty.array(ty.i32(), 4));
+TEST_F(SpvGeneratorImplTest, Access_Array_Value_ConstantIndex) {
+    auto* arr_val = b.FunctionParam("arr", ty.array(ty.i32(), 4));
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({arr_val});
-
     b.With(func->Block(), [&] {
-        b.Access(ty.i32(), arr_val, 1_u);
+        auto* result = b.Access(ty.i32(), arr_val, 1_u);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpDecorate %3 ArrayStride 4
-%2 = OpTypeVoid
-%4 = OpTypeInt 32 1
-%6 = OpTypeInt 32 0
-%5 = OpConstant %6 4
-%3 = OpTypeArray %4 %5
-%8 = OpTypeFunction %2 %3
-%1 = OpFunction %2 None %8
-%7 = OpFunctionParameter %3
-%9 = OpLabel
-%10 = OpCompositeExtract %4 %7 1
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpCompositeExtract %int %arr 1");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Array_Pointer_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Array_Pointer_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
-
     b.With(func->Block(), [&] {
-        auto* arr_var = b.Var(ty.ptr<function, array<i32, 4>>());
-        b.Access(ty.ptr<function, i32>(), arr_var, 1_u);
+        auto* arr_var = b.Var("arr", ty.ptr<function, array<i32, 4>>());
+        auto* result = b.Access(ty.ptr<function, i32>(), arr_var, 1_u);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpDecorate %7 ArrayStride 4
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%8 = OpTypeInt 32 1
-%10 = OpTypeInt 32 0
-%9 = OpConstant %10 4
-%7 = OpTypeArray %8 %9
-%6 = OpTypePointer Function %7
-%12 = OpTypePointer Function %8
-%13 = OpConstant %10 1
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%11 = OpAccessChain %12 %5 %13
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %arr %uint_1");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Array_Pointer_DynamicIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Array_Pointer_DynamicIndex) {
+    auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
-
+    func->SetParams({idx});
     b.With(func->Block(), [&] {
-        auto* idx_var = b.Var(ty.ptr<function, i32>());
-        auto* idx = b.Load(idx_var);
-        auto* arr_var = b.Var(ty.ptr<function, array<i32, 4>>());
-        b.Access(ty.ptr<function, i32>(), arr_var, idx);
+        auto* arr_var = b.Var("arr", ty.ptr<function, array<i32, 4>>());
+        auto* result = b.Access(ty.ptr<function, i32>(), arr_var, idx);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpDecorate %11 ArrayStride 4
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%7 = OpTypeInt 32 1
-%6 = OpTypePointer Function %7
-%13 = OpTypeInt 32 0
-%12 = OpConstant %13 4
-%11 = OpTypeArray %7 %12
-%10 = OpTypePointer Function %11
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%9 = OpVariable %10 Function
-%8 = OpLoad %7 %5
-%14 = OpAccessChain %6 %9 %8
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %arr %idx");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Matrix_Value_ConstantIndex) {
-    auto* mat_val = b.FunctionParam(ty.mat2x2(ty.f32()));
+TEST_F(SpvGeneratorImplTest, Access_Matrix_Value_ConstantIndex) {
+    auto* mat_val = b.FunctionParam("mat", ty.mat2x2(ty.f32()));
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({mat_val});
-
     b.With(func->Block(), [&] {
-        b.Access(ty.vec2(ty.f32()), mat_val, 1_u);
-        b.Access(ty.f32(), mat_val, 1_u, 0_u);
+        auto* result_vector = b.Access(ty.vec2(ty.f32()), mat_val, 1_u);
+        auto* result_scalar = b.Access(ty.f32(), mat_val, 1_u, 0_u);
         b.Return(func);
+        mod.SetName(result_vector, "result_vector");
+        mod.SetName(result_scalar, "result_scalar");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%5 = OpTypeFloat 32
-%4 = OpTypeVector %5 2
-%3 = OpTypeMatrix %4 2
-%7 = OpTypeFunction %2 %3
-%1 = OpFunction %2 None %7
-%6 = OpFunctionParameter %3
-%8 = OpLabel
-%9 = OpCompositeExtract %4 %6 1
-%10 = OpCompositeExtract %5 %6 1 0
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result_vector = OpCompositeExtract %v2float %mat 1");
+    EXPECT_INST("%result_scalar = OpCompositeExtract %float %mat 1 0");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Matrix_Pointer_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Matrix_Pointer_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
-
     b.With(func->Block(), [&] {
-        auto* mat_var = b.Var(ty.ptr<function, mat2x2<f32>>());
-        b.Access(ty.ptr<function, vec2<f32>>(), mat_var, 1_u);
-        b.Access(ty.ptr<function, f32>(), mat_var, 1_u, 0_u);
+        auto* mat_var = b.Var("mat", ty.ptr<function, mat2x2<f32>>());
+        auto* result_vector = b.Access(ty.ptr<function, vec2<f32>>(), mat_var, 1_u);
+        auto* result_scalar = b.Access(ty.ptr<function, f32>(), mat_var, 1_u, 0_u);
         b.Return(func);
+        mod.SetName(result_vector, "result_vector");
+        mod.SetName(result_scalar, "result_scalar");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%9 = OpTypeFloat 32
-%8 = OpTypeVector %9 2
-%7 = OpTypeMatrix %8 2
-%6 = OpTypePointer Function %7
-%11 = OpTypePointer Function %8
-%13 = OpTypeInt 32 0
-%12 = OpConstant %13 1
-%15 = OpTypePointer Function %9
-%16 = OpConstant %13 0
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%10 = OpAccessChain %11 %5 %12
-%14 = OpAccessChain %15 %5 %12 %16
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result_vector = OpAccessChain %_ptr_Function_v2float %mat %uint_1");
+    EXPECT_INST("%result_scalar = OpAccessChain %_ptr_Function_float %mat %uint_1 %uint_0");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Matrix_Pointer_DynamicIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Matrix_Pointer_DynamicIndex) {
+    auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
-
+    func->SetParams({idx});
     b.With(func->Block(), [&] {
-        auto* idx_var = b.Var(ty.ptr<function, i32>());
-        auto* idx = b.Load(idx_var);
-        auto* mat_var = b.Var(ty.ptr<function, mat2x2<f32>>());
-        b.Access(ty.ptr<function, vec2<f32>>(), mat_var, idx);
-        b.Access(ty.ptr<function, f32>(), mat_var, idx, idx);
+        auto* mat_var = b.Var("mat", ty.ptr<function, mat2x2<f32>>());
+        auto* result_vector = b.Access(ty.ptr<function, vec2<f32>>(), mat_var, idx);
+        auto* result_scalar = b.Access(ty.ptr<function, f32>(), mat_var, idx, idx);
         b.Return(func);
+        mod.SetName(result_vector, "result_vector");
+        mod.SetName(result_scalar, "result_scalar");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%7 = OpTypeInt 32 1
-%6 = OpTypePointer Function %7
-%13 = OpTypeFloat 32
-%12 = OpTypeVector %13 2
-%11 = OpTypeMatrix %12 2
-%10 = OpTypePointer Function %11
-%15 = OpTypePointer Function %12
-%17 = OpTypePointer Function %13
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%9 = OpVariable %10 Function
-%8 = OpLoad %7 %5
-%14 = OpAccessChain %15 %9 %8
-%16 = OpAccessChain %17 %9 %8 %8
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result_vector = OpAccessChain %_ptr_Function_v2float %mat %idx");
+    EXPECT_INST("%result_scalar = OpAccessChain %_ptr_Function_float %mat %idx %idx");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Vector_Value_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Vector_Value_ConstantIndex) {
+    auto* vec_val = b.FunctionParam("vec", ty.vec4(ty.i32()));
     auto* func = b.Function("foo", ty.void_());
-    auto* vec_val = b.FunctionParam(ty.vec4(ty.i32()));
     func->SetParams({vec_val});
-
     b.With(func->Block(), [&] {
-        b.Access(ty.i32(), vec_val, 1_u);
+        auto* result = b.Access(ty.i32(), vec_val, 1_u);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%4 = OpTypeInt 32 1
-%3 = OpTypeVector %4 4
-%6 = OpTypeFunction %2 %3
-%1 = OpFunction %2 None %6
-%5 = OpFunctionParameter %3
-%7 = OpLabel
-%8 = OpCompositeExtract %4 %5 1
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpCompositeExtract %int %vec 1");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Vector_Value_DynamicIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Vector_Value_DynamicIndex) {
+    auto* vec_val = b.FunctionParam("vec", ty.vec4(ty.i32()));
+    auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
-    auto* vec_val = b.FunctionParam(ty.vec4(ty.i32()));
-    func->SetParams({vec_val});
-
+    func->SetParams({vec_val, idx});
     b.With(func->Block(), [&] {
-        auto* idx_var = b.Var(ty.ptr<function, i32>());
-        auto* idx = b.Load(idx_var);
-        b.Access(ty.i32(), vec_val, idx);
+        auto* result = b.Access(ty.i32(), vec_val, idx);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%4 = OpTypeInt 32 1
-%3 = OpTypeVector %4 4
-%6 = OpTypeFunction %2 %3
-%9 = OpTypePointer Function %4
-%1 = OpFunction %2 None %6
-%5 = OpFunctionParameter %3
-%7 = OpLabel
-%8 = OpVariable %9 Function
-%10 = OpLoad %4 %8
-%11 = OpVectorExtractDynamic %4 %5 %10
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpVectorExtractDynamic %int %vec %idx");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Vector_Pointer_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Vector_Pointer_ConstantIndex) {
     auto* func = b.Function("foo", ty.void_());
-
     b.With(func->Block(), [&] {
-        auto* vec_var = b.Var(ty.ptr<function, vec4<i32>>());
-        b.Access(ty.ptr<function, i32>(), vec_var, 1_u);
+        auto* vec_var = b.Var("vec", ty.ptr<function, vec4<i32>>());
+        auto* result = b.Access(ty.ptr<function, i32>(), vec_var, 1_u);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%8 = OpTypeInt 32 1
-%7 = OpTypeVector %8 4
-%6 = OpTypePointer Function %7
-%10 = OpTypePointer Function %8
-%12 = OpTypeInt 32 0
-%11 = OpConstant %12 1
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%9 = OpAccessChain %10 %5 %11
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %vec %uint_1");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Vector_Pointer_DynamicIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Vector_Pointer_DynamicIndex) {
+    auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
-
+    func->SetParams({idx});
     b.With(func->Block(), [&] {
-        auto* idx_var = b.Var(ty.ptr<function, i32>());
-        auto* idx = b.Load(idx_var);
-        auto* vec_var = b.Var(ty.ptr<function, vec4<i32>>());
-        b.Access(ty.ptr<function, i32>(), vec_var, idx);
+        auto* vec_var = b.Var("vec", ty.ptr<function, vec4<i32>>());
+        auto* result = b.Access(ty.ptr<function, i32>(), vec_var, idx);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%7 = OpTypeInt 32 1
-%6 = OpTypePointer Function %7
-%11 = OpTypeVector %7 4
-%10 = OpTypePointer Function %11
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%9 = OpVariable %10 Function
-%8 = OpLoad %7 %5
-%12 = OpAccessChain %6 %9 %8
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result = OpAccessChain %_ptr_Function_int %vec %idx");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, NestedVector_Value_DynamicIndex) {
-    auto* val = b.FunctionParam(ty.array(ty.array(ty.vec4(ty.i32()), 4), 4));
+TEST_F(SpvGeneratorImplTest, Access_NestedVector_Value_DynamicIndex) {
+    auto* val = b.FunctionParam("arr", ty.array(ty.array(ty.vec4(ty.i32()), 4), 4));
+    auto* idx = b.FunctionParam("idx", ty.i32());
     auto* func = b.Function("foo", ty.void_());
-    func->SetParams({val});
-
+    func->SetParams({val, idx});
     b.With(func->Block(), [&] {
-        auto* idx_var = b.Var(ty.ptr<function, i32>());
-        auto* idx = b.Load(idx_var);
-        b.Access(ty.i32(), val, 1_u, 2_u, idx);
+        auto* result = b.Access(ty.i32(), val, 1_u, 2_u, idx);
         b.Return(func);
+        mod.SetName(result, "result");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpDecorate %4 ArrayStride 16
-OpDecorate %3 ArrayStride 64
-%2 = OpTypeVoid
-%6 = OpTypeInt 32 1
-%5 = OpTypeVector %6 4
-%8 = OpTypeInt 32 0
-%7 = OpConstant %8 4
-%4 = OpTypeArray %5 %7
-%3 = OpTypeArray %4 %7
-%10 = OpTypeFunction %2 %3
-%13 = OpTypePointer Function %6
-%1 = OpFunction %2 None %10
-%9 = OpFunctionParameter %3
-%11 = OpLabel
-%12 = OpVariable %13 Function
-%14 = OpLoad %6 %12
-%16 = OpCompositeExtract %5 %9 1 2
-%15 = OpVectorExtractDynamic %6 %16 %14
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%14 = OpCompositeExtract %v4int %arr 1 2");
+    EXPECT_INST("%result = OpVectorExtractDynamic %int %14 %idx");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Struct_Value_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Struct_Value_ConstantIndex) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.f32()},
                                                    {mod.symbols.Register("b"), ty.vec4<i32>()},
                                                });
-    auto* str_val = b.FunctionParam(str);
+    auto* str_val = b.FunctionParam("str", str);
     auto* func = b.Function("foo", ty.void_());
     func->SetParams({str_val});
-
     b.With(func->Block(), [&] {
-        b.Access(ty.i32(), str_val, 1_u);
-        b.Access(ty.i32(), str_val, 1_u, 2_u);
+        auto* result_a = b.Access(ty.f32(), str_val, 0_u);
+        auto* result_b = b.Access(ty.i32(), str_val, 1_u, 2_u);
         b.Return(func);
+        mod.SetName(result_a, "result_a");
+        mod.SetName(result_b, "result_b");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpMemberName %3 0 "a"
-OpMemberName %3 1 "b"
-OpName %3 "MyStruct"
-OpMemberDecorate %3 0 Offset 0
-OpMemberDecorate %3 1 Offset 16
-%2 = OpTypeVoid
-%4 = OpTypeFloat 32
-%6 = OpTypeInt 32 1
-%5 = OpTypeVector %6 4
-%3 = OpTypeStruct %4 %5
-%8 = OpTypeFunction %2 %3
-%1 = OpFunction %2 None %8
-%7 = OpFunctionParameter %3
-%9 = OpLabel
-%10 = OpCompositeExtract %6 %7 1
-%11 = OpCompositeExtract %6 %7 1 2
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result_a = OpCompositeExtract %float %str 0");
+    EXPECT_INST("%result_b = OpCompositeExtract %int %str 1 2");
 }
 
-TEST_F(SpvGeneratorImplTest_Access, Struct_Pointer_ConstantIndex) {
+TEST_F(SpvGeneratorImplTest, Access_Struct_Pointer_ConstantIndex) {
     auto* str =
         ty.Struct(mod.symbols.New("MyStruct"), {
                                                    {mod.symbols.Register("a"), ty.f32()},
                                                    {mod.symbols.Register("b"), ty.vec4<i32>()},
                                                });
     auto* func = b.Function("foo", ty.void_());
-
     b.With(func->Block(), [&] {
-        auto* str_var = b.Var(ty.ptr(function, str, read_write));
-        b.Access(ty.ptr<function, i32>(), str_var, 1_u);
-        b.Access(ty.ptr<function, i32>(), str_var, 1_u, 2_u);
+        auto* str_var = b.Var("str", ty.ptr(function, str, read_write));
+        auto* result_a = b.Access(ty.ptr<function, f32>(), str_var, 0_u);
+        auto* result_b = b.Access(ty.ptr<function, i32>(), str_var, 1_u, 2_u);
         b.Return(func);
+        mod.SetName(result_a, "result_a");
+        mod.SetName(result_b, "result_b");
     });
 
-    ASSERT_TRUE(IRIsValid()) << Error();
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-OpMemberName %7 0 "a"
-OpMemberName %7 1 "b"
-OpName %7 "MyStruct"
-OpMemberDecorate %7 0 Offset 0
-OpMemberDecorate %7 1 Offset 16
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%8 = OpTypeFloat 32
-%10 = OpTypeInt 32 1
-%9 = OpTypeVector %10 4
-%7 = OpTypeStruct %8 %9
-%6 = OpTypePointer Function %7
-%12 = OpTypePointer Function %10
-%14 = OpTypeInt 32 0
-%13 = OpConstant %14 1
-%16 = OpConstant %14 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpVariable %6 Function
-%11 = OpAccessChain %12 %5 %13
-%15 = OpAccessChain %12 %5 %13 %16
-OpReturn
-OpFunctionEnd
-)");
+    ASSERT_TRUE(Generate()) << Error();
+    EXPECT_INST("%result_a = OpAccessChain %_ptr_Function_float %str %uint_0");
+    EXPECT_INST("%result_b = OpAccessChain %_ptr_Function_int %str %uint_1 %uint_2");
 }
 
 }  // namespace
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
index 00bfeb0..8450235 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
@@ -167,12 +167,10 @@
 
 TEST_F(SpvGeneratorImplTest, Function_Parameters) {
     auto* i32 = ty.i32();
-    auto* x = b.FunctionParam(i32);
-    auto* y = b.FunctionParam(i32);
+    auto* x = b.FunctionParam("x", i32);
+    auto* y = b.FunctionParam("y", i32);
     auto* func = b.Function("foo", i32);
     func->SetParams({x, y});
-    mod.SetName(x, "x");
-    mod.SetName(y, "y");
 
     b.With(func->Block(), [&] {
         auto* result = b.Add(i32, x, y);
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 63bc82c..d0d6d24 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
@@ -25,7 +25,7 @@
     auto* loop = b.Loop();
 
     loop->Body()->Append(b.Continue(loop));
-    loop->Continuing()->Append(b.BreakIf(true, loop));
+    loop->Continuing()->Append(b.BreakIf(loop, true));
 
     func->Block()->Append(loop);
     func->Block()->Append(b.Return(func));
@@ -218,7 +218,7 @@
     auto* result = loop->Body()->Append(b.Equal(ty.i32(), 1_i, 2_i));
     loop->Body()->Append(b.Continue(loop, result));
 
-    loop->Continuing()->Append(b.BreakIf(result, loop));
+    loop->Continuing()->Append(b.BreakIf(loop, result));
 
     func->Block()->Append(loop);
     func->Block()->Append(b.Return(func));
@@ -260,7 +260,7 @@
 
     outer_loop->Body()->Append(inner_loop);
     outer_loop->Body()->Append(b.Continue(outer_loop));
-    outer_loop->Continuing()->Append(b.BreakIf(true, outer_loop));
+    outer_loop->Continuing()->Append(b.BreakIf(outer_loop, true));
 
     func->Block()->Append(outer_loop);
     func->Block()->Append(b.Return(func));
@@ -305,11 +305,11 @@
     auto* inner_loop = b.Loop();
 
     inner_loop->Body()->Append(b.Continue(inner_loop));
-    inner_loop->Continuing()->Append(b.BreakIf(true, inner_loop));
+    inner_loop->Continuing()->Append(b.BreakIf(inner_loop, true));
 
     outer_loop->Body()->Append(b.Continue(outer_loop));
     outer_loop->Continuing()->Append(inner_loop);
-    outer_loop->Continuing()->Append(b.BreakIf(true, outer_loop));
+    outer_loop->Continuing()->Append(b.BreakIf(outer_loop, true));
 
     func->Block()->Append(outer_loop);
     func->Block()->Append(b.Return(func));
@@ -351,23 +351,23 @@
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
-        auto* l = b.Loop();
+        auto* loop = b.Loop();
 
-        b.With(l->Initializer(), [&] { b.NextIteration(l, 1_i, false); });
+        b.With(loop->Initializer(), [&] { b.NextIteration(loop, 1_i, false); });
 
         auto* loop_param = b.BlockParam(ty.i32());
-        l->Body()->SetParams({loop_param});
+        loop->Body()->SetParams({loop_param});
 
-        b.With(l->Body(), [&] {
+        b.With(loop->Body(), [&] {
             auto* inc = b.Add(ty.i32(), loop_param, 1_i);
-            b.Continue(l, inc);
+            b.Continue(loop, inc);
         });
 
         auto* cont_param = b.BlockParam(ty.i32());
-        l->Continuing()->SetParams({cont_param});
-        b.With(l->Continuing(), [&] {
+        loop->Continuing()->SetParams({cont_param});
+        b.With(loop->Continuing(), [&] {
             auto* cmp = b.GreaterThan(ty.bool_(), cont_param, 5_i);
-            b.BreakIf(cmp, l, cont_param);
+            b.BreakIf(loop, cmp, cont_param);
         });
 
         b.Return(func);
@@ -409,26 +409,26 @@
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
-        auto* l = b.Loop();
+        auto* loop = b.Loop();
 
-        b.With(l->Initializer(), [&] { b.NextIteration(l, 1_i, false); });
+        b.With(loop->Initializer(), [&] { b.NextIteration(loop, 1_i, false); });
 
         auto* loop_param_a = b.BlockParam(ty.i32());
         auto* loop_param_b = b.BlockParam(ty.bool_());
-        l->Body()->SetParams({loop_param_a, loop_param_b});
+        loop->Body()->SetParams({loop_param_a, loop_param_b});
 
-        b.With(l->Body(), [&] {
+        b.With(loop->Body(), [&] {
             auto* inc = b.Add(ty.i32(), loop_param_a, 1_i);
-            b.Continue(l, inc, loop_param_b);
+            b.Continue(loop, inc, loop_param_b);
         });
 
         auto* cont_param_a = b.BlockParam(ty.i32());
         auto* cont_param_b = b.BlockParam(ty.bool_());
-        l->Continuing()->SetParams({cont_param_a, cont_param_b});
-        b.With(l->Continuing(), [&] {
+        loop->Continuing()->SetParams({cont_param_a, cont_param_b});
+        b.With(loop->Continuing(), [&] {
             auto* cmp = b.GreaterThan(ty.bool_(), cont_param_a, 5_i);
             auto* not_b = b.Not(ty.bool_(), cont_param_b);
-            b.BreakIf(cmp, l, cont_param_a, not_b);
+            b.BreakIf(loop, cmp, cont_param_a, not_b);
         });
 
         b.Return(func);
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_var_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_var_test.cc
index f0d3e0d..a79e326 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_var_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_var_test.cc
@@ -77,10 +77,8 @@
     auto* func = b.Function("foo", ty.void_());
 
     b.With(func->Block(), [&] {
-        auto* v = b.Var(ty.ptr<function, i32>());
+        b.Var("myvar", ty.ptr<function, i32>());
         b.Return(func);
-
-        mod.SetName(v, "myvar");
     });
 
     ASSERT_TRUE(IRIsValid()) << Error();
@@ -241,12 +239,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, PrivateVar_Name) {
-    auto* v = b.Var(ty.ptr<private_, i32>());
+    auto* v = b.Var("myvar", ty.ptr<private_, i32>());
     v->SetInitializer(b.Constant(42_i));
     b.RootBlock()->Append(v);
 
-    mod.SetName(v, "myvar");
-
     ASSERT_TRUE(generator_.Generate()) << generator_.Diagnostics().str();
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
 OpMemoryModel Logical GLSL450
@@ -269,7 +265,6 @@
 
 TEST_F(SpvGeneratorImplTest, PrivateVar_LoadAndStore) {
     auto* func = b.Function("foo", ty.void_(), ir::Function::PipelineStage::kFragment);
-    mod.functions.Push(func);
 
     auto* store_ty = ty.i32();
     auto* v = b.Var(ty.ptr(private_, store_ty));
@@ -328,8 +323,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, WorkgroupVar_Name) {
-    auto* v = b.RootBlock()->Append(b.Var(ty.ptr<workgroup, i32>()));
-    mod.SetName(v, "myvar");
+    b.RootBlock()->Append(b.Var("myvar", ty.ptr<workgroup, i32>()));
 
     ASSERT_TRUE(generator_.Generate()) << generator_.Diagnostics().str();
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
@@ -353,7 +347,6 @@
 TEST_F(SpvGeneratorImplTest, WorkgroupVar_LoadAndStore) {
     auto* func = b.Function("foo", ty.void_(), ir::Function::PipelineStage::kCompute,
                             std::array{1u, 1u, 1u});
-    mod.functions.Push(func);
 
     auto* store_ty = ty.i32();
     auto* v = b.RootBlock()->Append(b.Var(ty.ptr(workgroup, store_ty)));
@@ -442,10 +435,9 @@
 }
 
 TEST_F(SpvGeneratorImplTest, StorageVar_Name) {
-    auto* v = b.Var(ty.ptr<storage, i32>());
+    auto* v = b.Var("myvar", ty.ptr<storage, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
-    mod.SetName(v, "myvar");
 
     ASSERT_TRUE(generator_.Generate()) << generator_.Diagnostics().str();
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
@@ -479,7 +471,6 @@
 
     auto* func = b.Function("foo", ty.void_(), ir::Function::PipelineStage::kCompute,
                             std::array{1u, 1u, 1u});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         b.Load(v);
@@ -554,10 +545,9 @@
 }
 
 TEST_F(SpvGeneratorImplTest, UniformVar_Name) {
-    auto* v = b.Var(ty.ptr<uniform, i32>());
+    auto* v = b.Var("myvar", ty.ptr<uniform, i32>());
     v->SetBindingPoint(0, 0);
     b.RootBlock()->Append(v);
-    mod.SetName(v, "myvar");
 
     ASSERT_TRUE(generator_.Generate()) << generator_.Diagnostics().str();
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
@@ -591,7 +581,6 @@
 
     auto* func = b.Function("foo", ty.void_(), ir::Function::PipelineStage::kCompute,
                             std::array{1u, 1u, 1u});
-    mod.functions.Push(func);
 
     b.With(func->Block(), [&] {
         b.Load(v);
diff --git a/src/tint/writer/spirv/ir/test_helper_ir.h b/src/tint/writer/spirv/ir/test_helper_ir.h
index 08f8246..27559be 100644
--- a/src/tint/writer/spirv/ir/test_helper_ir.h
+++ b/src/tint/writer/spirv/ir/test_helper_ir.h
@@ -16,8 +16,10 @@
 #define SRC_TINT_WRITER_SPIRV_IR_TEST_HELPER_IR_H_
 
 #include <string>
+#include <utility>
 
 #include "gtest/gtest.h"
+#include "spirv-tools/libspirv.hpp"
 #include "src/tint/ir/builder.h"
 #include "src/tint/ir/validate.h"
 #include "src/tint/writer/spirv/ir/generator_impl_ir.h"
@@ -25,6 +27,10 @@
 
 namespace tint::writer::spirv {
 
+// Helper macro to check whether the SPIR-V output contains an instruction, dumping the full output
+// if the instruction was not present.
+#define EXPECT_INST(inst) ASSERT_THAT(output_, testing::HasSubstr(inst)) << output_
+
 /// The element type of a test.
 enum TestElementType {
     kBool,
@@ -54,6 +60,9 @@
     /// Validation errors
     std::string err_;
 
+    /// SPIR-V output.
+    std::string output_;
+
     /// @returns the error string from the validation
     std::string Error() const { return err_; }
 
@@ -67,6 +76,59 @@
         return true;
     }
 
+    /// Run the generator on the IR module and validate the result.
+    /// @returns true if generation and validation succeeded
+    bool Generate() {
+        if (!generator_.Generate()) {
+            err_ = generator_.Diagnostics().str();
+            return false;
+        }
+        if (!Validate()) {
+            return false;
+        }
+
+        output_ = Disassemble(generator_.Result(), SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES |
+                                                       SPV_BINARY_TO_TEXT_OPTION_INDENT |
+                                                       SPV_BINARY_TO_TEXT_OPTION_COMMENT);
+        return true;
+    }
+
+    /// Validate the generated SPIR-V using the SPIR-V Tools Validator.
+    /// @returns true if validation succeeded, false otherwise
+    bool Validate() {
+        auto binary = generator_.Result();
+
+        std::string spv_errors;
+        auto msg_consumer = [&spv_errors](spv_message_level_t level, const char*,
+                                          const spv_position_t& position, const char* message) {
+            switch (level) {
+                case SPV_MSG_FATAL:
+                case SPV_MSG_INTERNAL_ERROR:
+                case SPV_MSG_ERROR:
+                    spv_errors +=
+                        "error: line " + std::to_string(position.index) + ": " + message + "\n";
+                    break;
+                case SPV_MSG_WARNING:
+                    spv_errors +=
+                        "warning: line " + std::to_string(position.index) + ": " + message + "\n";
+                    break;
+                case SPV_MSG_INFO:
+                    spv_errors +=
+                        "info: line " + std::to_string(position.index) + ": " + message + "\n";
+                    break;
+                case SPV_MSG_DEBUG:
+                    break;
+            }
+        };
+
+        spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
+        tools.SetMessageConsumer(msg_consumer);
+
+        auto result = tools.Validate(binary);
+        err_ = std::move(spv_errors);
+        return result;
+    }
+
     /// @returns the disassembled types from the generated module.
     std::string DumpTypes() { return DumpInstructions(generator_.Module().Types()); }
 
diff --git a/src/tint/writer/spirv/spv_dump.cc b/src/tint/writer/spirv/spv_dump.cc
index da24446..6ded6ff 100644
--- a/src/tint/writer/spirv/spv_dump.cc
+++ b/src/tint/writer/spirv/spv_dump.cc
@@ -19,7 +19,7 @@
 
 namespace tint::writer::spirv {
 
-std::string Disassemble(const std::vector<uint32_t>& data) {
+std::string Disassemble(const std::vector<uint32_t>& data, uint32_t options /* = 0u */) {
     std::string spv_errors;
     spv_target_env target_env = SPV_ENV_UNIVERSAL_1_0;
 
@@ -49,7 +49,7 @@
     tools.SetMessageConsumer(msg_consumer);
 
     std::string result;
-    if (!tools.Disassemble(data, &result, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER)) {
+    if (!tools.Disassemble(data, &result, SPV_BINARY_TO_TEXT_OPTION_NO_HEADER | options)) {
         return "*** Invalid SPIR-V ***\n" + spv_errors;
     }
     return result;
diff --git a/src/tint/writer/spirv/spv_dump.h b/src/tint/writer/spirv/spv_dump.h
index 359f0cb..b9030a4 100644
--- a/src/tint/writer/spirv/spv_dump.h
+++ b/src/tint/writer/spirv/spv_dump.h
@@ -24,8 +24,9 @@
 
 /// Disassembles SPIR-V binary data into its textual form.
 /// @param data the SPIR-V binary data
+/// @param options the additional SPIR-V disassembler options to use
 /// @returns the disassembled SPIR-V string
-std::string Disassemble(const std::vector<uint32_t>& data);
+std::string Disassemble(const std::vector<uint32_t>& data, uint32_t options = 0u);
 
 /// Dumps the given builder to a SPIR-V disassembly string
 /// @param builder the builder to convert
diff --git a/src/tint/writer/syntax_tree/generator_impl.cc b/src/tint/writer/syntax_tree/generator_impl.cc
index 4574c14..b6ba3ea 100644
--- a/src/tint/writer/syntax_tree/generator_impl.cc
+++ b/src/tint/writer/syntax_tree/generator_impl.cc
@@ -520,6 +520,14 @@
                 }
                 Line() << "]";
             },
+            [&](const ast::IndexAttribute* index) {
+                line() << "IndexAttribute [";
+                {
+                    ScopedIndent idx(this);
+                    EmitExpression(index->expr);
+                }
+                line() << "]";
+            },
             [&](const ast::BuiltinAttribute* builtin) {
                 Line() << "BuiltinAttribute [";
                 {
diff --git a/src/tint/writer/wgsl/generator_impl.cc b/src/tint/writer/wgsl/generator_impl.cc
index 59aa35c..b36994a 100644
--- a/src/tint/writer/wgsl/generator_impl.cc
+++ b/src/tint/writer/wgsl/generator_impl.cc
@@ -430,6 +430,11 @@
                 EmitExpression(out, location->expr);
                 out << ")";
             },
+            [&](const ast::IndexAttribute* index) {
+                out << "index(";
+                EmitExpression(out, index->expr);
+                out << ")";
+            },
             [&](const ast::BuiltinAttribute* builtin) {
                 out << "builtin(";
                 EmitExpression(out, builtin->builtin);