diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index b14851f..7e2444c 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -894,6 +894,8 @@
     "constant/clone_context.h",
     "constant/composite.cc",
     "constant/composite.h",
+    "constant/manager.cc",
+    "constant/manager.h",
     "constant/node.cc",
     "constant/node.h",
     "constant/scalar.cc",
@@ -1230,8 +1232,6 @@
       "ir/disassembler.h",
       "ir/discard.cc",
       "ir/discard.h",
-      "ir/flow_node.cc",
-      "ir/flow_node.h",
       "ir/function.cc",
       "ir/function.h",
       "ir/function_param.cc",
@@ -1242,8 +1242,6 @@
       "ir/if.h",
       "ir/instruction.cc",
       "ir/instruction.h",
-      "ir/jump.cc",
-      "ir/jump.h",
       "ir/load.cc",
       "ir/load.h",
       "ir/loop.cc",
@@ -1683,6 +1681,7 @@
   tint_unittests_source_set("tint_unittests_constant_src") {
     sources = [
       "constant/composite_test.cc",
+      "constant/manager_test.cc",
       "constant/scalar_test.cc",
       "constant/splat_test.cc",
     ]
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 979c434..ffb4d9d 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -237,6 +237,8 @@
   constant/clone_context.h
   constant/composite.cc
   constant/composite.h
+  constant/manager.cc
+  constant/manager.h
   constant/scalar.cc
   constant/scalar.h
   constant/splat.cc
@@ -740,8 +742,6 @@
     ir/discard.h
     ir/from_program.cc
     ir/from_program.h
-    ir/flow_node.cc
-    ir/flow_node.h
     ir/function.cc
     ir/function.h
     ir/function_param.cc
@@ -752,8 +752,6 @@
     ir/if.h
     ir/instruction.cc
     ir/instruction.h
-    ir/jump.cc
-    ir/jump.h
     ir/load.cc
     ir/load.h
     ir/loop.cc
@@ -925,6 +923,7 @@
     ast/workgroup_attribute_test.cc
     clone_context_test.cc
     constant/composite_test.cc
+    constant/manager_test.cc
     constant/scalar_test.cc
     constant/splat_test.cc
     debug_test.cc
diff --git a/src/tint/constant/clone_context.h b/src/tint/constant/clone_context.h
index 3f597ed..5709baf 100644
--- a/src/tint/constant/clone_context.h
+++ b/src/tint/constant/clone_context.h
@@ -16,11 +16,10 @@
 #define SRC_TINT_CONSTANT_CLONE_CONTEXT_H_
 
 #include "src/tint/type/clone_context.h"
-#include "src/tint/utils/block_allocator.h"
 
-// Forward Declarations
+// Forward declarations
 namespace tint::constant {
-class Value;
+class Manager;
 }  // namespace tint::constant
 
 namespace tint::constant {
@@ -31,10 +30,7 @@
     type::CloneContext type_ctx;
 
     /// Destination information
-    struct {
-        /// The constant allocator
-        utils::BlockAllocator<constant::Value>* constants;
-    } dst;
+    constant::Manager& dst;
 };
 
 }  // namespace tint::constant
diff --git a/src/tint/constant/composite.cc b/src/tint/constant/composite.cc
index 5b004e0..488f6f0 100644
--- a/src/tint/constant/composite.cc
+++ b/src/tint/constant/composite.cc
@@ -16,6 +16,8 @@
 
 #include <utility>
 
+#include "src/tint/constant/manager.h"
+
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Composite);
 
 namespace tint::constant {
@@ -24,17 +26,19 @@
                      utils::VectorRef<const constant::Value*> els,
                      bool all_0,
                      bool any_0)
-    : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {}
+    : type(t), elements(std::move(els)), all_zero(all_0), any_zero(any_0), hash(CalcHash()) {
+    TINT_ASSERT(Constant, !elements.IsEmpty());
+}
 
 Composite::~Composite() = default;
 
-Composite* Composite::Clone(CloneContext& ctx) const {
+const Composite* Composite::Clone(CloneContext& ctx) const {
     auto* ty = type->Clone(ctx.type_ctx);
     utils::Vector<const constant::Value*, 4> els;
     for (const auto* el : elements) {
         els.Push(el->Clone(ctx));
     }
-    return ctx.dst.constants->Create<Composite>(ty, els, all_zero, any_zero);
+    return ctx.dst.Get<Composite>(ty, std::move(els), all_zero, any_zero);
 }
 
 }  // namespace tint::constant
diff --git a/src/tint/constant/composite.h b/src/tint/constant/composite.h
index 7a50640..23367a5 100644
--- a/src/tint/constant/composite.h
+++ b/src/tint/constant/composite.h
@@ -61,7 +61,7 @@
     /// Clones the constant into the provided context
     /// @param ctx the clone context
     /// @returns the cloned node
-    Composite* Clone(CloneContext& ctx) const override;
+    const Composite* Clone(CloneContext& ctx) const override;
 
     /// The composite type
     type::Type const* const type;
diff --git a/src/tint/constant/composite_test.cc b/src/tint/constant/composite_test.cc
index fd083db..6a4c12d 100644
--- a/src/tint/constant/composite_test.cc
+++ b/src/tint/constant/composite_test.cc
@@ -25,15 +25,15 @@
 using ConstantTest_Composite = TestHelper;
 
 TEST_F(ConstantTest_Composite, AllZero) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* compositeAll = create<Composite>(f32, utils::Vector{fPos0, fPos0});
-    auto* compositeAny = create<Composite>(f32, utils::Vector{fNeg0, fPos1, fPos0});
-    auto* compositeNone = create<Composite>(f32, utils::Vector{fNeg0, fNeg0});
+    auto* compositeAll = constants.Composite(vec3f, utils::Vector{fPos0, fPos0});
+    auto* compositeAny = constants.Composite(vec3f, utils::Vector{fNeg0, fPos1, fPos0});
+    auto* compositeNone = constants.Composite(vec3f, utils::Vector{fNeg0, fNeg0});
 
     EXPECT_TRUE(compositeAll->AllZero());
     EXPECT_FALSE(compositeAny->AllZero());
@@ -41,15 +41,15 @@
 }
 
 TEST_F(ConstantTest_Composite, AnyZero) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* compositeAll = create<Composite>(f32, utils::Vector{fPos0, fPos0});
-    auto* compositeAny = create<Composite>(f32, utils::Vector{fNeg0, fPos1, fPos0});
-    auto* compositeNone = create<Composite>(f32, utils::Vector{fNeg0, fNeg0});
+    auto* compositeAll = constants.Composite(vec3f, utils::Vector{fPos0, fPos0});
+    auto* compositeAny = constants.Composite(vec3f, utils::Vector{fNeg0, fPos1, fPos0});
+    auto* compositeNone = constants.Composite(vec3f, utils::Vector{fNeg0, fNeg0});
 
     EXPECT_TRUE(compositeAll->AnyZero());
     EXPECT_TRUE(compositeAny->AnyZero());
@@ -57,12 +57,12 @@
 }
 
 TEST_F(ConstantTest_Composite, Index) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* composite = create<Composite>(f32, utils::Vector{fPos1, fPos0});
+    auto* composite = constants.Composite(vec3f, utils::Vector{fPos1, fPos0});
 
     ASSERT_NE(composite->Index(0), nullptr);
     ASSERT_NE(composite->Index(1), nullptr);
@@ -75,20 +75,19 @@
 }
 
 TEST_F(ConstantTest_Composite, Clone) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* composite = create<Composite>(f32, utils::Vector{fPos1, fPos0});
+    auto* composite = constants.Composite(vec3f, utils::Vector{fPos1, fPos0});
 
-    type::Manager mgr;
-    utils::BlockAllocator<constant::Value> consts;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr}}, {&consts}};
+    constant::Manager mgr;
+    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = composite->As<Composite>()->Clone(ctx);
     ASSERT_NE(r, nullptr);
-    EXPECT_TRUE(r->type->Is<type::F32>());
+    EXPECT_TRUE(r->type->Is<type::Vector>());
     EXPECT_FALSE(r->all_zero);
     EXPECT_TRUE(r->any_zero);
     ASSERT_EQ(r->elements.Length(), 2u);
diff --git a/src/tint/constant/manager.cc b/src/tint/constant/manager.cc
new file mode 100644
index 0000000..829edb2
--- /dev/null
+++ b/src/tint/constant/manager.cc
@@ -0,0 +1,105 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/constant/manager.h"
+
+#include "src/tint/constant/composite.h"
+#include "src/tint/constant/scalar.h"
+#include "src/tint/constant/splat.h"
+#include "src/tint/type/abstract_float.h"
+#include "src/tint/type/abstract_int.h"
+#include "src/tint/type/bool.h"
+#include "src/tint/type/f16.h"
+#include "src/tint/type/f32.h"
+#include "src/tint/type/i32.h"
+#include "src/tint/type/manager.h"
+#include "src/tint/type/u32.h"
+#include "src/tint/utils/predicates.h"
+
+namespace tint::constant {
+
+Manager::Manager() = default;
+
+Manager::Manager(Manager&&) = default;
+
+Manager& Manager::operator=(Manager&& rhs) = default;
+
+Manager::~Manager() = default;
+
+const constant::Value* Manager::Composite(const type::Type* type,
+                                          utils::VectorRef<const constant::Value*> elements) {
+    if (elements.IsEmpty()) {
+        return nullptr;
+    }
+
+    bool any_zero = false;
+    bool all_zero = true;
+    bool all_equal = true;
+    auto* first = elements.Front();
+    for (auto* el : elements) {
+        if (!el) {
+            return nullptr;
+        }
+        if (!any_zero && el->AnyZero()) {
+            any_zero = true;
+        }
+        if (all_zero && !el->AllZero()) {
+            all_zero = false;
+        }
+        if (all_equal && el != first) {
+            all_equal = false;
+        }
+    }
+    if (all_equal) {
+        return Splat(type, elements.Front(), elements.Length());
+    }
+
+    return Get<constant::Composite>(type, std::move(elements), all_zero, any_zero);
+}
+
+const constant::Splat* Manager::Splat(const type::Type* type,
+                                      const constant::Value* element,
+                                      size_t n) {
+    return Get<constant::Splat>(type, element, n);
+}
+
+const Scalar<i32>* Manager::Get(i32 value) {
+    return Get<Scalar<i32>>(types.i32(), value);
+}
+
+const Scalar<u32>* Manager::Get(u32 value) {
+    return Get<Scalar<u32>>(types.u32(), value);
+}
+
+const Scalar<f32>* Manager::Get(f32 value) {
+    return Get<Scalar<f32>>(types.f32(), value);
+}
+
+const Scalar<f16>* Manager::Get(f16 value) {
+    return Get<Scalar<f16>>(types.f16(), value);
+}
+
+const Scalar<bool>* Manager::Get(bool value) {
+    return Get<Scalar<bool>>(types.bool_(), value);
+}
+
+const Scalar<AFloat>* Manager::Get(AFloat value) {
+    return Get<Scalar<AFloat>>(types.AFloat(), value);
+}
+
+const Scalar<AInt>* Manager::Get(AInt value) {
+    return Get<Scalar<AInt>>(types.AInt(), value);
+}
+
+}  // namespace tint::constant
diff --git a/src/tint/constant/manager.h b/src/tint/constant/manager.h
new file mode 100644
index 0000000..d356988
--- /dev/null
+++ b/src/tint/constant/manager.h
@@ -0,0 +1,157 @@
+// 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_CONSTANT_MANAGER_H_
+#define SRC_TINT_CONSTANT_MANAGER_H_
+
+#include <utility>
+
+#include "src/tint/constant/value.h"
+#include "src/tint/number.h"
+#include "src/tint/type/manager.h"
+#include "src/tint/utils/hash.h"
+#include "src/tint/utils/unique_allocator.h"
+
+namespace tint::constant {
+class Splat;
+
+template <typename T>
+class Scalar;
+}  // namespace tint::constant
+
+namespace tint::constant {
+
+/// The constant manager holds a type manager and all the pointers to the known constant values.
+class Manager final {
+  public:
+    /// Iterator is the type returned by begin() and end()
+    using TypeIterator = utils::BlockAllocator<Value>::ConstIterator;
+
+    /// Constructor
+    Manager();
+
+    /// Move constructor
+    Manager(Manager&&);
+
+    /// Move assignment operator
+    /// @param rhs the Manager to move
+    /// @return this Manager
+    Manager& operator=(Manager&& rhs);
+
+    /// Destructor
+    ~Manager();
+
+    /// Wrap returns a new Manager created with the constants and types of `inner`.
+    /// The Manager returned by Wrap is intended to temporarily extend the constants and types of an
+    /// existing immutable Manager. As the copied constants and types are owned by `inner`, `inner`
+    /// must not be destructed or assigned while using the returned Manager.
+    /// TODO(bclayton) - Evaluate whether there are safer alternatives to this
+    /// function. See crbug.com/tint/460.
+    /// @param inner the immutable Manager to extend
+    /// @return the Manager that wraps `inner`
+    static Manager Wrap(const Manager& inner) {
+        Manager out;
+        out.values_.Wrap(inner.values_);
+        out.types = type::Manager::Wrap(inner.types);
+        return out;
+    }
+
+    /// @param args the arguments used to construct the type, unique node or node.
+    /// @return a pointer to an instance of `T` with the provided arguments.
+    ///         If NODE derives from UniqueNode and an existing instance of `T` has been
+    ///         constructed, then the same pointer is returned.
+    template <typename NODE, typename... ARGS>
+    NODE* Get(ARGS&&... args) {
+        return values_.Get<NODE>(std::forward<ARGS>(args)...);
+    }
+
+    /// @returns an iterator to the beginning of the types
+    TypeIterator begin() const { return values_.begin(); }
+    /// @returns an iterator to the end of the types
+    TypeIterator end() const { return values_.end(); }
+
+    /// Constructs a constant of a vector, matrix or array type.
+    ///
+    /// Examines the element values and will return either a constant::Composite or a
+    /// constant::Splat, depending on the element types and values.
+    ///
+    /// @param type the composite type
+    /// @param elements the composite elements
+    /// @returns the value pointer
+    const constant::Value* Composite(const type::Type* type,
+                                     utils::VectorRef<const constant::Value*> elements);
+
+    /// Constructs a splat constant.
+    /// @param type the splat type
+    /// @param element the splat element
+    /// @param n the number of elements
+    /// @returns the value pointer
+    const constant::Splat* Splat(const type::Type* type, const constant::Value* element, size_t n);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the i32 value @p value
+    const Scalar<i32>* Get(i32 value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the u32 value @p value
+    const Scalar<u32>* Get(u32 value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the f32 value @p value
+    const Scalar<f32>* Get(f32 value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the f16 value @p value
+    const Scalar<f16>* Get(f16 value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the bool value @p value
+    const Scalar<bool>* Get(bool value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the AFloat value @p value
+    const Scalar<AFloat>* Get(AFloat value);
+
+    /// @param value the constant value
+    /// @return a Scalar holding the AInt value @p value
+    const Scalar<AInt>* Get(AInt value);
+
+    /// The type manager
+    type::Manager types;
+
+  private:
+    /// A specialization of utils::Hasher for constant::Value
+    struct Hasher {
+        /// @param value the value to hash
+        /// @returns a hash of the value
+        size_t operator()(const constant::Value& value) const { return value.Hash(); }
+    };
+
+    /// An equality helper for constant::Value
+    struct Equal {
+        /// @param a the LHS value
+        /// @param b the RHS value
+        /// @returns true if the two constants are equal
+        bool operator()(const constant::Value& a, const constant::Value& b) const {
+            return a.Equal(&b);
+        }
+    };
+
+    /// Unique types owned by the manager
+    utils::UniqueAllocator<Value, Hasher, Equal> values_;
+};
+
+}  // namespace tint::constant
+
+#endif  // SRC_TINT_CONSTANT_MANAGER_H_
diff --git a/src/tint/constant/manager_test.cc b/src/tint/constant/manager_test.cc
new file mode 100644
index 0000000..ab6135c
--- /dev/null
+++ b/src/tint/constant/manager_test.cc
@@ -0,0 +1,187 @@
+// Copyright 2023 The Tint Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "src/tint/constant/manager.h"
+
+#include "gtest/gtest.h"
+#include "src/tint/constant/scalar.h"
+#include "src/tint/type/abstract_float.h"
+#include "src/tint/type/abstract_int.h"
+#include "src/tint/type/bool.h"
+#include "src/tint/type/f16.h"
+#include "src/tint/type/f32.h"
+#include "src/tint/type/i32.h"
+#include "src/tint/type/manager.h"
+#include "src/tint/type/u32.h"
+
+namespace tint::constant {
+namespace {
+
+using namespace tint::number_suffixes;  // NOLINT
+
+template <typename T>
+size_t count(const T& range_loopable) {
+    size_t n = 0;
+    for (auto it : range_loopable) {
+        (void)it;
+        n++;
+    }
+    return n;
+}
+
+using ManagerTest = testing::Test;
+
+TEST_F(ManagerTest, GetUnregistered) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c)>);
+    ASSERT_NE(c, nullptr);
+}
+
+TEST_F(ManagerTest, GetSameConstantReturnsSamePtr) {
+    constant::Manager cm;
+
+    auto* c1 = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c1)>);
+    ASSERT_NE(c1, nullptr);
+
+    auto* c2 = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c2)>);
+    EXPECT_EQ(c1, c2);
+    EXPECT_EQ(c1->Type(), c2->Type());
+}
+
+TEST_F(ManagerTest, GetDifferentTypeReturnsDifferentPtr) {
+    constant::Manager cm;
+
+    auto* c1 = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c1)>);
+    ASSERT_NE(c1, nullptr);
+
+    auto* c2 = cm.Get(1_u);
+    static_assert(std::is_same_v<const Scalar<u32>*, decltype(c2)>);
+    EXPECT_NE(static_cast<const Value*>(c1), static_cast<const Value*>(c2));
+    EXPECT_NE(c1->Type(), c2->Type());
+}
+
+TEST_F(ManagerTest, GetDifferentValueReturnsDifferentPtr) {
+    constant::Manager cm;
+
+    auto* c1 = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c1)>);
+    ASSERT_NE(c1, nullptr);
+
+    auto* c2 = cm.Get(2_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c2)>);
+    ASSERT_NE(c2, nullptr);
+    EXPECT_NE(c1, c2);
+    EXPECT_EQ(c1->Type(), c2->Type());
+}
+
+TEST_F(ManagerTest, Get_i32) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_i);
+    static_assert(std::is_same_v<const Scalar<i32>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::I32>(c->Type()));
+    EXPECT_EQ(c->value, 1_i);
+}
+
+TEST_F(ManagerTest, Get_u32) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_u);
+    static_assert(std::is_same_v<const Scalar<u32>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::U32>(c->Type()));
+    EXPECT_EQ(c->value, 1_u);
+}
+
+TEST_F(ManagerTest, Get_f32) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_f);
+    static_assert(std::is_same_v<const Scalar<f32>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::F32>(c->Type()));
+    EXPECT_EQ(c->value, 1_f);
+}
+
+TEST_F(ManagerTest, Get_f16) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_h);
+    static_assert(std::is_same_v<const Scalar<f16>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::F16>(c->Type()));
+    EXPECT_EQ(c->value, 1_h);
+}
+
+TEST_F(ManagerTest, Get_bool) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(true);
+    static_assert(std::is_same_v<const Scalar<bool>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::Bool>(c->Type()));
+    EXPECT_EQ(c->value, true);
+}
+
+TEST_F(ManagerTest, Get_AFloat) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1._a);
+    static_assert(std::is_same_v<const Scalar<AFloat>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::AbstractFloat>(c->Type()));
+    EXPECT_EQ(c->value, 1._a);
+}
+
+TEST_F(ManagerTest, Get_AInt) {
+    constant::Manager cm;
+
+    auto* c = cm.Get(1_a);
+    static_assert(std::is_same_v<const Scalar<AInt>*, decltype(c)>);
+    ASSERT_TRUE(Is<type::AbstractInt>(c->Type()));
+    EXPECT_EQ(c->value, 1_a);
+}
+
+TEST_F(ManagerTest, WrapDoesntAffectInner_Constant) {
+    Manager inner;
+    Manager outer = Manager::Wrap(inner);
+
+    inner.Get(1_i);
+
+    EXPECT_EQ(count(inner), 1u);
+    EXPECT_EQ(count(outer), 0u);
+
+    outer.Get(1_i);
+
+    EXPECT_EQ(count(inner), 1u);
+    EXPECT_EQ(count(outer), 1u);
+}
+
+TEST_F(ManagerTest, WrapDoesntAffectInner_Types) {
+    Manager inner;
+    Manager outer = Manager::Wrap(inner);
+
+    inner.types.Get<type::I32>();
+
+    EXPECT_EQ(count(inner.types), 1u);
+    EXPECT_EQ(count(outer.types), 0u);
+
+    outer.types.Get<type::U32>();
+
+    EXPECT_EQ(count(inner.types), 1u);
+    EXPECT_EQ(count(outer.types), 1u);
+}
+
+}  // namespace
+}  // namespace tint::constant
diff --git a/src/tint/constant/scalar.h b/src/tint/constant/scalar.h
index ab5f852..474c9ad 100644
--- a/src/tint/constant/scalar.h
+++ b/src/tint/constant/scalar.h
@@ -15,6 +15,7 @@
 #ifndef SRC_TINT_CONSTANT_SCALAR_H_
 #define SRC_TINT_CONSTANT_SCALAR_H_
 
+#include "src/tint/constant/manager.h"
 #include "src/tint/constant/value.h"
 #include "src/tint/number.h"
 #include "src/tint/type/type.h"
@@ -61,9 +62,9 @@
     /// Clones the constant into the provided context
     /// @param ctx the clone context
     /// @returns the cloned node
-    Scalar* Clone(CloneContext& ctx) const override {
+    const Scalar* Clone(CloneContext& ctx) const override {
         auto* ty = type->Clone(ctx.type_ctx);
-        return ctx.dst.constants->Create<Scalar<T>>(ty, value);
+        return ctx.dst.Get<Scalar<T>>(ty, value);
     }
 
     /// @returns `value` if `T` is not a Number, otherwise ValueOf returns the inner value of the
diff --git a/src/tint/constant/scalar_test.cc b/src/tint/constant/scalar_test.cc
index 6dedf75..49881e5 100644
--- a/src/tint/constant/scalar_test.cc
+++ b/src/tint/constant/scalar_test.cc
@@ -24,40 +24,34 @@
 using ConstantTest_Scalar = TestHelper;
 
 TEST_F(ConstantTest_Scalar, AllZero) {
-    auto* i32 = create<type::I32>();
-    auto* u32 = create<type::U32>();
-    auto* f16 = create<type::F16>();
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
+    auto* i0 = constants.Get(0_i);
+    auto* iPos1 = constants.Get(1_i);
+    auto* iNeg1 = constants.Get(-1_i);
 
-    auto* i0 = create<Scalar<tint::i32>>(i32, 0_i);
-    auto* iPos1 = create<Scalar<tint::i32>>(i32, 1_i);
-    auto* iNeg1 = create<Scalar<tint::i32>>(i32, -1_i);
+    auto* u0 = constants.Get(0_u);
+    auto* u1 = constants.Get(1_u);
 
-    auto* u0 = create<Scalar<tint::u32>>(u32, 0_u);
-    auto* u1 = create<Scalar<tint::u32>>(u32, 1_u);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
+    auto* fNeg1 = constants.Get(-1_f);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
-    auto* fNeg1 = create<Scalar<tint::f32>>(f32, -1_f);
+    auto* f16Pos0 = constants.Get(0_h);
+    auto* f16Neg0 = constants.Get(-0_h);
+    auto* f16Pos1 = constants.Get(1_h);
+    auto* f16Neg1 = constants.Get(-1_h);
 
-    auto* f16Pos0 = create<Scalar<tint::f16>>(f16, 0_h);
-    auto* f16Neg0 = create<Scalar<tint::f16>>(f16, -0_h);
-    auto* f16Pos1 = create<Scalar<tint::f16>>(f16, 1_h);
-    auto* f16Neg1 = create<Scalar<tint::f16>>(f16, -1_h);
+    auto* bf = constants.Get(false);
+    auto* bt = constants.Get(true);
 
-    auto* bf = create<Scalar<bool>>(bool_, false);
-    auto* bt = create<Scalar<bool>>(bool_, true);
+    auto* afPos0 = constants.Get(0.0_a);
+    auto* afNeg0 = constants.Get(-0.0_a);
+    auto* afPos1 = constants.Get(1.0_a);
+    auto* afNeg1 = constants.Get(-1.0_a);
 
-    auto* afPos0 = create<Scalar<tint::AFloat>>(f32, 0.0_a);
-    auto* afNeg0 = create<Scalar<tint::AFloat>>(f32, -0.0_a);
-    auto* afPos1 = create<Scalar<tint::AFloat>>(f32, 1.0_a);
-    auto* afNeg1 = create<Scalar<tint::AFloat>>(f32, -1.0_a);
-
-    auto* ai0 = create<Scalar<tint::AInt>>(i32, 0_a);
-    auto* aiPos1 = create<Scalar<tint::AInt>>(i32, 1_a);
-    auto* aiNeg1 = create<Scalar<tint::AInt>>(i32, -1_a);
+    auto* ai0 = constants.Get(0_a);
+    auto* aiPos1 = constants.Get(1_a);
+    auto* aiNeg1 = constants.Get(-1_a);
 
     EXPECT_TRUE(i0->AllZero());
     EXPECT_FALSE(iPos1->AllZero());
@@ -90,40 +84,34 @@
 }
 
 TEST_F(ConstantTest_Scalar, AnyZero) {
-    auto* i32 = create<type::I32>();
-    auto* u32 = create<type::U32>();
-    auto* f16 = create<type::F16>();
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
+    auto* i0 = constants.Get(0_i);
+    auto* iPos1 = constants.Get(1_i);
+    auto* iNeg1 = constants.Get(-1_i);
 
-    auto* i0 = create<Scalar<tint::i32>>(i32, 0_i);
-    auto* iPos1 = create<Scalar<tint::i32>>(i32, 1_i);
-    auto* iNeg1 = create<Scalar<tint::i32>>(i32, -1_i);
+    auto* u0 = constants.Get(0_u);
+    auto* u1 = constants.Get(1_u);
 
-    auto* u0 = create<Scalar<tint::u32>>(u32, 0_u);
-    auto* u1 = create<Scalar<tint::u32>>(u32, 1_u);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
+    auto* fNeg1 = constants.Get(-1_f);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
-    auto* fNeg1 = create<Scalar<tint::f32>>(f32, -1_f);
+    auto* f16Pos0 = constants.Get(0_h);
+    auto* f16Neg0 = constants.Get(-0_h);
+    auto* f16Pos1 = constants.Get(1_h);
+    auto* f16Neg1 = constants.Get(-1_h);
 
-    auto* f16Pos0 = create<Scalar<tint::f16>>(f16, 0_h);
-    auto* f16Neg0 = create<Scalar<tint::f16>>(f16, -0_h);
-    auto* f16Pos1 = create<Scalar<tint::f16>>(f16, 1_h);
-    auto* f16Neg1 = create<Scalar<tint::f16>>(f16, -1_h);
+    auto* bf = constants.Get(false);
+    auto* bt = constants.Get(true);
 
-    auto* bf = create<Scalar<bool>>(bool_, false);
-    auto* bt = create<Scalar<bool>>(bool_, true);
+    auto* afPos0 = constants.Get(0.0_a);
+    auto* afNeg0 = constants.Get(-0.0_a);
+    auto* afPos1 = constants.Get(1.0_a);
+    auto* afNeg1 = constants.Get(-1.0_a);
 
-    auto* afPos0 = create<Scalar<tint::AFloat>>(f32, 0.0_a);
-    auto* afNeg0 = create<Scalar<tint::AFloat>>(f32, -0.0_a);
-    auto* afPos1 = create<Scalar<tint::AFloat>>(f32, 1.0_a);
-    auto* afNeg1 = create<Scalar<tint::AFloat>>(f32, -1.0_a);
-
-    auto* ai0 = create<Scalar<tint::AInt>>(i32, 0_a);
-    auto* aiPos1 = create<Scalar<tint::AInt>>(i32, 1_a);
-    auto* aiNeg1 = create<Scalar<tint::AInt>>(i32, -1_a);
+    auto* ai0 = constants.Get(0_a);
+    auto* aiPos1 = constants.Get(1_a);
+    auto* aiNeg1 = constants.Get(-1_a);
 
     EXPECT_TRUE(i0->AnyZero());
     EXPECT_FALSE(iPos1->AnyZero());
@@ -156,20 +144,14 @@
 }
 
 TEST_F(ConstantTest_Scalar, ValueOf) {
-    auto* i32 = create<type::I32>();
-    auto* u32 = create<type::U32>();
-    auto* f16 = create<type::F16>();
-    auto* f32 = create<type::F32>();
-    auto* bool_ = create<type::Bool>();
-
-    auto* i1 = create<Scalar<tint::i32>>(i32, 1_i);
-    auto* u1 = create<Scalar<tint::u32>>(u32, 1_u);
-    auto* f1 = create<Scalar<tint::f32>>(f32, 1_f);
-    auto* f16Pos1 = create<Scalar<tint::f16>>(f16, 1_h);
-    auto* bf = create<Scalar<bool>>(bool_, false);
-    auto* bt = create<Scalar<bool>>(bool_, true);
-    auto* af1 = create<Scalar<tint::AFloat>>(f32, 1.0_a);
-    auto* ai1 = create<Scalar<tint::AInt>>(i32, 1_a);
+    auto* i1 = constants.Get(1_i);
+    auto* u1 = constants.Get(1_u);
+    auto* f1 = constants.Get(1_f);
+    auto* f16Pos1 = constants.Get(1_h);
+    auto* bf = constants.Get(false);
+    auto* bt = constants.Get(true);
+    auto* af1 = constants.Get(1.0_a);
+    auto* ai1 = constants.Get(1_a);
 
     EXPECT_EQ(i1->ValueOf(), 1);
     EXPECT_EQ(u1->ValueOf(), 1u);
@@ -182,12 +164,10 @@
 }
 
 TEST_F(ConstantTest_Scalar, Clone) {
-    auto* i32 = create<type::I32>();
-    auto* val = create<Scalar<tint::i32>>(i32, 12_i);
+    auto* val = constants.Get(12_i);
 
-    type::Manager mgr;
-    utils::BlockAllocator<constant::Value> consts;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr}}, {&consts}};
+    constant::Manager mgr;
+    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = val->Clone(ctx);
     ASSERT_NE(r, nullptr);
