diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 83fcbf5..ce779bc 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -237,6 +237,8 @@
     "utils/bump_allocator.h",
     "utils/castable.cc",
     "utils/castable.h",
+    "utils/cli.cc",
+    "utils/cli.h",
     "utils/compiler_macros.h",
     "utils/concat.h",
     "utils/crc32.h",
@@ -1822,6 +1824,7 @@
       "utils/block_allocator_test.cc",
       "utils/bump_allocator_test.cc",
       "utils/castable_test.cc",
+      "utils/cli_test.cc",
       "utils/crc32_test.cc",
       "utils/defer_test.cc",
       "utils/enum_set_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index c20c850..2ecb97a 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -525,6 +525,8 @@
   utils/bump_allocator.h
   utils/castable.cc
   utils/castable.h
+  utils/cli.cc
+  utils/cli.h
   utils/compiler_macros.h
   utils/concat.h
   utils/crc32.h
@@ -1048,6 +1050,7 @@
     utils/bitset_test.cc
     utils/block_allocator_test.cc
     utils/bump_allocator_test.cc
+    utils/cli_test.cc
     utils/castable_test.cc
     utils/crc32_test.cc
     utils/defer_test.cc
diff --git a/src/tint/ast/transform/first_index_offset.cc b/src/tint/ast/transform/first_index_offset.cc
index 4c77efb..dd28585 100644
--- a/src/tint/ast/transform/first_index_offset.cc
+++ b/src/tint/ast/transform/first_index_offset.cc
@@ -51,8 +51,8 @@
 FirstIndexOffset::BindingPoint::BindingPoint(uint32_t b, uint32_t g) : binding(b), group(g) {}
 FirstIndexOffset::BindingPoint::~BindingPoint() = default;
 
-FirstIndexOffset::Data::Data(bool has_vtx_or_inst_index)
-    : has_vertex_or_instance_index(has_vtx_or_inst_index) {}
+FirstIndexOffset::Data::Data(bool has_vtx_index, bool has_inst_index)
+    : has_vertex_index(has_vtx_index), has_instance_index(has_inst_index) {}
 FirstIndexOffset::Data::Data(const Data&) = default;
 FirstIndexOffset::Data::~Data() = default;
 
@@ -81,7 +81,8 @@
     std::unordered_map<const sem::Variable*, const char*> builtin_vars;
     std::unordered_map<const type::StructMember*, const char*> builtin_members;
 
-    bool has_vertex_or_instance_index = false;
+    bool has_vertex_index = false;
+    bool has_instance_index = false;
 
     // Traverse the AST scanning for builtin accesses via variables (includes
     // parameters) or structure member accesses.
@@ -93,12 +94,12 @@
                     if (builtin == builtin::BuiltinValue::kVertexIndex) {
                         auto* sem_var = ctx.src->Sem().Get(var);
                         builtin_vars.emplace(sem_var, kFirstVertexName);
-                        has_vertex_or_instance_index = true;
+                        has_vertex_index = true;
                     }
                     if (builtin == builtin::BuiltinValue::kInstanceIndex) {
                         auto* sem_var = ctx.src->Sem().Get(var);
                         builtin_vars.emplace(sem_var, kFirstInstanceName);
-                        has_vertex_or_instance_index = true;
+                        has_instance_index = true;
                     }
                 }
             }
@@ -110,19 +111,19 @@
                     if (builtin == builtin::BuiltinValue::kVertexIndex) {
                         auto* sem_mem = ctx.src->Sem().Get(member);
                         builtin_members.emplace(sem_mem, kFirstVertexName);
-                        has_vertex_or_instance_index = true;
+                        has_vertex_index = true;
                     }
                     if (builtin == builtin::BuiltinValue::kInstanceIndex) {
                         auto* sem_mem = ctx.src->Sem().Get(member);
                         builtin_members.emplace(sem_mem, kFirstInstanceName);
-                        has_vertex_or_instance_index = true;
+                        has_instance_index = true;
                     }
                 }
             }
         }
     }
 
-    if (has_vertex_or_instance_index) {
+    if (has_vertex_index || has_instance_index) {
         // Add uniform buffer members and calculate byte offsets
         utils::Vector<const StructMember*, 8> members;
         members.Push(b.Member(kFirstVertexName, b.ty.u32()));
@@ -160,7 +161,7 @@
         });
     }
 
-    outputs.Add<Data>(has_vertex_or_instance_index);
+    outputs.Add<Data>(has_vertex_index, has_instance_index);
 
     ctx.Clone();
     return Program(std::move(b));
diff --git a/src/tint/ast/transform/first_index_offset.h b/src/tint/ast/transform/first_index_offset.h
index 44a3a63..c1dd512 100644
--- a/src/tint/ast/transform/first_index_offset.h
+++ b/src/tint/ast/transform/first_index_offset.h
@@ -84,9 +84,9 @@
     /// Data holds information about shader usage and constant buffer offsets.
     struct Data final : public utils::Castable<Data, Transform::Data> {
         /// Constructor
-        /// @param has_vtx_or_inst_index True if the shader uses vertex_index or
-        /// instance_index
-        explicit Data(bool has_vtx_or_inst_index);
+        /// @param has_vtx_index True if the shader uses vertex_index
+        /// @param has_inst_index True if the shader uses instance_index
+        Data(bool has_vtx_index, bool has_inst_index);
 
         /// Copy constructor
         Data(const Data&);
@@ -95,7 +95,9 @@
         ~Data() override;
 
         /// True if the shader uses vertex_index
-        const bool has_vertex_or_instance_index;
+        const bool has_vertex_index;
+        /// True if the shader uses instance_index
+        const bool has_instance_index;
     };
 
     /// Constructor
diff --git a/src/tint/ast/transform/first_index_offset_test.cc b/src/tint/ast/transform/first_index_offset_test.cc
index 8dc441f..ce480e2 100644
--- a/src/tint/ast/transform/first_index_offset_test.cc
+++ b/src/tint/ast/transform/first_index_offset_test.cc
@@ -86,7 +86,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, false);
+    EXPECT_EQ(data->has_vertex_index, false);
+    EXPECT_EQ(data->has_instance_index, false);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex) {
@@ -130,7 +131,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, false);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleVertexIndex_OutOfOrder) {
@@ -174,7 +176,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, false);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex) {
@@ -218,7 +221,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, false);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleInstanceIndex_OutOfOrder) {
@@ -262,7 +266,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, false);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex) {
@@ -318,7 +323,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 TEST_F(FirstIndexOffsetTest, BasicModuleBothIndex_OutOfOrder) {
@@ -374,7 +380,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 TEST_F(FirstIndexOffsetTest, NestedCalls) {
@@ -426,7 +433,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, false);
 }
 
 TEST_F(FirstIndexOffsetTest, NestedCalls_OutOfOrder) {
@@ -478,7 +486,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, false);
 }
 
 TEST_F(FirstIndexOffsetTest, MultipleEntryPoints) {
@@ -546,7 +555,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 TEST_F(FirstIndexOffsetTest, MultipleEntryPoints_OutOfOrder) {
@@ -614,7 +624,8 @@
     auto* data = got.data.Get<FirstIndexOffset::Data>();
 
     ASSERT_NE(data, nullptr);
-    EXPECT_EQ(data->has_vertex_or_instance_index, true);
+    EXPECT_EQ(data->has_vertex_index, true);
+    EXPECT_EQ(data->has_instance_index, true);
 }
 
 }  // namespace
diff --git a/src/tint/cmd/main.cc b/src/tint/cmd/main.cc
index 5d82479..ada1603 100644
--- a/src/tint/cmd/main.cc
+++ b/src/tint/cmd/main.cc
@@ -41,6 +41,8 @@
 #include "src/tint/ast/module.h"
 #include "src/tint/cmd/generate_external_texture_bindings.h"
 #include "src/tint/cmd/helper.h"
+#include "src/tint/utils/cli.h"
+#include "src/tint/utils/defer.h"
 #include "src/tint/utils/io/command.h"
 #include "src/tint/utils/string.h"
 #include "src/tint/utils/string_stream.h"
@@ -54,6 +56,36 @@
 #include "src/tint/ir/module.h"        // nogncheck
 #endif                                 // TINT_BUILD_IR
 
+#if TINT_BUILD_SPV_WRITER
+#define SPV_WRITER_ONLY(x) x
+#else
+#define SPV_WRITER_ONLY(x)
+#endif
+
+#if TINT_BUILD_WGSL_WRITER
+#define WGSL_WRITER_ONLY(x) x
+#else
+#define WGSL_WRITER_ONLY(x)
+#endif
+
+#if TINT_BUILD_MSL_WRITER
+#define MSL_WRITER_ONLY(x) x
+#else
+#define MSL_WRITER_ONLY(x)
+#endif
+
+#if TINT_BUILD_HLSL_WRITER
+#define HLSL_WRITER_ONLY(x) x
+#else
+#define HLSL_WRITER_ONLY(x)
+#endif
+
+#if TINT_BUILD_GLSL_WRITER
+#define GLSL_WRITER_ONLY(x) x
+#else
+#define GLSL_WRITER_ONLY(x)
+#endif
+
 namespace {
 
 /// Prints the given hash value in a format string that the end-to-end test runner can parse.
@@ -73,7 +105,6 @@
 };
 
 struct Options {
-    bool show_help = false;
     bool verbose = false;
 
     std::string input_filename;
@@ -99,12 +130,12 @@
     tint::reader::spirv::Options spirv_reader_options;
 #endif
 
-    std::vector<std::string> transforms;
+    tint::utils::Vector<std::string, 4> transforms;
 
     std::string fxc_path;
     std::string dxc_path;
     std::string xcrun_path;
-    std::unordered_map<std::string, double> overrides;
+    tint::utils::Hashmap<std::string, double, 8> overrides;
     std::optional<tint::sem::BindingPoint> hlsl_root_constant_binding_point;
 
 #if TINT_BUILD_IR
@@ -113,96 +144,10 @@
 #endif  // TINT_BUILD_IR
 
 #if TINT_BUILD_SYNTAX_TREE_WRITER
-    bool dump_syntax_tree = false;
-#endif  // TINB_BUILD_SYNTAX_TREE_WRITER
+    bool dump_ast = false;
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
 };
 
-const char kUsage[] = R"(Usage: tint [options] <input-file>
-
- options:
-  --format <spirv|spvasm|wgsl|msl|hlsl|none>  -- Output format.
-                               If not provided, will be inferred from output
-                               filename extension:
-                                   .spvasm -> spvasm
-                                   .spv    -> spirv
-                                   .wgsl   -> wgsl
-                                   .metal  -> msl
-                                   .hlsl   -> hlsl
-                               If none matches, then default to SPIR-V assembly.
-  -ep <name>                -- Output single entry point
-  --output-file <name>      -- Output file name.  Use "-" for standard output
-  -o <name>                 -- Output file name.  Use "-" for standard output
-  --transform <name list>   -- Runs transforms, name list is comma separated
-                               Available transforms:
-${transforms} --parse-only              -- Stop after parsing the input
-  --allow-non-uniform-derivatives  -- When using SPIR-V input, allow non-uniform derivatives by
-                               inserting a module-scope directive to suppress any uniformity
-                               violations that may be produced.
-  --disable-workgroup-init  -- Disable workgroup memory zero initialization.
-  --dump-inspector-bindings -- Dump reflection data about bindins to stdout.
-  -h                        -- This help text
-  --hlsl-root-constant-binding-point <group>,<binding>  -- Binding point for root constant.
-                               Specify the binding point for generated uniform buffer
-                               used for num_workgroups in HLSL. If not specified, then
-                               default to binding 0 of the largest used group plus 1,
-                               or group 0 if no resource bound.
-  --validate                -- Validates the generated shader with all available validators
-  --skip-hash <hash list>   -- Skips validation if the hash of the output is equal to any
-                               of the hash codes in the comma separated list of hashes
-  --print-hash              -- Emit the hash of the output program
-  --fxc                     -- Path to FXC dll, used to validate HLSL output.
-                               When specified, automatically enables HLSL validation with FXC
-  --dxc                     -- Path to DXC executable, used to validate HLSL output.
-                               When specified, automatically enables HLSL validation with DXC
-  --xcrun                   -- Path to xcrun executable, used to validate MSL output.
-                               When specified, automatically enables MSL validation
-  --overrides               -- Override values as IDENTIFIER=VALUE, comma-separated.
-  --rename-all              -- Renames all symbols.
-)";
-
-Format parse_format(const std::string& fmt) {
-    (void)fmt;
-
-#if TINT_BUILD_SPV_WRITER
-    if (fmt == "spirv") {
-        return Format::kSpirv;
-    }
-    if (fmt == "spvasm") {
-        return Format::kSpvAsm;
-    }
-#endif  // TINT_BUILD_SPV_WRITER
-
-#if TINT_BUILD_WGSL_WRITER
-    if (fmt == "wgsl") {
-        return Format::kWgsl;
-    }
-#endif  // TINT_BUILD_WGSL_WRITER
-
-#if TINT_BUILD_MSL_WRITER
-    if (fmt == "msl") {
-        return Format::kMsl;
-    }
-#endif  // TINT_BUILD_MSL_WRITER
-
-#if TINT_BUILD_HLSL_WRITER
-    if (fmt == "hlsl") {
-        return Format::kHlsl;
-    }
-#endif  // TINT_BUILD_HLSL_WRITER
-
-#if TINT_BUILD_GLSL_WRITER
-    if (fmt == "glsl") {
-        return Format::kGlsl;
-    }
-#endif  // TINT_BUILD_GLSL_WRITER
-
-    if (fmt == "none") {
-        return Format::kNone;
-    }
-
-    return Format::kUnknown;
-}
-
 /// @param filename the filename to inspect
 /// @returns the inferred format for the filename suffix
 Format infer_format(const std::string& filename) {
@@ -238,112 +183,154 @@
     return Format::kUnknown;
 }
 
-std::vector<std::string> split_on_char(std::string list, char c) {
-    std::vector<std::string> res;
+bool ParseArgs(tint::utils::VectorRef<std::string_view> arguments,
+               std::string transform_names,
+               Options* opts) {
+    using namespace tint::utils::cli;  // NOLINT(build/namespaces)
 
-    std::istringstream str(list);
-    while (str.good()) {
-        std::string substr;
-        getline(str, substr, c);
-        res.push_back(substr);
-    }
-    return res;
-}
+    tint::utils::Vector<EnumName<Format>, 8> format_enum_names{
+        EnumName(Format::kNone, "none"),
+    };
 
-std::vector<std::string> split_on_comma(std::string list) {
-    return split_on_char(list, ',');
-}
+    SPV_WRITER_ONLY(format_enum_names.Emplace(Format::kSpirv, "spirv"));
+    SPV_WRITER_ONLY(format_enum_names.Emplace(Format::kSpvAsm, "spvasm"));
+    WGSL_WRITER_ONLY(format_enum_names.Emplace(Format::kWgsl, "wgsl"));
+    MSL_WRITER_ONLY(format_enum_names.Emplace(Format::kMsl, "msl"));
+    HLSL_WRITER_ONLY(format_enum_names.Emplace(Format::kHlsl, "hlsl"));
+    GLSL_WRITER_ONLY(format_enum_names.Emplace(Format::kGlsl, "glsl"));
 
-std::vector<std::string> split_on_equal(std::string list) {
-    return split_on_char(list, '=');
-}
+    OptionSet options;
+    auto& fmt = options.Add<EnumOption<Format>>("format",
+                                                R"(Output format.
+If not provided, will be inferred from output filename extension:
+  .spvasm -> spvasm
+  .spv    -> spirv
+  .wgsl   -> wgsl
+  .metal  -> msl
+  .hlsl   -> hlsl)",
+                                                format_enum_names, ShortName{"f"});
+    TINT_DEFER(opts->format = fmt.value.value_or(Format::kUnknown));
 
-std::optional<uint64_t> parse_unsigned_number(std::string number) {
-    for (char c : number) {
-        if (!std::isdigit(c)) {
-            // Found a non-digital char, return nullopt
-            return std::nullopt;
-        }
-    }
-
-    errno = 0;
-    char* p_end;
-    uint64_t result;
-    // std::strtoull will not throw exception.
-    result = std::strtoull(number.c_str(), &p_end, 10);
-    if ((errno != 0) || (static_cast<size_t>(p_end - number.c_str()) != number.length())) {
-        // Unexpected conversion result
-        return std::nullopt;
-    }
-
-    return result;
-}
-
-bool ParseArgs(const std::vector<std::string>& args, Options* opts) {
-    for (size_t i = 1; i < args.size(); ++i) {
-        const std::string& arg = args[i];
-        if (arg == "--format") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for --format argument." << std::endl;
-                return false;
-            }
-            opts->format = parse_format(args[i]);
-
-            if (opts->format == Format::kUnknown) {
-                std::cerr << "Unknown output format: " << args[i] << std::endl;
-                return false;
-            }
-        } else if (arg == "-ep") {
-            if (i + 1 >= args.size()) {
-                std::cerr << "Missing value for -ep" << std::endl;
-                return false;
-            }
-            i++;
-            opts->ep_name = args[i];
+    auto& ep = options.Add<StringOption>("entry-point", "Output single entry point",
+                                         ShortName{"ep"}, Parameter{"name"});
+    TINT_DEFER({
+        if (ep.value.has_value()) {
+            opts->ep_name = *ep.value;
             opts->emit_single_entry_point = true;
+        }
+    });
 
-        } else if (arg == "-o" || arg == "--output-name") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
-                return false;
-            }
-            opts->output_file = args[i];
+    auto& output = options.Add<StringOption>("output-name", "Output file name", ShortName{"o"},
+                                             Parameter{"name"});
+    TINT_DEFER(opts->output_file = output.value.value_or(""));
 