diff --git a/src/tint/constant/splat.cc b/src/tint/constant/splat.cc
index 4ebfe5f..8adbed7 100644
--- a/src/tint/constant/splat.cc
+++ b/src/tint/constant/splat.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/constant/splat.h"
 
+#include "src/tint/constant/manager.h"
+
 TINT_INSTANTIATE_TYPEINFO(tint::constant::Splat);
 
 namespace tint::constant {
@@ -22,10 +24,10 @@
 
 Splat::~Splat() = default;
 
-Splat* Splat::Clone(CloneContext& ctx) const {
+const Splat* Splat::Clone(CloneContext& ctx) const {
     auto* ty = type->Clone(ctx.type_ctx);
     auto* element = el->Clone(ctx);
-    return ctx.dst.constants->Create<Splat>(ty, element, count);
+    return ctx.dst.Splat(ty, element, count);
 }
 
 }  // namespace tint::constant
diff --git a/src/tint/constant/splat.h b/src/tint/constant/splat.h
index d8e55a6..2bf82dd 100644
--- a/src/tint/constant/splat.h
+++ b/src/tint/constant/splat.h
@@ -57,7 +57,7 @@
     /// Clones the constant into the provided context
     /// @param ctx the clone context
     /// @returns the cloned node
-    Splat* Clone(CloneContext& ctx) const override;
+    const Splat* Clone(CloneContext& ctx) const override;
 
     /// The type of the splat element
     type::Type const* const type;
diff --git a/src/tint/constant/splat_test.cc b/src/tint/constant/splat_test.cc
index fe8aeda..0e2f21e 100644
--- a/src/tint/constant/splat_test.cc
+++ b/src/tint/constant/splat_test.cc
@@ -25,15 +25,15 @@
 using ConstantTest_Splat = TestHelper;
 
 TEST_F(ConstantTest_Splat, AllZero) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* SpfPos0 = create<Splat>(f32, fPos0, 2);
-    auto* SpfNeg0 = create<Splat>(f32, fNeg0, 2);
-    auto* SpfPos1 = create<Splat>(f32, fPos1, 2);
+    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 2);
+    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 2);
+    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 2);
 
     EXPECT_TRUE(SpfPos0->AllZero());
     EXPECT_FALSE(SpfNeg0->AllZero());
@@ -41,15 +41,15 @@
 }
 
 TEST_F(ConstantTest_Splat, AnyZero) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* fPos0 = create<Scalar<tint::f32>>(f32, 0_f);
-    auto* fNeg0 = create<Scalar<tint::f32>>(f32, -0_f);
-    auto* fPos1 = create<Scalar<tint::f32>>(f32, 1_f);
+    auto* fPos0 = constants.Get(0_f);
+    auto* fNeg0 = constants.Get(-0_f);
+    auto* fPos1 = constants.Get(1_f);
 
-    auto* SpfPos0 = create<Splat>(f32, fPos0, 2);
-    auto* SpfNeg0 = create<Splat>(f32, fNeg0, 2);
-    auto* SpfPos1 = create<Splat>(f32, fPos1, 2);
+    auto* SpfPos0 = constants.Splat(vec3f, fPos0, 2);
+    auto* SpfNeg0 = constants.Splat(vec3f, fNeg0, 2);
+    auto* SpfPos1 = constants.Splat(vec3f, fPos1, 2);
 
     EXPECT_TRUE(SpfPos0->AnyZero());
     EXPECT_FALSE(SpfNeg0->AnyZero());
@@ -57,10 +57,10 @@
 }
 
 TEST_F(ConstantTest_Splat, Index) {
-    auto* f32 = create<type::F32>();
+    auto* vec3f = create<type::Vector>(create<type::F32>(), 3u);
 
-    auto* f1 = create<Scalar<tint::f32>>(f32, 1_f);
-    auto* sp = create<Splat>(f32, f1, 2);
+    auto* f1 = constants.Get(1_f);
+    auto* sp = constants.Splat(vec3f, f1, 2);
 
     ASSERT_NE(sp->Index(0), nullptr);
     ASSERT_NE(sp->Index(1), nullptr);
@@ -71,17 +71,16 @@
 }
 
 TEST_F(ConstantTest_Splat, Clone) {
-    auto* i32 = create<type::I32>();
-    auto* val = create<Scalar<tint::i32>>(i32, 12_i);
-    auto* sp = create<Splat>(i32, val, 2);
+    auto* vec3i = create<type::Vector>(create<type::I32>(), 3u);
+    auto* val = constants.Get(12_i);
+    auto* sp = constants.Splat(vec3i, val, 2);
 
-    type::Manager mgr;
-    utils::BlockAllocator<constant::Value> consts;
-    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr}}, {&consts}};
+    constant::Manager mgr;
+    constant::CloneContext ctx{type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
 
     auto* r = sp->Clone(ctx);
     ASSERT_NE(r, nullptr);
-    EXPECT_TRUE(r->type->Is<type::I32>());
+    EXPECT_TRUE(r->type->Is<type::Vector>());
     EXPECT_TRUE(r->el->Is<Scalar<tint::i32>>());
     EXPECT_EQ(r->count, 2u);
 }
diff --git a/src/tint/constant/value.h b/src/tint/constant/value.h
index fe1f78a..baf1171 100644
--- a/src/tint/constant/value.h
+++ b/src/tint/constant/value.h
@@ -80,7 +80,7 @@
     /// Clones the constant into the provided context
     /// @param ctx the clone context
     /// @returns the cloned node
-    virtual Value* Clone(CloneContext& ctx) const = 0;
+    virtual const Value* Clone(CloneContext& ctx) const = 0;
 
   protected:
     /// @returns the value, if this is of a scalar value or abstract numeric, otherwise
diff --git a/src/tint/fuzzers/tint_common_fuzzer.cc b/src/tint/fuzzers/tint_common_fuzzer.cc
index 5595d10..6fa3b6e 100644
--- a/src/tint/fuzzers/tint_common_fuzzer.cc
+++ b/src/tint/fuzzers/tint_common_fuzzer.cc
@@ -248,7 +248,7 @@
             cfg.map.insert({override_id, 0.0});
         }
 