-        } else if (arg == "-h" || arg == "--help") {
-            opts->show_help = true;
-        } else if (arg == "-v" || arg == "--verbose") {
-            opts->verbose = true;
-        } else if (arg == "--transform") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
-                return false;
-            }
-            opts->transforms = split_on_comma(args[i]);
-        } else if (arg == "--parse-only") {
-            opts->parse_only = true;
-        } else if (arg == "--allow-non-uniform-derivatives") {
-#if TINT_BUILD_SPV_READER
-            opts->spirv_reader_options.allow_non_uniform_derivatives = true;
-#else
-            std::cerr << "Tint not built with the SPIR-V reader enabled" << std::endl;
-            return false;
-#endif
-        } else if (arg == "--disable-workgroup-init") {
-            opts->disable_workgroup_init = true;
-        } else if (arg == "--dump-inspector-bindings") {
-            opts->dump_inspector_bindings = true;
-        } else if (arg == "--validate") {
+    auto& fxc_path =
+        options.Add<StringOption>("fxc", R"(Path to FXC dll, used to validate HLSL output.
+When specified, automatically enables HLSL validation with FXC)",
+                                  Parameter{"path"});
+    TINT_DEFER(opts->fxc_path = fxc_path.value.value_or(""));
+
+    auto& dxc_path =
+        options.Add<StringOption>("dxc", R"(Path to DXC dll, used to validate HLSL output.
+When specified, automatically enables HLSL validation with DXC)",
+                                  Parameter{"path"});
+    TINT_DEFER(opts->dxc_path = dxc_path.value.value_or(""));
+
+    auto& xcrun =
+        options.Add<StringOption>("xcrun", R"(Path to xcrun executable, used to validate MSL output.
+When specified, automatically enables MSL validation)",
+                                  Parameter{"path"});
+    TINT_DEFER({
+        if (xcrun.value.has_value()) {
+            opts->xcrun_path = *xcrun.value;
             opts->validate = true;
-        } else if (arg == "--skip-hash") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing hash value for " << arg << std::endl;
-                return false;
+        }
+    });
+
+#if TINT_BUILD_IR
+    auto& dump_ir = options.Add<BoolOption>("dump-ir", "Writes the IR to stdout", Alias{"emit-ir"},
+                                            Default{false});
+    TINT_DEFER(opts->dump_ir = *dump_ir.value);
+
+    auto& use_ir = options.Add<BoolOption>(
+        "use-ir", "Use the IR for writers and transforms when possible", Default{false});
+    TINT_DEFER(opts->use_ir = *use_ir.value);
+#endif  // TINT_BUILD_IR
+
+    auto& verbose =
+        options.Add<BoolOption>("verbose", "Verbose output", ShortName{"v"}, Default{false});
+    TINT_DEFER(opts->verbose = *verbose.value);
+
+    auto& validate = options.Add<BoolOption>(
+        "validate", "Validates the generated shader with all available validators", Default{false});
+    TINT_DEFER(opts->validate = *validate.value);
+
+    auto& parse_only =
+        options.Add<BoolOption>("parse-only", "Stop after parsing the input", Default{false});
+    TINT_DEFER(opts->parse_only = *parse_only.value);
+
+#if TINT_BUILD_SPV_READER
+    auto& allow_nud =
+        options.Add<BoolOption>("allow-non-uniform-derivatives",
+                                R"(When using SPIR-V input, allow non-uniform derivatives by
+inserting a module-scope directive to suppress any uniformity
+violations that may be produced)",
+                                Default{false});
+    TINT_DEFER({
+        if (allow_nud.value.value_or(false)) {
+            opts->spirv_reader_options.allow_non_uniform_derivatives = true;
+        }
+    });
+#endif
+
+    auto& disable_wg_init = options.Add<BoolOption>(
+        "disable-workgroup-init", "Disable workgroup memory zero initialization", Default{false});
+    TINT_DEFER(opts->disable_workgroup_init = *disable_wg_init.value);
+
+    auto& rename_all = options.Add<BoolOption>("rename-all", "Renames all symbols", Default{false});
+    TINT_DEFER(opts->rename_all = *rename_all.value);
+
+    auto& dump_inspector_bindings = options.Add<BoolOption>(
+        "dump-inspector-bindings", "Dump reflection data about bindings to stdout",
+        Alias{"emit-inspector-bindings"}, Default{false});
+    TINT_DEFER(opts->dump_inspector_bindings = *dump_inspector_bindings.value);
+
+#if TINT_BUILD_SYNTAX_TREE_WRITER
+    auto& dump_ast = options.Add<BoolOption>("dump-ast", "Writes the AST to stdout",
+                                             Alias{"emit-ast"}, Default{false});
+    TINT_DEFER(opts->dump_ast = *dump_ast.value);
+#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
+
+    auto& print_hash = options.Add<BoolOption>("print-hash", "Emit the hash of the output program",
+                                               Default{false});
+    TINT_DEFER(opts->print_hash = *print_hash.value);
+
+    auto& transforms =
+        options.Add<StringOption>("transform", R"(Runs transforms, name list is comma separated
+Available transforms:
+)" + transform_names,
+                                  ShortName{"t"});
+    TINT_DEFER({
+        if (transforms.value.has_value()) {
+            for (auto transform : tint::utils::Split(*transforms.value, ",")) {
+                opts->transforms.Push(std::string(transform));
             }
-            for (auto hash : split_on_comma(args[i])) {
+        }
+    });
+
+    auto& hlsl_rc_bp = options.Add<StringOption>("hlsl-root-constant-binding-point",
+                                                 R"(Binding point for root constant.
+Specify the binding point for generated uniform buffer
+used for num_workgroups in HLSL. If not specified, then
+default to binding 0 of the largest used group plus 1,
+or group 0 if no resource bound)");
+
+    auto& skip_hash = options.Add<StringOption>(
+        "skip-hash", R"(Skips validation if the hash of the output is equal to any
+of the hash codes in the comma separated list of hashes)");
+    TINT_DEFER({
+        if (skip_hash.value.has_value()) {
+            for (auto hash : tint::utils::Split(*skip_hash.value, ",")) {
                 uint32_t value = 0;
                 int base = 10;
                 if (hash.size() > 2 && hash[0] == '0' && (hash[1] == 'x' || hash[1] == 'X')) {
@@ -353,91 +340,82 @@
                 std::from_chars(hash.data(), hash.data() + hash.size(), value, base);
                 opts->skip_hash.emplace(value);
             }
-        } else if (arg == "--print-hash") {
-            opts->print_hash = true;
-        } else if (arg == "--fxc") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
+        }
+    });
+
+    auto& overrides = options.Add<StringOption>(
+        "overrides", "Override values as IDENTIFIER=VALUE, comma-separated");
+
+    auto& help = options.Add<BoolOption>("help", "Show usage", ShortName{"h"});
+
+    auto show_usage = [&] {
+        std::cout << R"(Usage: tint [options] <input-file>
+
+Options:
+)";
+        options.ShowHelp(std::cout);
+    };
+
+    auto result = options.Parse(std::cerr, arguments);
+    if (!result) {
+        std::cerr << std::endl;
+        show_usage();
+        return false;
+    }
+    if (help.value.value_or(false)) {
+        show_usage();
+        return false;
+    }
+
+    if (overrides.value.has_value()) {
+        for (const auto& o : tint::utils::Split(*overrides.value, ",")) {
+            auto parts = tint::utils::Split(o, "=");
+            if (parts.Length() != 2) {
+                std::cerr << "override values must be of the form IDENTIFIER=VALUE";
                 return false;
             }
-            opts->fxc_path = args[i];
-        } else if (arg == "--dxc") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
+            auto value = tint::utils::ParseNumber<double>(parts[1]);
+            if (!value) {
+                std::cerr << "invalid override value: " << parts[1];
                 return false;
             }
-            opts->dxc_path = args[i];
-#if TINT_BUILD_IR
-        } else if (arg == "--dump-ir") {
-            opts->dump_ir = true;
-        } else if (arg == "--use-ir") {
-            opts->use_ir = true;
-#endif  // TINT_BUILD_IR
-#if TINT_BUILD_SYNTAX_TREE_WRITER
-        } else if (arg == "--dump-ast") {
-            opts->dump_syntax_tree = true;
-#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
-        } else if (arg == "--xcrun") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
-                return false;
-            }
-            opts->xcrun_path = args[i];
-            opts->validate = true;
-        } else if (arg == "--overrides") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
-                return false;
-            }
-            for (const auto& o : split_on_comma(args[i])) {
-                auto parts = split_on_equal(o);
-                opts->overrides.insert({parts[0], std::stod(parts[1])});
-            }
-        } else if (arg == "--rename-all") {
-            ++i;
-            opts->rename_all = true;
-        } else if (arg == "--hlsl-root-constant-binding-point") {
-            ++i;
-            if (i >= args.size()) {
-                std::cerr << "Missing value for " << arg << std::endl;
-                return false;
-            }
-            auto binding_points = split_on_comma(args[i]);
-            if (binding_points.size() != 2) {
-                std::cerr << "Invalid binding point for " << arg << ": " << args[i] << std::endl;
-                return false;
-            }
-            auto group = parse_unsigned_number(binding_points[0]);
-            if ((!group.has_value()) || (group.value() > std::numeric_limits<uint32_t>::max())) {
-                std::cerr << "Invalid group for " << arg << ": " << binding_points[0] << std::endl;
-                return false;
-            }
-            auto binding = parse_unsigned_number(binding_points[1]);
-            if ((!binding.has_value()) ||
-                (binding.value() > std::numeric_limits<uint32_t>::max())) {
-                std::cerr << "Invalid binding for " << arg << ": " << binding_points[1]
-                          << std::endl;
-                return false;
-            }
-            opts->hlsl_root_constant_binding_point = tint::sem::BindingPoint{
-                static_cast<uint32_t>(group.value()), static_cast<uint32_t>(binding.value())};
-        } else if (!arg.empty()) {
-            if (arg[0] == '-') {
-                std::cerr << "Unrecognized option: " << arg << std::endl;
-                return false;
-            }
-            if (!opts->input_filename.empty()) {
-                std::cerr << "More than one input file specified: '" << opts->input_filename
-                          << "' and '" << arg << "'" << std::endl;
-                return false;
-            }
-            opts->input_filename = arg;
+            opts->overrides.Add(std::string(parts[0]), value.Get());
         }
     }
+
+    if (hlsl_rc_bp.value.has_value()) {
+        auto binding_points = tint::utils::Split(*hlsl_rc_bp.value, ",");
+        if (binding_points.Length() != 2) {
+            std::cerr << "Invalid binding point for " << hlsl_rc_bp.name << ": "
+                      << *hlsl_rc_bp.value << std::endl;
+            return false;
+        }
+        auto group = tint::utils::ParseUint32(binding_points[0]);
+        if (!group) {
+            std::cerr << "Invalid group for " << hlsl_rc_bp.name << ": " << binding_points[0]
+                      << std::endl;
+            return false;
+        }
+        auto binding = tint::utils::ParseUint32(binding_points[1]);
+        if (!binding) {
+            std::cerr << "Invalid binding for " << hlsl_rc_bp.name << ": " << binding_points[1]
+                      << std::endl;
+            return false;
+        }
+        opts->hlsl_root_constant_binding_point =
+            tint::sem::BindingPoint{group.Get(), binding.Get()};
+    }
+
+    auto files = result.Get();
+    if (files.Length() > 1) {
+        std::cerr << "More than one input file specified: "
+                  << tint::utils::Join(Transform(files, tint::utils::Quote), ", ") << std::endl;
+        return false;
+    }
+    if (files.Length() == 1) {
+        opts->input_filename = files[0];
+    }
+
     return true;
 }
 
@@ -677,7 +655,7 @@
         const char* default_xcrun_exe = "xcrun";
 #endif
         auto xcrun = tint::utils::Command::LookPath(
-            options.xcrun_path.empty() ? default_xcrun_exe : options.xcrun_path);
+            options.xcrun_path.empty() ? default_xcrun_exe : std::string(options.xcrun_path));
         if (xcrun.Found()) {
             res = tint::val::Msl(xcrun.Path(), result.msl);
         } else {
@@ -738,8 +716,8 @@
         tint::val::Result dxc_res;
         bool dxc_found = false;
         if (options.validate || must_validate_dxc) {
-            auto dxc =
-                tint::utils::Command::LookPath(options.dxc_path.empty() ? "dxc" : options.dxc_path);
+            auto dxc = tint::utils::Command::LookPath(
+                options.dxc_path.empty() ? "dxc" : std::string(options.dxc_path));
             if (dxc.Found()) {
                 dxc_found = true;
 
@@ -757,8 +735,8 @@
             } else if (must_validate_dxc) {
                 // DXC was explicitly requested. Error if it could not be found.
                 dxc_res.failed = true;
-                dxc_res.output =
-                    "DXC executable '" + options.dxc_path + "' not found. Cannot validate";
+                dxc_res.output = "DXC executable '" + std::string(options.dxc_path) +
+                                 "' not found. Cannot validate";
             }
         }
 
@@ -766,7 +744,7 @@
         bool fxc_found = false;
         if (options.validate || must_validate_fxc) {
             auto fxc = tint::utils::Command::LookPath(
-                options.fxc_path.empty() ? tint::val::kFxcDLLName : options.fxc_path);
+                options.fxc_path.empty() ? tint::val::kFxcDLLName : std::string(options.fxc_path));
 
 #ifdef _WIN32
             if (fxc.Found()) {
@@ -913,7 +891,14 @@
 }  // namespace
 
 int main(int argc, const char** argv) {
-    std::vector<std::string> args(argv, argv + argc);
+    tint::utils::Vector<std::string_view, 8> arguments;
+    for (int i = 1; i < argc; i++) {
+        std::string_view arg(argv[i]);
+        if (!arg.empty()) {
+            arguments.Push(argv[i]);
+        }
+    }
+
     Options options;
 
     tint::SetInternalCompilerErrorReporter(&tint::cmd::TintInternalCompilerErrorReporter);
@@ -928,11 +913,6 @@
     };
 #endif  // TINT_BUILD_WGSL_WRITER
 
-    if (!ParseArgs(args, &options)) {
-        std::cerr << "Failed to parse arguments." << std::endl;
-        return 1;
-    }
-
     struct TransformFactory {
         const char* name;
         /// Build and adds the transform to the transform manager.
@@ -970,22 +950,23 @@
              tint::ast::transform::SubstituteOverride::Config cfg;
 
              std::unordered_map<tint::OverrideId, double> values;
-             values.reserve(options.overrides.size());
+             values.reserve(options.overrides.Count());
 
-             for (const auto& [name, value] : options.overrides) {
+             for (auto override : options.overrides) {
+                 const auto& name = override.key;
+                 const auto& value = override.value;
                  if (name.empty()) {
-                     std::cerr << "empty override name";
+                     std::cerr << "empty override name" << std::endl;
                      return false;
                  }
-                 if (isdigit(name[0])) {
-                     tint::OverrideId id{
-                         static_cast<decltype(tint::OverrideId::value)>(atoi(name.c_str()))};
+                 if (auto num = tint::utils::ParseNumber<decltype(tint::OverrideId::value)>(name)) {
+                     tint::OverrideId id{num.Get()};
                      values.emplace(id, value);
                  } else {
                      auto override_names = inspector.GetNamedOverrideIds();
                      auto it = override_names.find(name);
                      if (it == override_names.end()) {
-                         std::cerr << "unknown override '" << name << "'";
+                         std::cerr << "unknown override '" << name << "'" << std::endl;
                          return false;
                      }
                      values.emplace(it->second, value);
@@ -1007,20 +988,8 @@
         return names.str();
     };
 
-    if (options.show_help) {
-        std::string usage = tint::utils::ReplaceAll(kUsage, "${transforms}", transform_names());
-#if TINT_BUILD_IR
-        usage +=
-            "  --dump-ir                 -- Writes the IR to stdout\n"
-            "  --dump-ir-graph           -- Writes the IR graph to 'tint.dot' as a dot graph\n"
-            "  --use-ir                  -- Use the IR for writers and transforms when possible\n";
-#endif  // TINT_BUILD_IR
-#if TINT_BUILD_SYNTAX_TREE_WRITER
-        usage += "  --dump-ast                -- Writes the AST to stdout\n";
-#endif  // TINT_BUILD_SYNTAX_TREE_WRITER
-
-        std::cout << usage << std::endl;
-        return 0;
+    if (!ParseArgs(arguments, transform_names(), &options)) {
+        return 1;
     }
 
     // Implement output format defaults.
@@ -1056,7 +1025,7 @@
     }
 
 #if TINT_BUILD_SYNTAX_TREE_WRITER
-    if (options.dump_syntax_tree) {
+    if (options.dump_ast) {
         tint::writer::syntax_tree::Options gen_options;
         auto result = tint::writer::syntax_tree::Generate(program.get(), gen_options);
         if (!result.success) {
@@ -1138,12 +1107,12 @@
         }
 
         std::cerr << "Unknown transform: " << name << std::endl;
-        std::cerr << "Available transforms: " << std::endl << transform_names();
+        std::cerr << "Available transforms: " << std::endl << transform_names() << std::endl;
         return false;
     };
 
     // If overrides are provided, add the SubstituteOverride transform.
-    if (!options.overrides.empty()) {
+    if (!options.overrides.IsEmpty()) {
         if (!enable_transform("substitute_override")) {
             return 1;
         }
diff --git a/src/tint/constant/scalar.cc b/src/tint/constant/scalar.cc
index b77cb3b..9a9e551 100644
--- a/src/tint/constant/scalar.cc
+++ b/src/tint/constant/scalar.cc
@@ -14,6 +14,7 @@
 
 #include "src/tint/constant/scalar.h"
 
+TINT_INSTANTIATE_TYPEINFO(tint::constant::ScalarBase);
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<tint::AInt>);
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<tint::AFloat>);
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<tint::i32>);
@@ -21,3 +22,9 @@
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<tint::f16>);
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<tint::f32>);
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Scalar<bool>);
+
+namespace tint::constant {
+
+ScalarBase::~ScalarBase() = default;
+
+}
diff --git a/src/tint/constant/scalar.h b/src/tint/constant/scalar.h
index 474c9ad..23684ec 100644
--- a/src/tint/constant/scalar.h
+++ b/src/tint/constant/scalar.h
@@ -24,9 +24,16 @@
 
 namespace tint::constant {
 
+/// ScalarBase is the base class of all Scalar<T> specializations.
+/// Used for querying whether a value is a scalar type.
+class ScalarBase : public utils::Castable<ScalarBase, Value> {
+  public:
+    ~ScalarBase() override;
+};
+
 /// Scalar holds a single scalar or abstract-numeric value.
 template <typename T>
-class Scalar : public utils::Castable<Scalar<T>, Value> {
+class Scalar : public utils::Castable<Scalar<T>, ScalarBase> {
   public:
     static_assert(!std::is_same_v<UnwrapNumber<T>, T> || std::is_same_v<T, bool>,
                   "T must be a Number or bool");
diff --git a/src/tint/ir/break_if.cc b/src/tint/ir/break_if.cc
index f19fb79..c17ef54 100644
--- a/src/tint/ir/break_if.cc
+++ b/src/tint/ir/break_if.cc
@@ -14,19 +14,23 @@
 
 #include "src/tint/ir/break_if.h"
 
+#include <utility>
+
 #include "src/tint/ir/loop.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::BreakIf);
 
 namespace tint::ir {
 
-BreakIf::BreakIf(Value* condition, ir::Loop* loop)
-    : Base(utils::Empty), condition_(condition), loop_(loop) {
+BreakIf::BreakIf(Value* condition,
+                 ir::Loop* loop,
+                 utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), condition_(condition), loop_(loop) {
     TINT_ASSERT(IR, condition_);
     TINT_ASSERT(IR, loop_);
     condition_->AddUsage(this);
     loop_->AddUsage(this);
-    loop_->Start()->AddInboundBranch(this);
+    loop_->Body()->AddInboundBranch(this);
     loop_->Merge()->AddInboundBranch(this);
 }
 
diff --git a/src/tint/ir/break_if.h b/src/tint/ir/break_if.h
index 47fd4e8..9769378 100644
--- a/src/tint/ir/break_if.h
+++ b/src/tint/ir/break_if.h
@@ -32,7 +32,8 @@
     /// Constructor
     /// @param condition the break condition
     /// @param loop the loop containing the break-if
-    BreakIf(Value* condition, ir::Loop* loop);
+    /// @param args the branch arguments
+    BreakIf(Value* condition, ir::Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
     ~BreakIf() override;
 
     /// @returns the break condition
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 7f2d9c3..4706d59 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -54,8 +54,8 @@
     return ir.values.Create<If>(condition, CreateBlock(), CreateBlock(), CreateBlock());
 }
 
-Loop* Builder::CreateLoop() {
-    return ir.values.Create<Loop>(CreateBlock(), CreateBlock(), CreateBlock());
+Loop* Builder::CreateLoop(utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<Loop>(CreateBlock(), CreateBlock(), CreateBlock(), std::move(args));
 }
 
 Switch* Builder::CreateSwitch(Value* condition) {
@@ -201,31 +201,36 @@
     return ir.values.Create<ir::Var>(type);
 }
 
-ir::Return* Builder::Return(Function* func, utils::VectorRef<Value*> args) {
-    return ir.values.Create<ir::Return>(func, args);
+ir::Return* Builder::Return(Function* func, utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::Return>(func, std::move(args));
 }
 
-ir::NextIteration* Builder::NextIteration(Loop* loop) {
-    return ir.values.Create<ir::NextIteration>(loop);
+ir::NextIteration* Builder::NextIteration(Loop* loop,
+                                          utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::NextIteration>(loop, std::move(args));
 }
 
-ir::BreakIf* Builder::BreakIf(Value* condition, Loop* loop) {
-    return ir.values.Create<ir::BreakIf>(condition, loop);
+ir::BreakIf* Builder::BreakIf(Value* condition,
+                              Loop* loop,
+                              utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::BreakIf>(condition, loop, std::move(args));
 }
 
-ir::Continue* Builder::Continue(Loop* loop) {
-    return ir.values.Create<ir::Continue>(loop);
-}
-ir::ExitSwitch* Builder::ExitSwitch(Switch* sw) {
-    return ir.values.Create<ir::ExitSwitch>(sw);
+ir::Continue* Builder::Continue(Loop* loop, utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::Continue>(loop, std::move(args));
 }
 
-ir::ExitLoop* Builder::ExitLoop(Loop* loop) {
-    return ir.values.Create<ir::ExitLoop>(loop);
+ir::ExitSwitch* Builder::ExitSwitch(Switch* sw,
+                                    utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::ExitSwitch>(sw, std::move(args));
 }
 
-ir::ExitIf* Builder::ExitIf(If* i, utils::VectorRef<Value*> args) {
-    return ir.values.Create<ir::ExitIf>(i, args);
+ir::ExitLoop* Builder::ExitLoop(Loop* loop, utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::ExitLoop>(loop, std::move(args));
+}
+
+ir::ExitIf* Builder::ExitIf(If* i, utils::VectorRef<Value*> args /* = utils::Empty */) {
+    return ir.values.Create<ir::ExitIf>(i, std::move(args));
 }
 
 ir::BlockParam* Builder::BlockParam(const type::Type* type) {
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index b544cb2..092162c 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -84,8 +84,9 @@
     If* CreateIf(Value* condition);
 
     /// Creates a loop flow node
+    /// @param args the branch arguments
     /// @returns the flow node
-    Loop* CreateLoop();
+    Loop* CreateLoop(utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates a switch flow node
     /// @param condition the switch condition
@@ -336,39 +337,46 @@
     /// @param func the function being returned
     /// @param args the return arguments
     /// @returns the instruction
-    ir::Return* Return(Function* func, utils::VectorRef<Value*> args = {});
+    ir::Return* Return(Function* func, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates a loop next iteration instruction
     /// @param loop the loop being iterated
+    /// @param args the branch arguments
     /// @returns the instruction
-    ir::NextIteration* NextIteration(Loop* loop);
+    ir::NextIteration* NextIteration(Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates a loop break-if instruction
     /// @param condition the break condition
     /// @param loop the loop being iterated
+    /// @param args the branch arguments
     /// @returns the instruction
-    ir::BreakIf* BreakIf(Value* condition, Loop* loop);
+    ir::BreakIf* BreakIf(Value* condition,
+                         Loop* loop,
+                         utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates a continue instruction
     /// @param loop the loop being continued
+    /// @param args the branch arguments
     /// @returns the instruction
-    ir::Continue* Continue(Loop* loop);
+    ir::Continue* Continue(Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates an exit switch instruction
     /// @param sw the switch being exited
+    /// @param args the branch arguments
     /// @returns the instruction
-    ir::ExitSwitch* ExitSwitch(Switch* sw);
+    ir::ExitSwitch* ExitSwitch(Switch* sw, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates an exit loop instruction
     /// @param loop the loop being exited
+    /// @param args the branch arguments
     /// @returns the instruction
-    ir::ExitLoop* ExitLoop(Loop* loop);
+    ir::ExitLoop* ExitLoop(Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates an exit if instruction
     /// @param i the if being exited
     /// @param args the branch arguments
     /// @returns the instruction
-    ir::ExitIf* ExitIf(If* i, utils::VectorRef<Value*> args = {});
+    ir::ExitIf* ExitIf(If* i, utils::VectorRef<Value*> args = utils::Empty);
 
     /// Creates a new `BlockParam`
     /// @param type the parameter type
diff --git a/src/tint/ir/continue.cc b/src/tint/ir/continue.cc
index a4511ae..7edebf8 100644
--- a/src/tint/ir/continue.cc
+++ b/src/tint/ir/continue.cc
@@ -14,13 +14,16 @@
 
 #include "src/tint/ir/continue.h"
 
+#include <utility>
+
 #include "src/tint/ir/loop.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Continue);
 
 namespace tint::ir {
 
-Continue::Continue(ir::Loop* loop) : Base(utils::Empty), loop_(loop) {
+Continue::Continue(ir::Loop* loop, utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), loop_(loop) {
     TINT_ASSERT(IR, loop_);
     loop_->AddUsage(this);
     loop_->Continuing()->AddInboundBranch(this);
diff --git a/src/tint/ir/continue.h b/src/tint/ir/continue.h
index aea601a..a954e74 100644
--- a/src/tint/ir/continue.h
+++ b/src/tint/ir/continue.h
@@ -30,7 +30,8 @@
   public:
     /// Constructor
     /// @param loop the loop owning the continue block
-    explicit Continue(ir::Loop* loop);
+    /// @param args the branch arguments
+    explicit Continue(ir::Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
     ~Continue() override;
 
     /// @returns the loop owning the continue block
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index d8e472a..c7155d5 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -122,12 +122,7 @@
     Indent() << "%b" << IdOf(blk) << " = block";
     if (!blk->Params().IsEmpty()) {
         out_ << " (";
-        for (auto* p : blk->Params()) {
-            if (p != blk->Params().Front()) {
-                out_ << ", ";
-            }
-            EmitValue(p);
-        }
+        EmitValueList(blk->Params());
         out_ << ")";
     }
 
@@ -435,7 +430,7 @@
 }
 
 void Disassembler::EmitLoop(const Loop* l) {
-    out_ << "loop [s: %b" << IdOf(l->Start());
+    out_ << "loop [s: %b" << IdOf(l->Body());
 
     if (l->Continuing()->HasBranchTarget()) {
         out_ << ", c: %b" << IdOf(l->Continuing());
@@ -443,11 +438,18 @@
     if (l->Merge()->HasBranchTarget()) {
         out_ << ", m: %b" << IdOf(l->Merge());
     }
-    out_ << "]" << std::endl;
+    out_ << "]";
+
+    if (!l->Args().IsEmpty()) {
+        out_ << " ";
+        EmitValueList(l->Args());
+    }
+
+    out_ << std::endl;
 
     {
         ScopedIndent si(indent_size_);
-        Walk(l->Start());
+        Walk(l->Body());
         out_ << std::endl;
     }
 
@@ -515,38 +517,35 @@
         [&](const ir::ExitSwitch* es) { out_ << "exit_switch %b" << IdOf(es->Switch()->Merge()); },
         [&](const ir::ExitLoop* el) { out_ << "exit_loop %b" << IdOf(el->Loop()->Merge()); },
         [&](const ir::NextIteration* ni) {
-            out_ << "next_iteration %b" << IdOf(ni->Loop()->Start());
+            out_ << "next_iteration %b" << IdOf(ni->Loop()->Body());
         },
         [&](const ir::BreakIf* bi) {
             out_ << "break_if ";
             EmitValue(bi->Condition());
-            out_ << " %b" << IdOf(bi->Loop()->Start());
+            out_ << " %b" << IdOf(bi->Loop()->Body());
         },
         [&](Default) { out_ << "Unknown branch " << b->TypeInfo().name; });
 
     if (!b->Args().IsEmpty()) {
         out_ << " ";
-        for (auto* v : b->Args()) {
-            if (v != b->Args().Front()) {
-                out_ << ", ";
-            }
-            EmitValue(v);
-        }
+        EmitValueList(b->Args());
     }
     out_ << std::endl;
 }
 
-void Disassembler::EmitArgs(const Call* call) {
-    bool first = true;
-    for (const auto* arg : call->Args()) {
-        if (!first) {
+void Disassembler::EmitValueList(tint::utils::VectorRef<const tint::ir::Value*> values) {
+    for (auto* v : values) {
+        if (v != values.Front()) {
             out_ << ", ";
         }
-        first = false;
-        EmitValue(arg);
+        EmitValue(v);
     }
 }
 
+void Disassembler::EmitArgs(const Call* call) {
+    EmitValueList(call->Args());
+}
+
 void Disassembler::EmitBinary(const Binary* b) {
     EmitValueWithType(b);
     out_ << " = ";
diff --git a/src/tint/ir/disassembler.h b/src/tint/ir/disassembler.h
index 9194942..4d5d928 100644
--- a/src/tint/ir/disassembler.h
+++ b/src/tint/ir/disassembler.h
@@ -66,6 +66,7 @@
     void EmitInstruction(const Instruction* inst);
     void EmitValueWithType(const Value* val);
     void EmitValue(const Value* val);
+    void EmitValueList(tint::utils::VectorRef<const tint::ir::Value*> values);
     void EmitArgs(const Call* call);
     void EmitBinary(const Binary* b);
     void EmitUnary(const Unary* b);
diff --git a/src/tint/ir/exit_if.cc b/src/tint/ir/exit_if.cc
index 8b7de7f..16fac7f 100644
--- a/src/tint/ir/exit_if.cc
+++ b/src/tint/ir/exit_if.cc
@@ -14,13 +14,16 @@
 
 #include "src/tint/ir/exit_if.h"
 
+#include <utility>
+
 #include "src/tint/ir/if.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::ExitIf);
 
 namespace tint::ir {
 
-ExitIf::ExitIf(ir::If* i, utils::VectorRef<Value*> args) : Base(args), if_(i) {
+ExitIf::ExitIf(ir::If* i, utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), if_(i) {
     TINT_ASSERT(IR, if_);
     if_->AddUsage(this);
     if_->Merge()->AddInboundBranch(this);
diff --git a/src/tint/ir/exit_if.h b/src/tint/ir/exit_if.h
index 9ba1421..153b714 100644
--- a/src/tint/ir/exit_if.h
+++ b/src/tint/ir/exit_if.h
@@ -31,7 +31,7 @@
     /// Constructor
     /// @param i the if being exited
     /// @param args the branch arguments
-    explicit ExitIf(ir::If* i, utils::VectorRef<Value*> args = {});
+    explicit ExitIf(ir::If* i, utils::VectorRef<Value*> args = utils::Empty);
     ~ExitIf() override;
 
     /// @returns the if being exited
diff --git a/src/tint/ir/exit_loop.cc b/src/tint/ir/exit_loop.cc
index 5fe3910..0effcfc 100644
--- a/src/tint/ir/exit_loop.cc
+++ b/src/tint/ir/exit_loop.cc
@@ -14,13 +14,16 @@
 
 #include "src/tint/ir/exit_loop.h"
 
+#include <utility>
+
 #include "src/tint/ir/loop.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::ExitLoop);
 
 namespace tint::ir {
 
-ExitLoop::ExitLoop(ir::Loop* loop) : Base(utils::Empty), loop_(loop) {
+ExitLoop::ExitLoop(ir::Loop* loop, utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), loop_(loop) {
     TINT_ASSERT(IR, loop_);
     loop_->AddUsage(this);
     loop_->Merge()->AddInboundBranch(this);
diff --git a/src/tint/ir/exit_loop.h b/src/tint/ir/exit_loop.h
index 1df1119..4ef8110 100644
--- a/src/tint/ir/exit_loop.h
+++ b/src/tint/ir/exit_loop.h
@@ -30,7 +30,8 @@
   public:
     /// Constructor
     /// @param loop the loop being exited
-    explicit ExitLoop(ir::Loop* loop);
+    /// @param args the branch arguments
+    explicit ExitLoop(ir::Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
     ~ExitLoop() override;
 
     /// @returns the loop being exited
diff --git a/src/tint/ir/exit_switch.cc b/src/tint/ir/exit_switch.cc
index ba6a178..e9679e5 100644
--- a/src/tint/ir/exit_switch.cc
+++ b/src/tint/ir/exit_switch.cc
@@ -14,13 +14,16 @@
 
 #include "src/tint/ir/exit_switch.h"
 
+#include <utility>
+
 #include "src/tint/ir/switch.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::ExitSwitch);
 
 namespace tint::ir {
 
-ExitSwitch::ExitSwitch(ir::Switch* sw) : Base(utils::Empty), switch_(sw) {
+ExitSwitch::ExitSwitch(ir::Switch* sw, utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), switch_(sw) {
     TINT_ASSERT(IR, switch_);
     switch_->AddUsage(this);
     switch_->Merge()->AddInboundBranch(this);
diff --git a/src/tint/ir/exit_switch.h b/src/tint/ir/exit_switch.h
index 6b406fe..31a23e2 100644
--- a/src/tint/ir/exit_switch.h
+++ b/src/tint/ir/exit_switch.h
@@ -30,7 +30,8 @@
   public:
     /// Constructor
     /// @param sw the switch being exited
-    explicit ExitSwitch(ir::Switch* sw);
+    /// @param args the branch arguments
+    explicit ExitSwitch(ir::Switch* sw, utils::VectorRef<Value*> args = utils::Empty);
     ~ExitSwitch() override;
 
     /// @returns the switch being exited
diff --git a/src/tint/ir/from_program.cc b/src/tint/ir/from_program.cc
index 3dc52e1..4a442ee 100644
--- a/src/tint/ir/from_program.cc
+++ b/src/tint/ir/from_program.cc
@@ -642,7 +642,7 @@
 
         {
             ControlStackScope scope(this, loop_inst);
-            current_block_ = loop_inst->Start();
+            current_block_ = loop_inst->Body();
 
             // The loop doesn't use EmitBlock because it needs the scope stack to not get popped
             // until after the continuing block.
@@ -691,7 +691,7 @@
         {
             ControlStackScope scope(this, loop_inst);
 
-            current_block_ = loop_inst->Start();
+            current_block_ = loop_inst->Body();
 
             // Emit the while condition into the Start().target of the loop
             auto reg = EmitExpression(stmt->condition);
@@ -737,7 +737,7 @@
         {
             ControlStackScope scope(this, loop_inst);
 
-            current_block_ = loop_inst->Start();
+            current_block_ = loop_inst->Body();
 
             if (stmt->condition) {
                 // Emit the condition into the target target of the loop
diff --git a/src/tint/ir/from_program_test.cc b/src/tint/ir/from_program_test.cc
index 8f5348b..404b6c3 100644
--- a/src/tint/ir/from_program_test.cc
+++ b/src/tint/ir/from_program_test.cc
@@ -342,7 +342,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(0u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
 
@@ -379,7 +379,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -437,7 +437,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -511,7 +511,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(1u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -563,7 +563,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -601,7 +601,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Merge()->InboundBranches().Length());
 
@@ -632,7 +632,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, loop_flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(0u, loop_flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, loop_flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(2u, loop_flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -799,13 +799,13 @@
     auto m = res.Move();
     auto* flow = FindSingleValue<ir::Loop>(m);
 
-    ASSERT_NE(flow->Start()->Branch(), nullptr);
-    ASSERT_TRUE(flow->Start()->Branch()->Is<ir::If>());
-    auto* if_flow = flow->Start()->Branch()->As<ir::If>();
+    ASSERT_NE(flow->Body()->Branch(), nullptr);
+    ASSERT_TRUE(flow->Body()->Branch()->Is<ir::If>());
+    auto* if_flow = flow->Body()->Branch()->As<ir::If>();
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -860,13 +860,13 @@
     auto m = res.Move();
     auto* flow = FindSingleValue<ir::Loop>(m);
 
-    ASSERT_NE(flow->Start()->Branch(), nullptr);
-    ASSERT_TRUE(flow->Start()->Branch()->Is<ir::If>());
-    auto* if_flow = flow->Start()->Branch()->As<ir::If>();
+    ASSERT_NE(flow->Body()->Branch(), nullptr);
+    ASSERT_TRUE(flow->Body()->Branch()->Is<ir::If>());
+    auto* if_flow = flow->Body()->Branch()->As<ir::If>();
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(1u, flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(1u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -934,13 +934,13 @@
     auto m = res.Move();
     auto* flow = FindSingleValue<ir::Loop>(m);
 
-    ASSERT_NE(flow->Start()->Branch(), nullptr);
-    ASSERT_TRUE(flow->Start()->Branch()->Is<ir::If>());
-    auto* if_flow = flow->Start()->Branch()->As<ir::If>();
+    ASSERT_NE(flow->Body()->Branch(), nullptr);
+    ASSERT_TRUE(flow->Body()->Branch()->Is<ir::If>());
+    auto* if_flow = flow->Body()->Branch()->As<ir::If>();
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(2u, flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(2u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(2u, flow->Merge()->InboundBranches().Length());
     EXPECT_EQ(1u, if_flow->True()->InboundBranches().Length());
@@ -962,7 +962,7 @@
 
     ASSERT_EQ(1u, m.functions.Length());
 
-    EXPECT_EQ(0u, flow->Start()->InboundBranches().Length());
+    EXPECT_EQ(0u, flow->Body()->InboundBranches().Length());
     EXPECT_EQ(0u, flow->Continuing()->InboundBranches().Length());
     EXPECT_EQ(1u, flow->Merge()->InboundBranches().Length());
 
diff --git a/src/tint/ir/loop.cc b/src/tint/ir/loop.cc
index bd697bf..5b3e603 100644
--- a/src/tint/ir/loop.cc
+++ b/src/tint/ir/loop.cc
@@ -14,13 +14,18 @@
 
 #include "src/tint/ir/loop.h"
 
+#include <utility>
+
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Loop);
 
 namespace tint::ir {
 
-Loop::Loop(ir::Block* s, ir::Block* c, ir::Block* m)
-    : Base(utils::Empty), start_(s), continuing_(c), merge_(m) {
-    TINT_ASSERT(IR, start_);
+Loop::Loop(ir::Block* b,
+           ir::Block* c,
+           ir::Block* m,
+           utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), body_(b), continuing_(c), merge_(m) {
+    TINT_ASSERT(IR, body_);
     TINT_ASSERT(IR, continuing_);
     TINT_ASSERT(IR, merge_);
 }
diff --git a/src/tint/ir/loop.h b/src/tint/ir/loop.h
index aadfd30..0ac9463 100644
--- a/src/tint/ir/loop.h
+++ b/src/tint/ir/loop.h
@@ -24,16 +24,17 @@
 class Loop : public utils::Castable<Loop, Branch> {
   public:
     /// Constructor
-    /// @param s the start block
+    /// @param b the body block
     /// @param c the continuing block
     /// @param m the merge block
-    Loop(ir::Block* s, ir::Block* c, ir::Block* m);
+    /// @param args the branch arguments
+    Loop(ir::Block* b, ir::Block* c, ir::Block* m, utils::VectorRef<Value*> args = utils::Empty);
     ~Loop() override;
 
     /// @returns the switch start branch
-    const ir::Block* Start() const { return start_; }
+    const ir::Block* Body() const { return body_; }
     /// @returns the switch start branch
-    ir::Block* Start() { return start_; }
+    ir::Block* Body() { return body_; }
 
     /// @returns the switch continuing branch
     const ir::Block* Continuing() const { return continuing_; }
@@ -46,7 +47,7 @@
     ir::Block* Merge() { return merge_; }
 
   private:
-    ir::Block* start_ = nullptr;
+    ir::Block* body_ = nullptr;
     ir::Block* continuing_ = nullptr;
     ir::Block* merge_ = nullptr;
 };
diff --git a/src/tint/ir/next_iteration.cc b/src/tint/ir/next_iteration.cc
index 0c021eb..1e057d0 100644
--- a/src/tint/ir/next_iteration.cc
+++ b/src/tint/ir/next_iteration.cc
@@ -14,16 +14,19 @@
 
 #include "src/tint/ir/next_iteration.h"
 
+#include <utility>
+
 #include "src/tint/ir/loop.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::NextIteration);
 
 namespace tint::ir {
 
-NextIteration::NextIteration(ir::Loop* loop) : Base(utils::Empty), loop_(loop) {
+NextIteration::NextIteration(ir::Loop* loop, utils::VectorRef<Value*> args /* = utils::Empty */)
+    : Base(std::move(args)), loop_(loop) {
     TINT_ASSERT(IR, loop_);
     loop_->AddUsage(this);
-    loop_->Start()->AddInboundBranch(this);
+    loop_->Body()->AddInboundBranch(this);
 }
 
 NextIteration::~NextIteration() = default;
diff --git a/src/tint/ir/next_iteration.h b/src/tint/ir/next_iteration.h
index f1211e3..064ad3f 100644
--- a/src/tint/ir/next_iteration.h
+++ b/src/tint/ir/next_iteration.h
@@ -30,7 +30,8 @@
   public:
     /// Constructor
     /// @param loop the loop being iterated
-    explicit NextIteration(ir::Loop* loop);
+    /// @param args the branch arguments
+    explicit NextIteration(ir::Loop* loop, utils::VectorRef<Value*> args = utils::Empty);
     ~NextIteration() override;
 
     /// @returns the loop being iterated
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index c181f02..caf3e37 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -242,18 +242,25 @@
     return count;
 }
 
+/// Common data for constant conversion.
+struct ConvertContext {
+    ProgramBuilder& builder;
+    const Source& source;
+    bool use_runtime_semantics;
+};
+
+/// Converts the constant scalar value to the target type.
+/// @returns the converted scalar, or nullptr on error.
 template <typename T>
-ConstEval::Result ScalarConvert(const constant::Scalar<T>* scalar,
-                                ProgramBuilder& builder,
-                                const type::Type* target_ty,
-                                const Source& source,
-                                bool use_runtime_semantics) {
+const constant::ScalarBase* ScalarConvert(const constant::Scalar<T>* scalar,
+                                          const type::Type* target_ty,
+                                          ConvertContext& ctx) {
     TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
     if (target_ty == scalar->type) {
         // If the types are identical, then no conversion is needed.
         return scalar;
     }
-    return ZeroTypeDispatch(target_ty, [&](auto zero_to) -> ConstEval::Result {
+    return ZeroTypeDispatch(target_ty, [&](auto zero_to) -> const constant::ScalarBase* {
         // `value` is the source value.
         // `FROM` is the source type.
         // `TO` is the target type.
@@ -261,183 +268,219 @@
         using FROM = T;
         if constexpr (std::is_same_v<TO, bool>) {
             // [x -> bool]
-            return builder.constants.Get<constant::Scalar<TO>>(target_ty,
-                                                               !scalar->IsPositiveZero());
+            return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                   !scalar->IsPositiveZero());
         } else if constexpr (std::is_same_v<FROM, bool>) {
             // [bool -> x]
-            return builder.constants.Get<constant::Scalar<TO>>(target_ty,
-                                                               TO(scalar->value ? 1 : 0));
+            return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                   TO(scalar->value ? 1 : 0));
         } else if (auto conv = CheckedConvert<TO>(scalar->value)) {
             // Conversion success
-            return builder.constants.Get<constant::Scalar<TO>>(target_ty, conv.Get());
+            return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty, conv.Get());
             // --- Below this point are the failure cases ---
         } else if constexpr (IsAbstract<FROM>) {
             // [abstract-numeric -> x] - materialization failure
             auto msg = OverflowErrorMessage(scalar->value, target_ty->FriendlyName());
-            if (use_runtime_semantics) {
-                builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg, source);
+            if (ctx.use_runtime_semantics) {
+                ctx.builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg,
+                                                      ctx.source);
                 switch (conv.Failure()) {
                     case ConversionFailure::kExceedsNegativeLimit:
-                        return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                        return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                               TO::Lowest());
                     case ConversionFailure::kExceedsPositiveLimit:
-                        return builder.constants.Get<constant::Scalar<TO>>(target_ty,
-                                                                           TO::Highest());
+                        return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                               TO::Highest());
                 }
             } else {
-                builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, source);
-                return utils::Failure;
+                ctx.builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, ctx.source);
+                return nullptr;
             }
         } else if constexpr (IsFloatingPoint<TO>) {
             // [x -> floating-point] - number not exactly representable
             // https://www.w3.org/TR/WGSL/#floating-point-conversion
             auto msg = OverflowErrorMessage(scalar->value, target_ty->FriendlyName());
-            if (use_runtime_semantics) {
-                builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg, source);
+            if (ctx.use_runtime_semantics) {
+                ctx.builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg,
+                                                      ctx.source);
                 switch (conv.Failure()) {
                     case ConversionFailure::kExceedsNegativeLimit:
-                        return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                        return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                               TO::Lowest());
                     case ConversionFailure::kExceedsPositiveLimit:
-                        return builder.constants.Get<constant::Scalar<TO>>(target_ty,
-                                                                           TO::Highest());
+                        return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                               TO::Highest());
                 }
             } else {
-                builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, source);
-                return utils::Failure;
+                ctx.builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, ctx.source);
+                return nullptr;
             }
         } else if constexpr (IsFloatingPoint<FROM>) {
             // [floating-point -> integer] - number not exactly representable
             // https://www.w3.org/TR/WGSL/#floating-point-conversion
             switch (conv.Failure()) {
                 case ConversionFailure::kExceedsNegativeLimit:
-                    return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                    return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
                 case ConversionFailure::kExceedsPositiveLimit:
-                    return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Highest());
+                    return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                           TO::Highest());
             }
         } else if constexpr (IsIntegral<FROM>) {
             // [integer -> integer] - number not exactly representable
             // Static cast
-            return builder.constants.Get<constant::Scalar<TO>>(target_ty,
-                                                               static_cast<TO>(scalar->value));
+            return ctx.builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                   static_cast<TO>(scalar->value));
         }
-        return nullptr;  // Expression is not constant.
+        TINT_UNREACHABLE(Resolver, ctx.builder.Diagnostics()) << "Expression is not constant";
+        return nullptr;
     });
     TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
 }
 
-// Forward declare
-ConstEval::Result ConvertInternal(const constant::Value* c,
-                                  ProgramBuilder& builder,
-                                  const type::Type* target_ty,
-                                  const Source& source,
-                                  bool use_runtime_semantics);
+/// Converts the constant value to the target type.
+/// @returns the converted value, or nullptr on error.
+const constant::Value* ConvertInternal(const constant::Value* root_value,
+                                       const type::Type* root_target_ty,
+                                       ConvertContext& ctx) {
+    struct ActionConvert {
+        const constant::Value* value = nullptr;
+        const type::Type* target_ty = nullptr;
+    };
+    struct ActionBuildSplat {
+        size_t count = 0;
+        const type::Type* type = nullptr;
+    };
+    struct ActionBuildComposite {
+        size_t count = 0;
+        const type::Type* type = nullptr;
+    };
+    using Action = std::variant<ActionConvert, ActionBuildSplat, ActionBuildComposite>;
 
-ConstEval::Result CompositeConvert(const constant::Value* value,
-                                   ProgramBuilder& builder,
-                                   const type::Type* target_ty,
-                                   const Source& source,
-                                   bool use_runtime_semantics) {
-    const size_t el_count = value->NumElements();
+    utils::Vector<Action, 8> pending{
+        ActionConvert{root_value, root_target_ty},
+    };
 
-    // Convert each of the composite element types.
-    utils::Vector<const constant::Value*, 4> conv_els;
-    conv_els.Reserve(el_count);
+    utils::Vector<const constant::Value*, 32> value_stack;
 
-    std::function<const type::Type*(size_t idx)> target_el_ty;
-    if (auto* str = target_ty->As<type::Struct>()) {
-        if (TINT_UNLIKELY(str->Members().Length() != el_count)) {
-            TINT_ICE(Resolver, builder.Diagnostics())
-                << "const-eval conversion of structure has mismatched element counts";
-            return utils::Failure;
+    while (!pending.IsEmpty()) {
+        auto next = pending.Pop();
+
+        if (auto* build = std::get_if<ActionBuildSplat>(&next)) {
+            TINT_ASSERT(Resolver, value_stack.Length() >= 1);
+            auto* el = value_stack.Pop();
+            value_stack.Push(ctx.builder.constants.Splat(build->type, el, build->count));
+            continue;
         }
-        target_el_ty = [str](size_t idx) { return str->Members()[idx]->Type(); };
-    } else {
-        auto* el_ty = type::Type::ElementOf(target_ty);
-        target_el_ty = [el_ty](size_t) { return el_ty; };
-    }
 
-    for (size_t i = 0; i < el_count; i++) {
-        auto* el = value->Index(i);
-        auto conv_el = ConvertInternal(el, builder, target_el_ty(conv_els.Length()), source,
-                                       use_runtime_semantics);
-        if (!conv_el) {
-            return utils::Failure;
+        if (auto* build = std::get_if<ActionBuildComposite>(&next)) {
+            TINT_ASSERT(Resolver, value_stack.Length() >= build->count);
+            // Take build->count elements off the top of value_stack
+            // Note: The values are ordered with the first composite value at the top of the stack.
+            utils::Vector<const constant::Value*, 32> elements;
+            elements.Reserve(build->count);
+            for (size_t i = 0; i < build->count; i++) {
+                elements.Push(value_stack.Pop());
+            }
+            // Build the composite
+            value_stack.Push(ctx.builder.constants.Composite(build->type, std::move(elements)));
+            continue;
         }
-        if (!conv_el.Get()) {
+
+        auto* convert = std::get_if<ActionConvert>(&next);
+
+        bool ok = Switch(
+            convert->value,
+            [&](const constant::ScalarBase* scalar) {
+                auto* converted = Switch(
+                    scalar,
+                    [&](const constant::Scalar<tint::AFloat>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<tint::AInt>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<tint::u32>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<tint::i32>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<tint::f32>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<tint::f16>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    },
+                    [&](const constant::Scalar<bool>* val) {
+                        return ScalarConvert(val, convert->target_ty, ctx);
+                    });
+                if (!converted) {
+                    return false;
+                }
+                value_stack.Push(converted);
+                return true;
+            },
+            [&](const constant::Splat* splat) {
+                const type::Type* target_el_ty = nullptr;
+                if (auto* str = convert->target_ty->As<type::Struct>()) {
+                    // Structure conversion.
+                    auto members = str->Members();
+                    target_el_ty = members[0]->Type();
+
+                    // Structures can only be converted during materialization. The user cannot
+                    // declare the target structure type, so each member type must be the same
+                    // default materialization type.
+                    for (size_t i = 1; i < members.Length(); i++) {
+                        if (members[i]->Type() != target_el_ty) {
+                            TINT_ICE(Resolver, ctx.builder.Diagnostics())
+                                << "inconsistent target struct member types for SplatConvert";
+                            return false;
+                        }
+                    }
+                } else {
+                    target_el_ty = type::Type::ElementOf(convert->target_ty);
+                }
+
+                // Convert the single splatted element type.
+                pending.Push(ActionBuildSplat{splat->count, convert->target_ty});
+                pending.Push(ActionConvert{splat->el, target_el_ty});
+                return true;
+            },
+            [&](const constant::Composite* composite) {
+                const size_t el_count = composite->NumElements();
+
+                // Build the new composite from the converted element types.
+                pending.Push(ActionBuildComposite{el_count, convert->target_ty});
+
+                if (auto* str = convert->target_ty->As<type::Struct>()) {
+                    if (TINT_UNLIKELY(str->Members().Length() != el_count)) {
+                        TINT_ICE(Resolver, ctx.builder.Diagnostics())
+                            << "const-eval conversion of structure has mismatched element counts";
+                        return false;
+                    }
+                    // Struct composites can have different types for each member.
+                    auto members = str->Members();
+                    for (size_t i = 0; i < el_count; i++) {
+                        pending.Push(ActionConvert{composite->Index(i), members[i]->Type()});
+                    }
+                } else {
+                    // Non-struct composites have the same type for all elements.
+                    auto* el_ty = type::Type::ElementOf(convert->target_ty);
+                    for (size_t i = 0; i < el_count; i++) {
+                        auto* el = composite->Index(i);
+                        pending.Push(ActionConvert{el, el_ty});
+                    }
+                }
+
+                return true;
+            });
+        if (!ok) {
             return nullptr;
         }
-        conv_els.Push(conv_el.Get());
     }
-    return builder.constants.Composite(target_ty, std::move(conv_els));
-}
 
-ConstEval::Result SplatConvert(const constant::Splat* splat,
-                               ProgramBuilder& builder,
-                               const type::Type* target_ty,
-                               const Source& source,
-                               bool use_runtime_semantics) {
-    const type::Type* target_el_ty = nullptr;
-    if (auto* str = target_ty->As<type::Struct>()) {
-        // Structure conversion.
-        auto members = str->Members();
-        target_el_ty = members[0]->Type();
-
-        // Structures can only be converted during materialization. The user cannot declare the
-        // target structure type, so each member type must be the same default materialization type.
-        for (size_t i = 1; i < members.Length(); i++) {
-            if (members[i]->Type() != target_el_ty) {
-                TINT_ICE(Resolver, builder.Diagnostics())
-                    << "inconsistent target struct member types for SplatConvert";
-                return utils::Failure;
-            }
-        }
-    } else {
-        target_el_ty = type::Type::ElementOf(target_ty);
-    }
-    // Convert the single splatted element type.
-    auto conv_el = ConvertInternal(splat->el, builder, target_el_ty, source, use_runtime_semantics);
-    if (!conv_el) {
-        return utils::Failure;
-    }
-    if (!conv_el.Get()) {
-        return nullptr;
-    }
-    return builder.constants.Splat(target_ty, conv_el.Get(), splat->count);
-}
-
-ConstEval::Result ConvertInternal(const constant::Value* c,
-                                  ProgramBuilder& builder,
-                                  const type::Type* target_ty,
-                                  const Source& source,
-                                  bool use_runtime_semantics) {
-    return Switch(
-        c,
-        [&](const constant::Scalar<tint::AFloat>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<tint::AInt>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<tint::u32>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<tint::i32>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<tint::f32>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<tint::f16>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Scalar<bool>* val) {
-            return ScalarConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Splat* val) {
-            return SplatConvert(val, builder, target_ty, source, use_runtime_semantics);
-        },
-        [&](const constant::Composite* val) {
-            return CompositeConvert(val, builder, target_ty, source, use_runtime_semantics);
-        });
+    TINT_ASSERT(Resolver, value_stack.Length() == 1);
+    return value_stack.Pop();
 }
 
 namespace detail {
@@ -3752,7 +3795,9 @@
     if (value->Type() == target_ty) {
         return value;
     }
-    return ConvertInternal(value, builder, target_ty, source, use_runtime_semantics_);
+    ConvertContext ctx{builder, source, use_runtime_semantics_};
+    auto* converted = ConvertInternal(value, target_ty, ctx);
+    return converted ? Result(converted) : utils::Failure;
 }
 
 void ConstEval::AddError(const std::string& msg, const Source& source) const {
diff --git a/src/tint/type/manager.cc b/src/tint/type/manager.cc
index 0782633..4a98045 100644
--- a/src/tint/type/manager.cc
+++ b/src/tint/type/manager.cc
@@ -16,6 +16,7 @@
 
 #include "src/tint/type/abstract_float.h"
 #include "src/tint/type/abstract_int.h"
+#include "src/tint/type/array.h"
 #include "src/tint/type/bool.h"
 #include "src/tint/type/f16.h"
 #include "src/tint/type/f32.h"
@@ -123,4 +124,32 @@
 const type::Matrix* Manager::mat4x4(const type::Type* inner) {
     return mat(inner, 4, 4);
 }
+
+const type::Array* Manager::array(const type::Type* elem_ty,
+                                  uint32_t count,
+                                  uint32_t stride /* = 0*/) {
+    if (stride == 0) {
+        stride = elem_ty->Align();
+    }
+    return Get<type::Array>(/* element type */ elem_ty,
+                            /* element count */ Get<ConstantArrayCount>(count),
+                            /* array alignment */ elem_ty->Align(),
+                            /* array size */ count * stride,
+                            /* element stride */ stride,
+                            /* implicit stride */ elem_ty->Align());
+}
+
+const type::Array* Manager::runtime_array(const type::Type* elem_ty, uint32_t stride /* = 0 */) {
+    if (stride == 0) {
+        stride = elem_ty->Align();
+    }
+    return Get<type::Array>(
+        /* element type */ elem_ty,
+        /* element count */ Get<RuntimeArrayCount>(),
+        /* array alignment */ elem_ty->Align(),
+        /* array size */ stride,
+        /* element stride */ stride,
+        /* implicit stride */ elem_ty->Align());
+}
+
 }  // namespace tint::type
diff --git a/src/tint/type/manager.h b/src/tint/type/manager.h
index b4fa560..6492e53 100644
--- a/src/tint/type/manager.h
+++ b/src/tint/type/manager.h
@@ -26,6 +26,7 @@
 namespace tint::type {
 class AbstractFloat;
 class AbstractInt;
+class Array;
 class Bool;
 class F16;
 class F32;
@@ -182,6 +183,17 @@
     /// @returns the matrix type
     const type::Matrix* mat4x4(const type::Type* inner);
 
+    /// @param elem_ty the array element type
+    /// @param count the array element count
+    /// @param stride the optional array element stride
+    /// @returns the array type
+    const type::Array* array(const type::Type* elem_ty, uint32_t count, uint32_t stride = 0);
+
+    /// @param elem_ty the array element type
+    /// @param stride the optional array element stride
+    /// @returns the runtime array type
+    const type::Array* runtime_array(const type::Type* elem_ty, uint32_t stride = 0);
+
     /// @returns an iterator to the beginning of the types
     TypeIterator begin() const { return types_.begin(); }
     /// @returns an iterator to the end of the types
diff --git a/src/tint/utils/cli.cc b/src/tint/utils/cli.cc
new file mode 100644
index 0000000..2d3fd52
--- /dev/null
+++ b/src/tint/utils/cli.cc
@@ -0,0 +1,182 @@
+// 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/utils/cli.h"
+
+#include <algorithm>
+#include <sstream>
+#include <utility>
+
+#include "src/tint/utils/hashset.h"
+#include "src/tint/utils/string.h"
+#include "src/tint/utils/transform.h"
+
+namespace tint::utils::cli {
+
+Option::~Option() = default;
+
+void OptionSet::ShowHelp(std::ostream& s_out) {
+    utils::Vector<const Option*, 32> sorted_options;
+    for (auto* opt : options.Objects()) {
+        sorted_options.Push(opt);
+    }
+    sorted_options.Sort([](const Option* a, const Option* b) { return a->Name() < b->Name(); });
+
+    struct CmdInfo {
+        std::string left;
+        std::string right;
+    };
+    utils::Vector<CmdInfo, 64> cmd_infos;
+
+    for (auto* opt : sorted_options) {
+        {
+            std::stringstream left, right;
+            left << "--" << opt->Name();
+            if (auto param = opt->Parameter(); !param.empty()) {
+                left << " <" << param << ">";
+            }
+            right << opt->Description();
+            if (auto def = opt->DefaultValue(); !def.empty()) {
+                right << "\ndefault: " << def;
+            }
+            cmd_infos.Push({left.str(), right.str()});
+        }
+        if (auto alias = opt->Alias(); !alias.empty()) {
+            std::stringstream left, right;
+            left << "--" << alias;
+            right << "alias for --" << opt->Name();
+            cmd_infos.Push({left.str(), right.str()});
+        }
+        if (auto sn = opt->ShortName(); !sn.empty()) {
+            std::stringstream left, right;
+            left << " -" << sn;
+            right << "short name for --" << opt->Name();
+            cmd_infos.Push({left.str(), right.str()});
+        }
+    }
+
+    const size_t kMaxRightOffset = 30;
+
+    // Measure
+    size_t left_width = 0;
+    for (auto& cmd_info : cmd_infos) {
+        for (auto line : utils::Split(cmd_info.left, "\n")) {
+            if (line.length() < kMaxRightOffset) {
+                left_width = std::max(left_width, line.length());
+            }
+        }
+    }
+
+    // Print
+    left_width = std::min(left_width, kMaxRightOffset);
+
+    auto pad = [&](size_t n) {
+        while (n--) {
+            s_out << " ";
+        }
+    };
+
+    for (auto& cmd_info : cmd_infos) {
+        auto left_lines = utils::Split(cmd_info.left, "\n");
+        auto right_lines = utils::Split(cmd_info.right, "\n");
+
+        size_t num_lines = std::max(left_lines.Length(), right_lines.Length());
+        for (size_t i = 0; i < num_lines; i++) {
+            bool has_left = (i < left_lines.Length()) && !left_lines[i].empty();
+            bool has_right = (i < right_lines.Length()) && !right_lines[i].empty();
+            if (has_left) {
+                s_out << left_lines[i];
+                if (has_right) {
+                    if (left_lines[i].length() > left_width) {
+                        // Left exceeds column width.
+                        // Insert a new line and indent to the right
+                        s_out << std::endl;
+                        pad(left_width);
+                    } else {
+                        pad(left_width - left_lines[i].length());
+                    }
+                }
+            } else if (has_right) {
+                pad(left_width);
+            }
+            if (has_right) {
+                s_out << "  " << right_lines[i];
+            }
+            s_out << std::endl;
+        }
+    }
+}
+
+Result<OptionSet::Unconsumed> OptionSet::Parse(std::ostream& s_err,
+                                               utils::VectorRef<std::string_view> arguments_raw) {
+    // Build a map of name to option, and set defaults
+    utils::Hashmap<std::string, Option*, 32> options_by_name;
+    for (auto* opt : options.Objects()) {
+        opt->SetDefault();
+        for (auto name : {opt->Name(), opt->Alias(), opt->ShortName()}) {
+            if (!name.empty() && !options_by_name.Add(name, opt)) {
+                s_err << "multiple options with name '" << name << "'" << std::endl;
+                return Failure;
+            }
+        }
+    }
+
+    // Canonicalize arguments by splitting '--foo=x' into '--foo' 'x'.
+    std::deque<std::string_view> arguments;
+    for (auto arg : arguments_raw) {
+        if (HasPrefix(arg, "-")) {
+            if (auto eq_idx = arg.find("="); eq_idx != std::string_view::npos) {
+                arguments.push_back(arg.substr(0, eq_idx));
+                arguments.push_back(arg.substr(eq_idx + 1));
+                continue;
+            }
+        }
+        arguments.push_back(arg);
+    }
+
+    utils::Hashset<Option*, 8> options_parsed;
+
+    Unconsumed unconsumed;
+    while (!arguments.empty()) {
+        auto arg = std::move(arguments.front());
+        arguments.pop_front();
+        auto name = TrimLeft(arg, [](char c) { return c == '-'; });
+        if (arg == name || name.length() == 0) {
+            unconsumed.Push(arg);
+            continue;
+        }
+        if (auto opt = options_by_name.Find(name)) {
+            if (auto err = (*opt)->Parse(arguments); !err.empty()) {
+                s_err << err << std::endl;
+                return Failure;
+            }
+        } else {
+            s_err << "unknown flag: " << arg << std::endl;
+            auto names = options_by_name.Keys();
+            auto alternatives =
+                Transform(names, [&](const std::string& s) { return std::string_view(s); });
+            utils::StringStream ss;
+            utils::SuggestAlternativeOptions opts;
+            opts.prefix = "--";
+            opts.list_possible_values = false;
+            SuggestAlternatives(arg, alternatives.Slice(), ss, opts);
+            s_err << ss.str();
+            return Failure;
+        }
+    }
+
+    return unconsumed;
+}
+
+}  // namespace tint::utils::cli
diff --git a/src/tint/utils/cli.h b/src/tint/utils/cli.h
new file mode 100644
index 0000000..c1c3030
--- /dev/null
+++ b/src/tint/utils/cli.h
@@ -0,0 +1,410 @@
+// 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_UTILS_CLI_H_
+#define SRC_TINT_UTILS_CLI_H_
+
+#include <deque>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "src/tint/utils/block_allocator.h"
+#include "src/tint/utils/compiler_macros.h"
+#include "src/tint/utils/parse_num.h"
+#include "src/tint/utils/result.h"
+#include "src/tint/utils/string.h"
+#include "src/tint/utils/vector.h"
+
+namespace tint::utils::cli {
+
+/// Alias is a fluent-constructor helper for Options
+struct Alias {
+    /// The alias to apply to an Option
+    std::string value;
+
+    /// @param option the option to apply the alias to
+    template <typename T>
+    void Apply(T& option) {
+        option.alias = value;
+    }
+};
+
+/// ShortName is a fluent-constructor helper for Options
+struct ShortName {
+    /// The short-name to apply to an Option
+    std::string value;
+
+    /// @param option the option to apply the short name to
+    template <typename T>
+    void Apply(T& option) {
+        option.short_name = value;
+    }
+};
+
+/// Parameter is a fluent-constructor helper for Options
+struct Parameter {
+    /// The parameter name to apply to an Option
+    std::string value;
+
+    /// @param option the option to apply the parameter name to
+    template <typename T>
+    void Apply(T& option) {
+        option.parameter = value;
+    }
+};
+
+/// Default is a fluent-constructor helper for Options
+template <typename T>
+struct Default {
+    /// The default value to apply to an Option
+    T value;
+
+    /// @param option the option to apply the default value to
+    template <typename O>
+    void Apply(O& option) {
+        option.default_value = value;
+    }
+};
+
+/// Deduction guide for Default
+template <typename T>
+Default(T) -> Default<T>;
+
+/// Option is the base class for all command line options
+class Option {
+  public:
+    /// An alias to std::string, used to hold error messages.
+    using Error = std::string;
+
+    /// Destructor
+    virtual ~Option();
+
+    /// @return the name of the option, without any leading hyphens.
+    /// Example: 'help'
+    virtual std::string Name() const = 0;
+
+    /// @return the alias name of the option, without any leading hyphens. (optional)
+    /// Example: 'flag'
+    virtual std::string Alias() const = 0;
+
+    /// @return the shorter name of the option, without any leading hyphens. (optional)
+    /// Example: 'h'
+    virtual std::string ShortName() const = 0;
+
+    /// @return a string describing the parameter that the option expects.
+    /// Empty represents no expected parameter.
+    virtual std::string Parameter() const = 0;
+
+    /// @return a description of the option.
+    /// Example: 'shows this message'
+    virtual std::string Description() const = 0;
+
+    /// @return the default value of the option, or an empty string if there is no default value.
+    virtual std::string DefaultValue() const = 0;
+
+    /// Sets the option value to the default (called before arguments are parsed)
+    virtual void SetDefault() = 0;
+
+    /// Parses the option's arguments from the list of command line arguments, removing the consumed
+    /// arguments before returning. @p arguments will have already had the option's name consumed
+    /// before calling.
+    /// @param arguments the queue of unprocessed arguments. Parse() may take from the front of @p
+    /// arguments.
+    /// @return empty Error if successfully parsed, otherwise an error string.
+    virtual Error Parse(std::deque<std::string_view>& arguments) = 0;
+
+  protected:
+    /// An empty string, used to represent no-error.
+    static constexpr const char* Success = "";
+
+    /// @param expected the expected value(s) for the option
+    /// @return an Error message for a missing argument
+    Error ErrMissingArgument(std::string expected) const {
+        Error err = "missing value for option '--" + Name() + "'";
+        if (!expected.empty()) {
+            err += "Expected: " + expected;
+        }
+        return err;
+    }
+
+    /// @param got the argument value provided
+    /// @param reason the reason the argument is invalid (optional)
+    /// @return an Error message for an invalid argument
+    Error ErrInvalidArgument(std::string_view got, std::string reason) const {
+        Error err = "invalid value '" + std::string(got) + "' for option '--" + Name() + "'";
+        if (!reason.empty()) {
+            err += "\n" + reason;
+        }
+        return err;
+    }
+};
+
+/// OptionSet is a set of Options, which can parse the command line arguments.
+class OptionSet {
+  public:
+    /// Unconsumed is a list of unconsumed command line arguments
+    using Unconsumed = utils::Vector<std::string_view, 8>;
+
+    /// Constructs and returns a new Option to be owned by the OptionSet
+    /// @tparam T the Option type
+    /// @tparam ARGS the constructor argument types
+    /// @param args the constructor arguments
+    /// @return the constructed Option
+    template <typename T, typename... ARGS>
+    T& Add(ARGS&&... args) {
+        return *options.Create<T>(std::forward<ARGS>(args)...);
+    }
+
+    /// Prints to @p out the description of all the command line options.
+    /// @param out the output stream
+    void ShowHelp(std::ostream& out);
+
+    /// Parses all the options in @p options.
+    /// @param err the error stream
+    /// @param arguments the command line arguments, excluding the initial executable name
+    /// @return a Result holding a list of arguments that were not consumed as options
+    Result<Unconsumed> Parse(std::ostream& err, utils::VectorRef<std::string_view> arguments);
+
+  private:
+    /// The list of options to parse
+    utils::BlockAllocator<Option, 1024> options;
+};
+
+/// ValueOption is an option that accepts a single value
+template <typename T>
+class ValueOption : public Option {
+    static constexpr bool is_bool = std::is_same_v<T, bool>;
+    static constexpr bool is_number =
+        !is_bool && (std::is_integral_v<T> || std::is_floating_point_v<T>);
+    static constexpr bool is_string = std::is_same_v<T, std::string>;
+    static_assert(is_bool || is_number || is_string, "unsupported data type");
+
+  public:
+    /// The name of the option, without any leading hyphens.
+    std::string name;
+    /// The alias name of the option, without any leading hyphens.
+    std::string alias;
+    /// The shorter name of the option, without any leading hyphens.
+    std::string short_name;
+    /// A description of the option.
+    std::string description;
+    /// The default value.
+    std::optional<T> default_value;
+    /// The option value. Populated with Parse().
+    std::optional<T> value;
+    /// A string describing the name of the option's value.
+    std::string parameter = "value";
+
+    /// Constructor
+    ValueOption() = default;
+
+    /// Constructor
+    /// @param option_name the option name
+    /// @param option_description the option description
+    /// @param settings a number of fluent-constructor values that configure the option
+    /// @see ShortName, Parameter, Default
+    template <typename... SETTINGS>
+    ValueOption(std::string option_name, std::string option_description, SETTINGS&&... settings)
+        : name(std::move(option_name)), description(std::move(option_description)) {
+        (settings.Apply(*this), ...);
+    }
+
+    std::string Name() const override { return name; }
+
+    std::string Alias() const override { return alias; }
+
+    std::string ShortName() const override { return short_name; }
+
+    std::string Parameter() const override { return parameter; }
+
+    std::string Description() const override { return description; }
+
+    std::string DefaultValue() const override {
+        return default_value.has_value() ? ToString(*default_value) : "";
+    }
+
+    void SetDefault() override { value = default_value; }
+
+    Error Parse(std::deque<std::string_view>& arguments) override {
+        TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
+
+        if (arguments.empty()) {
+            if constexpr (is_bool) {
+                // Treat as flag (--blah)
+                value = true;
+                return Success;
+            } else {
+                return ErrMissingArgument(parameter);
+            }
+        }
+
+        auto arg = arguments.front();
+
+        if constexpr (is_number) {
+            auto result = ParseNumber<T>(arg);
+            if (result) {
+                value = result.Get();
+                arguments.pop_front();
+                return Success;
+            }
+            if (result.Failure() == ParseNumberError::kResultOutOfRange) {
+                return ErrInvalidArgument(arg, "value out of range");
+            }
+            return ErrInvalidArgument(arg, "failed to parse value");
+        } else if constexpr (is_string) {
+            value = arg;
+            arguments.pop_front();
+            return Success;
+        } else if constexpr (is_bool) {
+            if (arg == "true") {
+                value = true;
+                arguments.pop_front();
+                return Success;
+            }
+            if (arg == "false") {
+                value = false;
+                arguments.pop_front();
+                return Success;
+            }
+            // Next argument is assumed to be another option, or unconsumed argument.
+            // Treat as flag (--blah)
+            value = true;
+            return Success;
+        }
+
+        TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
+    }
+};
+
+/// BoolOption is an alias to ValueOption<bool>
+using BoolOption = ValueOption<bool>;
+
+/// StringOption is an alias to ValueOption<std::string>
+using StringOption = ValueOption<std::string>;
+
+/// EnumName is a pair of enum value and name.
+/// @tparam ENUM the enum type
+template <typename ENUM>
+struct EnumName {
+    /// Constructor
+    EnumName() = default;
+
+    /// Constructor
+    /// @param v the enum value
+    /// @param n the name of the enum value
+    EnumName(ENUM v, std::string n) : value(v), name(std::move(n)) {}
+
+    /// the enum value
+    ENUM value;
+    /// the name of the enum value
+    std::string name;
+};
+
+/// Deduction guide for EnumName
+template <typename ENUM>
+EnumName(ENUM, std::string) -> EnumName<ENUM>;
+
+/// EnumOption is an option that accepts an enumerator of values
+template <typename ENUM>
+class EnumOption : public Option {
+  public:
+    /// The name of the option, without any leading hyphens.
+    std::string name;
+    /// The alias name of the option, without any leading hyphens.
+    std::string alias;
+    /// The shorter name of the option, without any leading hyphens.
+    std::string short_name;
+    /// A description of the option.
+    std::string description;
+    /// The enum options as a pair of enum value to name
+    utils::Vector<EnumName<ENUM>, 8> enum_names;
+    /// The default value.
+    std::optional<ENUM> default_value;
+    /// The option value. Populated with Parse().
+    std::optional<ENUM> value;
+
+    /// Constructor
+    EnumOption() = default;
+
+    /// Constructor
+    /// @param option_name the option name
+    /// @param option_description the option description
+    /// @param names The enum options as a pair of enum value to name
+    /// @param settings a number of fluent-constructor values that configure the option
+    /// @see ShortName, Parameter, Default
+    template <typename... SETTINGS>
+    EnumOption(std::string option_name,
+               std::string option_description,
+               utils::VectorRef<EnumName<ENUM>> names,
+               SETTINGS&&... settings)
+        : name(std::move(option_name)),
+          description(std::move(option_description)),
+          enum_names(std::move(names)) {
+        (settings.Apply(*this), ...);
+    }
+
+    std::string Name() const override { return name; }
+
+    std::string ShortName() const override { return short_name; }
+
+    std::string Alias() const override { return alias; }
+
+    std::string Parameter() const override { return PossibleValues("|"); }
+
+    std::string Description() const override { return description; }
+
+    std::string DefaultValue() const override {
+        for (auto& enum_name : enum_names) {
+            if (enum_name.value == default_value) {
+                return enum_name.name;
+            }
+        }
+        return "";
+    }
+
+    void SetDefault() override { value = default_value; }
+
+    Error Parse(std::deque<std::string_view>& arguments) override {
+        if (arguments.empty()) {
+            return ErrMissingArgument("one of: " + PossibleValues(", "));
+        }
+        auto& arg = arguments.front();
+        for (auto& enum_name : enum_names) {
+            if (enum_name.name == arg) {
+                value = enum_name.value;
+                arguments.pop_front();
+                return Success;
+            }
+        }
+        return ErrInvalidArgument(arg, "Must be one of: " + PossibleValues(", "));
+    }
+
+    /// @param delimiter the delimiter between each enum option
+    /// @returns the accepted enum names delimited with @p delimiter
+    std::string PossibleValues(std::string delimiter) const {
+        std::string out;
+        for (auto& enum_name : enum_names) {
+            if (!out.empty()) {
+                out += delimiter;
+            }
+            out += enum_name.name;
+        }
+        return out;
+    }
+};
+
+}  // namespace tint::utils::cli
+
+#endif  // SRC_TINT_UTILS_CLI_H_
diff --git a/src/tint/utils/cli_test.cc b/src/tint/utils/cli_test.cc
new file mode 100644
index 0000000..cabbf14
--- /dev/null
+++ b/src/tint/utils/cli_test.cc
@@ -0,0 +1,299 @@
+// 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/utils/cli.h"
+
+#include <sstream>
+
+#include "gmock/gmock.h"
+#include "src/tint/utils/string.h"
+
+#include "src/tint/utils/transform.h"  // Used by ToStringList()
+
+namespace tint::utils::cli {
+namespace {
+
+// Workaround for https://github.com/google/googletest/issues/3081
+// Remove when using C++20
+template <size_t N>
+utils::Vector<std::string, N> ToStringList(const utils::Vector<std::string_view, N>& views) {
+    return Transform(views, [](std::string_view view) { return std::string(view); });
+}
+
+using CLITest = testing::Test;
+
+TEST_F(CLITest, ShowHelp_ValueWithParameter) {
+    OptionSet opts;
+    opts.Add<ValueOption<int>>("my_option", "sets the awesome value");
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--my_option <value>  sets the awesome value
+)");
+}
+
+TEST_F(CLITest, ShowHelp_ValueWithAlias) {
+    OptionSet opts;
+    opts.Add<ValueOption<int>>("my_option", "sets the awesome value", Alias{"alias"});
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--my_option <value>  sets the awesome value
+--alias              alias for --my_option
+)");
+}
+TEST_F(CLITest, ShowHelp_ValueWithShortName) {
+    OptionSet opts;
+    opts.Add<ValueOption<int>>("my_option", "sets the awesome value", ShortName{"a"});
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--my_option <value>  sets the awesome value
+ -a                  short name for --my_option
+)");
+}
+
+TEST_F(CLITest, ShowHelp_MultilineDesc) {
+    OptionSet opts;
+    opts.Add<ValueOption<int>>("an-option", R"(this is a
+multi-line description
+for an option
+)");
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--an-option <value>  this is a
+                     multi-line description
+                     for an option
+
+)");
+}
+
+TEST_F(CLITest, ShowHelp_LongName) {
+    OptionSet opts;
+    opts.Add<ValueOption<int>>("an-option-with-a-really-really-long-name",
+                               "this is an option that has a silly long name", ShortName{"a"});
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--an-option-with-a-really-really-long-name <value>
+     this is an option that has a silly long name
+ -a  short name for --an-option-with-a-really-really-long-name
+)");
+}
+
+TEST_F(CLITest, ShowHelp_EnumValue) {
+    enum class E { X, Y, Z };
+
+    OptionSet opts;
+    opts.Add<EnumOption<E>>("my_enum_option", "sets the awesome value",
+                            utils::Vector{
+                                EnumName(E::X, "X"),
+                                EnumName(E::Y, "Y"),
+                                EnumName(E::Z, "Z"),
+                            });
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--my_enum_option <X|Y|Z>  sets the awesome value
+)");
+}
+
+TEST_F(CLITest, ShowHelp_MixedValues) {
+    enum class E { X, Y, Z };
+
+    OptionSet opts;
+
+    opts.Add<ValueOption<int>>("option-a", "an integer");
+    opts.Add<BoolOption>("option-b", "a boolean");
+    opts.Add<EnumOption<E>>("option-c", "sets the awesome value",
+                            utils::Vector{
+                                EnumName(E::X, "X"),
+                                EnumName(E::Y, "Y"),
+                                EnumName(E::Z, "Z"),
+                            });
+
+    std::stringstream out;
+    out << std::endl;
+    opts.ShowHelp(out);
+    EXPECT_EQ(out.str(), R"(
+--option-a <value>  an integer
+--option-b <value>  a boolean
+--option-c <X|Y|Z>  sets the awesome value
+)");
+}
+
+TEST_F(CLITest, ParseBool_Flag) {
+    OptionSet opts;
+    auto& opt = opts.Add<BoolOption>("my_option", "a boolean value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option unconsumed", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre("unconsumed"));
+    EXPECT_EQ(opt.value, true);
+}
+
+TEST_F(CLITest, ParseBool_ExplicitTrue) {
+    OptionSet opts;
+    auto& opt = opts.Add<BoolOption>("my_option", "a boolean value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option true", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, true);
+}
+
+TEST_F(CLITest, ParseBool_ExplicitFalse) {
+    OptionSet opts;
+    auto& opt = opts.Add<BoolOption>("my_option", "a boolean value", Default{true});
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option false", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, false);
+}
+
+TEST_F(CLITest, ParseInt) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<int>>("my_option", "an integer value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option 42", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, 42);
+}
+
+TEST_F(CLITest, ParseUint64) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<uint64_t>>("my_option", "a uint64_t value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option 1000000", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, 1000000);
+}
+
+TEST_F(CLITest, ParseFloat) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<float>>("my_option", "a float value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option 1.25", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, 1.25f);
+}
+
+TEST_F(CLITest, ParseString) {
+    OptionSet opts;
+    auto& opt = opts.Add<StringOption>("my_option", "a string value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option blah", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, "blah");
+}
+
+TEST_F(CLITest, ParseEnum) {
+    enum class E { X, Y, Z };
+
+    OptionSet opts;
+    auto& opt = opts.Add<EnumOption<E>>("my_option", "sets the awesome value",
+                                        utils::Vector{
+                                            EnumName(E::X, "X"),
+                                            EnumName(E::Y, "Y"),
+                                            EnumName(E::Z, "Z"),
+                                        });
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option Y", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, E::Y);
+}
+
+TEST_F(CLITest, ParseShortName) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<int>>("my_option", "an integer value", ShortName{"o"});
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("-o 42", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, 42);
+}
+
+TEST_F(CLITest, ParseUnconsumed) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<int32_t>>("my_option", "a int32_t value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("abc --my_option -123 def", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre("abc", "def"));
+    EXPECT_EQ(opt.value, -123);
+}
+
+TEST_F(CLITest, ParseUsingEquals) {
+    OptionSet opts;
+    auto& opt = opts.Add<ValueOption<int>>("my_option", "an int value");
+
+    std::stringstream err;
+    auto res = opts.Parse(err, Split("--my_option=123", " "));
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_THAT(ToStringList(res.Get()), testing::ElementsAre());
+    EXPECT_EQ(opt.value, 123);
+}
+
+TEST_F(CLITest, SetValueToDefault) {
+    OptionSet opts;
+    auto& opt = opts.Add<BoolOption>("my_option", "a boolean value", Default{true});
+
+    std::stringstream err;
+    auto res = opts.Parse(err, utils::Empty);
+    ASSERT_TRUE(res) << err.str();
+    EXPECT_TRUE(err.str().empty());
+    EXPECT_EQ(opt.value, true);
+}
+
+}  // namespace
+}  // namespace tint::utils::cli
diff --git a/src/tint/utils/parse_num.h b/src/tint/utils/parse_num.h
index 6d4fcb4..7c4ff7e 100644
--- a/src/tint/utils/parse_num.h
+++ b/src/tint/utils/parse_num.h
@@ -18,6 +18,7 @@
 #include <optional>
 #include <string>
 
+#include "src/tint/utils/compiler_macros.h"
 #include "src/tint/utils/result.h"
 
 namespace tint::utils {
@@ -78,6 +79,8 @@
 /// @returns the string @p str parsed as a uint8_t
 Result<uint8_t, ParseNumberError> ParseUint8(std::string_view str);
 
+TINT_BEGIN_DISABLE_WARNING(UNREACHABLE_CODE);
+
 /// @param str the string
 /// @returns the string @p str parsed as a the number @p T
 template <typename T>
@@ -121,6 +124,8 @@
     return ParseNumberError::kUnparsable;
 }
 
+TINT_END_DISABLE_WARNING(UNREACHABLE_CODE);
+
 }  // namespace tint::utils
 
 #endif  // SRC_TINT_UTILS_PARSE_NUM_H_
diff --git a/src/tint/utils/string_test.cc b/src/tint/utils/string_test.cc
index 676c341..63f72a6 100644
--- a/src/tint/utils/string_test.cc
+++ b/src/tint/utils/string_test.cc
@@ -17,9 +17,18 @@
 #include "gmock/gmock.h"
 #include "src/tint/utils/string_stream.h"
 
+#include "src/tint/utils/transform.h"  // Used by ToStringList()
+
 namespace tint::utils {
 namespace {
 
+// Workaround for https://github.com/google/googletest/issues/3081
+// Remove when using C++20
+template <size_t N>
+utils::Vector<std::string, N> ToStringList(const utils::Vector<std::string_view, N>& views) {
+    return Transform(views, [](std::string_view view) { return std::string(view); });
+}
+
 TEST(StringTest, ReplaceAll) {
     EXPECT_EQ("xybbcc", ReplaceAll("aabbcc", "aa", "xy"));
     EXPECT_EQ("aaxycc", ReplaceAll("aabbcc", "bb", "xy"));
@@ -176,16 +185,15 @@
     EXPECT_EQ("'meow'", Quote("meow"));
 }
 
-#if 0  // Enable when moved to C++20 (https://github.com/google/googletest/issues/3081)
 TEST(StringTest, Split) {
-    EXPECT_THAT(Split("", ","), testing::ElementsAre(""));
-    EXPECT_THAT(Split("cat", ","), testing::ElementsAre("cat"));
-    EXPECT_THAT(Split("cat,", ","), testing::ElementsAre("cat", ""));
-    EXPECT_THAT(Split(",cat", ","), testing::ElementsAre("", "cat"));
-    EXPECT_THAT(Split("cat,dog,fish", ","), testing::ElementsAre("cat", "dog", "fish"));
-    EXPECT_THAT(Split("catdogfish", "dog"), testing::ElementsAre("cat", "fish"));
+    EXPECT_THAT(ToStringList(Split("", ",")), testing::ElementsAre(""));
+    EXPECT_THAT(ToStringList(Split("cat", ",")), testing::ElementsAre("cat"));
+    EXPECT_THAT(ToStringList(Split("cat,", ",")), testing::ElementsAre("cat", ""));
+    EXPECT_THAT(ToStringList(Split(",cat", ",")), testing::ElementsAre("", "cat"));
+    EXPECT_THAT(ToStringList(Split("cat,dog,fish", ",")),
+                testing::ElementsAre("cat", "dog", "fish"));
+    EXPECT_THAT(ToStringList(Split("catdogfish", "dog")), testing::ElementsAre("cat", "fish"));
 }
-#endif
 
 TEST(StringTest, Join) {
     EXPECT_EQ(Join(utils::Vector<int, 1>{}, ","), "");
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.cc b/src/tint/writer/spirv/ir/generator_impl_ir.cc
index a32f5b7..8ae01c8 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.cc
@@ -18,6 +18,7 @@
 
 #include "spirv/unified1/GLSL.std.450.h"
 #include "spirv/unified1/spirv.h"
+#include "src/tint/constant/scalar.h"
 #include "src/tint/ir/binary.h"
 #include "src/tint/ir/block.h"
 #include "src/tint/ir/break_if.h"
@@ -39,6 +40,7 @@
 #include "src/tint/ir/var.h"
 #include "src/tint/switch.h"
 #include "src/tint/transform/manager.h"
+#include "src/tint/type/array.h"
 #include "src/tint/type/bool.h"
 #include "src/tint/type/f16.h"
 #include "src/tint/type/f32.h"
@@ -100,11 +102,9 @@
 
     // TODO(crbug.com/tint/1906): Emit extensions.
 
-    // TODO(crbug.com/tint/1906): Emit variables.
-    (void)zero_init_workgroup_memory_;
+    // Emit module-scope declarations.
     if (ir_->root_block) {
-        TINT_ICE(Writer, diagnostics_) << "root block is unimplemented";
-        return false;
+        EmitRootBlock(ir_->root_block);
     }
 
     // Emit functions.
@@ -174,6 +174,14 @@
     });
 }
 
+uint32_t GeneratorImplIr::ConstantNull(const type::Type* type) {
+    return constant_nulls_.GetOrCreate(type, [&]() {
+        auto id = module_.NextId();
+        module_.PushType(spv::Op::OpConstantNull, {Type(type), id});
+        return id;
+    });
+}
+
 uint32_t GeneratorImplIr::Type(const type::Type* ty) {
     return types_.GetOrCreate(ty, [&]() {
         auto id = module_.NextId();
@@ -200,6 +208,18 @@
                 module_.PushType(spv::Op::OpTypeMatrix,
                                  {id, Type(mat->ColumnType()), mat->columns()});
             },
+            [&](const type::Array* arr) {
+                if (arr->ConstantCount()) {
+                    auto* count = ir_->constant_values.Get(u32(arr->ConstantCount().value()));
+                    module_.PushType(spv::Op::OpTypeArray,
+                                     {id, Type(arr->ElemType()), Constant(count)});
+                } else {
+                    TINT_ASSERT(Writer, arr->Count()->Is<type::RuntimeArrayCount>());
+                    module_.PushType(spv::Op::OpTypeRuntimeArray, {id, Type(arr->ElemType())});
+                }
+                module_.PushAnnot(spv::Op::OpDecorate,
+                                  {id, U32Operand(SpvDecorationArrayStride), arr->Stride()});
+            },
             [&](const type::Pointer* ptr) {
                 module_.PushType(
                     spv::Op::OpTypePointer,
@@ -320,6 +340,20 @@
                            {U32Operand(stage), id, ir_->NameOf(func).Name()});
 }
 
+void GeneratorImplIr::EmitRootBlock(const ir::Block* root_block) {
+    for (auto* inst : root_block->Instructions()) {
+        auto result = Switch(
+            inst,  //
+            [&](const ir::Var* v) { return EmitVar(v); },
+            [&](Default) {
+                TINT_ICE(Writer, diagnostics_)
+                    << "unimplemented root block instruction: " << inst->TypeInfo().name;
+                return 0u;
+            });
+        values_.Add(inst, result);
+    }
+}
+
 void GeneratorImplIr::EmitBlock(const ir::Block* block) {
     // Emit the label.
     // Skip if this is the function's entry block, as it will be emitted by the function object.
@@ -334,6 +368,22 @@
         return;
     }
 
+    // Emit Phi nodes for all the incoming block parameters
+    for (size_t param_idx = 0; param_idx < block->Params().Length(); param_idx++) {
+        auto* param = block->Params()[param_idx];
+        auto id = module_.NextId();
+        values_.Add(param, id);
+        OperandList ops{Type(param->Type()), id};
+
+        for (auto* incoming : block->InboundBranches()) {
+            auto* arg = incoming->Args()[param_idx];
+            ops.push_back(Value(arg));
+            ops.push_back(Label(incoming->Block()));
+        }
+
+        current_function_.push_inst(spv::Op::OpPhi, std::move(ops));
+    }
+
     // Emit the instructions.
     for (auto* inst : block->Instructions()) {
         auto result = Switch(
@@ -391,7 +441,7 @@
                                         {
                                             Value(breakif->Condition()),
                                             Label(breakif->Loop()->Merge()),
-                                            Label(breakif->Loop()->Start()),
+                                            Label(breakif->Loop()->Body()),
                                         });
         },
         [&](const ir::Continue* cont) {
@@ -407,7 +457,7 @@
             current_function_.push_inst(spv::Op::OpBranch, {Label(swtch->Switch()->Merge())});
         },
         [&](const ir::NextIteration* loop) {
-            current_function_.push_inst(spv::Op::OpBranch, {Label(loop->Loop()->Start())});
+            current_function_.push_inst(spv::Op::OpBranch, {Label(loop->Loop()->Body())});
         },
         [&](Default) {
             TINT_ICE(Writer, diagnostics_) << "unimplemented branch: " << b->TypeInfo().name;
@@ -421,16 +471,17 @@
 
     // Generate labels for the blocks. We emit the true or false block if it:
     // 1. contains instructions other then the branch, or
-    // 2. branches somewhere other then the Merge().
+    // 2. branches somewhere other then the Merge(), or
+    // 3. the merge has input parameters
     // Otherwise we skip them and branch straight to the merge block.
     uint32_t merge_label = Label(merge_block);
     uint32_t true_label = merge_label;
     uint32_t false_label = merge_label;
-    if (true_block->Instructions().Length() > 1 ||
+    if (true_block->Instructions().Length() > 1 || !merge_block->Params().IsEmpty() ||
         (true_block->HasBranchTarget() && !true_block->Branch()->Is<ir::ExitIf>())) {
         true_label = Label(true_block);
     }
-    if (false_block->Instructions().Length() > 1 ||
+    if (false_block->Instructions().Length() > 1 || !merge_block->Params().IsEmpty() ||
         (false_block->HasBranchTarget() && !false_block->Branch()->Is<ir::ExitIf>())) {
         false_label = Label(false_block);
     }
@@ -631,7 +682,7 @@
 
 void GeneratorImplIr::EmitLoop(const ir::Loop* loop) {
     auto header_label = module_.NextId();
-    auto body_label = Label(loop->Start());
+    auto body_label = Label(loop->Body());
     auto continuing_label = Label(loop->Continuing());
     auto merge_label = Label(loop->Merge());
 
@@ -643,11 +694,11 @@
     current_function_.push_inst(spv::Op::OpBranch, {body_label});
 
     // Emit the loop body.
-    EmitBlock(loop->Start());
+    EmitBlock(loop->Body());
 
     // Emit the loop continuing block.
     // The back-edge needs to go to the loop header, so update the label for the start block.
-    block_labels_.Replace(loop->Start(), header_label);
+    block_labels_.Replace(loop->Body(), header_label);
     if (loop->Continuing()->HasBranchTarget()) {
         EmitBlock(loop->Continuing());
     } else {
@@ -719,16 +770,41 @@
     TINT_ASSERT(Writer, ptr);
     auto ty = Type(ptr);
 
-    if (ptr->AddressSpace() == builtin::AddressSpace::kFunction) {
-        TINT_ASSERT(Writer, current_function_);
-        current_function_.push_var({ty, id, U32Operand(SpvStorageClassFunction)});
-        if (var->Initializer()) {
-            current_function_.push_inst(spv::Op::OpStore, {id, Value(var->Initializer())});
+    switch (ptr->AddressSpace()) {
+        case builtin::AddressSpace::kFunction: {
+            TINT_ASSERT(Writer, current_function_);
+            current_function_.push_var({ty, id, U32Operand(SpvStorageClassFunction)});
+            if (var->Initializer()) {
+                current_function_.push_inst(spv::Op::OpStore, {id, Value(var->Initializer())});
+            }
+            break;
         }
-    } else {
-        TINT_ICE(Writer, diagnostics_)
-            << "unimplemented variable address space " << ptr->AddressSpace();
-        return 0u;
+        case builtin::AddressSpace::kPrivate: {
+            TINT_ASSERT(Writer, !current_function_);
+            OperandList operands = {ty, id, U32Operand(SpvStorageClassPrivate)};
+            if (var->Initializer()) {
+                TINT_ASSERT(Writer, var->Initializer()->Is<ir::Constant>());
+                operands.push_back(Value(var->Initializer()));
+            }
+            module_.PushType(spv::Op::OpVariable, operands);
+            break;
+        }
+        case builtin::AddressSpace::kWorkgroup: {
+            TINT_ASSERT(Writer, !current_function_);
+            OperandList operands = {ty, id, U32Operand(SpvStorageClassWorkgroup)};
+            if (zero_init_workgroup_memory_) {
+                // If requested, use the VK_KHR_zero_initialize_workgroup_memory to zero-initialize
+                // the workgroup variable using an null constant initializer.
+                operands.push_back(ConstantNull(ptr->StoreType()));
+            }
+            module_.PushType(spv::Op::OpVariable, operands);
+            break;
+        }
+        default: {
+            TINT_ICE(Writer, diagnostics_)
+                << "unimplemented variable address space " << ptr->AddressSpace();
+            return 0u;
+        }
     }
 
     // Set the name if present.
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.h b/src/tint/writer/spirv/ir/generator_impl_ir.h
index 3c8783e..5793325 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.h
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.h
@@ -76,6 +76,11 @@
     /// @returns the result ID of the constant
     uint32_t Constant(const ir::Constant* constant);
 
+    /// Get the result ID of the OpConstantNull instruction for `type`, emitting it if necessary.
+    /// @param type the type to get the ID for
+    /// @returns the result ID of the OpConstantNull instruction
+    uint32_t ConstantNull(const type::Type* type);
+
     /// Get the result ID of the type `ty`, emitting a type declaration instruction if necessary.
     /// @param ty the type to get the ID for
     /// @returns the result ID of the type
@@ -104,6 +109,10 @@
     /// @param block the block to emit
     void EmitBlock(const ir::Block* block);
 
+    /// Emit the root block.
+    /// @param root_block the root block to emit
+    void EmitRootBlock(const ir::Block* root_block);
+
     /// Emit an `if` flow node.
     /// @param i the if node to emit
     void EmitIf(const ir::If* i);
@@ -194,6 +203,9 @@
     /// The map of constants to their result IDs.
     utils::Hashmap<const constant::Value*, uint32_t, 16> constants_;
 
+    /// The map of types to the result IDs of their OpConstantNull instructions.
+    utils::Hashmap<const type::Type*, uint32_t, 4> constant_nulls_;
+
     /// The map of non-constant values to their result IDs.
     utils::Hashmap<const ir::Value*, uint32_t, 8> values_;
 
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
index f43a09a..1c9b9ac 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_if_test.cc
@@ -142,5 +142,160 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param = b.BlockParam(b.ir.Types().i32());
+
+    auto* i = b.CreateIf(b.Constant(true));
+    i->True()->SetInstructions(utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(10_i)})});
+    i->False()->SetInstructions(utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(20_i)})});
+    i->Merge()->SetParams(utils::Vector{merge_param});
+    i->Merge()->SetInstructions(utils::Vector{b.Return(func, utils::Vector{merge_param})});
+
+    func->StartTarget()->SetInstructions(utils::Vector{i});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeBool
+%8 = OpConstantTrue %9
+%11 = OpTypeInt 32 1
+%12 = OpConstant %11 10
+%13 = OpConstant %11 20
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %5 None
+OpBranchConditional %8 %6 %7
+%6 = OpLabel
+OpBranch %5
+%7 = OpLabel
+OpBranch %5
+%5 = OpLabel
+%10 = OpPhi %11 %12 %6 %13 %7
+OpReturnValue %10
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue_TrueReturn) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param = b.BlockParam(b.ir.Types().i32());
+
+    auto* i = b.CreateIf(b.Constant(true));
+    i->True()->SetInstructions(utils::Vector{b.Return(func, utils::Vector{b.Constant(42_i)})});
+    i->False()->SetInstructions(utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(20_i)})});
+    i->Merge()->SetParams(utils::Vector{merge_param});
+    i->Merge()->SetInstructions(utils::Vector{b.Return(func, utils::Vector{merge_param})});
+
+    func->StartTarget()->SetInstructions(utils::Vector{i});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeBool
+%8 = OpConstantTrue %9
+%11 = OpTypeInt 32 1
+%10 = OpConstant %11 42
+%13 = OpConstant %11 20
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %5 None
+OpBranchConditional %8 %6 %7
+%6 = OpLabel
+OpReturnValue %10
+%7 = OpLabel
+OpBranch %5
+%5 = OpLabel
+%12 = OpPhi %11 %13 %7
+OpReturnValue %12
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, If_Phi_SingleValue_FalseReturn) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param = b.BlockParam(b.ir.Types().i32());
+
+    auto* i = b.CreateIf(b.Constant(true));
+    i->True()->SetInstructions(utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(10_i)})});
+    i->False()->SetInstructions(utils::Vector{b.Return(func, utils::Vector{b.Constant(42_i)})});
+    i->Merge()->SetParams(utils::Vector{merge_param});
+    i->Merge()->SetInstructions(utils::Vector{b.Return(func, utils::Vector{merge_param})});
+
+    func->StartTarget()->SetInstructions(utils::Vector{i});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeBool
+%8 = OpConstantTrue %9
+%11 = OpTypeInt 32 1
+%10 = OpConstant %11 42
+%13 = OpConstant %11 10
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %5 None
+OpBranchConditional %8 %6 %7
+%6 = OpLabel
+OpBranch %5
+%7 = OpLabel
+OpReturnValue %10
+%5 = OpLabel
+%12 = OpPhi %11 %13 %6
+OpReturnValue %12
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, If_Phi_MultipleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param_0 = b.BlockParam(b.ir.Types().i32());
+    auto* merge_param_1 = b.BlockParam(b.ir.Types().bool_());
+
+    auto* i = b.CreateIf(b.Constant(true));
+    i->True()->SetInstructions(
+        utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(10_i), b.Constant(true)})});
+    i->False()->SetInstructions(
+        utils::Vector{b.ExitIf(i, utils::Vector{b.Constant(20_i), b.Constant(false)})});
+    i->Merge()->SetParams(utils::Vector{merge_param_0, merge_param_1});
+    i->Merge()->SetInstructions(utils::Vector{
+        b.Return(func, utils::Vector{merge_param_0}),
+    });
+
+    func->StartTarget()->SetInstructions(utils::Vector{i});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%9 = OpTypeBool
+%8 = OpConstantTrue %9
+%11 = OpTypeInt 32 1
+%12 = OpConstant %11 10
+%13 = OpConstant %11 20
+%15 = OpConstantFalse %9
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %5 None
+OpBranchConditional %8 %6 %7
+%6 = OpLabel
+OpBranch %5
+%7 = OpLabel
+OpBranch %5
+%5 = OpLabel
+%10 = OpPhi %11 %12 %6 %13 %7
+%14 = OpPhi %9 %8 %6 %15 %7
+OpReturnValue %10
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace tint::writer::spirv
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 e16d116..a32a751 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_loop_test.cc
@@ -24,7 +24,7 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Start()->AddInstruction(b.Continue(loop));
+    loop->Body()->AddInstruction(b.Continue(loop));
     loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), loop));
     loop->Merge()->AddInstruction(b.Return(func));
 
@@ -58,7 +58,7 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Start()->AddInstruction(b.ExitLoop(loop));
+    loop->Body()->AddInstruction(b.ExitLoop(loop));
     loop->Merge()->AddInstruction(b.Return(func));
 
     func->StartTarget()->AddInstruction(loop);
@@ -93,7 +93,7 @@
     cond_break->False()->AddInstruction(b.ExitIf(cond_break));
     cond_break->Merge()->AddInstruction(b.Continue(loop));
 
-    loop->Start()->AddInstruction(cond_break);
+    loop->Body()->AddInstruction(cond_break);
     loop->Continuing()->AddInstruction(b.NextIteration(loop));
     loop->Merge()->AddInstruction(b.Return(func));
 
@@ -136,7 +136,7 @@
     cond_break->False()->AddInstruction(b.ExitIf(cond_break));
     cond_break->Merge()->AddInstruction(b.ExitLoop(loop));
 
-    loop->Start()->AddInstruction(cond_break);
+    loop->Body()->AddInstruction(cond_break);
     loop->Continuing()->AddInstruction(b.NextIteration(loop));
     loop->Merge()->AddInstruction(b.Return(func));
 
@@ -176,7 +176,7 @@
 
     auto* loop = b.CreateLoop();
 
-    loop->Start()->AddInstruction(b.Return(func));
+    loop->Body()->AddInstruction(b.Return(func));
 
     func->StartTarget()->AddInstruction(loop);
 
@@ -207,7 +207,7 @@
 
     auto* result = b.Equal(mod.Types().i32(), b.Constant(1_i), b.Constant(2_i));
 
-    loop->Start()->AddInstruction(result);
+    loop->Body()->AddInstruction(result);
     loop->Continuing()->AddInstruction(b.BreakIf(result, loop));
     loop->Merge()->AddInstruction(b.Return(func));
 
@@ -242,11 +242,11 @@
     auto* outer_loop = b.CreateLoop();
     auto* inner_loop = b.CreateLoop();
 
-    inner_loop->Start()->AddInstruction(b.ExitLoop(inner_loop));
+    inner_loop->Body()->AddInstruction(b.ExitLoop(inner_loop));
     inner_loop->Continuing()->AddInstruction(b.NextIteration(inner_loop));
     inner_loop->Merge()->AddInstruction(b.Continue(outer_loop));
 
-    outer_loop->Start()->AddInstruction(inner_loop);
+    outer_loop->Body()->AddInstruction(inner_loop);
     outer_loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), outer_loop));
     outer_loop->Merge()->AddInstruction(b.Return(func));
 
@@ -289,11 +289,11 @@
     auto* outer_loop = b.CreateLoop();
     auto* inner_loop = b.CreateLoop();
 
-    inner_loop->Start()->AddInstruction(b.Continue(inner_loop));
+    inner_loop->Body()->AddInstruction(b.Continue(inner_loop));
     inner_loop->Continuing()->AddInstruction(b.BreakIf(b.Constant(true), inner_loop));
     inner_loop->Merge()->AddInstruction(b.BreakIf(b.Constant(true), outer_loop));
 
-    outer_loop->Start()->AddInstruction(b.Continue(outer_loop));
+    outer_loop->Body()->AddInstruction(b.Continue(outer_loop));
     outer_loop->Continuing()->AddInstruction(inner_loop);
     outer_loop->Merge()->AddInstruction(b.Return(func));
 
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
index 92800a3..1c4d5d0 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_switch_test.cc
@@ -217,5 +217,131 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, Switch_Phi_SingleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param = b.BlockParam(b.ir.Types().i32());
+
+    auto* s = b.CreateSwitch(b.Constant(42_i));
+    auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
+                                                 ir::Switch::CaseSelector{nullptr}});
+    case_a->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(10_i)}));
+
+    auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
+    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
+
+    s->Merge()->SetParams(utils::Vector{merge_param});
+    s->Merge()->AddInstruction(b.Return(func));
+
+    func->StartTarget()->SetInstructions(utils::Vector{s});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpConstant %7 42
+%11 = OpConstant %7 10
+%12 = OpConstant %7 20
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %9 None
+OpSwitch %6 %5 1 %5 2 %8
+%5 = OpLabel
+OpBranch %9
+%8 = OpLabel
+OpBranch %9
+%9 = OpLabel
+%10 = OpPhi %7 %11 %5 %12 %8
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Switch_Phi_SingleValue_CaseReturn) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* s = b.CreateSwitch(b.Constant(42_i));
+    auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
+                                                 ir::Switch::CaseSelector{nullptr}});
+    case_a->AddInstruction(b.Return(func, utils::Vector{b.Constant(10_i)}));
+
+    auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
+    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i)}));
+
+    s->Merge()->SetParams(utils::Vector{b.BlockParam(b.ir.Types().i32())});
+    s->Merge()->AddInstruction(b.Return(func));
+
+    func->StartTarget()->SetInstructions(utils::Vector{s});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpConstant %7 42
+%10 = OpConstant %7 10
+%12 = OpConstant %7 20
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %9 None
+OpSwitch %6 %5 1 %5 2 %8
+%5 = OpLabel
+OpReturnValue %10
+%8 = OpLabel
+OpBranch %9
+%9 = OpLabel
+%11 = OpPhi %7 %12 %8
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Switch_Phi_MultipleValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+
+    auto* merge_param_0 = b.BlockParam(b.ir.Types().i32());
+    auto* merge_param_1 = b.BlockParam(b.ir.Types().bool_());
+
+    auto* s = b.CreateSwitch(b.Constant(42_i));
+    auto* case_a = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(1_i)},
+                                                 ir::Switch::CaseSelector{nullptr}});
+    case_a->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(10_i), b.Constant(true)}));
+
+    auto* case_b = b.CreateCase(s, utils::Vector{ir::Switch::CaseSelector{b.Constant(2_i)}});
+    case_b->AddInstruction(b.ExitSwitch(s, utils::Vector{b.Constant(20_i), b.Constant(false)}));
+
+    s->Merge()->SetParams(utils::Vector{merge_param_0, merge_param_1});
+    s->Merge()->AddInstruction(b.Return(func, utils::Vector{merge_param_0}));
+
+    func->StartTarget()->SetInstructions(utils::Vector{s});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%7 = OpTypeInt 32 1
+%6 = OpConstant %7 42
+%11 = OpConstant %7 10
+%12 = OpConstant %7 20
+%14 = OpTypeBool
+%15 = OpConstantTrue %14
+%16 = OpConstantFalse %14
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpSelectionMerge %9 None
+OpSwitch %6 %5 1 %5 2 %8
+%5 = OpLabel
+OpBranch %9
+%8 = OpLabel
+OpBranch %9
+%9 = OpLabel
+%10 = OpPhi %7 %11 %5 %12 %8
+%13 = OpPhi %14 %15 %5 %16 %8
+OpReturnValue %10
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace tint::writer::spirv
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
index 80e69c3..7b2142c 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_type_test.cc
@@ -125,6 +125,50 @@
               "%1 = OpTypeMatrix %2 4\n");
 }
 