-        if (!cfg.map.empty()) {
+        if (!default_values.empty()) {
             transform::DataMap override_data;
             override_data.Add<ast::transform::SubstituteOverride::Config>(cfg);
 
diff --git a/src/tint/ir/binary_test.cc b/src/tint/ir/binary_test.cc
index dc35978..281d04b 100644
--- a/src/tint/ir/binary_test.cc
+++ b/src/tint/ir/binary_test.cc
@@ -27,7 +27,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.And(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.And(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kAnd);
@@ -48,7 +48,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Or(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Or(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kOr);
@@ -68,7 +68,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Xor(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Xor(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kXor);
@@ -88,7 +88,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Equal(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Equal(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kEqual);
@@ -108,7 +108,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.NotEqual(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.NotEqual(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kNotEqual);
@@ -128,7 +128,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.LessThan(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.LessThan(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kLessThan);
@@ -148,8 +148,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst =
-        b.GreaterThan(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.GreaterThan(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kGreaterThan);
@@ -169,8 +168,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst =
-        b.LessThanEqual(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.LessThanEqual(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kLessThanEqual);
@@ -190,8 +188,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst =
-        b.GreaterThanEqual(b.ir.types.Get<type::Bool>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.GreaterThanEqual(mod.Types().bool_(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kGreaterThanEqual);
@@ -210,7 +207,7 @@
 TEST_F(IR_InstructionTest, CreateNot) {
     Module mod;
     Builder b{mod};
-    const auto* inst = b.Not(b.ir.types.Get<type::Bool>(), b.Constant(true));
+    const auto* inst = b.Not(mod.Types().bool_(), b.Constant(true));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kEqual);
@@ -230,7 +227,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.ShiftLeft(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.ShiftLeft(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kShiftLeft);
@@ -250,7 +247,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.ShiftRight(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.ShiftRight(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kShiftRight);
@@ -270,7 +267,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Add(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Add(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kAdd);
@@ -290,7 +287,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Subtract(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Subtract(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kSubtract);
@@ -310,7 +307,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Multiply(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Multiply(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kMultiply);
@@ -330,7 +327,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Divide(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Divide(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kDivide);
@@ -350,7 +347,7 @@
     Module mod;
     Builder b{mod};
 
-    const auto* inst = b.Modulo(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.Modulo(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     ASSERT_TRUE(inst->Is<Binary>());
     EXPECT_EQ(inst->Kind(), Binary::Kind::kModulo);
@@ -369,7 +366,7 @@
 TEST_F(IR_InstructionTest, Binary_Usage) {
     Module mod;
     Builder b{mod};
-    const auto* inst = b.And(b.ir.types.Get<type::I32>(), b.Constant(4_i), b.Constant(2_i));
+    const auto* inst = b.And(mod.Types().i32(), b.Constant(4_i), b.Constant(2_i));
 
     EXPECT_EQ(inst->Kind(), Binary::Kind::kAnd);
 
@@ -386,7 +383,7 @@
     Module mod;
     Builder b{mod};
     auto val = b.Constant(4_i);
-    const auto* inst = b.And(b.ir.types.Get<type::I32>(), val, val);
+    const auto* inst = b.And(mod.Types().i32(), val, val);
 
     EXPECT_EQ(inst->Kind(), Binary::Kind::kAnd);
     ASSERT_EQ(inst->LHS(), inst->RHS());
diff --git a/src/tint/ir/bitcast_test.cc b/src/tint/ir/bitcast_test.cc
index 6eda562..bf66e39 100644
--- a/src/tint/ir/bitcast_test.cc
+++ b/src/tint/ir/bitcast_test.cc
@@ -27,7 +27,7 @@
 TEST_F(IR_InstructionTest, Bitcast) {
     Module mod;
     Builder b{mod};
-    const auto* inst = b.Bitcast(b.ir.types.Get<type::I32>(), b.Constant(4_i));
+    const auto* inst = b.Bitcast(mod.Types().i32(), b.Constant(4_i));
 
     ASSERT_TRUE(inst->Is<ir::Bitcast>());
     ASSERT_NE(inst->Type(), nullptr);
@@ -43,7 +43,7 @@
 TEST_F(IR_InstructionTest, Bitcast_Usage) {
     Module mod;
     Builder b{mod};
-    const auto* inst = b.Bitcast(b.ir.types.Get<type::I32>(), b.Constant(4_i));
+    const auto* inst = b.Bitcast(mod.Types().i32(), b.Constant(4_i));
 
     const auto args = inst->Args();
     ASSERT_EQ(args.Length(), 1u);
diff --git a/src/tint/ir/block.h b/src/tint/ir/block.h
index abdf2a3..597ff2c 100644
--- a/src/tint/ir/block.h
+++ b/src/tint/ir/block.h
@@ -19,23 +19,22 @@
 
 #include "src/tint/ir/block_param.h"
 #include "src/tint/ir/branch.h"
-#include "src/tint/ir/flow_node.h"
 #include "src/tint/ir/instruction.h"
 #include "src/tint/utils/vector.h"
 
 namespace tint::ir {
 
-/// A flow node comprising a block of statements. The instructions in the block are a linear list of
-/// instructions to execute. The block will branch at the end. The only blocks which do not branch
-/// are the end blocks of functions.
-class Block : public utils::Castable<Block, FlowNode> {
+/// A block of statements. The instructions in the block are a linear list of instructions to
+/// execute. The block will branch at the end. The only blocks which do not branch are the end
+/// blocks of functions.
+class Block : public utils::Castable<Block> {
   public:
     /// Constructor
     Block();
     ~Block() override;
 
     /// @returns true if this is block has a branch target set
-    bool HasBranchTarget() const override {
+    bool HasBranchTarget() const {
         return !instructions_.IsEmpty() && instructions_.Back()->Is<ir::Branch>();
     }
 
@@ -49,7 +48,7 @@
 
     /// @param target the block to see if we trampoline too
     /// @returns if this block just branches to the provided target.
-    bool IsTrampoline(const FlowNode* target) const {
+    bool IsTrampoline(const Block* target) const {
         if (instructions_.Length() != 1) {
             return false;
         }
@@ -78,9 +77,23 @@
     /// @returns the params to the block
     utils::Vector<const BlockParam*, 0>& Params() { return params_; }
 
+    /// @returns the inbound branch list for the block
+    utils::VectorRef<ir::Branch*> InboundBranches() const { return inbound_branches_; }
+
+    /// Adds the given node to the inbound branches
+    /// @param node the node to add
+    void AddInboundBranch(ir::Branch* node) { inbound_branches_.Push(node); }
+
   private:
     utils::Vector<const Instruction*, 16> instructions_;
     utils::Vector<const BlockParam*, 0> params_;
+
+    /// The list of branches into this node. This list maybe empty for several
+    /// reasons:
+    ///   - Node is a start node
+    ///   - Node is a merge target outside control flow (e.g. an if that returns in both branches)
+    ///   - Node is a continue target outside control flow (e.g. a loop that returns)
+    utils::Vector<ir::Branch*, 2> inbound_branches_;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/branch.cc b/src/tint/ir/branch.cc
index a16b7ae..3648b61 100644
--- a/src/tint/ir/branch.cc
+++ b/src/tint/ir/branch.cc
@@ -16,13 +16,13 @@
 
 #include <utility>
 
-#include "src/tint/ir/flow_node.h"
+#include "src/tint/ir/block.h"
 
 TINT_INSTANTIATE_TYPEINFO(tint::ir::Branch);
 
 namespace tint::ir {
 
-Branch::Branch(FlowNode* to, utils::VectorRef<Value*> args) : to_(to), args_(std::move(args)) {
+Branch::Branch(Block* to, utils::VectorRef<Value*> args) : to_(to), args_(std::move(args)) {
     TINT_ASSERT(IR, to_);
     to_->AddInboundBranch(this);
     for (auto* arg : args) {
diff --git a/src/tint/ir/branch.h b/src/tint/ir/branch.h
index fcb1256..fe08b97 100644
--- a/src/tint/ir/branch.h
+++ b/src/tint/ir/branch.h
@@ -21,7 +21,7 @@
 
 // Forward declarations
 namespace tint::ir {
-class FlowNode;
+class Block;
 }  // namespace tint::ir
 
 namespace tint::ir {
@@ -32,17 +32,17 @@
     /// Constructor
     /// @param to the block to branch too
     /// @param args the branch arguments
-    explicit Branch(FlowNode* to, utils::VectorRef<Value*> args = {});
+    explicit Branch(Block* to, utils::VectorRef<Value*> args = {});
     ~Branch() override;
 
     /// @returns the block being branched too.
-    const FlowNode* To() const { return to_; }
+    const Block* To() const { return to_; }
 
     /// @returns the branch arguments
     utils::VectorRef<Value*> Args() const { return args_; }
 
   private:
-    FlowNode* to_;
+    Block* to_;
     utils::Vector<Value*, 2> args_;
 };
 
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 205754b..77c56c8 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -34,31 +34,31 @@
 }
 
 Block* Builder::CreateBlock() {
-    return ir.flow_nodes.Create<Block>();
+    return ir.blocks.Create<Block>();
 }
 
 RootTerminator* Builder::CreateRootTerminator() {
-    return ir.flow_nodes.Create<RootTerminator>();
+    return ir.blocks.Create<RootTerminator>();
 }
 
 FunctionTerminator* Builder::CreateFunctionTerminator() {
-    return ir.flow_nodes.Create<FunctionTerminator>();
+    return ir.blocks.Create<FunctionTerminator>();
 }
 
 Function* Builder::CreateFunction(std::string_view name,
-                                  type::Type* return_type,
+                                  const type::Type* return_type,
                                   Function::PipelineStage stage,
                                   std::optional<std::array<uint32_t, 3>> wg_size) {
     return CreateFunction(ir.symbols.Register(name), return_type, stage, wg_size);
 }
 
 Function* Builder::CreateFunction(Symbol name,
-                                  type::Type* return_type,
+                                  const type::Type* return_type,
                                   Function::PipelineStage stage,
                                   std::optional<std::array<uint32_t, 3>> wg_size) {
     TINT_ASSERT(IR, return_type);
 
-    auto* ir_func = ir.flow_nodes.Create<Function>(name, return_type, stage, wg_size);
+    auto* ir_func = ir.values.Create<Function>(name, return_type, stage, wg_size);
     ir_func->SetStartTarget(CreateBlock());
     ir_func->SetEndTarget(CreateFunctionTerminator());
 
@@ -170,7 +170,7 @@
 }
 
 Binary* Builder::Not(const type::Type* type, Value* val) {
-    return Equal(type, val, Constant(create<constant::Scalar<bool>>(type, false)));
+    return Equal(type, val, Constant(false));
 }
 
 ir::Bitcast* Builder::Bitcast(const type::Type* type, Value* val) {
@@ -217,14 +217,10 @@
     return ir.values.Create<ir::Var>(type);
 }
 
-ir::Branch* Builder::Branch(FlowNode* to, utils::VectorRef<Value*> args) {
+ir::Branch* Builder::Branch(Block* to, utils::VectorRef<Value*> args) {
     return ir.values.Create<ir::Branch>(to, args);
 }
 
-ir::Jump* Builder::Jump(FlowNode* to, utils::VectorRef<Value*> args) {
-    return ir.values.Create<ir::Jump>(to, args);
-}
-
 ir::BlockParam* Builder::BlockParam(const type::Type* type) {
     return ir.values.Create<ir::BlockParam>(type);
 }
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 78bcb9b..02d2b36 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -30,7 +30,6 @@
 #include "src/tint/ir/function_param.h"
 #include "src/tint/ir/function_terminator.h"
 #include "src/tint/ir/if.h"
-#include "src/tint/ir/jump.h"
 #include "src/tint/ir/load.h"
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/module.h"
@@ -76,7 +75,7 @@
     /// @param wg_size the workgroup_size
     /// @returns the flow node
     Function* CreateFunction(std::string_view name,
-                             type::Type* return_type,
+                             const type::Type* return_type,
                              Function::PipelineStage stage = Function::PipelineStage::kUndefined,
                              std::optional<std::array<uint32_t, 3>> wg_size = {});
 
@@ -87,7 +86,7 @@
     /// @param wg_size the workgroup_size
     /// @returns the flow node
     Function* CreateFunction(Symbol name,
-                             type::Type* return_type,
+                             const type::Type* return_type,
                              Function::PipelineStage stage = Function::PipelineStage::kUndefined,
                              std::optional<std::array<uint32_t, 3>> wg_size = {});
 
@@ -111,50 +110,6 @@
     /// @returns the start block for the case flow node
     Block* CreateCase(Switch* s, utils::VectorRef<Switch::CaseSelector> selectors);
 
-    /// Creates a constant::Value
-    /// @param args the arguments
-    /// @returns the new constant value
-    template <typename T, typename... ARGS>
-    utils::traits::EnableIf<utils::traits::IsTypeOrDerived<T, constant::Value>, const T>* create(
-        ARGS&&... args) {
-        return ir.constants_arena.Create<T>(std::forward<ARGS>(args)...);
-    }
-
-    /// @param v the value
-    /// @returns the constant value
-    const constant::Value* Bool(bool v) {
-        // TODO(dsinclair): Replace when constant::Value is uniqed by the arena.
-        return Constant(create<constant::Scalar<bool>>(ir.types.Get<type::Bool>(), v))->Value();
-    }
-
-    /// @param v the value
-    /// @returns the constant value
-    const constant::Value* U32(uint32_t v) {
-        // TODO(dsinclair): Replace when constant::Value is uniqed by the arena.
-        return Constant(create<constant::Scalar<u32>>(ir.types.Get<type::U32>(), u32(v)))->Value();
-    }
-
-    /// @param v the value
-    /// @returns the constant value
-    const constant::Value* I32(int32_t v) {
-        // TODO(dsinclair): Replace when constant::Value is uniqed by the arena.
-        return Constant(create<constant::Scalar<i32>>(ir.types.Get<type::I32>(), i32(v)))->Value();
-    }
-
-    /// @param v the value
-    /// @returns the constant value
-    const constant::Value* F16(float v) {
-        // TODO(dsinclair): Replace when constant::Value is uniqed by the arena.
-        return Constant(create<constant::Scalar<f16>>(ir.types.Get<type::F16>(), f16(v)))->Value();
-    }
-
-    /// @param v the value
-    /// @returns the constant value
-    const constant::Value* F32(float v) {
-        // TODO(dsinclair): Replace when constant::Value is uniqed by the arena.
-        return Constant(create<constant::Scalar<f32>>(ir.types.Get<type::F32>(), f32(v)))->Value();
-    }
-
     /// Creates a new ir::Constant
     /// @param val the constant value
     /// @returns the new constant
@@ -165,37 +120,27 @@
     /// Creates a ir::Constant for an i32 Scalar
     /// @param v the value
     /// @returns the new constant
-    ir::Constant* Constant(i32 v) {
-        return Constant(create<constant::Scalar<i32>>(ir.types.Get<type::I32>(), v));
-    }
+    ir::Constant* Constant(i32 v) { return Constant(ir.constant_values.Get(v)); }
 
     /// Creates a ir::Constant for a u32 Scalar
     /// @param v the value
     /// @returns the new constant
-    ir::Constant* Constant(u32 v) {
-        return Constant(create<constant::Scalar<u32>>(ir.types.Get<type::U32>(), v));
-    }
+    ir::Constant* Constant(u32 v) { return Constant(ir.constant_values.Get(v)); }
 
     /// Creates a ir::Constant for a f32 Scalar
     /// @param v the value
     /// @returns the new constant
-    ir::Constant* Constant(f32 v) {
-        return Constant(create<constant::Scalar<f32>>(ir.types.Get<type::F32>(), v));
-    }
+    ir::Constant* Constant(f32 v) { return Constant(ir.constant_values.Get(v)); }
 
     /// Creates a ir::Constant for a f16 Scalar
     /// @param v the value
     /// @returns the new constant
-    ir::Constant* Constant(f16 v) {
-        return Constant(create<constant::Scalar<f16>>(ir.types.Get<type::F16>(), v));
-    }
+    ir::Constant* Constant(f16 v) { return Constant(ir.constant_values.Get(v)); }
 
     /// Creates a ir::Constant for a bool Scalar
     /// @param v the value
     /// @returns the new constant
-    ir::Constant* Constant(bool v) {
-        return Constant(create<constant::Scalar<bool>>(ir.types.Get<type::Bool>(), v));
-    }
+    ir::Constant* Constant(bool v) { return Constant(ir.constant_values.Get(v)); }
 
     /// Creates an op for `lhs kind rhs`
     /// @param kind the kind of operation
@@ -403,13 +348,7 @@
     /// @param to the node being branched too
     /// @param args the branch arguments
     /// @returns the instruction
-    ir::Branch* Branch(FlowNode* to, utils::VectorRef<Value*> args = {});
-
-    /// Creates a jump declaration
-    /// @param to the node being branched too
-    /// @param args the branch arguments
-    /// @returns the instruction
-    ir::Jump* Jump(FlowNode* to, utils::VectorRef<Value*> args = {});
+    ir::Branch* Branch(Block* to, utils::VectorRef<Value*> args = {});
 
     /// Creates a new `BlockParam`
     /// @param type the parameter type
diff --git a/src/tint/ir/debug.cc b/src/tint/ir/debug.cc
index 7e8155d..ea6363e 100644
--- a/src/tint/ir/debug.cc
+++ b/src/tint/ir/debug.cc
@@ -29,56 +29,56 @@
 
 // static
 std::string Debug::AsDotGraph(const Module* mod) {
-    size_t node_count = 0;
+    size_t block_count = 0;
 
-    std::unordered_set<const FlowNode*> visited;
-    std::unordered_set<const FlowNode*> merge_nodes;
-    std::unordered_map<const FlowNode*, std::string> node_to_name;
+    std::unordered_set<const Block*> visited;
+    std::unordered_set<const Block*> merge_blocks;
+    std::unordered_map<const Block*, std::string> block_to_name;
     utils::StringStream out;
 
-    auto name_for = [&](const FlowNode* node) -> std::string {
-        if (node_to_name.count(node) > 0) {
-            return node_to_name[node];
+    auto name_for = [&](const Block* blk) -> std::string {
+        if (block_to_name.count(blk) > 0) {
+            return block_to_name[blk];
         }
 
-        std::string name = "node_" + std::to_string(node_count);
-        node_count += 1;
+        std::string name = "blk_" + std::to_string(block_count);
+        block_count += 1;
 
-        node_to_name[node] = name;
+        block_to_name[blk] = name;
         return name;
     };
 
-    std::function<void(const FlowNode*)> Graph = [&](const FlowNode* node) {
-        if (visited.count(node) > 0) {
+    std::function<void(const Block*)> Graph = [&](const Block* blk) {
+        if (visited.count(blk) > 0) {
             return;
         }
-        visited.insert(node);
+        visited.insert(blk);
 
         tint::Switch(
-            node,
+            blk,
+            [&](const ir::FunctionTerminator*) {
+                // Already done
+            },
             [&](const ir::Block* b) {
-                if (node_to_name.count(b) == 0) {
+                if (block_to_name.count(b) == 0) {
                     out << name_for(b) << R"( [label="block"])" << std::endl;
                 }
                 out << name_for(b) << " -> " << name_for(b->Branch()->To());
 
                 // Dashed lines to merge blocks
-                if (merge_nodes.count(b->Branch()->To()) != 0) {
+                if (merge_blocks.count(b->Branch()->To()) != 0) {
                     out << " [style=dashed]";
                 }
 
                 out << std::endl;
                 Graph(b->Branch()->To());
-            },
-            [&](const ir::FunctionTerminator*) {
-                // Already done
             });
     };
 
     out << "digraph G {" << std::endl;
     for (const auto* func : mod->functions) {
         // Cluster each function to label and draw a box around it.
-        out << "subgraph cluster_" << name_for(func) << " {" << std::endl;
+        out << "subgraph cluster_" << func->Name().Name() << " {" << std::endl;
         out << R"(label=")" << func->Name().Name() << R"(")" << std::endl;
         out << name_for(func->StartTarget()) << R"( [label="start"])" << std::endl;
         out << name_for(func->EndTarget()) << R"( [label="end"])" << std::endl;
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index 8eb0974..a0edd21 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -27,7 +27,6 @@
 #include "src/tint/ir/discard.h"
 #include "src/tint/ir/function_terminator.h"
 #include "src/tint/ir/if.h"
-#include "src/tint/ir/jump.h"
 #include "src/tint/ir/load.h"
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/root_terminator.h"
@@ -73,9 +72,9 @@
     }
 }
 
-size_t Disassembler::IdOf(const FlowNode* node) {
+size_t Disassembler::IdOf(const Block* node) {
     TINT_ASSERT(IR, node);
-    return flow_node_ids_.GetOrCreate(node, [&] { return flow_node_ids_.Count(); });
+    return block_ids_.GetOrCreate(node, [&] { return block_ids_.Count(); });
 }
 
 std::string_view Disassembler::IdOf(const Value* value) {
@@ -90,111 +89,106 @@
 
 std::string Disassembler::Disassemble() {
     if (mod_.root_block) {
-        walk_list_.push_back(mod_.root_block);
-        Walk();
-        TINT_ASSERT(IR, walk_list_.empty());
+        Indent() << "# Root block" << std::endl;
+        Walk(mod_.root_block);
+        Walk(mod_.root_block->Branch()->To());
     }
 
     for (auto* func : mod_.functions) {
-        walk_list_.push_back(func);
-        Walk();
-        TINT_ASSERT(IR, walk_list_.empty());
+        EmitFunction(func);
     }
     return out_.str();
 }
 
-void Disassembler::Walk() {
-    utils::Hashset<const FlowNode*, 32> visited_;
+void Disassembler::Walk(const Block* blk) {
+    if (visited_.Contains(blk)) {
+        return;
+    }
+    visited_.Add(blk);
 
-    while (!walk_list_.empty()) {
-        const FlowNode* node = walk_list_.front();
-        walk_list_.pop_front();
+    tint::Switch(
+        blk,
+        [&](const ir::FunctionTerminator* t) {
+            TINT_ASSERT(IR, in_function_);
+            Indent() << "%fn" << IdOf(t) << " = func_terminator" << std::endl;
+            in_function_ = false;
+        },
+        [&](const ir::RootTerminator* t) {
+            TINT_ASSERT(IR, !in_function_);
+            Indent() << "%fn" << IdOf(t) << " = root_terminator" << std::endl << std::endl;
+        },
+        [&](const ir::Block* b) {
+            // If this block is dead, nothing to do
+            if (!b->HasBranchTarget()) {
+                return;
+            }
 
-        if (visited_.Contains(node)) {
-            continue;
-        }
-        visited_.Add(node);
-
-        tint::Switch(
-            node,
-            [&](const ir::Function* f) {
-                in_function_ = true;
-
-                Indent() << "%fn" << IdOf(f) << " = func " << f->Name().Name() << "(";
-                for (auto* p : f->Params()) {
-                    if (p != f->Params().Front()) {
+            Indent() << "%fn" << IdOf(b) << " = block";
+            if (!b->Params().IsEmpty()) {
+                out_ << " (";
+                for (auto* p : b->Params()) {
+                    if (p != b->Params().Front()) {
                         out_ << ", ";
                     }
-                    out_ << "%" << IdOf(p) << ":" << p->Type()->FriendlyName();
+                    EmitValue(p);
                 }
-                out_ << "):" << f->ReturnType()->FriendlyName();
+                out_ << ")";
+            }
 
-                if (f->Stage() != Function::PipelineStage::kUndefined) {
-                    out_ << " [@" << f->Stage();
+            out_ << " {" << std::endl;
+            {
+                ScopedIndent si(indent_size_);
+                EmitBlockInstructions(b);
+            }
+            Indent() << "}" << std::endl;
 
-                    if (f->WorkgroupSize()) {
-                        auto arr = f->WorkgroupSize().value();
-                        out_ << " @workgroup_size(" << arr[0] << ", " << arr[1] << ", " << arr[2]
-                             << ")";
-                    }
+            if (!b->Branch()->To()->Is<FunctionTerminator>()) {
+                out_ << std::endl;
+            }
+        });
+}
 
-                    if (!f->ReturnAttributes().IsEmpty()) {
-                        out_ << " ra:";
+void Disassembler::EmitFunction(const Function* func) {
+    in_function_ = true;
 
-                        for (auto attr : f->ReturnAttributes()) {
-                            out_ << " @" << attr;
-                            if (attr == Function::ReturnAttribute::kLocation) {
-                                out_ << "(" << f->ReturnLocation().value() << ")";
-                            }
-                        }
-                    }
-
-                    out_ << "]";
-                }
-                out_ << " -> %fn" << IdOf(f->StartTarget()) << std::endl;
-                walk_list_.push_back(f->StartTarget());
-            },
-            [&](const ir::Block* b) {
-                // If this block is dead, nothing to do
-                if (!b->HasBranchTarget()) {
-                    return;
-                }
-
-                Indent() << "%fn" << IdOf(b) << " = block";
-                if (!b->Params().IsEmpty()) {
-                    out_ << " (";
-                    for (auto* p : b->Params()) {
-                        if (p != b->Params().Front()) {
-                            out_ << ", ";
-                        }
-                        EmitValue(p);
-                    }
-                    out_ << ")";
-                }
-
-                out_ << " {" << std::endl;
-                {
-                    ScopedIndent si(indent_size_);
-                    EmitBlockInstructions(b);
-                }
-                Indent() << "}" << std::endl;
-
-                if (!b->Branch()->To()->Is<FunctionTerminator>()) {
-                    out_ << std::endl;
-                }
-
-                walk_list_.push_back(b->Branch()->To());
-            },
-            [&](const ir::FunctionTerminator* t) {
-                TINT_ASSERT(IR, in_function_);
-                Indent() << "%fn" << IdOf(t) << " = func_terminator" << std::endl << std::endl;
-                in_function_ = false;
-            },
-            [&](const ir::RootTerminator* t) {
-                TINT_ASSERT(IR, !in_function_);
-                Indent() << "%fn" << IdOf(t) << " = root_terminator" << std::endl << std::endl;
-            });
+    Indent() << "%" << IdOf(func) << " = func " << func->Name().Name() << "(";
+    for (auto* p : func->Params()) {
+        if (p != func->Params().Front()) {
+            out_ << ", ";
+        }
+        out_ << "%" << IdOf(p) << ":" << p->Type()->FriendlyName();
     }
+    out_ << "):" << func->ReturnType()->FriendlyName();
+
+    if (func->Stage() != Function::PipelineStage::kUndefined) {
+        out_ << " [@" << func->Stage();
+
+        if (func->WorkgroupSize()) {
+            auto arr = func->WorkgroupSize().value();
+            out_ << " @workgroup_size(" << arr[0] << ", " << arr[1] << ", " << arr[2] << ")";
+        }
+
+        if (!func->ReturnAttributes().IsEmpty()) {
+            out_ << " ra:";
+
+            for (auto attr : func->ReturnAttributes()) {
+                out_ << " @" << attr;
+                if (attr == Function::ReturnAttribute::kLocation) {
+                    out_ << "(" << func->ReturnLocation().value() << ")";
+                }
+            }
+        }
+
+        out_ << "]";
+    }
+    out_ << " -> %fn" << IdOf(func->StartTarget()) << " {" << std::endl;
+
+    {
+        ScopedIndent si(indent_size_);
+        Walk(func->StartTarget());
+        Walk(func->EndTarget());
+    }
+    Indent() << "}" << std::endl;
 }
 
 void Disassembler::EmitValueWithType(const Value* val) {
@@ -333,40 +327,51 @@
         }
         out_ << "f: %fn" << IdOf(i->False());
     }
-    if (i->Merge()->IsConnected()) {
+    if (i->Merge()->HasBranchTarget()) {
         out_ << ", m: %fn" << IdOf(i->Merge());
     }
-    out_ << "]";
+    out_ << "]" << std::endl;
 
     if (has_true) {
-        walk_list_.push_back(i->True());
+        ScopedIndent si(indent_size_);
+        Indent() << "# True block" << std::endl;
+        Walk(i->True());
     }
     if (has_false) {
-        walk_list_.push_back(i->False());
+        ScopedIndent si(indent_size_);
+        Indent() << "# False block" << std::endl;
+        Walk(i->False());
     }
-    if (i->Merge()->IsConnected()) {
-        walk_list_.push_back(i->Merge());
+    if (i->Merge()->HasBranchTarget()) {
+        Indent() << "# Merge block" << std::endl;
+        Walk(i->Merge());
     }
 }
 
 void Disassembler::EmitLoop(const Loop* l) {
     out_ << "loop [s: %fn" << IdOf(l->Start());
 
-    if (l->Continuing()->IsConnected()) {
+    if (l->Continuing()->HasBranchTarget()) {
         out_ << ", c: %fn" << IdOf(l->Continuing());
     }
-    if (l->Merge()->IsConnected()) {
+    if (l->Merge()->HasBranchTarget()) {
         out_ << ", m: %fn" << IdOf(l->Merge());
     }
-    out_ << "]";
+    out_ << "]" << std::endl;
 
-    { walk_list_.push_back(l->Start()); }
-
-    if (l->Continuing()->IsConnected()) {
-        walk_list_.push_back(l->Continuing());
+    {
+        ScopedIndent si(indent_size_);
+        Walk(l->Start());
     }
-    if (l->Merge()->IsConnected()) {
-        walk_list_.push_back(l->Merge());
+
+    if (l->Continuing()->HasBranchTarget()) {
+        ScopedIndent si(indent_size_);
+        Indent() << "# Continuing block" << std::endl;
+        Walk(l->Continuing());
+    }
+    if (l->Merge()->HasBranchTarget()) {
+        Indent() << "# Merge block" << std::endl;
+        Walk(l->Merge());
     }
 }
 
@@ -392,32 +397,25 @@
         }
         out_ << ", %fn" << IdOf(c.Start()) << ")";
     }
-    if (s->Merge()->IsConnected()) {
+    if (s->Merge()->HasBranchTarget()) {
         out_ << ", m: %fn" << IdOf(s->Merge());
     }
-    out_ << "]";
+    out_ << "]" << std::endl;
 
     for (auto& c : s->Cases()) {
-        walk_list_.push_back(c.Start());
+        ScopedIndent si(indent_size_);
+        Indent() << "# Case block" << std::endl;
+        Walk(c.Start());
     }
-    if (s->Merge()->IsConnected()) {
-        walk_list_.push_back(s->Merge());
+    if (s->Merge()->HasBranchTarget()) {
+        Indent() << "# Merge block" << std::endl;
+        Walk(s->Merge());
     }
 }
 
 void Disassembler::EmitBranch(const Branch* b) {
-    if (b->Is<Jump>()) {
-        out_ << "jmp ";
-
-        // Stuff the thing we're jumping too into the front of the walk list so it will be emitted
-        // next.
-        walk_list_.push_front(b->To());
-    } else {
-        out_ << "br ";
-    }
-
     std::string suffix = "";
-    out_ << "%fn" << IdOf(b->To());
+    out_ << "br %fn" << IdOf(b->To());
     if (b->To()->Is<FunctionTerminator>()) {
         suffix = "return";
     } else if (b->To()->Is<RootTerminator>()) {
diff --git a/src/tint/ir/disassembler.h b/src/tint/ir/disassembler.h
index 7b9e4c5..f171031 100644
--- a/src/tint/ir/disassembler.h
+++ b/src/tint/ir/disassembler.h
@@ -15,18 +15,18 @@
 #ifndef SRC_TINT_IR_DISASSEMBLER_H_
 #define SRC_TINT_IR_DISASSEMBLER_H_
 
-#include <deque>
 #include <string>
 
 #include "src/tint/ir/binary.h"
+#include "src/tint/ir/block.h"
 #include "src/tint/ir/call.h"
-#include "src/tint/ir/flow_node.h"
 #include "src/tint/ir/if.h"
 #include "src/tint/ir/loop.h"
 #include "src/tint/ir/module.h"
 #include "src/tint/ir/switch.h"
 #include "src/tint/ir/unary.h"
 #include "src/tint/utils/hashmap.h"
+#include "src/tint/utils/hashset.h"
 #include "src/tint/utils/string_stream.h"
 
 namespace tint::ir {
@@ -53,10 +53,11 @@
   private:
     utils::StringStream& Indent();
 
-    size_t IdOf(const FlowNode* node);
+    size_t IdOf(const Block* blk);
     std::string_view IdOf(const Value* node);
 
-    void Walk();
+    void Walk(const Block* blk);
+    void EmitFunction(const Function* func);
     void EmitInstruction(const Instruction* inst);
     void EmitValueWithType(const Value* val);
     void EmitValue(const Value* val);
@@ -70,8 +71,8 @@
 
     const Module& mod_;
     utils::StringStream out_;
-    std::deque<const FlowNode*> walk_list_;
-    utils::Hashmap<const FlowNode*, size_t, 32> flow_node_ids_;
+    utils::Hashset<const Block*, 32> visited_;
+    utils::Hashmap<const Block*, size_t, 32> block_ids_;
     utils::Hashmap<const Value*, std::string, 32> value_ids_;
     uint32_t indent_size_ = 0;
     bool in_function_ = false;
diff --git a/src/tint/ir/flow_node.cc b/src/tint/ir/flow_node.cc
deleted file mode 100644
index bbbd78b..0000000
--- a/src/tint/ir/flow_node.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2022 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/ir/flow_node.h"
-
-TINT_INSTANTIATE_TYPEINFO(tint::ir::FlowNode);
-
-namespace tint::ir {
-
-FlowNode::FlowNode() = default;
-
-FlowNode::~FlowNode() = default;
-
-}  // namespace tint::ir
diff --git a/src/tint/ir/flow_node.h b/src/tint/ir/flow_node.h
deleted file mode 100644
index b072964..0000000
--- a/src/tint/ir/flow_node.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2022 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_TINT_IR_FLOW_NODE_H_
-#define SRC_TINT_IR_FLOW_NODE_H_
-
-#include "src/tint/utils/castable.h"
-#include "src/tint/utils/vector.h"
-
-// Forward Declarations
-namespace tint::ir {
-class Branch;
-}  // namespace tint::ir
-
-namespace tint::ir {
-
-/// Base class for flow nodes
-class FlowNode : public utils::Castable<FlowNode> {
-  public:
-    ~FlowNode() override;
-
-    /// @returns true if this node has inbound branches and branches out
-    bool IsConnected() const { return HasBranchTarget(); }
-
-    /// @returns true if the node has a branch target
-    virtual bool HasBranchTarget() const { return false; }
-
-    /// @returns the inbound branch list for the flow node
-    utils::VectorRef<Branch*> InboundBranches() const { return inbound_branches_; }
-
-    /// Adds the given node to the inbound branches
-    /// @param node the node to add
-    void AddInboundBranch(Branch* node) { inbound_branches_.Push(node); }
-
-  protected:
-    /// Constructor
-    FlowNode();
-
-  private:
-    /// The list of flow nodes which branch into this node. This list maybe empty for several
-    /// reasons:
-    ///   - Node is a start node
-    ///   - Node is a merge target outside control flow (e.g. an if that returns in both branches)
-    ///   - Node is a continue target outside control flow (e.g. a loop that returns)
-    utils::Vector<Branch*, 2> inbound_branches_;
-};
-
-}  // namespace tint::ir
-
-#endif  // SRC_TINT_IR_FLOW_NODE_H_
diff --git a/src/tint/ir/from_program.cc b/src/tint/ir/from_program.cc
index 212efea..f64037a 100644
--- a/src/tint/ir/from_program.cc
+++ b/src/tint/ir/from_program.cc
@@ -101,11 +101,7 @@
 // For an `if` and `switch` block, the merge has a registered incoming branch instruction of the
 // `if` and `switch. So, to determine if the merge is connected to any of the branches that happend
 // in the `if` or `switch` we need a `count` value that is larger then 1.
-bool IsConnected(const FlowNode* b, uint32_t count) {
-    // Function is always connected as it's the start.
-    if (b->Is<ir::Function>()) {
-        return true;
-    }
+bool IsConnected(const Block* b, uint32_t count) {
     return b->InboundBranches().Length() > count;
 }
 
@@ -136,9 +132,9 @@
     constant::CloneContext clone_ctx_{
         /* type_ctx */ type::CloneContext{
             /* src */ {&program_->Symbols()},
-            /* dst */ {&builder_.ir.symbols, &builder_.ir.types},
+            /* dst */ {&builder_.ir.symbols, &builder_.ir.Types()},
         },
-        /* dst */ {&builder_.ir.constants_arena},
+        /* dst */ {builder_.ir.constant_values},
     };
 
     /// The stack of control blocks.
@@ -170,21 +166,7 @@
         diagnostics_.add_error(tint::diag::System::IR, err, s);
     }
 
-    void JumpTo(FlowNode* node, utils::VectorRef<Value*> args = {}) {
-        TINT_ASSERT(IR, current_flow_block_);
-        TINT_ASSERT(IR, !current_flow_block_->HasBranchTarget());
-
-        current_flow_block_->Instructions().Push(builder_.Jump(node, args));
-        current_flow_block_ = nullptr;
-    }
-    void JumpToIfNeeded(FlowNode* node) {
-        if (!current_flow_block_ || current_flow_block_->HasBranchTarget()) {
-            return;
-        }
-        JumpTo(node);
-    }
-
-    void BranchTo(FlowNode* node, utils::VectorRef<Value*> args = {}) {
+    void BranchTo(Block* node, utils::VectorRef<Value*> args = {}) {
         TINT_ASSERT(IR, current_flow_block_);
         TINT_ASSERT(IR, !current_flow_block_->HasBranchTarget());
 
@@ -192,7 +174,7 @@
         current_flow_block_ = nullptr;
     }
 
-    void BranchToIfNeeded(FlowNode* node) {
+    void BranchToIfNeeded(Block* node) {
         if (!current_flow_block_ || current_flow_block_->HasBranchTarget()) {
             return;
         }
@@ -357,7 +339,7 @@
 
             // If the branch target has already been set then a `return` was called. Only set in
             // the case where `return` wasn't called.
-            JumpToIfNeeded(current_function_->EndTarget());
+            BranchToIfNeeded(current_function_->EndTarget());
         }
 
         TINT_ASSERT(IR, control_stack_.IsEmpty());
@@ -587,7 +569,7 @@
 
             // The current block didn't `break`, `return` or `continue`, go to the continuing
             // block.
-            JumpToIfNeeded(loop_inst->Continuing());
+            BranchToIfNeeded(loop_inst->Continuing());
 
             current_flow_block_ = loop_inst->Continuing();
             if (stmt->continuing) {
@@ -634,7 +616,7 @@
             current_flow_block_ = if_inst->Merge();
             EmitBlock(stmt->body);
 
-            JumpToIfNeeded(loop_inst->Continuing());
+            BranchToIfNeeded(loop_inst->Continuing());
         }
         // The while loop always has a path to the Merge().target as the break statement comes
         // before anything inside the loop.
@@ -678,7 +660,7 @@
             }
 
             EmitBlock(stmt->body);
-            JumpToIfNeeded(loop_inst->Continuing());
+            BranchToIfNeeded(loop_inst->Continuing());
 
             if (stmt->continuing) {
                 current_flow_block_ = loop_inst->Continuing();
@@ -766,7 +748,7 @@
 
     // Discard is being treated as an instruction. The semantics in WGSL is demote_to_helper, so
     // the code has to continue as before it just predicates writes. If WGSL grows some kind of
-    // terminating discard that would probably make sense as a FlowNode but would then require
+    // terminating discard that would probably make sense as a Block but would then require
     // figuring out the multi-level exit that is triggered.
     void EmitDiscard(const ast::DiscardStatement*) {
         auto* inst = builder_.Discard();
@@ -859,7 +841,7 @@
             var,
             [&](const ast::Var* v) {
                 auto* ref = sem->Type()->As<type::Reference>();
-                auto* ty = builder_.ir.types.Get<type::Pointer>(
+                auto* ty = builder_.ir.Types().Get<type::Pointer>(
                     ref->StoreType()->Clone(clone_ctx_.type_ctx), ref->AddressSpace(),
                     ref->Access());
 
@@ -964,7 +946,7 @@
         auto* if_inst = builder_.CreateIf(lhs.Get());
         current_flow_block_->Instructions().Push(if_inst);
 
-        auto* result = builder_.BlockParam(builder_.ir.types.Get<type::Bool>());
+        auto* result = builder_.BlockParam(builder_.ir.Types().bool_());
         if_inst->Merge()->SetParams(utils::Vector{result});
 
         utils::Result<Value*> rhs;
diff --git a/src/tint/ir/from_program_binary_test.cc b/src/tint/ir/from_program_binary_test.cc
index 6e63e40..7909bda 100644
--- a/src/tint/ir/from_program_binary_test.cc
+++ b/src/tint/ir/from_program_binary_test.cc
@@ -34,20 +34,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = add %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = add %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -59,22 +59,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = add %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = add %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -86,22 +87,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = add %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = add %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -113,20 +115,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = sub %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = sub %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -138,22 +140,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, i32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:i32 = load %v1
-  %3:i32 = sub %2, 1i
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:i32 = load %v1
+    %4:i32 = sub %3, 1i
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -165,22 +168,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = sub %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = sub %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -192,20 +196,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = mul %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = mul %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -217,22 +221,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = mul %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = mul %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -244,20 +249,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = div %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = div %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -269,22 +274,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = div %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = div %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -296,20 +302,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = mod %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = mod %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -321,22 +327,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = mod %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = mod %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -348,20 +355,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = and %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = and %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -373,22 +380,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, bool, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:bool = load %v1
-  %3:bool = and %2, false
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:bool = load %v1
+    %4:bool = and %3, false
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -400,20 +408,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = or %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = or %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -425,22 +433,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, bool, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:bool = load %v1
-  %3:bool = or %2, false
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:bool = load %v1
+    %4:bool = or %3, false
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -452,20 +461,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = xor %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = xor %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -477,22 +486,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = xor %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = xor %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -504,43 +514,51 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():bool -> %fn2
-%fn2 = block {
-  br %fn3 true  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():bool -> %fn1 {
+  %fn1 = block {
+    br %fn2 true  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:bool = call my_func
+    if %3 [t: %fn4, f: %fn5, m: %fn6]
+      # True block
+      %fn4 = block {
+        br %fn6 false
+      }
 
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:bool = call my_func
-  if %1 [t: %fn6, f: %fn7, m: %fn8]
+      # False block
+      %fn5 = block {
+        br %fn6 %3
+      }
+
+    # Merge block
+    %fn6 = block (%4:bool) {
+      if %4:bool [t: %fn7, f: %fn8, m: %fn9]
+        # True block
+        %fn7 = block {
+          br %fn9
+        }
+
+        # False block
+        %fn8 = block {
+          br %fn9
+        }
+
+      # Merge block
+      %fn9 = block {
+        br %fn10  # return
+      }
+
+    }
+
+
+  }
+
+  %fn10 = func_terminator
 }
-
-%fn6 = block {
-  br %fn8 false
-}
-
-%fn7 = block {
-  br %fn8 %1
-}
-
-%fn8 = block (%2:bool) {
-  if %2:bool [t: %fn9, f: %fn10, m: %fn11]
-}
-
-%fn9 = block {
-  br %fn11
-}
-
-%fn10 = block {
-  br %fn11
-}
-
-%fn11 = block {
-  jmp %fn12  # return
-}
-%fn12 = func_terminator
-
 )");
 }
 
@@ -552,43 +570,51 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():bool -> %fn2
-%fn2 = block {
-  br %fn3 true  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():bool -> %fn1 {
+  %fn1 = block {
+    br %fn2 true  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:bool = call my_func
+    if %3 [t: %fn4, f: %fn5, m: %fn6]
+      # True block
+      %fn4 = block {
+        br %fn6 %3
+      }
 
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:bool = call my_func
-  if %1 [t: %fn6, f: %fn7, m: %fn8]
+      # False block
+      %fn5 = block {
+        br %fn6 true
+      }
+
+    # Merge block
+    %fn6 = block (%4:bool) {
+      if %4:bool [t: %fn7, f: %fn8, m: %fn9]
+        # True block
+        %fn7 = block {
+          br %fn9
+        }
+
+        # False block
+        %fn8 = block {
+          br %fn9
+        }
+
+      # Merge block
+      %fn9 = block {
+        br %fn10  # return
+      }
+
+    }
+
+
+  }
+
+  %fn10 = func_terminator
 }
-
-%fn6 = block {
-  br %fn8 %1
-}
-
-%fn7 = block {
-  br %fn8 true
-}
-
-%fn8 = block (%2:bool) {
-  if %2:bool [t: %fn9, f: %fn10, m: %fn11]
-}
-
-%fn9 = block {
-  br %fn11
-}
-
-%fn10 = block {
-  br %fn11
-}
-
-%fn11 = block {
-  jmp %fn12  # return
-}
-%fn12 = func_terminator
-
 )");
 }
 
@@ -600,20 +626,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = eq %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = eq %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -625,20 +651,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = neq %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = neq %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -650,20 +676,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = lt %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = lt %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -675,20 +701,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = gt %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = gt %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -700,20 +726,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = lte %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = lte %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -725,20 +751,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:bool = gte %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:bool = gte %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -750,20 +776,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = shiftl %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = shiftl %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -775,22 +801,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = shiftl %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = shiftl %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -802,20 +829,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 0u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = shiftr %1, 4u
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = shiftr %3, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -827,22 +854,23 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v1:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:u32 = load %v1
-  %3:u32 = shiftr %2, 1u
-  store %v1, %3
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = load %v1
+    %4:u32 = shiftr %3, 1u
+    store %v1, %4
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -856,37 +884,41 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():f32 -> %fn2
-%fn2 = block {
-  br %fn3 0.0f  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():f32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0.0f  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:f32 = call my_func
+    %4:bool = lt %3, 2.0f
+    if %4 [t: %fn4, f: %fn5, m: %fn6]
+      # True block
+      %fn4 = block {
+        %5:f32 = call my_func
+        %6:f32 = call my_func
+        %7:f32 = mul 2.29999995231628417969f, %6
+        %8:f32 = div %5, %7
+        %9:bool = gt 2.5f, %8
+        br %fn6 %9
+      }
 
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:f32 = call my_func
-  %2:bool = lt %1, 2.0f
-  if %2 [t: %fn6, f: %fn7, m: %fn8]
+      # False block
+      %fn5 = block {
+        br %fn6 %4
+      }
+
+    # Merge block
+    %fn6 = block (%tint_symbol:bool) {
+      br %fn7  # return
+    }
+
+  }
+
+  %fn7 = func_terminator
 }
-
-%fn6 = block {
-  %3:f32 = call my_func
-  %4:f32 = call my_func
-  %5:f32 = mul 2.29999995231628417969f, %4
-  %6:f32 = div %3, %5
-  %7:bool = gt 2.5f, %6
-  br %fn8 %7
-}
-
-%fn7 = block {
-  br %fn8 %2
-}
-
-%fn8 = block (%tint_symbol:bool) {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
-
 )");
 }
 
@@ -899,19 +931,19 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func(%p:bool):bool -> %fn2
-%fn2 = block {
-  br %fn3 true  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func(%p:bool):bool -> %fn1 {
+  %fn1 = block {
+    br %fn2 true  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %tint_symbol:bool = call my_func, false
-  jmp %fn6  # return
+%3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %tint_symbol:bool = call my_func, false
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_call_test.cc b/src/tint/ir/from_program_call_test.cc
index 2f74508..2d0f1ab 100644
--- a/src/tint/ir/from_program_call_test.cc
+++ b/src/tint/ir/from_program_call_test.cc
@@ -35,20 +35,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():f32 -> %fn2
-%fn2 = block {
-  br %fn3 0.0f  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():f32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 0.0f  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:f32 = call my_func
-  %tint_symbol:f32 = bitcast %1
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:f32 = call my_func
+    %tint_symbol:f32 = bitcast %3
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -62,13 +62,13 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func test_function():void [@fragment] -> %fn2
-%fn2 = block {
-  discard
-  jmp %fn3  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func test_function():void [@fragment] -> %fn1 {
+  %fn1 = block {
+    discard
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
@@ -80,19 +80,19 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func(%p:f32):void -> %fn2
-%fn2 = block {
-  jmp %fn3  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func(%p:f32):void -> %fn1 {
+  %fn1 = block {
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %2:void = call my_func, 6.0f
-  jmp %fn6  # return
+%3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %4:void = call my_func, 6.0f
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -104,21 +104,22 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %i:ptr<private, i32, read_write> = var, 1i
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:i32 = load %i
-  %tint_symbol:f32 = convert i32, %2
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:i32 = load %i
+    %tint_symbol:f32 = convert i32, %3
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -129,7 +130,8 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %i:ptr<private, vec3<f32>, read_write> = var, vec3<f32> 0.0f
   br %fn2  # root_end
 }
@@ -147,21 +149,22 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %i:ptr<private, f32, read_write> = var, 1.0f
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  %2:f32 = load %i
-  %tint_symbol:vec3<f32> = construct 2.0f, 3.0f, %2
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:f32 = load %i
+    %tint_symbol:vec3<f32> = construct 2.0f, 3.0f, %3
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_materialize_test.cc b/src/tint/ir/from_program_materialize_test.cc
index 009d417..68bb81a 100644
--- a/src/tint/ir/from_program_materialize_test.cc
+++ b/src/tint/ir/from_program_materialize_test.cc
@@ -34,12 +34,12 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func test_function():f32 -> %fn2
-%fn2 = block {
-  br %fn3 2.0f  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func test_function():f32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 2.0f  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_store_test.cc b/src/tint/ir/from_program_store_test.cc
index ab0945b..1559f95 100644
--- a/src/tint/ir/from_program_store_test.cc
+++ b/src/tint/ir/from_program_store_test.cc
@@ -35,20 +35,21 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %a:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  store %a, 4u
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    store %a, 4u
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_test.cc b/src/tint/ir/from_program_test.cc
index 197e7e3..bc3b2a1 100644
--- a/src/tint/ir/from_program_test.cc
+++ b/src/tint/ir/from_program_test.cc
@@ -70,12 +70,12 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func f():void -> %fn2
-%fn2 = block {
-  jmp %fn3  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func f():void -> %fn1 {
+  %fn1 = block {
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
@@ -95,12 +95,12 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func f(%a:u32):u32 -> %fn2
-%fn2 = block {
-  br %fn3 %a  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func f(%a:u32):u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 %a  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
@@ -121,12 +121,12 @@
 
     EXPECT_EQ(m->functions[0]->Stage(), Function::PipelineStage::kUndefined);
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func f(%a:u32, %b:i32, %c:bool):void -> %fn2
-%fn2 = block {
-  jmp %fn3  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func f(%a:u32, %b:i32, %c:bool):void -> %fn1 {
+  %fn1 = block {
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
@@ -159,24 +159,28 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  if true [t: %fn3, f: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    if true [t: %fn2, f: %fn3, m: %fn4]
+      # True block
+      %fn2 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn5
-}
+      # False block
+      %fn3 = block {
+        br %fn4
+      }
 
-%fn4 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -199,23 +203,27 @@
     EXPECT_EQ(2u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  if true [t: %fn3, f: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    if true [t: %fn2, f: %fn3, m: %fn4]
+      # True block
+      %fn2 = block {
+        br %fn5  # return
+      }
+      # False block
+      %fn3 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn6  # return
-}
-%fn4 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -238,23 +246,27 @@
     EXPECT_EQ(2u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  if true [t: %fn3, f: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    if true [t: %fn2, f: %fn3, m: %fn4]
+      # True block
+      %fn2 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn5
-}
+      # False block
+      %fn3 = block {
+        br %fn5  # return
+      }
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn4 = block {
-  br %fn6  # return
-}
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -277,19 +289,22 @@
     EXPECT_EQ(2u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  if true [t: %fn3, f: %fn4]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    if true [t: %fn2, f: %fn3]
+      # True block
+      %fn2 = block {
+        br %fn4  # return
+      }
+      # False block
+      %fn3 = block {
+        br %fn4  # return
+      }
 
-%fn3 = block {
-  br %fn5  # return
-}
-%fn4 = block {
-  br %fn5  # return
-}
-%fn5 = func_terminator
+  }
 
+  %fn4 = func_terminator
+}
 )");
 }
 
@@ -309,36 +324,43 @@
     ASSERT_NE(loop_flow, nullptr);
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  if true [t: %fn3, f: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    if true [t: %fn2, f: %fn3, m: %fn4]
+      # True block
+      %fn2 = block {
+        loop [s: %fn5, c: %fn6, m: %fn7]
+          %fn5 = block {
+            br %fn7
+          }
 
-%fn3 = block {
-  loop [s: %fn6, c: %fn7, m: %fn8]
-}
+          # Continuing block
+          %fn6 = block {
+            br %fn5
+          }
 
-%fn4 = block {
-  br %fn5
-}
+        # Merge block
+        %fn7 = block {
+          br %fn4
+        }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
 
-%fn6 = block {
-  br %fn8
-}
+      }
 
-%fn7 = block {
-  br %fn6
-}
+      # False block
+      %fn3 = block {
+        br %fn4
+      }
 
-%fn8 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
+  }
+
+  %fn8 = func_terminator
+}
 )");
 }
 
@@ -361,24 +383,27 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn5
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn4 = block {
-  br %fn3
-}
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -407,36 +432,43 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        if true [t: %fn5, f: %fn6, m: %fn7]
+          # True block
+          %fn5 = block {
+            br %fn4
+          }
 
-%fn3 = block {
-  if true [t: %fn6, f: %fn7, m: %fn8]
-}
+          # False block
+          %fn6 = block {
+            br %fn7
+          }
 
-%fn4 = block {
-  br %fn3
-}
+        # Merge block
+        %fn7 = block {
+          br %fn3
+        }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
 
-%fn6 = block {
-  br %fn5
-}
+      }
 
-%fn7 = block {
-  br %fn8
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn8 = block {
-  br %fn4
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
+  }
+
+  %fn8 = func_terminator
+}
 )");
 }
 
@@ -464,36 +496,43 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        br %fn3
+      }
 
-%fn3 = block {
-  jmp %fn4
-}
+      # Continuing block
+      %fn3 = block {
+        if true [t: %fn5, f: %fn6, m: %fn7]
+          # True block
+          %fn5 = block {
+            br %fn4
+          }
 
-%fn4 = block {
-  if true [t: %fn6, f: %fn7, m: %fn8]
-}
+          # False block
+          %fn6 = block {
+            br %fn7
+          }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
+        # Merge block
+        %fn7 = block {
+          br %fn2
+        }
 
-%fn6 = block {
-  br %fn5
-}
 
-%fn7 = block {
-  br %fn8
-}
+      }
 
-%fn8 = block {
-  br %fn3
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
+  }
+
+  %fn8 = func_terminator
+}
 )");
 }
 
@@ -508,36 +547,43 @@
 
     auto m = res.Move();
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        br %fn3
+      }
 
-%fn3 = block {
-  jmp %fn4
-}
+      # Continuing block
+      %fn3 = block {
+        if true [t: %fn5, f: %fn6, m: %fn7]
+          # True block
+          %fn5 = block {
+            br %fn4
+          }
 
-%fn4 = block {
-  if true [t: %fn6, f: %fn7, m: %fn8]
-}
+          # False block
+          %fn6 = block {
+            br %fn7
+          }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
+        # Merge block
+        %fn7 = block {
+          br %fn2
+        }
 
-%fn6 = block {
-  br %fn5
-}
 
-%fn7 = block {
-  br %fn8
-}
+      }
 
-%fn8 = block {
-  br %fn3
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
+  }
+
+  %fn8 = func_terminator
+}
 )");
 }
 
@@ -565,32 +611,38 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3]
+      %fn2 = block {
+        if true [t: %fn4, f: %fn5, m: %fn6]
+          # True block
+          %fn4 = block {
+            br %fn7  # return
+          }
+          # False block
+          %fn5 = block {
+            br %fn6
+          }
 
-%fn3 = block {
-  if true [t: %fn5, f: %fn6, m: %fn7]
-}
+        # Merge block
+        %fn6 = block {
+          br %fn3
+        }
 
-%fn4 = block {
-  br %fn3
-}
 
-%fn5 = block {
-  br %fn8  # return
-}
-%fn6 = block {
-  br %fn7
-}
+      }
 
-%fn7 = block {
-  br %fn4
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
+
+
+  }
+
+  %fn7 = func_terminator
 }
-
-%fn8 = func_terminator
-
 )");
 }
 
@@ -613,20 +665,22 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3]
+      %fn2 = block {
+        br %fn4  # return
+      }
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn3 = block {
-  br %fn5  # return
-}
-%fn4 = block {
-  br %fn3
-}
 
-%fn5 = func_terminator
+  }
 
+  %fn4 = func_terminator
+}
 )");
 }
 
@@ -658,45 +712,56 @@
     EXPECT_EQ(3u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        br %fn5  # return
+      }
+      # Continuing block
+      %fn3 = block {
+        if true [t: %fn6, f: %fn7, m: %fn8]
+          # True block
+          %fn6 = block {
+            br %fn4
+          }
 
-%fn3 = block {
-  br %fn6  # return
-}
-%fn4 = block {
-  if true [t: %fn7, f: %fn8, m: %fn9]
-}
+          # False block
+          %fn7 = block {
+            br %fn8
+          }
 
-%fn5 = block {
-  if true [t: %fn10, f: %fn11, m: %fn12]
-}
+        # Merge block
+        %fn8 = block {
+          br %fn2
+        }
 
-%fn6 = func_terminator
 
-%fn7 = block {
-  br %fn5
-}
+      }
 
-%fn8 = block {
-  br %fn9
-}
+    # Merge block
+    %fn4 = block {
+      if true [t: %fn9, f: %fn10, m: %fn11]
+        # True block
+        %fn9 = block {
+          br %fn5  # return
+        }
+        # False block
+        %fn10 = block {
+          br %fn11
+        }
 
-%fn9 = block {
-  br %fn3
-}
+      # Merge block
+      %fn11 = block {
+        br %fn5  # return
+      }
 
-%fn10 = block {
-  br %fn6  # return
-}
-%fn11 = block {
-  br %fn12
-}
+    }
 
-%fn12 = block {
-  jmp %fn6  # return
+
+  }
+
+  %fn5 = func_terminator
 }
 )");
 }
@@ -725,32 +790,38 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        if true [t: %fn5, f: %fn6]
+          # True block
+          %fn5 = block {
+            br %fn4
+          }
 
-%fn3 = block {
-  if true [t: %fn6, f: %fn7]
-}
+          # False block
+          %fn6 = block {
+            br %fn4
+          }
 
-%fn4 = block {
-  br %fn3
-}
 
-%fn5 = block {
-  jmp %fn8  # return
-}
-%fn8 = func_terminator
+      }
 
-%fn6 = block {
-  br %fn5
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn7 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn7  # return
+    }
 
+  }
+
+  %fn7 = func_terminator
+}
 )");
 }
 
@@ -772,108 +843,136 @@
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        loop [s: %fn5, c: %fn6, m: %fn7]
+          %fn5 = block {
+            if true [t: %fn8, f: %fn9, m: %fn10]
+              # True block
+              %fn8 = block {
+                br %fn7
+              }
 
-%fn3 = block {
-  loop [s: %fn6, c: %fn7, m: %fn8]
-}
+              # False block
+              %fn9 = block {
+                br %fn10
+              }
 
-%fn4 = block {
-  br %fn3
-}
+            # Merge block
+            %fn10 = block {
+              if true [t: %fn11, f: %fn12, m: %fn13]
+                # True block
+                %fn11 = block {
+                  br %fn6
+                }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
+                # False block
+                %fn12 = block {
+                  br %fn13
+                }
 
-%fn6 = block {
-  if true [t: %fn10, f: %fn11, m: %fn12]
-}
+              # Merge block
+              %fn13 = block {
+                br %fn6
+              }
 
-%fn7 = block {
-  loop [s: %fn13, c: %fn14, m: %fn15]
-}
 
-%fn8 = block {
-  if true [t: %fn16, f: %fn17, m: %fn18]
-}
+            }
 
-%fn10 = block {
-  br %fn8
-}
 
-%fn11 = block {
-  br %fn12
-}
+          }
 
-%fn12 = block {
-  if true [t: %fn19, f: %fn20, m: %fn21]
-}
+          # Continuing block
+          %fn6 = block {
+            loop [s: %fn14, c: %fn15, m: %fn16]
+              %fn14 = block {
+                br %fn16
+              }
 
-%fn13 = block {
-  br %fn15
-}
+              # Continuing block
+              %fn15 = block {
+                br %fn14
+              }
 
-%fn14 = block {
-  br %fn13
-}
+            # Merge block
+            %fn16 = block {
+              loop [s: %fn17, c: %fn18, m: %fn19]
+                %fn17 = block {
+                  br %fn18
+                }
 
-%fn15 = block {
-  loop [s: %fn22, c: %fn23, m: %fn24]
-}
+                # Continuing block
+                %fn18 = block {
+                  if true [t: %fn20, f: %fn21, m: %fn22]
+                    # True block
+                    %fn20 = block {
+                      br %fn19
+                    }
 
-%fn16 = block {
-  br %fn5
-}
+                    # False block
+                    %fn21 = block {
+                      br %fn22
+                    }
 
-%fn17 = block {
-  br %fn18
-}
+                  # Merge block
+                  %fn22 = block {
+                    br %fn17
+                  }
 
-%fn18 = block {
-  jmp %fn4
-}
 
-%fn19 = block {
-  br %fn7
-}
+                }
 
-%fn20 = block {
-  br %fn21
-}
+              # Merge block
+              %fn19 = block {
+                br %fn5
+              }
 
-%fn21 = block {
-  jmp %fn7
-}
 
-%fn22 = block {
-  jmp %fn23
-}
+            }
 
-%fn23 = block {
-  if true [t: %fn25, f: %fn26, m: %fn27]
-}
 
-%fn24 = block {
-  br %fn6
-}
+          }
 
-%fn25 = block {
-  br %fn24
-}
+        # Merge block
+        %fn7 = block {
+          if true [t: %fn23, f: %fn24, m: %fn25]
+            # True block
+            %fn23 = block {
+              br %fn4
+            }
 
-%fn26 = block {
-  br %fn27
-}
+            # False block
+            %fn24 = block {
+              br %fn25
+            }
 
-%fn27 = block {
-  br %fn22
-}
+          # Merge block
+          %fn25 = block {
+            br %fn3
+          }
 
+
+        }
+
+
+      }
+
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
+
+    # Merge block
+    %fn4 = block {
+      br %fn26  # return
+    }
+
+  }
+
+  %fn26 = func_terminator
+}
 )");
 }
 
@@ -903,36 +1002,43 @@
     EXPECT_EQ(2u, if_flow->Merge()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        if false [t: %fn5, f: %fn6, m: %fn7]
+          # True block
+          %fn5 = block {
+            br %fn7
+          }
 
-%fn3 = block {
-  if false [t: %fn6, f: %fn7, m: %fn8]
-}
+          # False block
+          %fn6 = block {
+            br %fn4
+          }
 
-%fn4 = block {
-  br %fn3
-}
+        # Merge block
+        %fn7 = block {
+          br %fn3
+        }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
 
-%fn6 = block {
-  br %fn8
-}
+      }
 
-%fn7 = block {
-  br %fn5
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn8 = block {
-  jmp %fn4
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
+  }
+
+  %fn8 = func_terminator
+}
 )");
 }
 
@@ -962,34 +1068,41 @@
     EXPECT_EQ(2u, if_flow->Merge()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        if true [t: %fn5, f: %fn6, m: %fn7]
+          # True block
+          %fn5 = block {
+            br %fn7
+          }
 
-%fn3 = block {
-  if true [t: %fn6, f: %fn7, m: %fn8]
-}
+          # False block
+          %fn6 = block {
+            br %fn4
+          }
 
-%fn4 = block {
-  br %fn3
-}
+        # Merge block
+        %fn7 = block {
+          br %fn8  # return
+        }
 
-%fn5 = block {
-  jmp %fn9  # return
-}
-%fn9 = func_terminator
+      }
 
-%fn6 = block {
-  br %fn8
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn7 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn8  # return
+    }
 
-%fn8 = block {
-  br %fn9  # return
+  }
+
+  %fn8 = func_terminator
 }
 )");
 }
@@ -1054,24 +1167,27 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  loop [s: %fn3, c: %fn4, m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    loop [s: %fn2, c: %fn3, m: %fn4]
+      %fn2 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn5
-}
+      # Continuing block
+      %fn3 = block {
+        br %fn2
+      }
 
-%fn4 = block {
-  br %fn3
-}
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -1114,28 +1230,33 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  switch 1i [c: (0i, %fn3), c: (1i, %fn4), c: (default, %fn5), m: %fn6]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    switch 1i [c: (0i, %fn2), c: (1i, %fn3), c: (default, %fn4), m: %fn5]
+      # Case block
+      %fn2 = block {
+        br %fn5
+      }
 
-%fn3 = block {
-  br %fn6
-}
+      # Case block
+      %fn3 = block {
+        br %fn5
+      }
 
-%fn4 = block {
-  br %fn6
-}
+      # Case block
+      %fn4 = block {
+        br %fn5
+      }
 
-%fn5 = block {
-  br %fn6
-}
+    # Merge block
+    %fn5 = block {
+      br %fn6  # return
+    }
 
-%fn6 = block {
-  jmp %fn7  # return
-}
-%fn7 = func_terminator
+  }
 
+  %fn6 = func_terminator
+}
 )");
 }
 
@@ -1174,20 +1295,23 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  switch 1i [c: (0i 1i default, %fn3), m: %fn4]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    switch 1i [c: (0i 1i default, %fn2), m: %fn3]
+      # Case block
+      %fn2 = block {
+        br %fn3
+      }
 
-%fn3 = block {
-  br %fn4
-}
+    # Merge block
+    %fn3 = block {
+      br %fn4  # return
+    }
 
-%fn4 = block {
-  jmp %fn5  # return
-}
-%fn5 = func_terminator
+  }
 
+  %fn4 = func_terminator
+}
 )");
 }
 
@@ -1214,20 +1338,23 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  switch 1i [c: (default, %fn3), m: %fn4]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    switch 1i [c: (default, %fn2), m: %fn3]
+      # Case block
+      %fn2 = block {
+        br %fn3
+      }
 
-%fn3 = block {
-  br %fn4
-}
+    # Merge block
+    %fn3 = block {
+      br %fn4  # return
+    }
 
-%fn4 = block {
-  jmp %fn5  # return
-}
-%fn5 = func_terminator
+  }
 
+  %fn4 = func_terminator
+}
 )");
 }
 
@@ -1263,24 +1390,28 @@
     EXPECT_EQ(1u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  switch 1i [c: (0i, %fn3), c: (default, %fn4), m: %fn5]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    switch 1i [c: (0i, %fn2), c: (default, %fn3), m: %fn4]
+      # Case block
+      %fn2 = block {
+        br %fn4
+      }
 
-%fn3 = block {
-  br %fn5
-}
+      # Case block
+      %fn3 = block {
+        br %fn4
+      }
 
-%fn4 = block {
-  br %fn5
-}
+    # Merge block
+    %fn4 = block {
+      br %fn5  # return
+    }
 
-%fn5 = block {
-  jmp %fn6  # return
-}
-%fn6 = func_terminator
+  }
 
+  %fn5 = func_terminator
+}
 )");
 }
 
@@ -1318,19 +1449,22 @@
     EXPECT_EQ(2u, func->EndTarget()->InboundBranches().Length());
 
     EXPECT_EQ(Disassemble(m),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  switch 1i [c: (0i, %fn3), c: (default, %fn4)]
-}
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    switch 1i [c: (0i, %fn2), c: (default, %fn3)]
+      # Case block
+      %fn2 = block {
+        br %fn4  # return
+      }
+      # Case block
+      %fn3 = block {
+        br %fn4  # return
+      }
 
-%fn3 = block {
-  br %fn5  # return
-}
-%fn4 = block {
-  br %fn5  # return
-}
-%fn5 = func_terminator
+  }
 
+  %fn4 = func_terminator
+}
 )");
 }
 
@@ -1342,19 +1476,19 @@
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%fn1 = func b():i32 -> %fn2
-%fn2 = block {
-  br %fn3 1i  # return
+              R"(%1 = func b():i32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 1i  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:i32 = call b
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:i32 = call b
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_unary_test.cc b/src/tint/ir/from_program_unary_test.cc
index a47acf6..dc13f25 100644
--- a/src/tint/ir/from_program_unary_test.cc
+++ b/src/tint/ir/from_program_unary_test.cc
@@ -34,20 +34,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():bool -> %fn2
-%fn2 = block {
-  br %fn3 false  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():bool -> %fn1 {
+  %fn1 = block {
+    br %fn2 false  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:bool = call my_func
-  %tint_symbol:bool = eq %1, false
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:bool = call my_func
+    %tint_symbol:bool = eq %3, false
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -59,20 +59,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():u32 -> %fn2
-%fn2 = block {
-  br %fn3 1u  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():u32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 1u  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:u32 = call my_func
-  %tint_symbol:u32 = complement %1
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:u32 = call my_func
+    %tint_symbol:u32 = complement %3
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -84,20 +84,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = func my_func():i32 -> %fn2
-%fn2 = block {
-  br %fn3 1i  # return
+    EXPECT_EQ(Disassemble(m.Get()), R"(%1 = func my_func():i32 -> %fn1 {
+  %fn1 = block {
+    br %fn2 1i  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
-%fn4 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn5
-%fn5 = block {
-  %1:i32 = call my_func
-  %tint_symbol:i32 = negation %1
-  jmp %fn6  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    %3:i32 = call my_func
+    %tint_symbol:i32 = negation %3
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn6 = func_terminator
-
 )");
 }
 
@@ -110,19 +110,20 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v2:ptr<private, i32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
@@ -137,20 +138,21 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %v3:ptr<private, i32, read_write> = var
   br %fn2  # root_end
 }
 
 %fn2 = root_terminator
 
-%fn3 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn4
-%fn4 = block {
-  store %v3, 42i
-  jmp %fn5  # return
+%2 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn3 {
+  %fn3 = block {
+    store %v3, 42i
+    br %fn4  # return
+  }
+  %fn4 = func_terminator
 }
-%fn5 = func_terminator
-
 )");
 }
 
diff --git a/src/tint/ir/from_program_var_test.cc b/src/tint/ir/from_program_var_test.cc
index 2e49265..85a0319 100644
--- a/src/tint/ir/from_program_var_test.cc
+++ b/src/tint/ir/from_program_var_test.cc
@@ -32,7 +32,8 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %a:ptr<private, u32, read_write> = var
   br %fn2  # root_end
 }
@@ -49,7 +50,8 @@
     auto m = Build();
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
-    EXPECT_EQ(Disassemble(m.Get()), R"(%fn1 = block {
+    EXPECT_EQ(Disassemble(m.Get()), R"(# Root block
+%fn1 = block {
   %a:ptr<private, u32, read_write> = var, 2u
   br %fn2  # root_end
 }
@@ -67,13 +69,13 @@
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  %a:ptr<function, u32, read_write> = var
-  jmp %fn3  # return
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    %a:ptr<function, u32, read_write> = var
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 
@@ -86,13 +88,13 @@
     ASSERT_TRUE(m) << (!m ? m.Failure() : "");
 
     EXPECT_EQ(Disassemble(m.Get()),
-              R"(%fn1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  %a:ptr<function, u32, read_write> = var, 2u
-  jmp %fn3  # return
+              R"(%1 = func test_function():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    %a:ptr<function, u32, read_write> = var, 2u
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )");
 }
 }  // namespace
diff --git a/src/tint/ir/function.cc b/src/tint/ir/function.cc
index d6cd6fc..d60376f 100644
--- a/src/tint/ir/function.cc
+++ b/src/tint/ir/function.cc
@@ -19,7 +19,7 @@
 namespace tint::ir {
 
 Function::Function(Symbol name,
-                   type::Type* rt,
+                   const type::Type* rt,
                    PipelineStage stage,
                    std::optional<std::array<uint32_t, 3>> wg_size)
     : Base(), name_(name), return_type_(rt), pipeline_stage_(stage), workgroup_size_(wg_size) {}
diff --git a/src/tint/ir/function.h b/src/tint/ir/function.h
index e966e14..a9f0c1a 100644
--- a/src/tint/ir/function.h
+++ b/src/tint/ir/function.h
@@ -19,8 +19,8 @@
 #include <optional>
 #include <utility>
 
-#include "src/tint/ir/flow_node.h"
 #include "src/tint/ir/function_param.h"
+#include "src/tint/ir/value.h"
 #include "src/tint/symbol.h"
 #include "src/tint/type/type.h"
 
@@ -33,7 +33,7 @@
 namespace tint::ir {
 
 /// An IR representation of a function
-class Function : public utils::Castable<Function, FlowNode> {
+class Function : public utils::Castable<Function, Value> {
   public:
     /// The pipeline stage for an entry point
     enum class PipelineStage {
@@ -69,7 +69,7 @@
     /// @param stage the function stage
     /// @param wg_size the workgroup_size
     Function(Symbol n,
-             type::Type* rt,
+             const type::Type* rt,
              PipelineStage stage = PipelineStage::kUndefined,
              std::optional<std::array<uint32_t, 3>> wg_size = {});
     ~Function() override;
diff --git a/src/tint/ir/function_terminator.h b/src/tint/ir/function_terminator.h
index 668eab6..42aa01e 100644
--- a/src/tint/ir/function_terminator.h
+++ b/src/tint/ir/function_terminator.h
@@ -15,13 +15,13 @@
 #ifndef SRC_TINT_IR_FUNCTION_TERMINATOR_H_
 #define SRC_TINT_IR_FUNCTION_TERMINATOR_H_
 
-#include "src/tint/ir/flow_node.h"
+#include "src/tint/ir/block.h"
 
 namespace tint::ir {
 
-/// Flow node used as the end of a function. Must only be used as the `end_target` in a function
-/// flow node. There are no instructions and no branches from this node.
-class FunctionTerminator : public utils::Castable<FunctionTerminator, FlowNode> {
+/// Block used as the end of a function. Must only be used as the `end_target` in a function. There
+/// are no instructions in this block.
+class FunctionTerminator : public utils::Castable<FunctionTerminator, Block> {
   public:
     /// Constructor
     FunctionTerminator();
diff --git a/src/tint/ir/jump.cc b/src/tint/ir/jump.cc
deleted file mode 100644
index cda2f06..0000000
--- a/src/tint/ir/jump.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2023 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/tint/ir/jump.h"
-
-TINT_INSTANTIATE_TYPEINFO(tint::ir::Jump);
-
-namespace tint::ir {
-
-Jump::Jump(FlowNode* to, utils::VectorRef<Value*> args) : Base(to, args) {}
-
-Jump::~Jump() = default;
-
-}  // namespace tint::ir
diff --git a/src/tint/ir/jump.h b/src/tint/ir/jump.h
deleted file mode 100644
index 3159755..0000000
--- a/src/tint/ir/jump.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2023 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_TINT_IR_JUMP_H_
-#define SRC_TINT_IR_JUMP_H_
-
-#include "src/tint/ir/block.h"
-#include "src/tint/ir/branch.h"
-#include "src/tint/ir/value.h"
-#include "src/tint/utils/castable.h"
-
-namespace tint::ir {
-
-/// A jump instruction. A jump is walk continuing.
-class Jump : public utils::Castable<Jump, Branch> {
-  public:
-    /// Constructor
-    /// @param to the block to branch too
-    /// @param args the branch arguments
-    explicit Jump(FlowNode* to, utils::VectorRef<Value*> args = {});
-    ~Jump() override;
-};
-
-}  // namespace tint::ir
-
-#endif  // SRC_TINT_IR_JUMP_H_
diff --git a/src/tint/ir/load_test.cc b/src/tint/ir/load_test.cc
index 9881e98..72359e7 100644
--- a/src/tint/ir/load_test.cc
+++ b/src/tint/ir/load_test.cc
@@ -27,8 +27,8 @@
     Module mod;
     Builder b{mod};
 
-    auto* store_type = b.ir.types.Get<type::I32>();
-    auto* var = b.Declare(b.ir.types.Get<type::Pointer>(
+    auto* store_type = mod.Types().i32();
+    auto* var = b.Declare(mod.Types().Get<type::Pointer>(
         store_type, builtin::AddressSpace::kFunction, builtin::Access::kReadWrite));
     const auto* inst = b.Load(var);
 
@@ -45,8 +45,8 @@
     Module mod;
     Builder b{mod};
 
-    auto* store_type = b.ir.types.Get<type::I32>();
-    auto* var = b.Declare(b.ir.types.Get<type::Pointer>(
+    auto* store_type = mod.Types().i32();
+    auto* var = b.Declare(mod.Types().Get<type::Pointer>(
         store_type, builtin::AddressSpace::kFunction, builtin::Access::kReadWrite));
     const auto* inst = b.Load(var);
 
diff --git a/src/tint/ir/module.h b/src/tint/ir/module.h
index c6cf74c..1520888 100644
--- a/src/tint/ir/module.h
+++ b/src/tint/ir/module.h
@@ -17,7 +17,8 @@
 
 #include <string>
 
-#include "src/tint/constant/value.h"
+#include "src/tint/constant/manager.h"
+#include "src/tint/ir/block.h"
 #include "src/tint/ir/constant.h"
 #include "src/tint/ir/function.h"
 #include "src/tint/ir/instruction.h"
@@ -65,10 +66,15 @@
     /// @return the unique symbol of the given value.
     Symbol SetName(const Value* value, std::string_view name);
 
-    /// The flow node allocator
-    utils::BlockAllocator<FlowNode> flow_nodes;
-    /// The constant allocator
-    utils::BlockAllocator<constant::Value> constants_arena;
+    /// @return the type manager for the module
+    type::Manager& Types() { return constant_values.types; }
+
+    /// The block allocator
+    utils::BlockAllocator<Block> blocks;
+
+    /// The constant value manager
+    constant::Manager constant_values;
+
     /// The value allocator
     utils::BlockAllocator<Value> values;
 
@@ -78,34 +84,11 @@
     /// The block containing module level declarations, if any exist.
     Block* root_block = nullptr;
 
-    /// The type manager for the module
-    type::Manager types;
-
     /// The symbol table for the module
     SymbolTable symbols{prog_id_};
 
-    /// ConstantHasher provides a hash function for a constant::Value pointer, hashing the value
-    /// instead of the pointer itself.
-    struct ConstantHasher {
-        /// @param c the constant pointer to create a hash for
-        /// @return the hash value
-        inline std::size_t operator()(const constant::Value* c) const { return c->Hash(); }
-    };
-
-    /// ConstantEquals provides an equality function for two constant::Value pointers, comparing
-    /// their values instead of the pointers.
-    struct ConstantEquals {
-        /// @param a the first constant pointer to compare
-        /// @param b the second constant pointer to compare
-        /// @return the hash value
-        inline bool operator()(const constant::Value* a, const constant::Value* b) const {
-            return a->Equal(b);
-        }
-    };
-
     /// The map of constant::Value to their ir::Constant.
-    utils::Hashmap<const constant::Value*, ir::Constant*, 16, ConstantHasher, ConstantEquals>
-        constants;
+    utils::Hashmap<const constant::Value*, ir::Constant*, 16> constants;
 };
 
 }  // namespace tint::ir
diff --git a/src/tint/ir/module_test.cc b/src/tint/ir/module_test.cc
index 9cd36ae..f15aa35 100644
--- a/src/tint/ir/module_test.cc
+++ b/src/tint/ir/module_test.cc
@@ -25,20 +25,20 @@
 
 TEST_F(IR_ModuleTest, NameOfUnnamed) {
     Module mod;
-    auto* v = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
+    auto* v = mod.values.Create<ir::Var>(mod.Types().i32());
     EXPECT_FALSE(mod.NameOf(v).IsValid());
 }
 
 TEST_F(IR_ModuleTest, SetName) {
     Module mod;
-    auto* v = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
+    auto* v = mod.values.Create<ir::Var>(mod.Types().i32());
     EXPECT_EQ(mod.SetName(v, "a").Name(), "a");
     EXPECT_EQ(mod.NameOf(v).Name(), "a");
 }
 
 TEST_F(IR_ModuleTest, SetNameRename) {
     Module mod;
-    auto* v = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
+    auto* v = mod.values.Create<ir::Var>(mod.Types().i32());
     EXPECT_EQ(mod.SetName(v, "a").Name(), "a");
     EXPECT_EQ(mod.SetName(v, "b").Name(), "b");
     EXPECT_EQ(mod.NameOf(v).Name(), "b");
@@ -46,9 +46,9 @@
 
 TEST_F(IR_ModuleTest, SetNameCollision) {
     Module mod;
-    auto* a = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
-    auto* b = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
-    auto* c = mod.values.Create<ir::Var>(mod.types.Get<type::I32>());
+    auto* a = mod.values.Create<ir::Var>(mod.Types().i32());
+    auto* b = mod.values.Create<ir::Var>(mod.Types().i32());
+    auto* c = mod.values.Create<ir::Var>(mod.Types().i32());
     EXPECT_EQ(mod.SetName(a, "x").Name(), "x");
     EXPECT_EQ(mod.SetName(b, "x_1").Name(), "x_1");
     EXPECT_EQ(mod.SetName(c, "x").Name(), "x_2");
diff --git a/src/tint/ir/root_terminator.h b/src/tint/ir/root_terminator.h
index 361aa6d..4a52b32 100644
--- a/src/tint/ir/root_terminator.h
+++ b/src/tint/ir/root_terminator.h
@@ -15,13 +15,12 @@
 #ifndef SRC_TINT_IR_ROOT_TERMINATOR_H_
 #define SRC_TINT_IR_ROOT_TERMINATOR_H_
 
-#include "src/tint/ir/flow_node.h"
+#include "src/tint/ir/block.h"
 
 namespace tint::ir {
 
-/// Flow node used as the end of a function. Must only be used as the `end_target` in a function
-/// flow node. There are no instructions and no branches from this node.
-class RootTerminator : public utils::Castable<RootTerminator, FlowNode> {
+/// Block used as the end of a root block. There are no instructions in this block.
+class RootTerminator : public utils::Castable<RootTerminator, Block> {
   public:
     /// Constructor
     RootTerminator();
diff --git a/src/tint/ir/to_program.cc b/src/tint/ir/to_program.cc
index c1cb9f9..842f41d 100644
--- a/src/tint/ir/to_program.cc
+++ b/src/tint/ir/to_program.cc
@@ -23,7 +23,6 @@
 #include "src/tint/ir/function_terminator.h"
 #include "src/tint/ir/if.h"
 #include "src/tint/ir/instruction.h"
-#include "src/tint/ir/jump.h"
 #include "src/tint/ir/load.h"
 #include "src/tint/ir/module.h"
 #include "src/tint/ir/store.h"
@@ -99,7 +98,7 @@
         if (!ret_ty) {
             return nullptr;
         }
-        auto* body = FlowNodeGraph(fn->StartTarget());
+        auto* body = BlockGraph(fn->StartTarget());
         if (!body) {
             return nullptr;
         }
@@ -109,13 +108,13 @@
                       std::move(ret_attrs));
     }
 
-    const ast::BlockStatement* FlowNodeGraph(const ir::Block* start_node) {
+    const ast::BlockStatement* BlockGraph(const ir::Block* start_node) {
         // TODO(crbug.com/tint/1902): Check if the block is dead
         utils::Vector<const ast::Statement*,
                       decltype(ast::BlockStatement::statements)::static_length>
             stmts;
 
-        const ir::FlowNode* block = start_node;
+        const ir::Block* block = start_node;
 
         // TODO(crbug.com/tint/1902): Handle block arguments.
 
@@ -127,6 +126,8 @@
             Status status = tint::Switch(
                 block,
 
+                [&](const ir::FunctionTerminator*) { return kStop; },
+
                 [&](const ir::Block* blk) {
                     for (auto* inst : blk->Instructions()) {
                         auto stmt = Stmt(inst);
@@ -137,10 +138,7 @@
                             stmts.Push(s);
                         }
                     }
-                    if (blk->Branch()->Is<Jump>() && blk->Branch()->To()->Is<Block>()) {
-                        block = blk->Branch()->To()->As<Block>();
-                        return kContinue;
-                    } else if (auto* if_ = blk->Branch()->As<ir::If>()) {
+                    if (auto* if_ = blk->Branch()->As<ir::If>()) {
                         if (if_->Merge()->HasBranchTarget()) {
                             block = if_->Merge();
                             return kContinue;
@@ -154,8 +152,6 @@
                     return kStop;
                 },
 
-                [&](const ir::FunctionTerminator*) { return kStop; },
-
                 [&](Default) {
                     UNHANDLED_CASE(block);
                     return kError;
@@ -175,7 +171,7 @@
     const ast::IfStatement* If(const ir::If* i) {
         SCOPED_NESTING();
         auto* cond = Expr(i->Condition());
-        auto* t = FlowNodeGraph(i->True());
+        auto* t = BlockGraph(i->True());
         if (TINT_UNLIKELY(!t)) {
             return nullptr;
         }
@@ -191,7 +187,7 @@
                 }
                 return b.If(cond, t, b.Else(f));
             } else {
-                auto* f = FlowNodeGraph(i->False());
+                auto* f = BlockGraph(i->False());
                 if (!f) {
                     return nullptr;
                 }
@@ -214,7 +210,7 @@
             s->Cases(),  //
             [&](const ir::Switch::Case c) -> const tint::ast::CaseStatement* {
                 SCOPED_NESTING();
-                auto* body = FlowNodeGraph(c.start);
+                auto* body = BlockGraph(c.start);
                 if (!body) {
                     return nullptr;
                 }
@@ -274,7 +270,7 @@
     }
 
     /// @return true if there are no instructions between @p node and and @p stop_at
-    bool IsEmpty(const ir::Block* node, const ir::FlowNode* stop_at) {
+    bool IsEmpty(const ir::Block* node, const ir::Block* stop_at) {
         if (node->Instructions().IsEmpty()) {
             return true;
         }
diff --git a/src/tint/ir/transform/add_empty_entry_point.cc b/src/tint/ir/transform/add_empty_entry_point.cc
index f40c60e..2372ef54 100644
--- a/src/tint/ir/transform/add_empty_entry_point.cc
+++ b/src/tint/ir/transform/add_empty_entry_point.cc
@@ -35,9 +35,8 @@
     }
 
     ir::Builder builder(*ir);
-    auto* ep =
-        builder.CreateFunction(ir->symbols.New("unused_entry_point"), ir->types.Get<type::Void>(),
-                               Function::PipelineStage::kCompute, std::array{1u, 1u, 1u});
+    auto* ep = builder.CreateFunction(ir->symbols.New("unused_entry_point"), ir->Types().void_(),
+                                      Function::PipelineStage::kCompute, std::array{1u, 1u, 1u});
     ep->StartTarget()->SetInstructions(utils::Vector{builder.Branch(ep->EndTarget())});
     ir->functions.Push(ep);
 }
diff --git a/src/tint/ir/transform/add_empty_entry_point_test.cc b/src/tint/ir/transform/add_empty_entry_point_test.cc
index c86c09c..fec4192 100644
--- a/src/tint/ir/transform/add_empty_entry_point_test.cc
+++ b/src/tint/ir/transform/add_empty_entry_point_test.cc
@@ -25,12 +25,12 @@
 
 TEST_F(IR_AddEmptyEntryPointTest, EmptyModule) {
     auto* expect = R"(
-%fn1 = func unused_entry_point():void [@compute @workgroup_size(1, 1, 1)] -> %fn2
-%fn2 = block {
-  br %fn3  # return
+%1 = func unused_entry_point():void [@compute @workgroup_size(1, 1, 1)] -> %fn1 {
+  %fn1 = block {
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )";
 
     Run<AddEmptyEntryPoint>();
@@ -39,18 +39,17 @@
 }
 
 TEST_F(IR_AddEmptyEntryPointTest, ExistingEntryPoint) {
-    auto* ep =
-        b.CreateFunction("main", mod.types.Get<type::Void>(), Function::PipelineStage::kFragment);
+    auto* ep = b.CreateFunction("main", mod.Types().void_(), Function::PipelineStage::kFragment);
     ep->StartTarget()->SetInstructions(utils::Vector{b.Branch(ep->EndTarget())});
     mod.functions.Push(ep);
 
     auto* expect = R"(
-%fn1 = func main():void [@fragment] -> %fn2
-%fn2 = block {
-  br %fn3  # return
+%1 = func main():void [@fragment] -> %fn1 {
+  %fn1 = block {
+    br %fn2  # return
+  }
+  %fn2 = func_terminator
 }
-%fn3 = func_terminator
-
 )";
 
     Run<AddEmptyEntryPoint>();
diff --git a/src/tint/ir/unary_test.cc b/src/tint/ir/unary_test.cc
index bb0b4f2..92ad24c 100644
--- a/src/tint/ir/unary_test.cc
+++ b/src/tint/ir/unary_test.cc
@@ -26,7 +26,7 @@
 TEST_F(IR_InstructionTest, CreateComplement) {
     Module mod;
     Builder b{mod};
-    auto* inst = b.Complement(b.ir.types.Get<type::I32>(), b.Constant(4_i));
+    auto* inst = b.Complement(mod.Types().i32(), b.Constant(4_i));
 
     ASSERT_TRUE(inst->Is<Unary>());
     EXPECT_EQ(inst->Kind(), Unary::Kind::kComplement);
@@ -40,7 +40,7 @@
 TEST_F(IR_InstructionTest, CreateNegation) {
     Module mod;
     Builder b{mod};
-    auto* inst = b.Negation(b.ir.types.Get<type::I32>(), b.Constant(4_i));
+    auto* inst = b.Negation(mod.Types().i32(), b.Constant(4_i));
 
     ASSERT_TRUE(inst->Is<Unary>());
     EXPECT_EQ(inst->Kind(), Unary::Kind::kNegation);
@@ -54,7 +54,7 @@
 TEST_F(IR_InstructionTest, Unary_Usage) {
     Module mod;
     Builder b{mod};
-    auto* inst = b.Negation(b.ir.types.Get<type::I32>(), b.Constant(4_i));
+    auto* inst = b.Negation(mod.Types().i32(), b.Constant(4_i));
 
     EXPECT_EQ(inst->Kind(), Unary::Kind::kNegation);
 
diff --git a/src/tint/program.cc b/src/tint/program.cc
index a1cf5c8..92a9f02 100644
--- a/src/tint/program.cc
+++ b/src/tint/program.cc
@@ -37,10 +37,9 @@
 Program::Program(Program&& program)
     : id_(std::move(program.id_)),
       highest_node_id_(std::move(program.highest_node_id_)),
-      types_(std::move(program.types_)),
+      constants_(std::move(program.constants_)),
       ast_nodes_(std::move(program.ast_nodes_)),
       sem_nodes_(std::move(program.sem_nodes_)),
-      constant_nodes_(std::move(program.constant_nodes_)),
       ast_(std::move(program.ast_)),
       sem_(std::move(program.sem_)),
       symbols_(std::move(program.symbols_)),
@@ -63,10 +62,9 @@
     }
 
     // The above must be called *before* the calls to std::move() below
-    types_ = std::move(builder.Types());
+    constants_ = std::move(builder.constants);
     ast_nodes_ = std::move(builder.ASTNodes());
     sem_nodes_ = std::move(builder.SemNodes());
-    constant_nodes_ = std::move(builder.ConstantNodes());
     ast_ = &builder.AST();  // ast::Module is actually a heap allocation.
     sem_ = std::move(builder.Sem());
     symbols_ = std::move(builder.Symbols());
@@ -89,10 +87,9 @@
     moved_ = false;
     id_ = std::move(program.id_);
     highest_node_id_ = std::move(program.highest_node_id_);
-    types_ = std::move(program.types_);
+    constants_ = std::move(program.constants_);
     ast_nodes_ = std::move(program.ast_nodes_);
     sem_nodes_ = std::move(program.sem_nodes_);
-    constant_nodes_ = std::move(program.constant_nodes_);
     ast_ = std::move(program.ast_);
     sem_ = std::move(program.sem_);
     symbols_ = std::move(program.symbols_);
diff --git a/src/tint/program.h b/src/tint/program.h
index ae46acd..940a6ec 100644
--- a/src/tint/program.h
+++ b/src/tint/program.h
@@ -19,7 +19,7 @@
 #include <unordered_set>
 
 #include "src/tint/ast/function.h"
-#include "src/tint/constant/value.h"
+#include "src/tint/constant/manager.h"
 #include "src/tint/program_id.h"
 #include "src/tint/sem/info.h"
 #include "src/tint/symbol_table.h"
@@ -44,9 +44,6 @@
     /// SemNodeAllocator is an alias to BlockAllocator<sem::Node>
     using SemNodeAllocator = utils::BlockAllocator<sem::Node>;
 
-    /// ConstantAllocator is an alias to BlockAllocator<constant::Value>
-    using ConstantAllocator = utils::BlockAllocator<constant::Value>;
-
     /// Constructor
     Program();
 
@@ -72,10 +69,16 @@
     /// @returns the last allocated (numerically highest) AST node identifier.
     ast::NodeID HighestASTNodeID() const { return highest_node_id_; }
 
+    /// @returns a reference to the program's constants
+    const constant::Manager& Constants() const {
+        AssertNotMoved();
+        return constants_;
+    }
+
     /// @returns a reference to the program's types
     const type::Manager& Types() const {
         AssertNotMoved();
-        return types_;
+        return constants_.types;
     }
 
     /// @returns a reference to the program's AST nodes storage
@@ -165,10 +168,9 @@
 
     ProgramID id_;
     ast::NodeID highest_node_id_;
-    type::Manager types_;
+    constant::Manager constants_;
     ASTNodeAllocator ast_nodes_;
     SemNodeAllocator sem_nodes_;
-    ConstantAllocator constant_nodes_;
     ast::Module* ast_ = nullptr;
     sem::Info sem_;
     SymbolTable symbols_{id_};
diff --git a/src/tint/program_builder.cc b/src/tint/program_builder.cc
index fc2e795..20a3fc4 100644
--- a/src/tint/program_builder.cc
+++ b/src/tint/program_builder.cc
@@ -38,9 +38,9 @@
       ast_(ast_nodes_.Create<ast::Module>(id_, AllocateNodeID(), Source{})) {}
 
 ProgramBuilder::ProgramBuilder(ProgramBuilder&& rhs)
-    : id_(std::move(rhs.id_)),
+    : constants(std::move(rhs.constants)),
+      id_(std::move(rhs.id_)),
       last_ast_node_id_(std::move(rhs.last_ast_node_id_)),
-      types_(std::move(rhs.types_)),
       ast_nodes_(std::move(rhs.ast_nodes_)),
       sem_nodes_(std::move(rhs.sem_nodes_)),
       ast_(std::move(rhs.ast_)),
@@ -57,7 +57,7 @@
     AssertNotMoved();
     id_ = std::move(rhs.id_);
     last_ast_node_id_ = std::move(rhs.last_ast_node_id_);
-    types_ = std::move(rhs.types_);
+    constants = std::move(rhs.constants);
     ast_nodes_ = std::move(rhs.ast_nodes_);
     sem_nodes_ = std::move(rhs.sem_nodes_);
     ast_ = std::move(rhs.ast_);
@@ -72,7 +72,7 @@
     ProgramBuilder builder;
     builder.id_ = program->ID();
     builder.last_ast_node_id_ = program->HighestASTNodeID();
-    builder.types_ = type::Manager::Wrap(program->Types());
+    builder.constants = constant::Manager::Wrap(program->Constants());
     builder.ast_ =
         builder.create<ast::Module>(program->AST().source, program->AST().GlobalDeclarations());
     builder.sem_ = sem::Info::Wrap(program->Sem());
@@ -136,39 +136,4 @@
                 });
 }
 
-const constant::Value* ProgramBuilder::createSplatOrComposite(
-    const type::Type* type,
-    utils::VectorRef<const constant::Value*> elements) {
-    if (elements.IsEmpty()) {
-        return nullptr;
-    }
-
-    bool any_zero = false;
-    bool all_zero = true;
-    bool all_equal = true;
-    auto* first = elements.Front();
-    for (auto* el : elements) {
-        if (!el) {
-            return nullptr;
-        }
-        if (!any_zero && el->AnyZero()) {
-            any_zero = true;
-        }
-        if (all_zero && !el->AllZero()) {
-            all_zero = false;
-        }
-        if (all_equal && el != first) {
-            if (!el->Equal(first)) {
-                all_equal = false;
-            }
-        }
-    }
-    if (all_equal) {
-        return create<constant::Splat>(type, elements[0], elements.Length());
-    }
-
-    return constant_nodes_.Create<constant::Composite>(type, std::move(elements), all_zero,
-                                                       any_zero);
-}
-
 }  // namespace tint
diff --git a/src/tint/program_builder.h b/src/tint/program_builder.h
index b944e21..459edaa 100644
--- a/src/tint/program_builder.h
+++ b/src/tint/program_builder.h
@@ -78,9 +78,7 @@
 #include "src/tint/builtin/extension.h"
 #include "src/tint/builtin/interpolation_sampling.h"
 #include "src/tint/builtin/interpolation_type.h"
-#include "src/tint/constant/composite.h"
-#include "src/tint/constant/splat.h"
-#include "src/tint/constant/value.h"
+#include "src/tint/constant/manager.h"
 #include "src/tint/number.h"
 #include "src/tint/program.h"
 #include "src/tint/program_id.h"
@@ -328,9 +326,6 @@
     /// SemNodeAllocator is an alias to BlockAllocator<sem::Node>
     using SemNodeAllocator = utils::BlockAllocator<sem::Node>;
 
-    /// ConstantAllocator is an alias to BlockAllocator<constant::Value>
-    using ConstantAllocator = utils::BlockAllocator<constant::Value>;
-
     /// Constructor
     ProgramBuilder();
 
@@ -364,13 +359,13 @@
     /// @returns a reference to the program's types
     type::Manager& Types() {
         AssertNotMoved();
-        return types_;
+        return constants.types;
     }
 
     /// @returns a reference to the program's types
     const type::Manager& Types() const {
         AssertNotMoved();
-        return types_;
+        return constants.types;
     }
 
     /// @returns a reference to the program's AST nodes storage
@@ -397,12 +392,6 @@
         return sem_nodes_;
     }
 
-    /// @returns a reference to the program's semantic constant storage
-    ConstantAllocator& ConstantNodes() {
-        AssertNotMoved();
-        return constant_nodes_;
-    }
-
     /// @returns a reference to the program's AST root Module
     ast::Module& AST() {
         AssertNotMoved();
@@ -528,53 +517,6 @@
         return sem_nodes_.Create<T>(std::forward<ARGS>(args)...);
     }
 
-    /// Creates a new constant::Value owned by the ProgramBuilder.
-    /// When the ProgramBuilder is destructed, the sem::Node will also be destructed.
-    /// @param args the arguments to pass to the constructor
-    /// @returns the node pointer
-    template <typename T, typename... ARGS>
-    utils::traits::EnableIf<utils::traits::IsTypeOrDerived<T, constant::Value> &&
-                                !utils::traits::IsTypeOrDerived<T, constant::Composite> &&
-                                !utils::traits::IsTypeOrDerived<T, constant::Splat>,
-                            T>*
-    create(ARGS&&... args) {
-        AssertNotMoved();
-        return constant_nodes_.Create<T>(std::forward<ARGS>(args)...);
-    }
-
-    /// Constructs a constant of a vector, matrix or array type.
-    ///
-    /// Examines the element values and will return either a constant::Composite or a
-    /// constant::Splat, depending on the element types and values.
-    ///
-    /// @param type the composite type
-    /// @param elements the composite elements
-    /// @returns the node pointer
-    template <
-        typename T,
-        typename = utils::traits::EnableIf<utils::traits::IsTypeOrDerived<T, constant::Composite> ||
-                                           utils::traits::IsTypeOrDerived<T, constant::Splat>>>
-    const constant::Value* create(const type::Type* type,
-                                  utils::VectorRef<const constant::Value*> elements) {
-        AssertNotMoved();
-        return createSplatOrComposite(type, elements);
-    }
-
-    /// Constructs a splat constant.
-    /// @param type the splat type
-    /// @param element the splat element
-    /// @param n the number of elements
-    /// @returns the node pointer
-    template <
-        typename T,
-        typename = utils::traits::EnableIf<utils::traits::IsTypeOrDerived<T, constant::Splat>>>
-    const constant::Splat* create(const type::Type* type,
-                                  const constant::Value* element,
-                                  size_t n) {
-        AssertNotMoved();
-        return constant_nodes_.Create<constant::Splat>(type, element, n);
-    }
-
     /// Creates a new type::Node owned by the ProgramBuilder.
     /// When the ProgramBuilder is destructed, owned ProgramBuilder and the returned node will also
     /// be destructed. If T derives from type::UniqueNode, then the calling create() for the same
@@ -584,7 +526,7 @@
     template <typename T, typename... ARGS>
     utils::traits::EnableIfIsType<T, type::Node>* create(ARGS&&... args) {
         AssertNotMoved();
-        return types_.Get<T>(std::forward<ARGS>(args)...);
+        return constants.types.Get<T>(std::forward<ARGS>(args)...);
     }
 
     /// Marks this builder as moved, preventing any further use of the builder.
@@ -3953,6 +3895,9 @@
     /// @returns the function
     const ast::Function* WrapInFunction(utils::VectorRef<const ast::Statement*> stmts);
 
+    /// The constants manager
+    constant::Manager constants;
+
     /// The builder types
     TypesBuilder const ty{this};
 
@@ -3961,16 +3906,10 @@
     void AssertNotMoved() const;
 
   private:
-    const constant::Value* createSplatOrComposite(
-        const type::Type* type,
-        utils::VectorRef<const constant::Value*> elements);
-
     ProgramID id_;
     ast::NodeID last_ast_node_id_ = ast::NodeID{static_cast<decltype(ast::NodeID::value)>(0) - 1};
-    type::Manager types_;
     ASTNodeAllocator ast_nodes_;
     SemNodeAllocator sem_nodes_;
-    ConstantAllocator constant_nodes_;
     ast::Module* ast_;
     sem::Info sem_;
     SymbolTable symbols_{id_};
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 35ea8bb..c181f02 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -261,13 +261,15 @@
         using FROM = T;
         if constexpr (std::is_same_v<TO, bool>) {
             // [x -> bool]
-            return builder.create<constant::Scalar<TO>>(target_ty, !scalar->IsPositiveZero());
+            return builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                               !scalar->IsPositiveZero());
         } else if constexpr (std::is_same_v<FROM, bool>) {
             // [bool -> x]
-            return builder.create<constant::Scalar<TO>>(target_ty, TO(scalar->value ? 1 : 0));
+            return 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.create<constant::Scalar<TO>>(target_ty, conv.Get());
+            return 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
@@ -276,9 +278,10 @@
                 builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg, source);
                 switch (conv.Failure()) {
                     case ConversionFailure::kExceedsNegativeLimit:
-                        return builder.create<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                        return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
                     case ConversionFailure::kExceedsPositiveLimit:
-                        return builder.create<constant::Scalar<TO>>(target_ty, TO::Highest());
+                        return builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                           TO::Highest());
                 }
             } else {
                 builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, source);
@@ -292,9 +295,10 @@
                 builder.Diagnostics().add_warning(tint::diag::System::Resolver, msg, source);
                 switch (conv.Failure()) {
                     case ConversionFailure::kExceedsNegativeLimit:
-                        return builder.create<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                        return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
                     case ConversionFailure::kExceedsPositiveLimit:
-                        return builder.create<constant::Scalar<TO>>(target_ty, TO::Highest());
+                        return builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                                           TO::Highest());
                 }
             } else {
                 builder.Diagnostics().add_error(tint::diag::System::Resolver, msg, source);
@@ -305,14 +309,15 @@
             // https://www.w3.org/TR/WGSL/#floating-point-conversion
             switch (conv.Failure()) {
                 case ConversionFailure::kExceedsNegativeLimit:
-                    return builder.create<constant::Scalar<TO>>(target_ty, TO::Lowest());
+                    return builder.constants.Get<constant::Scalar<TO>>(target_ty, TO::Lowest());
                 case ConversionFailure::kExceedsPositiveLimit:
-                    return builder.create<constant::Scalar<TO>>(target_ty, TO::Highest());
+                    return 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.create<constant::Scalar<TO>>(target_ty, static_cast<TO>(scalar->value));
+            return builder.constants.Get<constant::Scalar<TO>>(target_ty,
+                                                               static_cast<TO>(scalar->value));
         }
         return nullptr;  // Expression is not constant.
     });
@@ -362,7 +367,7 @@
         }
         conv_els.Push(conv_el.Get());
     }
-    return builder.create<constant::Composite>(target_ty, std::move(conv_els));
+    return builder.constants.Composite(target_ty, std::move(conv_els));
 }
 
 ConstEval::Result SplatConvert(const constant::Splat* splat,
@@ -396,7 +401,7 @@
     if (!conv_el.Get()) {
         return nullptr;
     }
-    return builder.create<constant::Splat>(target_ty, conv_el.Get(), splat->count);
+    return builder.constants.Splat(target_ty, conv_el.Get(), splat->count);
 }
 
 ConstEval::Result ConvertInternal(const constant::Value* c,
@@ -466,7 +471,7 @@
             return el.Failure();
         }
     }
-    return builder.create<constant::Composite>(composite_ty, std::move(els));
+    return builder.constants.Composite(composite_ty, std::move(els));
 }
 }  // namespace detail
 
@@ -520,7 +525,7 @@
             return el.Failure();
         }
     }
-    return builder.create<constant::Composite>(composite_ty, std::move(els));
+    return builder.constants.Composite(composite_ty, std::move(els));
 }
 }  // namespace
 
@@ -542,7 +547,7 @@
             }
         }
     }
-    return builder.create<constant::Scalar<T>>(t, v);
+    return builder.constants.Get<constant::Scalar<T>>(t, v);
 }
 
 const constant::Value* ConstEval::ZeroValue(const type::Type* type) {
@@ -550,16 +555,16 @@
         type,  //
         [&](const type::Vector* v) -> const constant::Value* {
             auto* zero_el = ZeroValue(v->type());
-            return builder.create<constant::Splat>(type, zero_el, v->Width());
+            return builder.constants.Splat(type, zero_el, v->Width());
         },
         [&](const type::Matrix* m) -> const constant::Value* {
             auto* zero_el = ZeroValue(m->ColumnType());
-            return builder.create<constant::Splat>(type, zero_el, m->columns());
+            return builder.constants.Splat(type, zero_el, m->columns());
         },
         [&](const type::Array* a) -> const constant::Value* {
             if (auto n = a->ConstantCount()) {
                 if (auto* zero_el = ZeroValue(a->ElemType())) {
-                    return builder.create<constant::Splat>(type, zero_el, n.value());
+                    return builder.constants.Splat(type, zero_el, n.value());
                 }
             }
             return nullptr;
@@ -578,9 +583,9 @@
             }
             if (zero_by_type.Count() == 1) {
                 // All members were of the same type, so the zero value is the same for all members.
-                return builder.create<constant::Splat>(type, zeros[0], s->Members().Length());
+                return builder.constants.Splat(type, zeros[0], s->Members().Length());
             }
-            return builder.create<constant::Composite>(s, std::move(zeros));
+            return builder.constants.Composite(s, std::move(zeros));
         },
         [&](Default) -> const constant::Value* {
             return ZeroTypeDispatch(type, [&](auto zero) -> const constant::Value* {
@@ -1260,7 +1265,7 @@
     }
 
     // Multiple arguments. Must be a value constructor.
-    return builder.create<constant::Composite>(ty, std::move(args));
+    return builder.constants.Composite(ty, std::move(args));
 }
 
 ConstEval::Result ConstEval::Conv(const type::Type* ty,
@@ -1295,8 +1300,7 @@
                                       utils::VectorRef<const constant::Value*> args,
                                       const Source&) {
     if (auto* arg = args[0]) {
-        return builder.create<constant::Splat>(ty, arg,
-                                               static_cast<const type::Vector*>(ty)->Width());
+        return builder.constants.Splat(ty, arg, static_cast<const type::Vector*>(ty)->Width());
     }
     return nullptr;
 }
@@ -1304,7 +1308,7 @@
 ConstEval::Result ConstEval::VecInitS(const type::Type* ty,
                                       utils::VectorRef<const constant::Value*> args,
                                       const Source&) {
-    return builder.create<constant::Composite>(ty, args);
+    return builder.constants.Composite(ty, args);
 }
 
 ConstEval::Result ConstEval::VecInitM(const type::Type* ty,
@@ -1330,7 +1334,7 @@
             els.Push(val);
         }
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::MatInitS(const type::Type* ty,
@@ -1345,15 +1349,15 @@
             auto i = r + c * m->rows();
             column.Push(args[i]);
         }
-        els.Push(builder.create<constant::Composite>(m->ColumnType(), std::move(column)));
+        els.Push(builder.constants.Composite(m->ColumnType(), std::move(column)));
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::MatInitV(const type::Type* ty,
                                       utils::VectorRef<const constant::Value*> args,
                                       const Source&) {
-    return builder.create<constant::Composite>(ty, args);
+    return builder.constants.Composite(ty, args);
 }
 
 ConstEval::Result ConstEval::Index(const type::Type* ty,
@@ -1411,7 +1415,7 @@
     }
     auto values = utils::Transform<4>(
         indices, [&](uint32_t i) { return vec_val->Index(static_cast<size_t>(i)); });
-    return builder.create<constant::Composite>(ty, std::move(values));
+    return builder.constants.Composite(ty, std::move(values));
 }
 
 ConstEval::Result ConstEval::Bitcast(const type::Type* ty,
@@ -1557,7 +1561,7 @@
         }
         result.Push(r.Get());
     }
-    return builder.create<constant::Composite>(ty, result);
+    return builder.constants.Composite(ty, result);
 }
 ConstEval::Result ConstEval::OpMultiplyVecMat(const type::Type* ty,
                                               utils::VectorRef<const constant::Value*> args,
@@ -1607,7 +1611,7 @@
         }
         result.Push(r.Get());
     }
-    return builder.create<constant::Composite>(ty, result);
+    return builder.constants.Composite(ty, result);
 }
 
 ConstEval::Result ConstEval::OpMultiplyMatMat(const type::Type* ty,
@@ -1669,9 +1673,9 @@
 
         // Add column vector to matrix
         auto* col_vec_ty = ty->As<type::Matrix>()->ColumnType();
-        result_mat.Push(builder.create<constant::Composite>(col_vec_ty, col_vec));
+        result_mat.Push(builder.constants.Composite(col_vec_ty, col_vec));
     }
-    return builder.create<constant::Composite>(ty, result_mat);
+    return builder.constants.Composite(ty, result_mat);
 }
 
 ConstEval::Result ConstEval::OpDivide(const type::Type* ty,
@@ -2311,7 +2315,7 @@
         return utils::Failure;
     }
 
-    return builder.create<constant::Composite>(
+    return builder.constants.Composite(
         ty, utils::Vector<const constant::Value*, 3>{x.Get(), y.Get(), z.Get()});
 }
 
@@ -2707,20 +2711,20 @@
         }
         auto fract_ty = builder.create<type::Vector>(fract_els[0]->Type(), vec->Width());
         auto exp_ty = builder.create<type::Vector>(exp_els[0]->Type(), vec->Width());
-        return builder.create<constant::Composite>(
+        return builder.constants.Composite(
             ty, utils::Vector<const constant::Value*, 2>{
-                    builder.create<constant::Composite>(fract_ty, std::move(fract_els)),
-                    builder.create<constant::Composite>(exp_ty, std::move(exp_els)),
+                    builder.constants.Composite(fract_ty, std::move(fract_els)),
+                    builder.constants.Composite(exp_ty, std::move(exp_els)),
                 });
     } else {
         auto fe = scalar(arg);
         if (!fe.fract || !fe.exp) {
             return utils::Failure;
         }
-        return builder.create<constant::Composite>(ty, utils::Vector<const constant::Value*, 2>{
-                                                           fe.fract.Get(),
-                                                           fe.exp.Get(),
-                                                       });
+        return builder.constants.Composite(ty, utils::Vector<const constant::Value*, 2>{
+                                                   fe.fract.Get(),
+                                                   fe.exp.Get(),
+                                               });
     }
 }
 
@@ -3014,7 +3018,7 @@
         return utils::Failure;
     }
 
-    return builder.create<constant::Composite>(ty, std::move(fields));
+    return builder.constants.Composite(ty, std::move(fields));
 }
 
 ConstEval::Result ConstEval::normalize(const type::Type* ty,
@@ -3600,10 +3604,9 @@
         for (size_t c = 0; c < mat_ty->columns(); ++c) {
             new_col_vec.Push(me(r, c));
         }
-        result_mat.Push(
-            builder.create<constant::Composite>(result_mat_ty->ColumnType(), new_col_vec));
+        result_mat.Push(builder.constants.Composite(result_mat_ty->ColumnType(), new_col_vec));
     }
-    return builder.create<constant::Composite>(ty, result_mat);
+    return builder.constants.Composite(ty, result_mat);
 }
 
 ConstEval::Result ConstEval::trunc(const type::Type* ty,
@@ -3643,7 +3646,7 @@
         }
         els.Push(el.Get());
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::unpack2x16snorm(const type::Type* ty,
@@ -3663,7 +3666,7 @@
         }
         els.Push(el.Get());
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::unpack2x16unorm(const type::Type* ty,
@@ -3682,7 +3685,7 @@
         }
         els.Push(el.Get());
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::unpack4x8snorm(const type::Type* ty,
@@ -3702,7 +3705,7 @@
         }
         els.Push(el.Get());
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::unpack4x8unorm(const type::Type* ty,
@@ -3721,7 +3724,7 @@
         }
         els.Push(el.Get());
     }
-    return builder.create<constant::Composite>(ty, std::move(els));
+    return builder.constants.Composite(ty, std::move(els));
 }
 
 ConstEval::Result ConstEval::quantizeToF16(const type::Type* ty,
diff --git a/src/tint/resolver/const_eval_conversion_test.cc b/src/tint/resolver/const_eval_conversion_test.cc
index 350afb2..468d2b4 100644
--- a/src/tint/resolver/const_eval_conversion_test.cc
+++ b/src/tint/resolver/const_eval_conversion_test.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "src/tint/constant/splat.h"
 #include "src/tint/resolver/const_eval_test.h"
 #include "src/tint/sem/materialize.h"
 
diff --git a/src/tint/resolver/const_eval_runtime_semantics_test.cc b/src/tint/resolver/const_eval_runtime_semantics_test.cc
index eb0cf52..2e41482 100644
--- a/src/tint/resolver/const_eval_runtime_semantics_test.cc
+++ b/src/tint/resolver/const_eval_runtime_semantics_test.cc
@@ -37,29 +37,11 @@
         diag::Formatter formatter{style};
         return formatter.format(Diagnostics());
     }
-
-    /// Helper to make a scalar constant::Value from a value.
-    template <typename T>
-    const constant::Value* Scalar(T value) {
-        if constexpr (IsAbstract<T>) {
-            if constexpr (IsFloatingPoint<T>) {
-                return create<constant::Scalar<AFloat>>(create<type::AbstractFloat>(), value);
-            } else if constexpr (IsIntegral<T>) {
-                return create<constant::Scalar<AInt>>(create<type::AbstractInt>(), value);
-            }
-        } else if constexpr (IsFloatingPoint<T>) {
-            return create<constant::Scalar<f32>>(create<type::F32>(), value);
-        } else if constexpr (IsSignedIntegral<T>) {
-            return create<constant::Scalar<i32>>(create<type::I32>(), value);
-        } else if constexpr (IsUnsignedIntegral<T>) {
-            return create<constant::Scalar<u32>>(create<type::U32>(), value);
-        }
-    }
 };
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Add_AInt_Overflow) {
-    auto* a = Scalar(AInt::Highest());
-    auto* b = Scalar(AInt(1));
+    auto* a = constants.Get(AInt::Highest());
+    auto* b = constants.Get(AInt(1));
     auto result = const_eval.OpPlus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), 0);