+TEST_F(SpvGeneratorImplTest, Type_Array_DefaultStride) {
+    auto* arr = mod.Types().array(mod.Types().f32(), 4u);
+    auto id = generator_.Type(arr);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%2 = OpTypeFloat 32\n"
+              "%4 = OpTypeInt 32 0\n"
+              "%3 = OpConstant %4 4\n"
+              "%1 = OpTypeArray %2 %3\n");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 4\n");
+}
+
+TEST_F(SpvGeneratorImplTest, Type_Array_ExplicitStride) {
+    auto* arr = mod.Types().array(mod.Types().f32(), 4u, 16);
+    auto id = generator_.Type(arr);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%2 = OpTypeFloat 32\n"
+              "%4 = OpTypeInt 32 0\n"
+              "%3 = OpConstant %4 4\n"
+              "%1 = OpTypeArray %2 %3\n");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 16\n");
+}
+
+TEST_F(SpvGeneratorImplTest, Type_RuntimeArray_DefaultStride) {
+    auto* arr = mod.Types().runtime_array(mod.Types().f32());
+    auto id = generator_.Type(arr);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%2 = OpTypeFloat 32\n"
+              "%1 = OpTypeRuntimeArray %2\n");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 4\n");
+}
+
+TEST_F(SpvGeneratorImplTest, Type_RuntimeArray_ExplicitStride) {
+    auto* arr = mod.Types().runtime_array(mod.Types().f32(), 16);
+    auto id = generator_.Type(arr);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%2 = OpTypeFloat 32\n"
+              "%1 = OpTypeRuntimeArray %2\n");
+    EXPECT_EQ(DumpInstructions(generator_.Module().Annots()), "OpDecorate %1 ArrayStride 16\n");
+}
+
 // Test that we can emit multiple types.
 // Includes types with the same opcode but different parameters.
 TEST_F(SpvGeneratorImplTest, Type_Multiple) {
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 574a0b0..8ad2c10 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
@@ -180,5 +180,235 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, PrivateVar_NoInit) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kPrivate,
+                                              builtin::Access::kReadWrite);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{b.Declare(ty)});
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %4 "unused_entry_point"
+OpExecutionMode %4 LocalSize 1 1 1
+OpName %4 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Private %3
+%1 = OpVariable %2 Private
+%5 = OpTypeVoid
+%6 = OpTypeFunction %5
+%4 = OpFunction %5 None %6
+%7 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, PrivateVar_WithInit) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kPrivate,
+                                              builtin::Access::kReadWrite);
+    auto* v = b.Declare(ty);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{v});
+    v->SetInitializer(b.Constant(42_i));
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %5 "unused_entry_point"
+OpExecutionMode %5 LocalSize 1 1 1
+OpName %5 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Private %3
+%4 = OpConstant %3 42
+%1 = OpVariable %2 Private %4
+%6 = OpTypeVoid
+%7 = OpTypeFunction %6
+%5 = OpFunction %6 None %7
+%8 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, PrivateVar_Name) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kPrivate,
+                                              builtin::Access::kReadWrite);
+    auto* v = b.Declare(ty);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{v});
+    v->SetInitializer(b.Constant(42_i));
+    mod.SetName(v, "myvar");
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %5 "unused_entry_point"
+OpExecutionMode %5 LocalSize 1 1 1
+OpName %1 "myvar"
+OpName %5 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Private %3
+%4 = OpConstant %3 42
+%1 = OpVariable %2 Private %4
+%6 = OpTypeVoid
+%7 = OpTypeFunction %6
+%5 = OpFunction %6 None %7
+%8 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, PrivateVar_LoadAndStore) {
+    auto* func =
+        b.CreateFunction("foo", mod.Types().void_(), ir::Function::PipelineStage::kFragment);
+    mod.functions.Push(func);
+
+    auto* store_ty = mod.Types().i32();
+    auto* ty = mod.Types().Get<type::Pointer>(store_ty, builtin::AddressSpace::kPrivate,
+                                              builtin::Access::kReadWrite);
+    auto* v = b.Declare(ty);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{v});
+    v->SetInitializer(b.Constant(42_i));
+
+    auto* load = b.Load(v);
+    auto* add = b.Add(store_ty, v, b.Constant(1_i));
+    auto* store = b.Store(v, add);
+    func->StartTarget()->SetInstructions(utils::Vector{load, add, store, b.Return(func)});
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %5 "foo"
+OpExecutionMode %5 OriginUpperLeft
+OpName %5 "foo"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Private %3
+%4 = OpConstant %3 42
+%1 = OpVariable %2 Private %4
+%6 = OpTypeVoid
+%7 = OpTypeFunction %6
+%11 = OpConstant %3 1
+%5 = OpFunction %6 None %7
+%8 = OpLabel
+%9 = OpLoad %3 %1
+%10 = OpIAdd %3 %1 %11
+OpStore %1 %10
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, WorkgroupVar) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kWorkgroup,
+                                              builtin::Access::kReadWrite);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{b.Declare(ty)});
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %4 "unused_entry_point"
+OpExecutionMode %4 LocalSize 1 1 1
+OpName %4 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Workgroup %3
+%1 = OpVariable %2 Workgroup
+%5 = OpTypeVoid
+%6 = OpTypeFunction %5
+%4 = OpFunction %5 None %6
+%7 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, WorkgroupVar_Name) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kWorkgroup,
+                                              builtin::Access::kReadWrite);
+    auto* v = b.Declare(ty);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{v});
+    mod.SetName(v, "myvar");
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %4 "unused_entry_point"
+OpExecutionMode %4 LocalSize 1 1 1
+OpName %1 "myvar"
+OpName %4 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Workgroup %3
+%1 = OpVariable %2 Workgroup
+%5 = OpTypeVoid
+%6 = OpTypeFunction %5
+%4 = OpFunction %5 None %6
+%7 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, WorkgroupVar_LoadAndStore) {
+    auto* func = b.CreateFunction("foo", mod.Types().void_(), ir::Function::PipelineStage::kCompute,
+                                  std::array{1u, 1u, 1u});
+    mod.functions.Push(func);
+
+    auto* store_ty = mod.Types().i32();
+    auto* ty = mod.Types().Get<type::Pointer>(store_ty, builtin::AddressSpace::kWorkgroup,
+                                              builtin::Access::kReadWrite);
+    auto* v = b.Declare(ty);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{v});
+
+    auto* load = b.Load(v);
+    auto* add = b.Add(store_ty, v, b.Constant(1_i));
+    auto* store = b.Store(v, add);
+    func->StartTarget()->SetInstructions(utils::Vector{load, add, store, b.Return(func)});
+
+    generator_.Generate();
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %4 "foo"
+OpExecutionMode %4 LocalSize 1 1 1
+OpName %4 "foo"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Workgroup %3
+%1 = OpVariable %2 Workgroup
+%5 = OpTypeVoid
+%6 = OpTypeFunction %5
+%10 = OpConstant %3 1
+%4 = OpFunction %5 None %6
+%7 = OpLabel
+%8 = OpLoad %3 %1
+%9 = OpIAdd %3 %1 %10
+OpStore %1 %9
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, WorkgroupVar_ZeroInitializeWithExtension) {
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kWorkgroup,
+                                              builtin::Access::kReadWrite);
+    b.CreateRootBlockIfNeeded()->SetInstructions(utils::Vector{b.Declare(ty)});
+
+    // Create a generator with the zero_init_workgroup_memory flag set to `true`.
+    spirv::GeneratorImplIr gen(&mod, true);
+    gen.Generate();
+    EXPECT_EQ(DumpModule(gen.Module()), R"(OpCapability Shader
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %5 "unused_entry_point"
+OpExecutionMode %5 LocalSize 1 1 1
+OpName %5 "unused_entry_point"
+%3 = OpTypeInt 32 1
+%2 = OpTypePointer Workgroup %3
+%4 = OpConstantNull %3
+%1 = OpVariable %2 Workgroup %4
+%6 = OpTypeVoid
+%7 = OpTypeFunction %6
+%5 = OpFunction %6 None %7
+%8 = OpLabel
+OpReturn
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace tint::writer::spirv