@@ -68,8 +50,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Add_AFloat_Overflow) {
-    auto* a = Scalar(AFloat::Highest());
-    auto* b = Scalar(AFloat::Highest());
+    auto* a = constants.Get(AFloat::Highest());
+    auto* b = constants.Get(AFloat::Highest());
     auto result = const_eval.OpPlus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AFloat>(), 0.f);
@@ -79,8 +61,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Add_F32_Overflow) {
-    auto* a = Scalar(f32::Highest());
-    auto* b = Scalar(f32::Highest());
+    auto* a = constants.Get(f32::Highest());
+    auto* b = constants.Get(f32::Highest());
     auto result = const_eval.OpPlus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -90,8 +72,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Sub_AInt_Overflow) {
-    auto* a = Scalar(AInt::Lowest());
-    auto* b = Scalar(AInt(1));
+    auto* a = constants.Get(AInt::Lowest());
+    auto* b = constants.Get(AInt(1));
     auto result = const_eval.OpMinus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), 0);
@@ -100,8 +82,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Sub_AFloat_Overflow) {
-    auto* a = Scalar(AFloat::Lowest());
-    auto* b = Scalar(AFloat::Highest());
+    auto* a = constants.Get(AFloat::Lowest());
+    auto* b = constants.Get(AFloat::Highest());
     auto result = const_eval.OpMinus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AFloat>(), 0.f);
@@ -111,8 +93,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Sub_F32_Overflow) {
-    auto* a = Scalar(f32::Lowest());
-    auto* b = Scalar(f32::Highest());
+    auto* a = constants.Get(f32::Lowest());
+    auto* b = constants.Get(f32::Highest());
     auto result = const_eval.OpMinus(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -122,8 +104,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mul_AInt_Overflow) {
-    auto* a = Scalar(AInt::Highest());
-    auto* b = Scalar(AInt(2));
+    auto* a = constants.Get(AInt::Highest());
+    auto* b = constants.Get(AInt(2));
     auto result = const_eval.OpMultiply(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), 0);
@@ -132,8 +114,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mul_AFloat_Overflow) {
-    auto* a = Scalar(AFloat::Highest());
-    auto* b = Scalar(AFloat::Highest());
+    auto* a = constants.Get(AFloat::Highest());
+    auto* b = constants.Get(AFloat::Highest());
     auto result = const_eval.OpMultiply(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AFloat>(), 0.f);
@@ -143,8 +125,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mul_F32_Overflow) {
-    auto* a = Scalar(f32::Highest());
-    auto* b = Scalar(f32::Highest());
+    auto* a = constants.Get(f32::Highest());
+    auto* b = constants.Get(f32::Highest());
     auto result = const_eval.OpMultiply(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -154,8 +136,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_AInt_ZeroDenominator) {
-    auto* a = Scalar(AInt(42));
-    auto* b = Scalar(AInt(0));
+    auto* a = constants.Get(AInt(42));
+    auto* b = constants.Get(AInt(0));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), 42);
@@ -163,8 +145,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_I32_ZeroDenominator) {
-    auto* a = Scalar(i32(42));
-    auto* b = Scalar(i32(0));
+    auto* a = constants.Get(i32(42));
+    auto* b = constants.Get(i32(0));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 42);
@@ -172,8 +154,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_U32_ZeroDenominator) {
-    auto* a = Scalar(u32(42));
-    auto* b = Scalar(u32(0));
+    auto* a = constants.Get(u32(42));
+    auto* b = constants.Get(u32(0));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 42);
@@ -181,8 +163,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_AFloat_ZeroDenominator) {
-    auto* a = Scalar(AFloat(42));
-    auto* b = Scalar(AFloat(0));
+    auto* a = constants.Get(AFloat(42));
+    auto* b = constants.Get(AFloat(0));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AFloat>(), 42.f);
@@ -190,8 +172,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_F32_ZeroDenominator) {
-    auto* a = Scalar(f32(42));
-    auto* b = Scalar(f32(0));
+    auto* a = constants.Get(f32(42));
+    auto* b = constants.Get(f32(0));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 42.f);
@@ -199,8 +181,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Div_I32_MostNegativeByMinInt) {
-    auto* a = Scalar(i32::Lowest());
-    auto* b = Scalar(i32(-1));
+    auto* a = constants.Get(i32::Lowest());
+    auto* b = constants.Get(i32(-1));
     auto result = const_eval.OpDivide(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), i32::Lowest());
@@ -208,8 +190,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_AInt_ZeroDenominator) {
-    auto* a = Scalar(AInt(42));
-    auto* b = Scalar(AInt(0));
+    auto* a = constants.Get(AInt(42));
+    auto* b = constants.Get(AInt(0));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), 0);
@@ -217,8 +199,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_I32_ZeroDenominator) {
-    auto* a = Scalar(i32(42));
-    auto* b = Scalar(i32(0));
+    auto* a = constants.Get(i32(42));
+    auto* b = constants.Get(i32(0));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 0);
@@ -226,8 +208,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_U32_ZeroDenominator) {
-    auto* a = Scalar(u32(42));
-    auto* b = Scalar(u32(0));
+    auto* a = constants.Get(u32(42));
+    auto* b = constants.Get(u32(0));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0);
@@ -235,8 +217,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_AFloat_ZeroDenominator) {
-    auto* a = Scalar(AFloat(42));
-    auto* b = Scalar(AFloat(0));
+    auto* a = constants.Get(AFloat(42));
+    auto* b = constants.Get(AFloat(0));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AFloat>(), 0.f);
@@ -244,8 +226,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_F32_ZeroDenominator) {
-    auto* a = Scalar(f32(42));
-    auto* b = Scalar(f32(0));
+    auto* a = constants.Get(f32(42));
+    auto* b = constants.Get(f32(0));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -253,8 +235,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Mod_I32_MostNegativeByMinInt) {
-    auto* a = Scalar(i32::Lowest());
-    auto* b = Scalar(i32(-1));
+    auto* a = constants.Get(i32::Lowest());
+    auto* b = constants.Get(i32(-1));
     auto result = const_eval.OpModulo(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 0);
@@ -262,8 +244,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftLeft_AInt_SignChange) {
-    auto* a = Scalar(AInt(0x0FFFFFFFFFFFFFFFll));
-    auto* b = Scalar(u32(9));
+    auto* a = constants.Get(AInt(0x0FFFFFFFFFFFFFFFll));
+    auto* b = constants.Get(u32(9));
     auto result = const_eval.OpShiftLeft(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<AInt>(), static_cast<AInt>(0x0FFFFFFFFFFFFFFFull << 9));
@@ -271,8 +253,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftLeft_I32_SignChange) {
-    auto* a = Scalar(i32(0x0FFFFFFF));
-    auto* b = Scalar(u32(9));
+    auto* a = constants.Get(i32(0x0FFFFFFF));
+    auto* b = constants.Get(u32(9));
     auto result = const_eval.OpShiftLeft(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), static_cast<i32>(0x0FFFFFFFu << 9));
@@ -280,8 +262,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftLeft_I32_MoreThanBitWidth) {
-    auto* a = Scalar(i32(0x1));
-    auto* b = Scalar(u32(33));
+    auto* a = constants.Get(i32(0x1));
+    auto* b = constants.Get(u32(33));
     auto result = const_eval.OpShiftLeft(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 2);
@@ -291,8 +273,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftLeft_U32_MoreThanBitWidth) {
-    auto* a = Scalar(u32(0x1));
-    auto* b = Scalar(u32(33));
+    auto* a = constants.Get(u32(0x1));
+    auto* b = constants.Get(u32(33));
     auto result = const_eval.OpShiftLeft(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 2);
@@ -302,8 +284,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftRight_I32_MoreThanBitWidth) {
-    auto* a = Scalar(i32(0x2));
-    auto* b = Scalar(u32(33));
+    auto* a = constants.Get(i32(0x2));
+    auto* b = constants.Get(u32(33));
     auto result = const_eval.OpShiftRight(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 1);
@@ -313,8 +295,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ShiftRight_U32_MoreThanBitWidth) {
-    auto* a = Scalar(u32(0x2));
-    auto* b = Scalar(u32(33));
+    auto* a = constants.Get(u32(0x2));
+    auto* b = constants.Get(u32(33));
     auto result = const_eval.OpShiftRight(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 1);
@@ -324,7 +306,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Acos_F32_OutOfRange) {
-    auto* a = Scalar(f32(2));
+    auto* a = constants.Get(f32(2));
     auto result = const_eval.acos(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -333,7 +315,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Acosh_F32_OutOfRange) {
-    auto* a = Scalar(f32(-1));
+    auto* a = constants.Get(f32(-1));
     auto result = const_eval.acosh(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -341,7 +323,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Asin_F32_OutOfRange) {
-    auto* a = Scalar(f32(2));
+    auto* a = constants.Get(f32(2));
     auto result = const_eval.asin(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -350,7 +332,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Atanh_F32_OutOfRange) {
-    auto* a = Scalar(f32(2));
+    auto* a = constants.Get(f32(2));
     auto result = const_eval.atanh(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -359,7 +341,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Exp_F32_Overflow) {
-    auto* a = Scalar(f32(1000));
+    auto* a = constants.Get(f32(1000));
     auto result = const_eval.exp(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -367,7 +349,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Exp2_F32_Overflow) {
-    auto* a = Scalar(f32(1000));
+    auto* a = constants.Get(f32(1000));
     auto result = const_eval.exp2(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -375,9 +357,9 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ExtractBits_I32_TooManyBits) {
-    auto* a = Scalar(i32(0x12345678));
-    auto* offset = Scalar(u32(24));
-    auto* count = Scalar(u32(16));
+    auto* a = constants.Get(i32(0x12345678));
+    auto* offset = constants.Get(u32(24));
+    auto* count = constants.Get(u32(16));
     auto result = const_eval.extractBits(a->Type(), utils::Vector{a, offset, count}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 0x12);
@@ -386,9 +368,9 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, ExtractBits_U32_TooManyBits) {
-    auto* a = Scalar(u32(0x12345678));
-    auto* offset = Scalar(u32(24));
-    auto* count = Scalar(u32(16));
+    auto* a = constants.Get(u32(0x12345678));
+    auto* offset = constants.Get(u32(24));
+    auto* count = constants.Get(u32(16));
     auto result = const_eval.extractBits(a->Type(), utils::Vector{a, offset, count}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0x12);
@@ -397,10 +379,10 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, InsertBits_I32_TooManyBits) {
-    auto* a = Scalar(i32(0x99345678));
-    auto* b = Scalar(i32(0x12));
-    auto* offset = Scalar(u32(24));
-    auto* count = Scalar(u32(16));
+    auto* a = constants.Get(i32(0x99345678));
+    auto* b = constants.Get(i32(0x12));
+    auto* offset = constants.Get(u32(24));
+    auto* count = constants.Get(u32(16));
     auto result = const_eval.insertBits(a->Type(), utils::Vector{a, b, offset, count}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<i32>(), 0x12345678);
@@ -409,10 +391,10 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, InsertBits_U32_TooManyBits) {
-    auto* a = Scalar(u32(0x99345678));
-    auto* b = Scalar(u32(0x12));
-    auto* offset = Scalar(u32(24));
-    auto* count = Scalar(u32(16));
+    auto* a = constants.Get(u32(0x99345678));
+    auto* b = constants.Get(u32(0x12));
+    auto* offset = constants.Get(u32(24));
+    auto* count = constants.Get(u32(16));
     auto result = const_eval.insertBits(a->Type(), utils::Vector{a, b, offset, count}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0x12345678);
@@ -421,7 +403,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, InverseSqrt_F32_OutOfRange) {
-    auto* a = Scalar(f32(-1));
+    auto* a = constants.Get(f32(-1));
     auto result = const_eval.inverseSqrt(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -429,8 +411,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, LDExpr_F32_OutOfRange) {
-    auto* a = Scalar(f32(42.f));
-    auto* b = Scalar(f32(200));
+    auto* a = constants.Get(f32(42.f));
+    auto* b = constants.Get(f32(200));
     auto result = const_eval.ldexp(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -438,7 +420,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Log_F32_OutOfRange) {
-    auto* a = Scalar(f32(-1));
+    auto* a = constants.Get(f32(-1));
     auto result = const_eval.log(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -446,7 +428,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Log2_F32_OutOfRange) {
-    auto* a = Scalar(f32(-1));
+    auto* a = constants.Get(f32(-1));
     auto result = const_eval.log2(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -454,7 +436,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Normalize_ZeroLength) {
-    auto* zero = Scalar(f32(0));
+    auto* zero = constants.Get(f32(0));
     auto* vec =
         const_eval.VecSplat(create<type::Vector>(create<type::F32>(), 4u), utils::Vector{zero}, {})
             .Get();
@@ -468,8 +450,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Pack2x16Float_OutOfRange) {
-    auto* a = Scalar(f32(75250.f));
-    auto* b = Scalar(f32(42.1f));
+    auto* a = constants.Get(f32(75250.f));
+    auto* b = constants.Get(f32(42.1f));
     auto* vec =
         const_eval.VecInitS(create<type::Vector>(create<type::F32>(), 2u), utils::Vector{a, b}, {})
             .Get();
@@ -480,8 +462,8 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Pow_F32_Overflow) {
-    auto* a = Scalar(f32(2));
-    auto* b = Scalar(f32(1000));
+    auto* a = constants.Get(f32(2));
+    auto* b = constants.Get(f32(1000));
     auto result = const_eval.pow(a->Type(), utils::Vector{a, b}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -489,7 +471,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Unpack2x16Float_OutOfRange) {
-    auto* a = Scalar(u32(0x51437C00));
+    auto* a = constants.Get(u32(0x51437C00));
     auto result = const_eval.unpack2x16float(create<type::U32>(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_FLOAT_EQ(result.Get()->Index(0)->ValueAs<f32>(), 0.f);
@@ -498,7 +480,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, QuantizeToF16_OutOfRange) {
-    auto* a = Scalar(f32(75250.f));
+    auto* a = constants.Get(f32(75250.f));
     auto result = const_eval.quantizeToF16(create<type::U32>(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<u32>(), 0);
@@ -506,7 +488,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Sqrt_F32_OutOfRange) {
-    auto* a = Scalar(f32(-1));
+    auto* a = constants.Get(f32(-1));
     auto result = const_eval.sqrt(a->Type(), utils::Vector{a}, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -514,7 +496,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Bitcast_Infinity) {
-    auto* a = Scalar(u32(0x7F800000));
+    auto* a = constants.Get(u32(0x7F800000));
     auto result = const_eval.Bitcast(create<type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -522,7 +504,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Bitcast_NaN) {
-    auto* a = Scalar(u32(0x7FC00000));
+    auto* a = constants.Get(u32(0x7FC00000));
     auto result = const_eval.Bitcast(create<type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), 0.f);
@@ -530,7 +512,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Convert_F32_TooHigh) {
-    auto* a = Scalar(AFloat::Highest());
+    auto* a = constants.Get(AFloat::Highest());
     auto result = const_eval.Convert(create<type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f32::kHighestValue);
@@ -540,7 +522,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Convert_F32_TooLow) {
-    auto* a = Scalar(AFloat::Lowest());
+    auto* a = constants.Get(AFloat::Lowest());
     auto result = const_eval.Convert(create<type::F32>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f32::kLowestValue);
@@ -550,7 +532,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Convert_F16_TooHigh) {
-    auto* a = Scalar(f32(1000000.0));
+    auto* a = constants.Get(f32(1000000.0));
     auto result = const_eval.Convert(create<type::F16>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f16::kHighestValue);
@@ -558,7 +540,7 @@
 }
 
 TEST_F(ResolverConstEvalRuntimeSemanticsTest, Convert_F16_TooLow) {
-    auto* a = Scalar(f32(-1000000.0));
+    auto* a = constants.Get(f32(-1000000.0));
     auto result = const_eval.Convert(create<type::F16>(), a, {});
     ASSERT_TRUE(result);
     EXPECT_EQ(result.Get()->ValueAs<f32>(), f16::kLowestValue);
@@ -571,10 +553,10 @@
     auto* a = const_eval
                   .VecInitS(vec4f,
                             utils::Vector{
-                                Scalar(f32(1)),
-                                Scalar(f32(4)),
-                                Scalar(f32(-1)),
-                                Scalar(f32(65536)),
+                                constants.Get(f32(1)),
+                                constants.Get(f32(4)),
+                                constants.Get(f32(-1)),
+                                constants.Get(f32(65536)),
                             },
                             {})
                   .Get();
diff --git a/src/tint/transform/manager_test.cc b/src/tint/transform/manager_test.cc
index d1f6333..75afa93 100644
--- a/src/tint/transform/manager_test.cc
+++ b/src/tint/transform/manager_test.cc
@@ -51,7 +51,7 @@
     void Run(ir::Module* mod, const DataMap&, DataMap&) const override {
         ir::Builder builder(*mod);
         auto* func =
-            builder.CreateFunction(mod->symbols.New("ir_func"), mod->types.Get<type::Void>());
+            builder.CreateFunction(mod->symbols.New("ir_func"), mod->Types().Get<type::Void>());
         func->StartTarget()->SetInstructions(utils::Vector{builder.Branch(func->EndTarget())});
         mod->functions.Push(func);
     }
@@ -69,7 +69,7 @@
     ir::Module mod;
     ir::Builder builder(mod);
     auto* func =
-        builder.CreateFunction(builder.ir.symbols.New("main"), builder.ir.types.Get<type::Void>());
+        builder.CreateFunction(builder.ir.symbols.New("main"), mod.Types().Get<type::Void>());
     func->StartTarget()->SetInstructions(utils::Vector{builder.Branch(func->EndTarget())});
     builder.ir.functions.Push(func);
     return mod;
diff --git a/src/tint/type/manager.cc b/src/tint/type/manager.cc
index 666a1d3..0782633 100644
--- a/src/tint/type/manager.cc
+++ b/src/tint/type/manager.cc
@@ -14,6 +14,18 @@
 
 #include "src/tint/type/manager.h"
 
+#include "src/tint/type/abstract_float.h"
+#include "src/tint/type/abstract_int.h"
+#include "src/tint/type/bool.h"
+#include "src/tint/type/f16.h"
+#include "src/tint/type/f32.h"
+#include "src/tint/type/i32.h"
+#include "src/tint/type/matrix.h"
+#include "src/tint/type/type.h"
+#include "src/tint/type/u32.h"
+#include "src/tint/type/vector.h"
+#include "src/tint/type/void.h"
+
 namespace tint::type {
 
 Manager::Manager() = default;
@@ -24,4 +36,91 @@
 
 Manager::~Manager() = default;
 
+const type::Void* Manager::void_() {
+    return Get<type::Void>();
+}
+
+const type::Bool* Manager::bool_() {
+    return Get<type::Bool>();
+}
+
+const type::I32* Manager::i32() {
+    return Get<type::I32>();
+}
+
+const type::U32* Manager::u32() {
+    return Get<type::U32>();
+}
+
+const type::F32* Manager::f32() {
+    return Get<type::F32>();
+}
+
+const type::F16* Manager::f16() {
+    return Get<type::F16>();
+}
+
+const type::AbstractFloat* Manager::AFloat() {
+    return Get<type::AbstractFloat>();
+}
+
+const type::AbstractInt* Manager::AInt() {
+    return Get<type::AbstractInt>();
+}
+
+const type::Vector* Manager::vec(const type::Type* inner, uint32_t size) {
+    return Get<type::Vector>(inner, size);
+}
+
+const type::Vector* Manager::vec2(const type::Type* inner) {
+    return vec(inner, 2);
+}
+
+const type::Vector* Manager::vec3(const type::Type* inner) {
+    return vec(inner, 3);
+}
+
+const type::Vector* Manager::vec4(const type::Type* inner) {
+    return vec(inner, 4);
+}
+
+const type::Matrix* Manager::mat(const type::Type* inner, uint32_t cols, uint32_t rows) {
+    return Get<type::Matrix>(vec(inner, rows), cols);
+}
+
+const type::Matrix* Manager::mat2x2(const type::Type* inner) {
+    return mat(inner, 2, 2);
+}
+
+const type::Matrix* Manager::mat2x3(const type::Type* inner) {
+    return mat(inner, 2, 3);
+}
+
+const type::Matrix* Manager::mat2x4(const type::Type* inner) {
+    return mat(inner, 2, 4);
+}
+
+const type::Matrix* Manager::mat3x2(const type::Type* inner) {
+    return mat(inner, 3, 2);
+}
+
+const type::Matrix* Manager::mat3x3(const type::Type* inner) {
+    return mat(inner, 3, 3);
+}
+
+const type::Matrix* Manager::mat3x4(const type::Type* inner) {
+    return mat(inner, 3, 4);
+}
+
+const type::Matrix* Manager::mat4x2(const type::Type* inner) {
+    return mat(inner, 4, 2);
+}
+
+const type::Matrix* Manager::mat4x3(const type::Type* inner) {
+    return mat(inner, 4, 3);
+}
+
+const type::Matrix* Manager::mat4x4(const type::Type* inner) {
+    return mat(inner, 4, 4);
+}
 }  // namespace tint::type
diff --git a/src/tint/type/manager.h b/src/tint/type/manager.h
index 4eb48bb..b4fa560 100644
--- a/src/tint/type/manager.h
+++ b/src/tint/type/manager.h
@@ -18,10 +18,24 @@
 #include <utility>
 
 #include "src/tint/type/type.h"
-#include "src/tint/type/vector.h"
+#include "src/tint/type/unique_node.h"
 #include "src/tint/utils/hash.h"
 #include "src/tint/utils/unique_allocator.h"
 
+// Forward declarations
+namespace tint::type {
+class AbstractFloat;
+class AbstractInt;
+class Bool;
+class F16;
+class F32;
+class I32;
+class Matrix;
+class U32;
+class Vector;
+class Void;
+}  // namespace tint::type
+
 namespace tint::type {
 
 /// The type manager holds all the pointers to the known types.
@@ -85,22 +99,88 @@
         return types_.Find<TYPE>(std::forward<ARGS>(args)...);
     }
 
+    /// @returns a void type
+    const type::Void* void_();
+
+    /// @returns a bool type
+    const type::Bool* bool_();
+
+    /// @returns an i32 type
+    const type::I32* i32();
+
+    /// @returns a u32 type
+    const type::U32* u32();
+
+    /// @returns an f32 type
+    const type::F32* f32();
+
+    /// @returns an f16 type
+    const type::F16* f16();
+
+    /// @returns a abstract-float type
+    const type::AbstractFloat* AFloat();
+
+    /// @returns a abstract-int type
+    const type::AbstractInt* AInt();
+
     /// @param inner the inner type
     /// @param size the vector size
     /// @returns the vector type
-    type::Type* vec(type::Type* inner, uint32_t size) { return Get<type::Vector>(inner, size); }
+    const type::Vector* vec(const type::Type* inner, uint32_t size);
 
     /// @param inner the inner type
     /// @returns the vector type
-    type::Type* vec2(type::Type* inner) { return vec(inner, 2); }
+    const type::Vector* vec2(const type::Type* inner);
 
     /// @param inner the inner type
     /// @returns the vector type
-    type::Type* vec3(type::Type* inner) { return vec(inner, 3); }
+    const type::Vector* vec3(const type::Type* inner);
 
     /// @param inner the inner type
     /// @returns the vector type
-    type::Type* vec4(type::Type* inner) { return vec(inner, 4); }
+    const type::Vector* vec4(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @param cols the number of columns
+    /// @param rows the number of rows
+    /// @returns the matrix type
+    const type::Matrix* mat(const type::Type* inner, uint32_t cols, uint32_t rows);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat2x2(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat2x3(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat2x4(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat3x2(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat3x3(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat3x4(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat4x2(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat4x3(const type::Type* inner);
+
+    /// @param inner the inner type
+    /// @returns the matrix type
+    const type::Matrix* mat4x4(const type::Type* inner);
 
     /// @returns an iterator to the beginning of the types
     TypeIterator begin() const { return types_.begin(); }
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index a15f6a9..549f366 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -52,6 +52,7 @@
 #include "src/tint/ast/transform/unshadow.h"
 #include "src/tint/ast/transform/zero_init_workgroup_memory.h"
 #include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/constant/splat.h"
 #include "src/tint/constant/value.h"
 #include "src/tint/debug.h"
 #include "src/tint/sem/block_statement.h"
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index 95d2022..eb07e8e 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -51,6 +51,7 @@
 #include "src/tint/ast/transform/vectorize_scalar_matrix_initializers.h"
 #include "src/tint/ast/transform/zero_init_workgroup_memory.h"
 #include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/constant/splat.h"
 #include "src/tint/constant/value.h"
 #include "src/tint/debug.h"
 #include "src/tint/sem/block_statement.h"
diff --git a/src/tint/writer/msl/generator_impl.cc b/src/tint/writer/msl/generator_impl.cc
index 55b9f8d..4c51b17 100644
--- a/src/tint/writer/msl/generator_impl.cc
+++ b/src/tint/writer/msl/generator_impl.cc
@@ -49,6 +49,7 @@
 #include "src/tint/ast/transform/vectorize_scalar_matrix_initializers.h"
 #include "src/tint/ast/transform/zero_init_workgroup_memory.h"
 #include "src/tint/ast/variable_decl_statement.h"
+#include "src/tint/constant/splat.h"
 #include "src/tint/constant/value.h"
 #include "src/tint/sem/call.h"
 #include "src/tint/sem/function.h"
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.cc b/src/tint/writer/spirv/ir/generator_impl_ir.cc
index 44bead9..05802f8 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.cc
@@ -14,6 +14,8 @@
 
 #include "src/tint/writer/spirv/ir/generator_impl_ir.h"
 
+#include <utility>
+
 #include "spirv/unified1/spirv.h"
 #include "src/tint/ir/binary.h"
 #include "src/tint/ir/block.h"
@@ -23,6 +25,7 @@
 #include "src/tint/ir/module.h"
 #include "src/tint/ir/store.h"
 #include "src/tint/ir/transform/add_empty_entry_point.h"
+#include "src/tint/ir/user_call.h"
 #include "src/tint/ir/var.h"
 #include "src/tint/switch.h"
 #include "src/tint/transform/manager.h"
@@ -30,6 +33,7 @@
 #include "src/tint/type/f16.h"
 #include "src/tint/type/f32.h"
 #include "src/tint/type/i32.h"
+#include "src/tint/type/matrix.h"
 #include "src/tint/type/pointer.h"
 #include "src/tint/type/type.h"
 #include "src/tint/type/u32.h"
@@ -146,6 +150,13 @@
                 }
                 module_.PushType(spv::Op::OpConstantComposite, operands);
             },
+            [&](const type::Matrix* mat) {
+                OperandList operands = {Type(ty), id};
+                for (uint32_t i = 0; i < mat->columns(); i++) {
+                    operands.push_back(Constant(constant->Index(i)));
+                }
+                module_.PushType(spv::Op::OpConstantComposite, operands);
+            },
             [&](Default) {
                 TINT_ICE(Writer, diagnostics_) << "unhandled constant type: " << ty->FriendlyName();
             });
@@ -175,6 +186,10 @@
             [&](const type::Vector* vec) {
                 module_.PushType(spv::Op::OpTypeVector, {id, Type(vec->type()), vec->Width()});
             },
+            [&](const type::Matrix* mat) {
+                module_.PushType(spv::Op::OpTypeMatrix,
+                                 {id, Type(mat->ColumnType()), mat->columns()});
+            },
             [&](const type::Pointer* ptr) {
                 module_.PushType(
                     spv::Op::OpTypePointer,
@@ -191,17 +206,13 @@
     return Switch(
         value,  //
         [&](const ir::Constant* constant) { return Constant(constant); },
-        [&](const ir::Instruction* inst) {
-            auto id = instructions_.Find(inst);
+        [&](const ir::Value*) {
+            auto id = values_.Find(value);
             if (TINT_UNLIKELY(!id)) {
-                TINT_ICE(Writer, diagnostics_) << "missing instruction result";
+                TINT_ICE(Writer, diagnostics_) << "missing result ID for value";
                 return 0u;
             }
             return *id;
-        },
-        [&](Default) {
-            TINT_ICE(Writer, diagnostics_) << "unhandled value node: " << value->TypeInfo().name;
-            return 0u;
         });
 }
 
@@ -212,6 +223,7 @@
 void GeneratorImplIr::EmitFunction(const ir::Function* func) {
     // Make an ID for the function.
     auto id = module_.NextId();
+    functions_.Add(func->Name(), id);
 
     // Emit the function name.
     module_.PushDebug(spv::Op::OpName, {id, Operand(func->Name().Name())});
@@ -224,9 +236,22 @@
     // Get the ID for the return type.
     auto return_type_id = Type(func->ReturnType());
 
-    // Get the ID for the function type (creating it if needed).
-    // TODO(jrprice): Add the parameter types when they are supported in the IR.
     FunctionType function_type{return_type_id, {}};
+    InstructionList params;
+
+    // Generate function parameter declarations and add their type IDs to the function signature.
+    for (auto* param : func->Params()) {
+        auto param_type_id = Type(param->Type());
+        auto param_id = module_.NextId();
+        params.push_back(Instruction(spv::Op::OpFunctionParameter, {param_type_id, param_id}));
+        values_.Add(param, param_id);
+        function_type.param_type_ids.Push(param_type_id);
+        if (auto name = ir_->NameOf(param)) {
+            module_.PushDebug(spv::Op::OpName, {param_id, Operand(name.Name())});
+        }
+    }
+
+    // Get the ID for the function type (creating it if needed).
     auto function_type_id = function_types_.GetOrCreate(function_type, [&]() {
         auto func_ty_id = module_.NextId();
         OperandList operands = {func_ty_id, return_type_id};
@@ -242,9 +267,8 @@
                     {return_type_id, id, U32Operand(SpvFunctionControlMaskNone), function_type_id}};
 
     // Create a function that we will add instructions to.
-    // TODO(jrprice): Add the parameter declarations when they are supported in the IR.
     auto entry_block = module_.NextId();
-    current_function_ = Function(decl, entry_block, {});
+    current_function_ = Function(decl, entry_block, std::move(params));
     TINT_DEFER(current_function_ = Function());
 
     // Emit the body of the function.
@@ -309,6 +333,7 @@
                 EmitStore(s);
                 return 0u;
             },
+            [&](const ir::UserCall* c) { return EmitUserCall(c); },
             [&](const ir::Var* v) { return EmitVar(v); },
             [&](const ir::If* i) {
                 EmitIf(i);
@@ -323,21 +348,24 @@
                     << "unimplemented instruction: " << inst->TypeInfo().name;
                 return 0u;
             });
-        instructions_.Add(inst, result);
+        values_.Add(inst, result);
     }
 }
 
 void GeneratorImplIr::EmitBranch(const ir::Branch* b) {
     Switch(
         b->To(),
-        [&](const ir::Block* blk) { current_function_.push_inst(spv::Op::OpBranch, {Label(blk)}); },
         [&](const ir::FunctionTerminator*) {
-            // TODO(jrprice): Handle the return value, which will be a branch argument.
             if (!b->Args().IsEmpty()) {
-                TINT_ICE(Writer, diagnostics_) << "unimplemented return value";
+                TINT_ASSERT(Writer, b->Args().Length() == 1u);
+                OperandList operands;
+                operands.push_back(Value(b->Args()[0]));
+                current_function_.push_inst(spv::Op::OpReturnValue, operands);
+            } else {
+                current_function_.push_inst(spv::Op::OpReturn, {});
             }
-            current_function_.push_inst(spv::Op::OpReturn, {});
         },
+        [&](const ir::Block* blk) { current_function_.push_inst(spv::Op::OpBranch, {Label(blk)}); },
         [&](Default) {
             // A block may not have an outward branch (e.g. an unreachable merge
             // block).
@@ -384,6 +412,7 @@
 
 uint32_t GeneratorImplIr::EmitBinary(const ir::Binary* binary) {
     auto id = module_.NextId();
+    auto* lhs_ty = binary->LHS()->Type();
 
     // Determine the opcode.
     spv::Op op = spv::Op::Max;
@@ -396,6 +425,81 @@
             op = binary->Type()->is_integer_scalar_or_vector() ? spv::Op::OpISub : spv::Op::OpFSub;
             break;
         }
+
+        case ir::Binary::Kind::kAnd: {
+            op = spv::Op::OpBitwiseAnd;
+            break;
+        }
+        case ir::Binary::Kind::kOr: {
+            op = spv::Op::OpBitwiseOr;
+            break;
+        }
+        case ir::Binary::Kind::kXor: {
+            op = spv::Op::OpBitwiseXor;
+            break;
+        }
+
+        case ir::Binary::Kind::kEqual: {
+            if (lhs_ty->is_bool_scalar_or_vector()) {
+                op = spv::Op::OpLogicalEqual;
+            } else if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdEqual;
+            } else if (lhs_ty->is_integer_scalar_or_vector()) {
+                op = spv::Op::OpIEqual;
+            }
+            break;
+        }
+        case ir::Binary::Kind::kNotEqual: {
+            if (lhs_ty->is_bool_scalar_or_vector()) {
+                op = spv::Op::OpLogicalNotEqual;
+            } else if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdNotEqual;
+            } else if (lhs_ty->is_integer_scalar_or_vector()) {
+                op = spv::Op::OpINotEqual;
+            }
+            break;
+        }
+        case ir::Binary::Kind::kGreaterThan: {
+            if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdGreaterThan;
+            } else if (lhs_ty->is_signed_integer_scalar_or_vector()) {
+                op = spv::Op::OpSGreaterThan;
+            } else if (lhs_ty->is_unsigned_integer_scalar_or_vector()) {
+                op = spv::Op::OpUGreaterThan;
+            }
+            break;
+        }
+        case ir::Binary::Kind::kGreaterThanEqual: {
+            if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdGreaterThanEqual;
+            } else if (lhs_ty->is_signed_integer_scalar_or_vector()) {
+                op = spv::Op::OpSGreaterThanEqual;
+            } else if (lhs_ty->is_unsigned_integer_scalar_or_vector()) {
+                op = spv::Op::OpUGreaterThanEqual;
+            }
+            break;
+        }
+        case ir::Binary::Kind::kLessThan: {
+            if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdLessThan;
+            } else if (lhs_ty->is_signed_integer_scalar_or_vector()) {
+                op = spv::Op::OpSLessThan;
+            } else if (lhs_ty->is_unsigned_integer_scalar_or_vector()) {
+                op = spv::Op::OpULessThan;
+            }
+            break;
+        }
+        case ir::Binary::Kind::kLessThanEqual: {
+            if (lhs_ty->is_float_scalar_or_vector()) {
+                op = spv::Op::OpFOrdLessThanEqual;
+            } else if (lhs_ty->is_signed_integer_scalar_or_vector()) {
+                op = spv::Op::OpSLessThanEqual;
+            } else if (lhs_ty->is_unsigned_integer_scalar_or_vector()) {
+                op = spv::Op::OpULessThanEqual;
+            }
+            break;
+        }
+
         default: {
             TINT_ICE(Writer, diagnostics_)
                 << "unimplemented binary instruction: " << static_cast<uint32_t>(binary->Kind());
@@ -419,6 +523,16 @@
     current_function_.push_inst(spv::Op::OpStore, {Value(store->To()), Value(store->From())});
 }
 
+uint32_t GeneratorImplIr::EmitUserCall(const ir::UserCall* call) {
+    auto id = module_.NextId();
+    OperandList operands = {Type(call->Type()), id, functions_.Get(call->Name()).value()};
+    for (auto* arg : call->Args()) {
+        operands.push_back(Value(arg));
+    }
+    current_function_.push_inst(spv::Op::OpFunctionCall, operands);
+    return id;
+}
+
 uint32_t GeneratorImplIr::EmitVar(const ir::Var* var) {
     auto id = module_.NextId();
     auto* ptr = var->Type()->As<type::Pointer>();
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.h b/src/tint/writer/spirv/ir/generator_impl_ir.h
index ccd09ad..ee790a0 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.h
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.h
@@ -20,6 +20,7 @@
 #include "src/tint/constant/value.h"
 #include "src/tint/diagnostic/diagnostic.h"
 #include "src/tint/ir/constant.h"
+#include "src/tint/symbol.h"
 #include "src/tint/utils/hashmap.h"
 #include "src/tint/utils/vector.h"
 #include "src/tint/writer/spirv/binary_writer.h"
@@ -36,6 +37,7 @@
 class Load;
 class Module;
 class Store;
+class UserCall;
 class Value;
 class Var;
 }  // namespace tint::ir
@@ -117,6 +119,11 @@
     /// @param store the store instruction to emit
     void EmitStore(const ir::Store* store);
 
+    /// Emit a user call instruction.
+    /// @param call the user call instruction to emit
+    /// @returns the result ID of the instruction
+    uint32_t EmitUserCall(const ir::UserCall* call);
+
     /// Emit a var instruction.
     /// @param var the var instruction to emit
     /// @returns the result ID of the instruction
@@ -171,8 +178,12 @@
     /// The map of constants to their result IDs.
     utils::Hashmap<const constant::Value*, uint32_t, 16> constants_;
 
-    /// The map of instructions to their result IDs.
-    utils::Hashmap<const ir::Instruction*, uint32_t, 8> instructions_;
+    /// The map of functions to their result IDs.
+    /// TODO(jrprice): Merge into `values_` map when `ir::Function` becomes an `ir::Value`.
+    utils::Hashmap<Symbol, uint32_t, 8> functions_;
+
+    /// The map of non-constant values to their result IDs.
+    utils::Hashmap<const ir::Value*, uint32_t, 8> values_;
 
     /// The map of blocks to the IDs of their label instructions.
     utils::Hashmap<const ir::Block*, uint32_t, 8> block_labels_;
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_binary_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_binary_test.cc
index 8792239..71a2a36 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_binary_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_binary_test.cc
@@ -14,208 +14,272 @@
 
 #include "src/tint/writer/spirv/ir/test_helper_ir.h"
 
+#include "gmock/gmock.h"
+#include "src/tint/ir/binary.h"
+
 using namespace tint::number_suffixes;  // NOLINT
 
 namespace tint::writer::spirv {
 namespace {
 
-TEST_F(SpvGeneratorImplTest, Binary_Add_I32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+/// The element type of a test.
+enum Type {
+    kBool,
+    kI32,
+    kU32,
+    kF32,
+    kF16,
+};
+
+/// A parameterized test case.
+struct BinaryTestCase {
+    /// The element type to test.
+    Type type;
+    /// The binary operation.
+    enum ir::Binary::Kind kind;
+    /// The expected SPIR-V instruction.
+    std::string spirv_inst;
+};
+
+/// A helper class for parameterized binary instruction tests.
+class BinaryInstructionTest : public SpvGeneratorImplTestWithParam<BinaryTestCase> {
+  protected:
+    /// Helper to make a scalar type corresponding to the element type `ty`.
+    /// @param ty the element type
+    /// @returns the scalar type
+    const type::Type* MakeScalarType(Type ty) {
+        switch (ty) {
+            case kBool:
+                return mod.Types().bool_();
+            case kI32:
+                return mod.Types().i32();
+            case kU32:
+                return mod.Types().u32();
+            case kF32:
+                return mod.Types().f32();
+            case kF16:
+                return mod.Types().f16();
+        }
+        return nullptr;
+    }
+
+    /// Helper to make a vector type corresponding to the element type `ty`.
+    /// @param ty the element type
+    /// @returns the vector type
+    const type::Type* MakeVectorType(Type ty) { return mod.Types().vec2(MakeScalarType(ty)); }
+
+    /// Helper to make a scalar value with the scalar type `ty`.
+    /// @param ty the element type
+    /// @returns the scalar value
+    ir::Value* MakeScalarValue(Type ty) {
+        switch (ty) {
+            case kBool:
+                return b.Constant(true);
+            case kI32:
+                return b.Constant(1_i);
+            case kU32:
+                return b.Constant(1_u);
+            case kF32:
+                return b.Constant(1_f);
+            case kF16:
+                return b.Constant(1_h);
+        }
+        return nullptr;
+    }
+
+    /// Helper to make a vector value with an element type of `ty`.
+    /// @param ty the element type
+    /// @returns the vector value
+    ir::Value* MakeVectorValue(Type ty) {
+        switch (ty) {
+            case kBool:
+                return b.Constant(b.ir.constant_values.Composite(
+                    MakeVectorType(ty), utils::Vector{b.ir.constant_values.Get(true),
+                                                      b.ir.constant_values.Get(false)}));
+            case kI32:
+                return b.Constant(b.ir.constant_values.Composite(
+                    MakeVectorType(ty), utils::Vector{b.ir.constant_values.Get(42_i),
+                                                      b.ir.constant_values.Get(-10_i)}));
+            case kU32:
+                return b.Constant(b.ir.constant_values.Composite(
+                    MakeVectorType(ty),
+                    utils::Vector{b.ir.constant_values.Get(42_u), b.ir.constant_values.Get(10_u)}));
+            case kF32:
+                return b.Constant(b.ir.constant_values.Composite(
+                    MakeVectorType(ty), utils::Vector{b.ir.constant_values.Get(42_f),
+                                                      b.ir.constant_values.Get(-0.5_f)}));
+            case kF16:
+                return b.Constant(b.ir.constant_values.Composite(
+                    MakeVectorType(ty), utils::Vector{b.ir.constant_values.Get(42_h),
+                                                      b.ir.constant_values.Get(-0.5_h)}));
+        }
+        return nullptr;
+    }
+};
+
+using Arithmetic = BinaryInstructionTest;
+TEST_P(Arithmetic, Scalar) {
+    auto params = GetParam();
+
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Add(mod.types.Get<type::I32>(), b.Constant(1_i), b.Constant(2_i)),
+        utils::Vector{b.CreateBinary(params.kind, MakeScalarType(params.type),
+                                     MakeScalarValue(params.type), MakeScalarValue(params.type)),
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeInt 32 1
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpIAdd %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
+TEST_P(Arithmetic, Vector) {
+    auto params = GetParam();
 
-TEST_F(SpvGeneratorImplTest, Binary_Add_U32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Add(mod.types.Get<type::U32>(), b.Constant(1_u), b.Constant(2_u)),
+        utils::Vector{b.CreateBinary(params.kind, MakeVectorType(params.type),
+                                     MakeVectorValue(params.type), MakeVectorValue(params.type)),
+
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeInt 32 0
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpIAdd %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
+INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest_Binary_I32,
+                         Arithmetic,
+                         testing::Values(BinaryTestCase{kI32, ir::Binary::Kind::kAdd, "OpIAdd"},
+                                         BinaryTestCase{kI32, ir::Binary::Kind::kSubtract,
+                                                        "OpISub"}));
+INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest_Binary_U32,
+                         Arithmetic,
+                         testing::Values(BinaryTestCase{kU32, ir::Binary::Kind::kAdd, "OpIAdd"},
+                                         BinaryTestCase{kU32, ir::Binary::Kind::kSubtract,
+                                                        "OpISub"}));
+INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest_Binary_F32,
+                         Arithmetic,
+                         testing::Values(BinaryTestCase{kF32, ir::Binary::Kind::kAdd, "OpFAdd"},
+                                         BinaryTestCase{kF32, ir::Binary::Kind::kSubtract,
+                                                        "OpFSub"}));
+INSTANTIATE_TEST_SUITE_P(SpvGeneratorImplTest_Binary_F16,
+                         Arithmetic,
+                         testing::Values(BinaryTestCase{kF16, ir::Binary::Kind::kAdd, "OpFAdd"},
+                                         BinaryTestCase{kF16, ir::Binary::Kind::kSubtract,
+                                                        "OpFSub"}));
 
-TEST_F(SpvGeneratorImplTest, Binary_Add_F32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+using Bitwise = BinaryInstructionTest;
+TEST_P(Bitwise, Scalar) {
+    auto params = GetParam();
+
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Add(mod.types.Get<type::F32>(), b.Constant(1_f), b.Constant(2_f)),
+        utils::Vector{b.CreateBinary(params.kind, MakeScalarType(params.type),
+                                     MakeScalarValue(params.type), MakeScalarValue(params.type)),
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeFloat 32
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpFAdd %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
+TEST_P(Bitwise, Vector) {
+    auto params = GetParam();
 
-TEST_F(SpvGeneratorImplTest, Binary_Sub_I32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Subtract(mod.types.Get<type::I32>(), b.Constant(1_i), b.Constant(2_i)),
+        utils::Vector{b.CreateBinary(params.kind, MakeVectorType(params.type),
+                                     MakeVectorValue(params.type), MakeVectorValue(params.type)),
+
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeInt 32 1
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpISub %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_I32,
+    Bitwise,
+    testing::Values(BinaryTestCase{kI32, ir::Binary::Kind::kAnd, "OpBitwiseAnd"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kOr, "OpBitwiseOr"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kXor, "OpBitwiseXor"}));
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_U32,
+    Bitwise,
+    testing::Values(BinaryTestCase{kU32, ir::Binary::Kind::kAnd, "OpBitwiseAnd"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kOr, "OpBitwiseOr"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kXor, "OpBitwiseXor"}));
 
-TEST_F(SpvGeneratorImplTest, Binary_Sub_U32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+using Comparison = BinaryInstructionTest;
+TEST_P(Comparison, Scalar) {
+    auto params = GetParam();
+
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Subtract(mod.types.Get<type::U32>(), b.Constant(1_u), b.Constant(2_u)),
+        utils::Vector{b.CreateBinary(params.kind, mod.Types().bool_(), MakeScalarValue(params.type),
+                                     MakeScalarValue(params.type)),
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeInt 32 0
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpISub %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
+TEST_P(Comparison, Vector) {
+    auto params = GetParam();
 
-TEST_F(SpvGeneratorImplTest, Binary_Sub_F32) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(
-        utils::Vector{b.Subtract(mod.types.Get<type::F32>(), b.Constant(1_f), b.Constant(2_f)),
+        utils::Vector{b.CreateBinary(params.kind, mod.Types().vec2(mod.Types().bool_()),
+                                     MakeVectorValue(params.type), MakeVectorValue(params.type)),
+
                       b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%6 = OpTypeFloat 32
-%7 = OpConstant %6 1
-%8 = OpConstant %6 2
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpFSub %6 %7 %8
-OpReturn
-OpFunctionEnd
-)");
+    EXPECT_THAT(DumpModule(generator_.Module()), ::testing::HasSubstr(params.spirv_inst));
 }
-
-TEST_F(SpvGeneratorImplTest, Binary_Sub_Vec2i) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
-    auto* lhs = b.create<constant::Composite>(mod.types.vec2(mod.types.Get<type::I32>()),
-                                              utils::Vector{b.I32(42), b.I32(-1)}, false, false);
-    auto* rhs = b.create<constant::Composite>(mod.types.vec2(mod.types.Get<type::I32>()),
-                                              utils::Vector{b.I32(0), b.I32(-43)}, false, false);
-    func->StartTarget()->SetInstructions(
-        utils::Vector{b.Subtract(mod.types.Get<type::Vector>(mod.types.Get<type::I32>(), 2u),
-                                 b.Constant(lhs), b.Constant(rhs)),
-                      b.Branch(func->EndTarget())});
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%7 = OpTypeInt 32 1
-%6 = OpTypeVector %7 2
-%9 = OpConstant %7 42
-%10 = OpConstant %7 -1
-%8 = OpConstantComposite %6 %9 %10
-%12 = OpConstant %7 0
-%13 = OpConstant %7 -43
-%11 = OpConstantComposite %6 %12 %13
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpISub %6 %8 %11
-OpReturn
-OpFunctionEnd
-)");
-}
-
-TEST_F(SpvGeneratorImplTest, Binary_Sub_Vec4f) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
-    auto* lhs = b.create<constant::Composite>(
-        mod.types.vec4(mod.types.Get<type::F32>()),
-        utils::Vector{b.F32(42), b.F32(-1), b.F32(0), b.F32(1.25)}, false, false);
-    auto* rhs = b.create<constant::Composite>(
-        mod.types.vec4(mod.types.Get<type::F32>()),
-        utils::Vector{b.F32(0), b.F32(1.25), b.F32(-42), b.F32(1)}, false, false);
-    func->StartTarget()->SetInstructions(
-        utils::Vector{b.Subtract(mod.types.Get<type::Vector>(mod.types.Get<type::F32>(), 4u),
-                                 b.Constant(lhs), b.Constant(rhs)),
-                      b.Branch(func->EndTarget())});
-
-    generator_.EmitFunction(func);
-    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
-%2 = OpTypeVoid
-%3 = OpTypeFunction %2
-%7 = OpTypeFloat 32
-%6 = OpTypeVector %7 4
-%9 = OpConstant %7 42
-%10 = OpConstant %7 -1
-%11 = OpConstant %7 0
-%12 = OpConstant %7 1.25
-%8 = OpConstantComposite %6 %9 %10 %11 %12
-%14 = OpConstant %7 -42
-%15 = OpConstant %7 1
-%13 = OpConstantComposite %6 %11 %12 %14 %15
-%1 = OpFunction %2 None %3
-%4 = OpLabel
-%5 = OpFSub %6 %8 %13
-OpReturn
-OpFunctionEnd
-)");
-}
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_I32,
+    Comparison,
+    testing::Values(BinaryTestCase{kI32, ir::Binary::Kind::kEqual, "OpIEqual"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kNotEqual, "OpINotEqual"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kGreaterThan, "OpSGreaterThan"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kGreaterThanEqual,
+                                   "OpSGreaterThanEqual"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kLessThan, "OpSLessThan"},
+                    BinaryTestCase{kI32, ir::Binary::Kind::kLessThanEqual, "OpSLessThanEqual"}));
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_U32,
+    Comparison,
+    testing::Values(BinaryTestCase{kU32, ir::Binary::Kind::kEqual, "OpIEqual"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kNotEqual, "OpINotEqual"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kGreaterThan, "OpUGreaterThan"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kGreaterThanEqual,
+                                   "OpUGreaterThanEqual"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kLessThan, "OpULessThan"},
+                    BinaryTestCase{kU32, ir::Binary::Kind::kLessThanEqual, "OpULessThanEqual"}));
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_F32,
+    Comparison,
+    testing::Values(BinaryTestCase{kF32, ir::Binary::Kind::kEqual, "OpFOrdEqual"},
+                    BinaryTestCase{kF32, ir::Binary::Kind::kNotEqual, "OpFOrdNotEqual"},
+                    BinaryTestCase{kF32, ir::Binary::Kind::kGreaterThan, "OpFOrdGreaterThan"},
+                    BinaryTestCase{kF32, ir::Binary::Kind::kGreaterThanEqual,
+                                   "OpFOrdGreaterThanEqual"},
+                    BinaryTestCase{kF32, ir::Binary::Kind::kLessThan, "OpFOrdLessThan"},
+                    BinaryTestCase{kF32, ir::Binary::Kind::kLessThanEqual, "OpFOrdLessThanEqual"}));
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_F16,
+    Comparison,
+    testing::Values(BinaryTestCase{kF16, ir::Binary::Kind::kEqual, "OpFOrdEqual"},
+                    BinaryTestCase{kF16, ir::Binary::Kind::kNotEqual, "OpFOrdNotEqual"},
+                    BinaryTestCase{kF16, ir::Binary::Kind::kGreaterThan, "OpFOrdGreaterThan"},
+                    BinaryTestCase{kF16, ir::Binary::Kind::kGreaterThanEqual,
+                                   "OpFOrdGreaterThanEqual"},
+                    BinaryTestCase{kF16, ir::Binary::Kind::kLessThan, "OpFOrdLessThan"},
+                    BinaryTestCase{kF16, ir::Binary::Kind::kLessThanEqual, "OpFOrdLessThanEqual"}));
+INSTANTIATE_TEST_SUITE_P(
+    SpvGeneratorImplTest_Binary_Bool,
+    Comparison,
+    testing::Values(BinaryTestCase{kBool, ir::Binary::Kind::kEqual, "OpLogicalEqual"},
+                    BinaryTestCase{kBool, ir::Binary::Kind::kNotEqual, "OpLogicalNotEqual"}));
 
 TEST_F(SpvGeneratorImplTest, Binary_Chain) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
-    auto* a = b.Subtract(mod.types.Get<type::I32>(), b.Constant(1_i), b.Constant(2_i));
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
+    auto* a = b.Subtract(mod.Types().i32(), b.Constant(1_i), b.Constant(2_i));
     func->StartTarget()->SetInstructions(
-        utils::Vector{a, b.Add(mod.types.Get<type::I32>(), a, a), b.Branch(func->EndTarget())});
+        utils::Vector{a, b.Add(mod.Types().i32(), a, a), b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
     EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_constant_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_constant_test.cc
index 75775ff..7cb240a 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_constant_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_constant_test.cc
@@ -63,9 +63,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Constant_Vec4Bool) {
-    auto* v = b.create<constant::Composite>(
-        mod.types.vec4(mod.types.Get<type::Bool>()),
-        utils::Vector{b.Bool(true), b.Bool(false), b.Bool(false), b.Bool(true)}, false, true);
+    auto const_bool = [&](bool val) { return mod.constant_values.Get(val); };
+    auto* v = mod.constant_values.Composite(
+        mod.Types().vec4(mod.Types().bool_()),
+        utils::Vector{const_bool(true), const_bool(false), const_bool(false), const_bool(true)});
 
     generator_.Constant(b.Constant(v));
     EXPECT_EQ(DumpTypes(), R"(%3 = OpTypeBool
@@ -77,8 +78,9 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Constant_Vec2i) {
-    auto* v = b.create<constant::Composite>(mod.types.vec2(mod.types.Get<type::I32>()),
-                                            utils::Vector{b.I32(42), b.I32(-1)}, false, false);
+    auto const_i32 = [&](float val) { return mod.constant_values.Get(i32(val)); };
+    auto* v = mod.constant_values.Composite(mod.Types().vec2(mod.Types().i32()),
+                                            utils::Vector{const_i32(42), const_i32(-1)});
     generator_.Constant(b.Constant(v));
     EXPECT_EQ(DumpTypes(), R"(%3 = OpTypeInt 32 1
 %2 = OpTypeVector %3 2
@@ -89,9 +91,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Constant_Vec3u) {
-    auto* v = b.create<constant::Composite>(mod.types.vec3(mod.types.Get<type::U32>()),
-                                            utils::Vector{b.U32(42), b.U32(0), b.U32(4000000000)},
-                                            false, true);
+    auto const_u32 = [&](float val) { return mod.constant_values.Get(u32(val)); };
+    auto* v = mod.constant_values.Composite(
+        mod.Types().vec3(mod.Types().u32()),
+        utils::Vector{const_u32(42), const_u32(0), const_u32(4000000000)});
     generator_.Constant(b.Constant(v));
     EXPECT_EQ(DumpTypes(), R"(%3 = OpTypeInt 32 0
 %2 = OpTypeVector %3 3
@@ -103,9 +106,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Constant_Vec4f) {
-    auto* v = b.create<constant::Composite>(
-        mod.types.vec4(mod.types.Get<type::F32>()),
-        utils::Vector{b.F32(42), b.F32(0), b.F32(0.25), b.F32(-1)}, false, true);
+    auto const_f32 = [&](float val) { return mod.constant_values.Get(f32(val)); };
+    auto* v = mod.constant_values.Composite(
+        mod.Types().vec4(mod.Types().f32()),
+        utils::Vector{const_f32(42), const_f32(0), const_f32(0.25), const_f32(-1)});
     generator_.Constant(b.Constant(v));
     EXPECT_EQ(DumpTypes(), R"(%3 = OpTypeFloat 32
 %2 = OpTypeVector %3 4
@@ -118,8 +122,9 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Constant_Vec2h) {
-    auto* v = b.create<constant::Composite>(mod.types.vec2(mod.types.Get<type::F16>()),
-                                            utils::Vector{b.F16(42), b.F16(0.25)}, false, false);
+    auto const_f16 = [&](float val) { return mod.constant_values.Get(f16(val)); };
+    auto* v = mod.constant_values.Composite(mod.Types().vec2(mod.Types().f16()),
+                                            utils::Vector{const_f16(42), const_f16(0.25)});
     generator_.Constant(b.Constant(v));
     EXPECT_EQ(DumpTypes(), R"(%3 = OpTypeFloat 16
 %2 = OpTypeVector %3 2
@@ -129,6 +134,69 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, Constant_Mat2x3f) {
+    auto const_f32 = [&](float val) { return mod.constant_values.Get(f32(val)); };
+    auto* f32 = mod.Types().f32();
+    auto* v = mod.constant_values.Composite(
+        mod.Types().mat2x3(f32),
+        utils::Vector{
+            mod.constant_values.Composite(
+                mod.Types().vec3(f32),
+                utils::Vector{const_f32(42), const_f32(-1), const_f32(0.25)}),
+            mod.constant_values.Composite(
+                mod.Types().vec3(f32),
+                utils::Vector{const_f32(-42), const_f32(0), const_f32(-0.25)}),
+        });
+    generator_.Constant(b.Constant(v));
+    EXPECT_EQ(DumpTypes(), R"(%4 = OpTypeFloat 32
+%3 = OpTypeVector %4 3
+%2 = OpTypeMatrix %3 2
+%6 = OpConstant %4 42
+%7 = OpConstant %4 -1
+%8 = OpConstant %4 0.25
+%5 = OpConstantComposite %3 %6 %7 %8
+%10 = OpConstant %4 -42
+%11 = OpConstant %4 0
+%12 = OpConstant %4 -0.25
+%9 = OpConstantComposite %3 %10 %11 %12
+%1 = OpConstantComposite %2 %5 %9
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Constant_Mat4x2h) {
+    auto const_f16 = [&](float val) { return mod.constant_values.Get(f16(val)); };
+    auto* f16 = mod.Types().f16();
+    auto* v = mod.constant_values.Composite(
+        mod.Types().mat4x2(f16),
+        utils::Vector{
+            mod.constant_values.Composite(mod.Types().vec2(f16),
+                                          utils::Vector{const_f16(42), const_f16(-1)}),
+            mod.constant_values.Composite(mod.Types().vec2(f16),
+                                          utils::Vector{const_f16(0), const_f16(0.25)}),
+            mod.constant_values.Composite(mod.Types().vec2(f16),
+                                          utils::Vector{const_f16(-42), const_f16(1)}),
+            mod.constant_values.Composite(mod.Types().vec2(f16),
+                                          utils::Vector{const_f16(0.5), const_f16(-0)}),
+        });
+    generator_.Constant(b.Constant(v));
+    EXPECT_EQ(DumpTypes(), R"(%4 = OpTypeFloat 16
+%3 = OpTypeVector %4 2
+%2 = OpTypeMatrix %3 4
+%6 = OpConstant %4 0x1.5p+5
+%7 = OpConstant %4 -0x1p+0
+%5 = OpConstantComposite %3 %6 %7
+%9 = OpConstant %4 0x0p+0
+%10 = OpConstant %4 0x1p-2
+%8 = OpConstantComposite %3 %9 %10
+%12 = OpConstant %4 -0x1.5p+5
+%13 = OpConstant %4 0x1p+0
+%11 = OpConstantComposite %3 %12 %13
+%15 = OpConstant %4 0x1p-1
+%14 = OpConstantComposite %3 %15 %9
+%1 = OpConstantComposite %2 %5 %8 %11 %14
+)");
+}
+
 // Test that we do not emit the same constant more than once.
 TEST_F(SpvGeneratorImplTest, Constant_Deduplicate) {
     generator_.Constant(b.Constant(i32(42)));
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
index 7221963..22b0594 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
@@ -18,7 +18,7 @@
 namespace {
 
 TEST_F(SpvGeneratorImplTest, Function_Empty) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
@@ -34,7 +34,7 @@
 
 // Test that we do not emit the same function type more than once.
 TEST_F(SpvGeneratorImplTest, Function_DeduplicateType) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
     func->StartTarget()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
@@ -46,7 +46,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Compute) {
-    auto* func = b.CreateFunction("main", mod.types.Get<type::Void>(),
+    auto* func = b.CreateFunction("main", mod.Types().void_(),
                                   ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
     func->StartTarget()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
 
@@ -64,8 +64,8 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Fragment) {
-    auto* func = b.CreateFunction("main", mod.types.Get<type::Void>(),
-                                  ir::Function::PipelineStage::kFragment);
+    auto* func =
+        b.CreateFunction("main", mod.Types().void_(), ir::Function::PipelineStage::kFragment);
     func->StartTarget()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
@@ -83,7 +83,7 @@
 
 TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Vertex) {
     auto* func =
-        b.CreateFunction("main", mod.types.Get<type::Void>(), ir::Function::PipelineStage::kVertex);
+        b.CreateFunction("main", mod.Types().void_(), ir::Function::PipelineStage::kVertex);
     func->StartTarget()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
@@ -99,16 +99,16 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Function_EntryPoint_Multiple) {
-    auto* f1 = b.CreateFunction("main1", mod.types.Get<type::Void>(),
-                                ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
+    auto* f1 = b.CreateFunction("main1", mod.Types().void_(), ir::Function::PipelineStage::kCompute,
+                                {{32, 4, 1}});
     f1->StartTarget()->SetInstructions(utils::Vector{b.Branch(f1->EndTarget())});
 
-    auto* f2 = b.CreateFunction("main2", mod.types.Get<type::Void>(),
-                                ir::Function::PipelineStage::kCompute, {{8, 2, 16}});
+    auto* f2 = b.CreateFunction("main2", mod.Types().void_(), ir::Function::PipelineStage::kCompute,
+                                {{8, 2, 16}});
     f2->StartTarget()->SetInstructions(utils::Vector{b.Branch(f2->EndTarget())});
 
-    auto* f3 = b.CreateFunction("main3", mod.types.Get<type::Void>(),
-                                ir::Function::PipelineStage::kFragment);
+    auto* f3 =
+        b.CreateFunction("main3", mod.Types().void_(), ir::Function::PipelineStage::kFragment);
     f3->StartTarget()->SetInstructions(utils::Vector{b.Branch(f3->EndTarget())});
 
     generator_.EmitFunction(f1);
@@ -140,5 +140,118 @@
 )");
 }
 
+TEST_F(SpvGeneratorImplTest, Function_ReturnValue) {
+    auto* func = b.CreateFunction("foo", mod.Types().i32());
+    func->StartTarget()->SetInstructions(
+        utils::Vector{b.Branch(func->EndTarget(), utils::Vector{b.Constant(i32(42))})});
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+%2 = OpTypeInt 32 1
+%3 = OpTypeFunction %2
+%5 = OpConstant %2 42
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpReturnValue %5
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Function_Parameters) {
+    auto* i32 = mod.Types().i32();
+    auto* x = b.FunctionParam(i32);
+    auto* y = b.FunctionParam(i32);
+    auto* result = b.Add(i32, x, y);
+    auto* func = b.CreateFunction("foo", i32);
+    func->SetParams(utils::Vector{x, y});
+    func->StartTarget()->SetInstructions(
+        utils::Vector{result, b.Branch(func->EndTarget(), utils::Vector{result})});
+    mod.SetName(x, "x");
+    mod.SetName(y, "y");
+
+    generator_.EmitFunction(func);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+OpName %3 "x"
+OpName %4 "y"
+%2 = OpTypeInt 32 1
+%5 = OpTypeFunction %2 %2 %2
+%1 = OpFunction %2 None %5
+%3 = OpFunctionParameter %2
+%4 = OpFunctionParameter %2
+%6 = OpLabel
+%7 = OpIAdd %2 %3 %4
+OpReturnValue %7
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Function_Call) {
+    auto* i32_ty = mod.Types().i32();
+    auto* x = b.FunctionParam(i32_ty);
+    auto* y = b.FunctionParam(i32_ty);
+    auto* result = b.Add(i32_ty, x, y);
+    auto* foo = b.CreateFunction("foo", i32_ty);
+    foo->SetParams(utils::Vector{x, y});
+    foo->StartTarget()->SetInstructions(
+        utils::Vector{result, b.Branch(foo->EndTarget(), utils::Vector{result})});
+
+    auto* bar = b.CreateFunction("bar", mod.Types().void_());
+    bar->StartTarget()->SetInstructions(
+        utils::Vector{b.UserCall(i32_ty, mod.symbols.Get("foo"),
+                                 utils::Vector{b.Constant(i32(2)), b.Constant(i32(3))}),
+                      b.Branch(bar->EndTarget())});
+
+    generator_.EmitFunction(foo);
+    generator_.EmitFunction(bar);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+OpName %8 "bar"
+%2 = OpTypeInt 32 1
+%5 = OpTypeFunction %2 %2 %2
+%9 = OpTypeVoid
+%10 = OpTypeFunction %9
+%13 = OpConstant %2 2
+%14 = OpConstant %2 3
+%1 = OpFunction %2 None %5
+%3 = OpFunctionParameter %2
+%4 = OpFunctionParameter %2
+%6 = OpLabel
+%7 = OpIAdd %2 %3 %4
+OpReturnValue %7
+OpFunctionEnd
+%8 = OpFunction %9 None %10
+%11 = OpLabel
+%12 = OpFunctionCall %2 %1 %13 %14
+OpReturn
+OpFunctionEnd
+)");
+}
+
+TEST_F(SpvGeneratorImplTest, Function_Call_Void) {
+    auto* foo = b.CreateFunction("foo", mod.Types().void_());
+    foo->StartTarget()->SetInstructions(utils::Vector{b.Branch(foo->EndTarget())});
+
+    auto* bar = b.CreateFunction("bar", mod.Types().void_());
+    bar->StartTarget()->SetInstructions(
+        utils::Vector{b.UserCall(mod.Types().void_(), mod.symbols.Get("foo"), utils::Empty),
+                      b.Branch(bar->EndTarget())});
+
+    generator_.EmitFunction(foo);
+    generator_.EmitFunction(bar);
+    EXPECT_EQ(DumpModule(generator_.Module()), R"(OpName %1 "foo"
+OpName %5 "bar"
+%2 = OpTypeVoid
+%3 = OpTypeFunction %2
+%1 = OpFunction %2 None %3
+%4 = OpLabel
+OpReturn
+OpFunctionEnd
+%5 = OpFunction %2 None %3
+%6 = OpLabel
+%7 = OpFunctionCall %2 %1
+OpReturn
+OpFunctionEnd
+)");
+}
+
 }  // namespace
 }  // namespace tint::writer::spirv
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 dc312d1..ff7defc 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
@@ -20,7 +20,7 @@
 namespace {
 
 TEST_F(SpvGeneratorImplTest, If_TrueEmpty_FalseEmpty) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
     auto* i = b.CreateIf(b.Constant(true));
     i->True()->SetInstructions(utils::Vector{b.Branch(i->Merge())});
@@ -46,7 +46,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, If_FalseEmpty) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
     auto* i = b.CreateIf(b.Constant(true));
     i->False()->SetInstructions(utils::Vector{b.Branch(i->Merge())});
@@ -54,7 +54,7 @@
 
     auto* true_block = i->True();
     true_block->SetInstructions(utils::Vector{
-        b.Add(mod.types.Get<type::I32>(), b.Constant(1_i), b.Constant(1_i)), b.Branch(i->Merge())});
+        b.Add(mod.Types().i32(), b.Constant(1_i), b.Constant(1_i)), b.Branch(i->Merge())});
 
     func->StartTarget()->SetInstructions(utils::Vector{i});
 
@@ -80,7 +80,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, If_TrueEmpty) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
     auto* i = b.CreateIf(b.Constant(true));
     i->True()->SetInstructions(utils::Vector{b.Branch(i->Merge())});
@@ -88,7 +88,7 @@
 
     auto* false_block = i->False();
     false_block->SetInstructions(utils::Vector{
-        b.Add(mod.types.Get<type::I32>(), b.Constant(1_i), b.Constant(1_i)), b.Branch(i->Merge())});
+        b.Add(mod.Types().i32(), b.Constant(1_i), b.Constant(1_i)), b.Branch(i->Merge())});
 
     func->StartTarget()->SetInstructions(utils::Vector{i});
 
@@ -114,7 +114,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, If_BothBranchesReturn) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
     auto* i = b.CreateIf(b.Constant(true));
     i->True()->SetInstructions(utils::Vector{b.Branch(func->EndTarget())});
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 38bf1f0..80e69c3 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
@@ -25,43 +25,43 @@
 namespace {
 
 TEST_F(SpvGeneratorImplTest, Type_Void) {
-    auto id = generator_.Type(mod.types.Get<type::Void>());
+    auto id = generator_.Type(mod.Types().void_());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeVoid\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Bool) {
-    auto id = generator_.Type(mod.types.Get<type::Bool>());
+    auto id = generator_.Type(mod.Types().bool_());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeBool\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_I32) {
-    auto id = generator_.Type(mod.types.Get<type::I32>());
+    auto id = generator_.Type(mod.Types().i32());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeInt 32 1\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_U32) {
-    auto id = generator_.Type(mod.types.Get<type::U32>());
+    auto id = generator_.Type(mod.Types().u32());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeInt 32 0\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_F32) {
-    auto id = generator_.Type(mod.types.Get<type::F32>());
+    auto id = generator_.Type(mod.Types().f32());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeFloat 32\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_F16) {
-    auto id = generator_.Type(mod.types.Get<type::F16>());
+    auto id = generator_.Type(mod.Types().f16());
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(), "%1 = OpTypeFloat 16\n");
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Vec2i) {
-    auto* vec = b.ir.types.Get<type::Vector>(b.ir.types.Get<type::I32>(), 2u);
+    auto* vec = mod.Types().Get<type::Vector>(mod.Types().i32(), 2u);
     auto id = generator_.Type(vec);
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(),
@@ -70,7 +70,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Vec3u) {
-    auto* vec = b.ir.types.Get<type::Vector>(b.ir.types.Get<type::U32>(), 3u);
+    auto* vec = mod.Types().Get<type::Vector>(mod.Types().u32(), 3u);
     auto id = generator_.Type(vec);
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(),
@@ -79,7 +79,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Vec4f) {
-    auto* vec = b.ir.types.Get<type::Vector>(b.ir.types.Get<type::F32>(), 4u);
+    auto* vec = mod.Types().Get<type::Vector>(mod.Types().f32(), 4u);
     auto id = generator_.Type(vec);
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(),
@@ -88,7 +88,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Vec4h) {
-    auto* vec = b.ir.types.Get<type::Vector>(b.ir.types.Get<type::F16>(), 2u);
+    auto* vec = mod.Types().Get<type::Vector>(mod.Types().f16(), 2u);
     auto id = generator_.Type(vec);
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(),
@@ -97,7 +97,7 @@
 }
 
 TEST_F(SpvGeneratorImplTest, Type_Vec4Bool) {
-    auto* vec = b.ir.types.Get<type::Vector>(b.ir.types.Get<type::Bool>(), 4u);
+    auto* vec = mod.Types().Get<type::Vector>(mod.Types().bool_(), 4u);
     auto id = generator_.Type(vec);
     EXPECT_EQ(id, 1u);
     EXPECT_EQ(DumpTypes(),
@@ -105,13 +105,33 @@
               "%1 = OpTypeVector %2 4\n");
 }
 
+TEST_F(SpvGeneratorImplTest, Type_Mat2x3f) {
+    auto* vec = mod.Types().mat2x3(mod.Types().f32());
+    auto id = generator_.Type(vec);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%3 = OpTypeFloat 32\n"
+              "%2 = OpTypeVector %3 3\n"
+              "%1 = OpTypeMatrix %2 2\n");
+}
+
+TEST_F(SpvGeneratorImplTest, Type_Mat4x2h) {
+    auto* vec = mod.Types().mat4x2(mod.Types().f16());
+    auto id = generator_.Type(vec);
+    EXPECT_EQ(id, 1u);
+    EXPECT_EQ(DumpTypes(),
+              "%3 = OpTypeFloat 16\n"
+              "%2 = OpTypeVector %3 2\n"
+              "%1 = OpTypeMatrix %2 4\n");
+}
+
 // Test that we can emit multiple types.
 // Includes types with the same opcode but different parameters.
 TEST_F(SpvGeneratorImplTest, Type_Multiple) {
-    EXPECT_EQ(generator_.Type(mod.types.Get<type::I32>()), 1u);
-    EXPECT_EQ(generator_.Type(mod.types.Get<type::U32>()), 2u);
-    EXPECT_EQ(generator_.Type(mod.types.Get<type::F32>()), 3u);
-    EXPECT_EQ(generator_.Type(mod.types.Get<type::F16>()), 4u);
+    EXPECT_EQ(generator_.Type(mod.Types().i32()), 1u);
+    EXPECT_EQ(generator_.Type(mod.Types().u32()), 2u);
+    EXPECT_EQ(generator_.Type(mod.Types().f32()), 3u);
+    EXPECT_EQ(generator_.Type(mod.Types().f16()), 4u);
     EXPECT_EQ(DumpTypes(), R"(%1 = OpTypeInt 32 1
 %2 = OpTypeInt 32 0
 %3 = OpTypeFloat 32
@@ -121,7 +141,7 @@
 
 // Test that we do not emit the same type more than once.
 TEST_F(SpvGeneratorImplTest, Type_Deduplicate) {
-    auto* i32 = mod.types.Get<type::I32>();
+    auto* i32 = mod.Types().i32();
     EXPECT_EQ(generator_.Type(i32), 1u);
     EXPECT_EQ(generator_.Type(i32), 1u);
     EXPECT_EQ(generator_.Type(i32), 1u);
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 6c9fbc3..4a42bdc 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
@@ -21,10 +21,10 @@
 namespace {
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_NoInit) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* ty = mod.types.Get<type::Pointer>(
-        mod.types.Get<type::I32>(), builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     func->StartTarget()->SetInstructions(utils::Vector{b.Declare(ty), b.Branch(func->EndTarget())});
 
     generator_.EmitFunction(func);
@@ -42,10 +42,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_WithInit) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* ty = mod.types.Get<type::Pointer>(
-        mod.types.Get<type::I32>(), builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     auto* v = b.Declare(ty);
     v->SetInitializer(b.Constant(42_i));
 
@@ -68,10 +68,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_Name) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* ty = mod.types.Get<type::Pointer>(
-        mod.types.Get<type::I32>(), builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     auto* v = b.Declare(ty);
     func->StartTarget()->SetInstructions(utils::Vector{v, b.Branch(func->EndTarget())});
     mod.SetName(v, "myvar");
@@ -92,10 +92,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_DeclInsideBlock) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* ty = mod.types.Get<type::Pointer>(
-        mod.types.Get<type::I32>(), builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     auto* v = b.Declare(ty);
     v->SetInitializer(b.Constant(42_i));
 
@@ -132,11 +132,11 @@
 }
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_Load) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* store_ty = mod.types.Get<type::I32>();
-    auto* ty = mod.types.Get<type::Pointer>(store_ty, builtin::AddressSpace::kFunction,
-                                            builtin::Access::kReadWrite);
+    auto* store_ty = mod.Types().i32();
+    auto* ty = mod.Types().Get<type::Pointer>(store_ty, builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     auto* v = b.Declare(ty);
     func->StartTarget()->SetInstructions(utils::Vector{v, b.Load(v), b.Branch(func->EndTarget())});
 
@@ -156,10 +156,10 @@
 }
 
 TEST_F(SpvGeneratorImplTest, FunctionVar_Store) {
-    auto* func = b.CreateFunction("foo", mod.types.Get<type::Void>());
+    auto* func = b.CreateFunction("foo", mod.Types().void_());
 
-    auto* ty = mod.types.Get<type::Pointer>(
-        mod.types.Get<type::I32>(), builtin::AddressSpace::kFunction, builtin::Access::kReadWrite);
+    auto* ty = mod.Types().Get<type::Pointer>(mod.Types().i32(), builtin::AddressSpace::kFunction,
+                                              builtin::Access::kReadWrite);
     auto* v = b.Declare(ty);
     func->StartTarget()->SetInstructions(
         utils::Vector{v, b.Store(v, b.Constant(42_i)), b.Branch(func->EndTarget())});