diff --git a/src/tint/cmd/fuzz/ir/fuzz.h b/src/tint/cmd/fuzz/ir/fuzz.h
index 183ebe1..533cac4 100644
--- a/src/tint/cmd/fuzz/ir/fuzz.h
+++ b/src/tint/cmd/fuzz/ir/fuzz.h
@@ -81,7 +81,7 @@
 
 /// Registers the fuzzer function with the IR fuzzer executable.
 /// @param fuzzer the fuzzer
-void Register(const IRFuzzer& fuzzer);
+void Register([[maybe_unused]] const IRFuzzer& fuzzer);
 
 /// TINT_IR_MODULE_FUZZER registers the fuzzer function.
 #define TINT_IR_MODULE_FUZZER(FUNCTION) \
diff --git a/src/tint/cmd/tint/main.cc b/src/tint/cmd/tint/main.cc
index 9797feb..22add27 100644
--- a/src/tint/cmd/tint/main.cc
+++ b/src/tint/cmd/tint/main.cc
@@ -1184,8 +1184,8 @@
              std::unordered_map<tint::OverrideId, double> values;
              values.reserve(options.overrides.Count());
 
-             for (auto override : options.overrides) {
-                 const auto& name = override.key;
+             for (auto& override : options.overrides) {
+                 const auto& name = override.key.Value();
                  const auto& value = override.value;
                  if (name.empty()) {
                      std::cerr << "empty override name\n";
diff --git a/src/tint/lang/core/constant/composite_test.cc b/src/tint/lang/core/constant/composite_test.cc
index 1e0e550..f03f323 100644
--- a/src/tint/lang/core/constant/composite_test.cc
+++ b/src/tint/lang/core/constant/composite_test.cc
@@ -47,8 +47,8 @@
     auto* fPos1 = constants.Get(1_f);
     auto* fNeg1 = constants.Get(-1_f);
 
-    auto* compositePosZeros = constants.Composite(vec3f, Vector{fPos0, fPos0});
-    auto* compositeNegZeros = constants.Composite(vec3f, Vector{fNeg0, fNeg0});
+    auto* compositePosZeros = constants.Composite(vec3f, Vector{fPos0, fPos0, fPos0});
+    auto* compositeNegZeros = constants.Composite(vec3f, Vector{fNeg0, fNeg0, fNeg0});
     auto* compositeMixed = constants.Composite(vec3f, Vector{fNeg0, fPos1, fPos0});
     auto* compositePosNeg = constants.Composite(vec3f, Vector{fNeg1, fPos1, fPos1});
 
@@ -66,8 +66,8 @@
     auto* fPos1 = constants.Get(1_f);
     auto* fNeg1 = constants.Get(-1_f);
 
-    auto* compositePosZeros = constants.Composite(vec3f, Vector{fPos0, fPos0});
-    auto* compositeNegZeros = constants.Composite(vec3f, Vector{fNeg0, fNeg0});
+    auto* compositePosZeros = constants.Composite(vec3f, Vector{fPos0, fPos0, fPos0});
+    auto* compositeNegZeros = constants.Composite(vec3f, Vector{fNeg0, fNeg0, fNeg0});
     auto* compositeMixed = constants.Composite(vec3f, Vector{fNeg0, fPos1, fPos0});
     auto* compositePosNeg = constants.Composite(vec3f, Vector{fNeg1, fPos1, fPos1});
 
@@ -78,12 +78,12 @@
 }
 
 TEST_F(ConstantTest_Composite, Index) {
-    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec2f = create<core::type::Vector>(create<core::type::F32>(), 2u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fPos1 = constants.Get(1_f);
 
-    auto* composite = constants.Composite(vec3f, Vector{fPos1, fPos0});
+    auto* composite = constants.Composite(vec2f, Vector{fPos1, fPos0});
 
     ASSERT_NE(composite->Index(0), nullptr);
     ASSERT_NE(composite->Index(1), nullptr);
@@ -96,12 +96,12 @@
 }
 
 TEST_F(ConstantTest_Composite, Clone) {
-    auto* vec3f = create<core::type::Vector>(create<core::type::F32>(), 3u);
+    auto* vec2f = create<core::type::Vector>(create<core::type::F32>(), 2u);
 
     auto* fPos0 = constants.Get(0_f);
     auto* fPos1 = constants.Get(1_f);
 
-    auto* composite = constants.Composite(vec3f, Vector{fPos1, fPos0});
+    auto* composite = constants.Composite(vec2f, Vector{fPos1, fPos0});
 
     constant::Manager mgr;
     constant::CloneContext ctx{core::type::CloneContext{{nullptr}, {nullptr, &mgr.types}}, mgr};
diff --git a/src/tint/lang/core/constant/eval_runtime_semantics_test.cc b/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
index 95798e9..d48c8c9 100644
--- a/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
+++ b/src/tint/lang/core/constant/eval_runtime_semantics_test.cc
@@ -479,8 +479,9 @@
 }
 
 TEST_F(ConstEvalRuntimeSemanticsTest, Unpack2x16Float_OutOfRange) {
+    auto* vec2f = create<core::type::Vector>(create<core::type::F32>(), 2u);
     auto* a = constants.Get(u32(0x51437C00));
-    auto result = eval.unpack2x16float(create<core::type::U32>(), Vector{a}, {});
+    auto result = eval.unpack2x16float(vec2f, Vector{a}, {});
     ASSERT_EQ(result, Success);
     EXPECT_FLOAT_EQ(result.Get()->Index(0)->ValueAs<f32>(), 0.f);
     EXPECT_FLOAT_EQ(result.Get()->Index(1)->ValueAs<f32>(), 42.09375f);
diff --git a/src/tint/lang/core/constant/manager.cc b/src/tint/lang/core/constant/manager.cc
index ddd19d8..69feff2 100644
--- a/src/tint/lang/core/constant/manager.cc
+++ b/src/tint/lang/core/constant/manager.cc
@@ -144,7 +144,7 @@
             zeros.Reserve(s->Members().Length());
             for (auto* member : s->Members()) {
                 auto* zero =
-                    zero_by_type.GetOrCreate(member->Type(), [&] { return Zero(member->Type()); });
+                    zero_by_type.GetOrAdd(member->Type(), [&] { return Zero(member->Type()); });
                 if (!zero) {
                     return nullptr;
                 }
diff --git a/src/tint/lang/core/core.def b/src/tint/lang/core/core.def
index 4a5ed76..1e57b92 100644
--- a/src/tint/lang/core/core.def
+++ b/src/tint/lang/core/core.def
@@ -851,7 +851,7 @@
 @stage("fragment", "compute") fn atomicCompareExchangeWeak<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
 
 @must_use @stage("compute") fn subgroupBallot() -> vec4<u32>
-@must_use @stage("compute") fn subgroupBroadcast<T: fiu32>(value: T, @const sourceLaneIndex: u32) -> T
+@must_use @stage("compute") fn subgroupBroadcast<T: fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T
 
 ////////////////////////////////////////////////////////////////////////////////
 // Value constructors                                                         //
diff --git a/src/tint/lang/core/intrinsic/data.cc b/src/tint/lang/core/intrinsic/data.cc
index 97482d5..a127690 100644
--- a/src/tint/lang/core/intrinsic/data.cc
+++ b/src/tint/lang/core/intrinsic/data.cc
@@ -4686,41 +4686,46 @@
   {
     /* [29] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(65),
+    /* matcher_index */ TypeMatcherIndex(67),
   },
   {
     /* [30] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(57),
+    /* matcher_index */ TypeMatcherIndex(65),
   },
   {
     /* [31] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(58),
+    /* matcher_index */ TypeMatcherIndex(57),
   },
   {
     /* [32] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(55),
+    /* matcher_index */ TypeMatcherIndex(58),
   },
   {
     /* [33] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(56),
+    /* matcher_index */ TypeMatcherIndex(55),
   },
   {
     /* [34] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(59),
+    /* matcher_index */ TypeMatcherIndex(56),
   },
   {
     /* [35] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(54),
+    /* matcher_index */ TypeMatcherIndex(59),
   },
   {
     /* [36] */
     /* name */ "T",
+    /* matcher_index */ TypeMatcherIndex(54),
+  },
+  {
+    /* [37] */
+    /* name */ "T",
     /* matcher_index */ TypeMatcherIndex(71),
   },
 };
@@ -5540,7 +5545,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(52),
@@ -6437,7 +6442,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
@@ -6723,7 +6728,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(72),
@@ -7399,7 +7404,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(102),
@@ -7412,7 +7417,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(385),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(102),
@@ -7477,7 +7482,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(108),
@@ -7490,7 +7495,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(388),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(108),
@@ -7555,7 +7560,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(114),
@@ -7568,7 +7573,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(391),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(114),
@@ -7633,7 +7638,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(120),
@@ -7646,7 +7651,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(394),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(120),
@@ -7711,7 +7716,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(126),
@@ -7724,7 +7729,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(397),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(126),
@@ -7789,7 +7794,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(132),
@@ -7802,7 +7807,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(400),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(132),
@@ -7867,7 +7872,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(138),
@@ -7880,7 +7885,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(403),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(138),
@@ -7945,7 +7950,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(144),
@@ -7958,7 +7963,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(406),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(144),
@@ -8023,7 +8028,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(150),
@@ -8036,7 +8041,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(409),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(150),
@@ -8426,7 +8431,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -8439,7 +8444,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -8478,7 +8483,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -8491,7 +8496,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -8608,7 +8613,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(30),
+    /* template_types */ TemplateTypeIndex(31),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(31),
@@ -8647,7 +8652,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(31),
+    /* template_types */ TemplateTypeIndex(32),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(33),
@@ -8686,7 +8691,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(32),
+    /* template_types */ TemplateTypeIndex(33),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
@@ -8725,7 +8730,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(33),
+    /* template_types */ TemplateTypeIndex(34),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(85),
@@ -8764,7 +8769,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(34),
+    /* template_types */ TemplateTypeIndex(35),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
@@ -10233,7 +10238,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10246,7 +10251,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10285,7 +10290,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10298,7 +10303,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10467,7 +10472,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(16),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10480,7 +10485,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(351),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10493,7 +10498,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(16),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10506,7 +10511,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(351),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10948,7 +10953,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(0),
+    /* template_types */ TemplateTypeIndex(29),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(348),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10987,7 +10992,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(213),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(156),
@@ -11926,7 +11931,7 @@
   },
   {
     /* [120] */
-    /* fn subgroupBroadcast<T : fiu32>(value: T, @const sourceLaneIndex: u32) -> T */
+    /* fn subgroupBroadcast<T : fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T */
     /* num overloads */ 1,
     /* overloads */ OverloadIndex(465),
   },
diff --git a/src/tint/lang/core/ir/binary/encode.cc b/src/tint/lang/core/ir/binary/encode.cc
index ed03faa..ef364ce 100644
--- a/src/tint/lang/core/ir/binary/encode.cc
+++ b/src/tint/lang/core/ir/binary/encode.cc
@@ -175,7 +175,7 @@
         if (block_in == nullptr) {
             return 0;
         }
-        return blocks_.GetOrCreate(block_in, [&]() -> uint32_t {
+        return blocks_.GetOrAdd(block_in, [&]() -> uint32_t {
             auto& block_out = *mod_out_.add_blocks();
             auto id = static_cast<uint32_t>(blocks_.Count());
             for (auto* inst : *block_in) {
@@ -351,7 +351,7 @@
         if (type_in == nullptr) {
             return 0;
         }
-        return types_.GetOrCreate(type_in, [&]() -> uint32_t {
+        return types_.GetOrAdd(type_in, [&]() -> uint32_t {
             pb::Type type_out;
             tint::Switch(
                 type_in,  //
@@ -498,7 +498,7 @@
         if (!value_in) {
             return 0;
         }
-        return values_.GetOrCreate(value_in, [&] {
+        return values_.GetOrAdd(value_in, [&] {
             auto& value_out = *mod_out_.add_values();
             auto id = static_cast<uint32_t>(mod_out_.values().size());
 
@@ -563,7 +563,7 @@
         if (!constant_in) {
             return 0;
         }
-        return constant_values_.GetOrCreate(constant_in, [&] {
+        return constant_values_.GetOrAdd(constant_in, [&] {
             pb::ConstantValue constant_out;
             tint::Switch(
                 constant_in,  //
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index e427f34..3640439 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -298,7 +298,7 @@
     /// @param val the constant value
     /// @returns the new constant
     ir::Constant* Constant(const core::constant::Value* val) {
-        return ir.constants.GetOrCreate(val, [&] { return ir.values.Create<ir::Constant>(val); });
+        return ir.constants.GetOrAdd(val, [&] { return ir.values.Create<ir::Constant>(val); });
     }
 
     /// Creates a ir::Constant for an i32 Scalar
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index 6397f8a..2e95c2c 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -110,12 +110,12 @@
 
 size_t Disassembler::IdOf(const Block* node) {
     TINT_ASSERT(node);
-    return block_ids_.GetOrCreate(node, [&] { return block_ids_.Count(); });
+    return block_ids_.GetOrAdd(node, [&] { return block_ids_.Count(); });
 }
 
 std::string Disassembler::IdOf(const Value* value) {
     TINT_ASSERT(value);
-    return value_ids_.GetOrCreate(value, [&] {
+    return value_ids_.GetOrAdd(value, [&] {
         if (auto sym = mod_.NameOf(value)) {
             if (ids_.Add(sym.Name())) {
                 return sym.Name();
@@ -137,7 +137,7 @@
         return "undef";
     }
 
-    return if_names_.GetOrCreate(inst, [&] { return "if_" + std::to_string(if_names_.Count()); });
+    return if_names_.GetOrAdd(inst, [&] { return "if_" + std::to_string(if_names_.Count()); });
 }
 
 std::string Disassembler::NameOf(const Loop* inst) {
@@ -145,8 +145,8 @@
         return "undef";
     }
 
-    return loop_names_.GetOrCreate(inst,
-                                   [&] { return "loop_" + std::to_string(loop_names_.Count()); });
+    return loop_names_.GetOrAdd(inst,
+                                [&] { return "loop_" + std::to_string(loop_names_.Count()); });
 }
 
 std::string Disassembler::NameOf(const Switch* inst) {
@@ -154,7 +154,7 @@
         return "undef";
     }
 
-    return switch_names_.GetOrCreate(
+    return switch_names_.GetOrAdd(
         inst, [&] { return "switch_" + std::to_string(switch_names_.Count()); });
 }
 
diff --git a/src/tint/lang/core/ir/disassembler.h b/src/tint/lang/core/ir/disassembler.h
index 8f15e95..c585fc4 100644
--- a/src/tint/lang/core/ir/disassembler.h
+++ b/src/tint/lang/core/ir/disassembler.h
@@ -89,24 +89,20 @@
     /// @param inst the instruction to retrieve
     /// @returns the source for the instruction
     Source InstructionSource(const Instruction* inst) {
-        return instruction_to_src_.Get(inst).value_or(Source{});
+        return instruction_to_src_.GetOr(inst, Source{});
     }
 
     /// @param operand the operand to retrieve
     /// @returns the source for the operand
-    Source OperandSource(IndexedValue operand) {
-        return operand_to_src_.Get(operand).value_or(Source{});
-    }
+    Source OperandSource(IndexedValue operand) { return operand_to_src_.GetOr(operand, Source{}); }
 
     /// @param result the result to retrieve
     /// @returns the source for the result
-    Source ResultSource(IndexedValue result) {
-        return result_to_src_.Get(result).value_or(Source{});
-    }
+    Source ResultSource(IndexedValue result) { return result_to_src_.GetOr(result, Source{}); }
 
     /// @param blk teh block to retrieve
     /// @returns the source for the block
-    Source BlockSource(const Block* blk) { return block_to_src_.Get(blk).value_or(Source{}); }
+    Source BlockSource(const Block* blk) { return block_to_src_.GetOr(blk, Source{}); }
 
     /// Stores the given @p src location for @p inst instruction
     /// @param inst the instruction to store
diff --git a/src/tint/lang/core/ir/module.cc b/src/tint/lang/core/ir/module.cc
index 4738c14..cbc747b 100644
--- a/src/tint/lang/core/ir/module.cc
+++ b/src/tint/lang/core/ir/module.cc
@@ -49,7 +49,7 @@
 }
 
 Symbol Module::NameOf(const Value* value) const {
-    return value_to_name_.Get(value).value_or(Symbol{});
+    return value_to_name_.GetOr(value, Symbol{});
 }
 
 void Module::SetName(Instruction* inst, std::string_view name) {
diff --git a/src/tint/lang/core/ir/transform/binary_polyfill.cc b/src/tint/lang/core/ir/transform/binary_polyfill.cc
index 83fb233..27d3b13 100644
--- a/src/tint/lang/core/ir/transform/binary_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/binary_polyfill.cc
@@ -155,7 +155,7 @@
         bool is_signed = result_ty->is_signed_integer_scalar_or_vector();
 
         auto& helpers = is_div ? int_div_helpers : int_mod_helpers;
-        auto* helper = helpers.GetOrCreate(result_ty, [&] {
+        auto* helper = helpers.GetOrAdd(result_ty, [&] {
             // Generate a name for the helper function.
             StringStream name;
             name << "tint_" << (is_div ? "div_" : "mod_");
diff --git a/src/tint/lang/core/ir/transform/conversion_polyfill.cc b/src/tint/lang/core/ir/transform/conversion_polyfill.cc
index 705d946..5d4fdbc 100644
--- a/src/tint/lang/core/ir/transform/conversion_polyfill.cc
+++ b/src/tint/lang/core/ir/transform/conversion_polyfill.cc
@@ -106,7 +106,7 @@
         auto* src_el_ty = src_ty->DeepestElement();
 
         auto& helpers = src_el_ty->Is<type::F32>() ? f32toi_helpers : f16toi_helpers;
-        auto* helper = helpers.GetOrCreate(res_ty, [&] {
+        auto* helper = helpers.GetOrAdd(res_ty, [&] {
             // Generate a name for the helper function.
             StringStream name;
             name << "tint_";
diff --git a/src/tint/lang/core/ir/transform/demote_to_helper.cc b/src/tint/lang/core/ir/transform/demote_to_helper.cc
index 6c61cbc..a460c41 100644
--- a/src/tint/lang/core/ir/transform/demote_to_helper.cc
+++ b/src/tint/lang/core/ir/transform/demote_to_helper.cc
@@ -91,7 +91,7 @@
     /// @param func the function to check
     /// @returns true if @p func contains a discard instruction
     bool HasDiscard(Function* func) {
-        return function_discard_status.GetOrCreate(func, [&] { return HasDiscard(func->Block()); });
+        return function_discard_status.GetOrAdd(func, [&] { return HasDiscard(func->Block()); });
     }
 
     /// Check if a block (transitively) contains a discard instruction.
diff --git a/src/tint/lang/core/ir/transform/direct_variable_access.cc b/src/tint/lang/core/ir/transform/direct_variable_access.cc
index 95a601e..5297c81 100644
--- a/src/tint/lang/core/ir/transform/direct_variable_access.cc
+++ b/src/tint/lang/core/ir/transform/direct_variable_access.cc
@@ -356,7 +356,7 @@
             }
 
             // Look to see if this callee signature already has a variant created.
-            auto* new_target = (*target_info)->variants_by_sig.GetOrCreate(signature, [&] {
+            auto* new_target = (*target_info)->variants_by_sig.GetOrAdd(signature, [&] {
                 // New signature.
 
                 // Clone the original function to seed the new variant.
diff --git a/src/tint/lang/core/ir/transform/preserve_padding.cc b/src/tint/lang/core/ir/transform/preserve_padding.cc
index 49da61f..79e6588 100644
--- a/src/tint/lang/core/ir/transform/preserve_padding.cc
+++ b/src/tint/lang/core/ir/transform/preserve_padding.cc
@@ -124,7 +124,7 @@
         }
 
         // The type contains padding bytes, so call a helper function that decomposes the accesses.
-        auto* helper = helpers.GetOrCreate(store_type, [&] {
+        auto* helper = helpers.GetOrAdd(store_type, [&] {
             auto* func = b.Function("tint_store_and_preserve_padding", ty.void_());
             auto* target = b.FunctionParam("target", ty.ptr(storage, store_type));
             auto* value_param = b.FunctionParam("value_param", store_type);
diff --git a/src/tint/lang/core/ir/transform/shader_io.cc b/src/tint/lang/core/ir/transform/shader_io.cc
index a0c6d78..9586785 100644
--- a/src/tint/lang/core/ir/transform/shader_io.cc
+++ b/src/tint/lang/core/ir/transform/shader_io.cc
@@ -228,9 +228,9 @@
     /// Finalize any state needed to complete the transform.
     void Finalize() {
         // Remove IO attributes from all structure members that had them prior to this transform.
-        for (auto* member : members_to_strip) {
+        for (auto& member : members_to_strip) {
             // TODO(crbug.com/tint/745): Remove the const_cast.
-            const_cast<core::type::StructMember*>(member)->SetAttributes({});
+            const_cast<core::type::StructMember*>(member.Value())->SetAttributes({});
         }
     }
 };
diff --git a/src/tint/lang/core/ir/transform/std140.cc b/src/tint/lang/core/ir/transform/std140.cc
index ba436eb..f2caaf5 100644
--- a/src/tint/lang/core/ir/transform/std140.cc
+++ b/src/tint/lang/core/ir/transform/std140.cc
@@ -125,7 +125,7 @@
     /// @param type the type to rewrite
     /// @returns the new type
     const core::type::Type* RewriteType(const core::type::Type* type) {
-        return rewritten_types.GetOrCreate(type, [&]() -> const core::type::Type* {
+        return rewritten_types.GetOrAdd(type, [&]() -> const core::type::Type* {
             return tint::Switch(
                 type,
                 [&](const core::type::Array* arr) -> const core::type::Type* {
@@ -219,7 +219,7 @@
             orig_ty,  //
             [&](const core::type::Struct* str) -> Value* {
                 // Create a helper function that converts the struct to the original type.
-                auto* helper = convert_helpers.GetOrCreate(str, [&] {
+                auto* helper = convert_helpers.GetOrAdd(str, [&] {
                     auto* input_str = source->Type()->As<core::type::Struct>();
                     auto* func = b.Function("convert_" + str->FriendlyName(), str);
                     auto* input = b.FunctionParam("input", input_str);
diff --git a/src/tint/lang/core/ir/transform/value_to_let.cc b/src/tint/lang/core/ir/transform/value_to_let.cc
index bbdcab0..ac51672 100644
--- a/src/tint/lang/core/ir/transform/value_to_let.cc
+++ b/src/tint/lang/core/ir/transform/value_to_let.cc
@@ -84,7 +84,7 @@
         Access pending_access = Access::kLoad;
 
         auto put_pending_in_lets = [&] {
-            for (auto* pending : pending_resolution) {
+            for (auto& pending : pending_resolution) {
                 PutInLet(pending);
             }
             pending_resolution.Clear();
@@ -97,7 +97,7 @@
                     case 0:  // No usage
                         break;
                     case 1: {  // Single usage
-                        auto* usage = (*usages.begin()).instruction;
+                        auto usage = (*usages.begin())->instruction;
                         if (usage->Block() == inst->Block()) {
                             // Usage in same block. Assign to pending_resolution, as we don't
                             // know whether its safe to inline yet.
diff --git a/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc b/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc
index db902b4..eeef8b2 100644
--- a/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc
@@ -105,7 +105,7 @@
                 if (ptr && ptr->AddressSpace() == core::AddressSpace::kWorkgroup) {
                     // Record the usage of the variable for each block that references it.
                     var->Result(0)->ForEachUse([&](const Usage& use) {
-                        block_to_direct_vars.GetOrZero(use.instruction->Block())->Add(var);
+                        block_to_direct_vars.GetOrAddZero(use.instruction->Block()).Add(var);
                     });
                     var_to_id.Add(var, next_id++);
                 }
@@ -184,7 +184,7 @@
     /// @param func the function
     /// @returns the set of transitively referenced workgroup variables
     VarSet GetReferencedVars(Function* func) {
-        return function_to_transitive_vars.GetOrCreate(func, [&] {
+        return function_to_transitive_vars.GetOrAdd(func, [&] {
             VarSet vars;
             GetReferencedVars(func->Block(), vars);
             return vars;
@@ -196,8 +196,8 @@
     /// @param vars the set of transitively referenced workgroup variables to populate
     void GetReferencedVars(Block* block, VarSet& vars) {
         // Add directly referenced vars.
-        if (auto itr = block_to_direct_vars.Find(block)) {
-            for (auto* var : *itr) {
+        if (auto itr = block_to_direct_vars.Get(block)) {
+            for (auto& var : *itr) {
                 vars.Add(var);
             }
         }
@@ -209,7 +209,7 @@
                 [&](UserCall* call) {
                     // Get variables referenced by a function called from this block.
                     auto callee_vars = GetReferencedVars(call->Target());
-                    for (auto* var : callee_vars) {
+                    for (auto& var : callee_vars) {
                         vars.Add(var);
                     }
                 },
@@ -234,7 +234,7 @@
                        StoreMap& stores) {
         // If this type can be trivially zeroed, store to the whole element.
         if (CanTriviallyZero(type)) {
-            stores.GetOrZero(iteration_count)->Push(Store{var, type, indices});
+            stores.GetOrAddZero(iteration_count).Push(Store{var, type, indices});
             return;
         }
 
@@ -253,7 +253,7 @@
                 PrepareStores(var, arr->ElemType(), iteration_count * count, new_indices, stores);
             },
             [&](const type::Atomic*) {
-                stores.GetOrZero(iteration_count)->Push(Store{var, type, indices});
+                stores.GetOrAddZero(iteration_count).Push(Store{var, type, indices});
             },
             [&](const type::Struct* str) {
                 for (auto* member : str->Members()) {
diff --git a/src/tint/lang/core/ir/value.cc b/src/tint/lang/core/ir/value.cc
index e062a62..c1a66e8 100644
--- a/src/tint/lang/core/ir/value.cc
+++ b/src/tint/lang/core/ir/value.cc
@@ -55,14 +55,14 @@
     while (!uses_.IsEmpty()) {
         auto& use = *uses_.begin();
         auto* replacement = replacer(use);
-        use.instruction->SetOperand(use.operand_index, replacement);
+        use->instruction->SetOperand(use->operand_index, replacement);
     }
 }
 
 void Value::ReplaceAllUsesWith(Value* replacement) {
     while (!uses_.IsEmpty()) {
         auto& use = *uses_.begin();
-        use.instruction->SetOperand(use.operand_index, replacement);
+        use->instruction->SetOperand(use->operand_index, replacement);
     }
 }
 
diff --git a/src/tint/lang/core/ir/value.h b/src/tint/lang/core/ir/value.h
index 55f7463..e2819bc 100644
--- a/src/tint/lang/core/ir/value.h
+++ b/src/tint/lang/core/ir/value.h
@@ -100,7 +100,7 @@
     /// @param instruction the instruction
     /// @param operand_index the in
     bool HasUsage(const Instruction* instruction, size_t operand_index) const {
-        return uses_.Contains({const_cast<Instruction*>(instruction), operand_index});
+        return uses_.Contains(Usage{const_cast<Instruction*>(instruction), operand_index});
     }
 
     /// Apply a function to all uses of the value that exist prior to calling this method.
diff --git a/src/tint/lang/core/ir/var.cc b/src/tint/lang/core/ir/var.cc
index 11a9287..92f2446 100644
--- a/src/tint/lang/core/ir/var.cc
+++ b/src/tint/lang/core/ir/var.cc
@@ -78,7 +78,7 @@
     if (result->Usages().All([](const Usage& u) { return u.instruction->Is<ir::Store>(); })) {
         while (!result->Usages().IsEmpty()) {
             auto& usage = *result->Usages().begin();
-            usage.instruction->Destroy();
+            usage->instruction->Destroy();
         }
         Destroy();
     }
diff --git a/src/tint/lang/core/type/manager.h b/src/tint/lang/core/type/manager.h
index f02290b..0a9a201 100644
--- a/src/tint/lang/core/type/manager.h
+++ b/src/tint/lang/core/type/manager.h
@@ -172,7 +172,7 @@
               typename _ = std::enable_if<tint::traits::IsTypeOrDerived<TYPE, Type>>,
               typename... ARGS>
     auto* Find(ARGS&&... args) const {
-        return types_.Find<ToType<TYPE>>(std::forward<ARGS>(args)...);
+        return types_.Find<TYPE>(std::forward<ARGS>(args)...);
     }
 
     /// @returns a void type
@@ -501,16 +501,6 @@
     TypeIterator end() const { return types_.end(); }
 
   private:
-    /// ToType<T> is specialized for various `T` types and each specialization contains a single
-    /// `type` alias to the corresponding type deriving from `core::type::Type`.
-    template <typename T>
-    struct ToTypeImpl {
-        using type = T;
-    };
-
-    template <typename T>
-    using ToType = typename ToTypeImpl<T>::type;
-
     /// Unique types owned by the manager
     UniqueAllocator<Type> types_;
     /// Unique nodes (excluding types) owned by the manager
diff --git a/src/tint/lang/core/type/struct.h b/src/tint/lang/core/type/struct.h
index 539c27b..1ea2b0b 100644
--- a/src/tint/lang/core/type/struct.h
+++ b/src/tint/lang/core/type/struct.h
@@ -148,7 +148,7 @@
     /// @returns true iff this structure has been used by address space that's
     /// host-shareable.
     bool IsHostShareable() const {
-        for (auto sc : address_space_usage_) {
+        for (auto& sc : address_space_usage_) {
             if (core::IsHostShareable(sc)) {
                 return true;
             }
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
index 1a66806..bd3deb4 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
@@ -398,8 +398,8 @@
         auto* src_vec = src_type->As<core::type::Vector>();
         TINT_ASSERT(src_vec);
         TINT_ASSERT(((src_vec->Width() == 2u) || (src_vec->Width() == 4u)));
-        std::string fn = GetOrCreate(
-            bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
+        std::string fn =
+            GetOrAdd(bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
                 TextBuffer b;
                 TINT_DEFER(helpers_.Append(b));
 
@@ -452,8 +452,8 @@
         auto* dst_vec = dst_type->As<core::type::Vector>();
         TINT_ASSERT(dst_vec);
         TINT_ASSERT(((dst_vec->Width() == 2u) || (dst_vec->Width() == 4u)));
-        std::string fn = GetOrCreate(
-            bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
+        std::string fn =
+            GetOrAdd(bitcast_funcs_, BinaryOperandType{{src_type, dst_type}}, [&]() -> std::string {
                 TextBuffer b;
                 TINT_DEFER(helpers_.Append(b));
 
@@ -613,37 +613,37 @@
     auto* ret_ty = TypeOf(expr)->UnwrapRef();
     auto* lhs_ty = TypeOf(expr->lhs)->UnwrapRef();
     auto* rhs_ty = TypeOf(expr->rhs)->UnwrapRef();
-    fn = tint::GetOrCreate(float_modulo_funcs_, BinaryOperandType{{lhs_ty, rhs_ty}},
-                           [&]() -> std::string {
-                               TextBuffer b;
-                               TINT_DEFER(helpers_.Append(b));
+    fn = tint::GetOrAdd(float_modulo_funcs_, BinaryOperandType{{lhs_ty, rhs_ty}},
+                        [&]() -> std::string {
+                            TextBuffer b;
+                            TINT_DEFER(helpers_.Append(b));
 
-                               auto fn_name = UniqueIdentifier("tint_float_modulo");
-                               std::vector<std::string> parameter_names;
-                               {
-                                   auto decl = Line(&b);
-                                   EmitTypeAndName(decl, ret_ty, core::AddressSpace::kUndefined,
-                                                   core::Access::kUndefined, fn_name);
-                                   {
-                                       ScopedParen sp(decl);
-                                       const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
-                                       EmitTypeAndName(decl, ty, core::AddressSpace::kUndefined,
-                                                       core::Access::kUndefined, "lhs");
-                                       decl << ", ";
-                                       ty = TypeOf(expr->rhs)->UnwrapRef();
-                                       EmitTypeAndName(decl, ty, core::AddressSpace::kUndefined,
-                                                       core::Access::kUndefined, "rhs");
-                                   }
-                                   decl << " {";
-                               }
-                               {
-                                   ScopedIndent si(&b);
-                                   Line(&b) << "return (lhs - rhs * trunc(lhs / rhs));";
-                               }
-                               Line(&b) << "}";
-                               Line(&b);
-                               return fn_name;
-                           });
+                            auto fn_name = UniqueIdentifier("tint_float_modulo");
+                            std::vector<std::string> parameter_names;
+                            {
+                                auto decl = Line(&b);
+                                EmitTypeAndName(decl, ret_ty, core::AddressSpace::kUndefined,
+                                                core::Access::kUndefined, fn_name);
+                                {
+                                    ScopedParen sp(decl);
+                                    const auto* ty = TypeOf(expr->lhs)->UnwrapRef();
+                                    EmitTypeAndName(decl, ty, core::AddressSpace::kUndefined,
+                                                    core::Access::kUndefined, "lhs");
+                                    decl << ", ";
+                                    ty = TypeOf(expr->rhs)->UnwrapRef();
+                                    EmitTypeAndName(decl, ty, core::AddressSpace::kUndefined,
+                                                    core::Access::kUndefined, "rhs");
+                                }
+                                decl << " {";
+                            }
+                            {
+                                ScopedIndent si(&b);
+                                Line(&b) << "return (lhs - rhs * trunc(lhs / rhs));";
+                            }
+                            Line(&b) << "}";
+                            Line(&b);
+                            return fn_name;
+                        });
 
     // Call the helper
     out << fn;
@@ -1145,7 +1145,7 @@
     if (vec_ty->type()->is_integer_scalar()) {
         // GLSL does not have a builtin for dot() with integer vector types.
         // Generate the helper function if it hasn't been created already
-        fn = tint::GetOrCreate(int_dot_funcs_, vec_ty, [&]() -> std::string {
+        fn = tint::GetOrAdd(int_dot_funcs_, vec_ty, [&]() -> std::string {
             TextBuffer b;
             TINT_DEFER(helpers_.Append(b));
 
@@ -2942,7 +2942,7 @@
                                    const sem::BuiltinFn* builtin,
                                    F&& build) {
     // Generate the helper function if it hasn't been created already
-    auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
+    auto fn = tint::GetOrAdd(builtins_, builtin, [&]() -> std::string {
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
@@ -3009,8 +3009,8 @@
 std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
-        name = tint::GetOrCreate(builtin_struct_names_, s,
-                                 [&] { return UniqueIdentifier(name.substr(2)); });
+        name = tint::GetOrAdd(builtin_struct_names_, s,
+                              [&] { return UniqueIdentifier(name.substr(2)); });
     }
     return name;
 }
diff --git a/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc b/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
index 819241a..6762ee6 100644
--- a/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
+++ b/src/tint/lang/glsl/writer/ast_raise/combine_samplers.cc
@@ -191,8 +191,8 @@
         if (IsGlobal(pair)) {
             // Both texture and sampler are global; add a new global variable
             // to represent the combined sampler (if not already created).
-            GetOrCreate(global_combined_texture_samplers_, pair,
-                        [&] { return CreateCombinedGlobal(texture_var, sampler_var, name); });
+            GetOrAdd(global_combined_texture_samplers_, pair,
+                     [&] { return CreateCombinedGlobal(texture_var, sampler_var, name); });
         } else {
             // Either texture or sampler (or both) is a function parameter;
             // add a new function parameter to represent the combined sampler.
diff --git a/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc b/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
index 5ac9fec..2b31e07 100644
--- a/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
+++ b/src/tint/lang/glsl/writer/ast_raise/texture_builtins_from_uniform.cc
@@ -139,7 +139,7 @@
                                 TINT_ICE_ON_NO_MATCH);
                         },
                         [&](const sem::Function* user_fn) {
-                            auto user_param_to_info = fn_to_data.Find(user_fn);
+                            auto user_param_to_info = fn_to_data.Get(user_fn);
                             if (!user_param_to_info) {
                                 // Uninterested function not calling texture builtins with function
                                 // texture param.
@@ -149,11 +149,10 @@
                                         user_fn->Declaration()->params.Length());
                             for (size_t i = 0; i < call->Arguments().Length(); i++) {
                                 auto param = user_fn->Declaration()->params[i];
-                                auto info = user_param_to_info->Get(param);
-                                if (info.has_value()) {
+                                if (auto info = user_param_to_info->Get(param)) {
                                     auto* arg = call->Arguments()[i];
                                     auto* texture_sem = arg->RootIdentifier();
-                                    auto& args = call_to_data.GetOrCreate(call_expr, [&] {
+                                    auto& args = call_to_data.GetOrAdd(call_expr, [&] {
                                         return Vector<
                                             std::variant<BindingPoint, const ast::Parameter*>, 4>();
                                     });
@@ -183,8 +182,8 @@
 
         // If any functions need extra params, add them now.
         if (!fn_to_data.IsEmpty()) {
-            for (auto pair : fn_to_data) {
-                auto* fn = pair.key;
+            for (auto& pair : fn_to_data) {
+                auto* fn = pair.key.Value();
 
                 // Reorder the param to a vector to make sure params are in the correct order.
                 Vector<const ast::Parameter*, 4> extra_params_in_order;
@@ -201,8 +200,8 @@
         }
 
         // Replace all interested texture builtin calls.
-        for (auto pair : builtin_to_replace) {
-            auto call = pair.key;
+        for (auto& pair : builtin_to_replace) {
+            auto call = pair.key.Value();
             if (std::holds_alternative<BindingPoint>(pair.value)) {
                 // This texture is a global variable with binding point.
                 // Read builtin value from uniform buffer.
@@ -216,8 +215,8 @@
         }
 
         // Insert all extra args to interested function calls.
-        for (auto pair : call_to_data) {
-            auto call = pair.key;
+        for (auto& pair : call_to_data) {
+            auto call = pair.key.Value();
             for (auto new_arg_info : pair.value) {
                 if (std::holds_alternative<BindingPoint>(new_arg_info)) {
                     // This texture is a global variable with binding point.
@@ -363,7 +362,7 @@
 
         // Load the builtin value from the UBO.
         auto member_sym = bindpoint_to_syms.Get(binding);
-        TINT_ASSERT(member_sym.has_value());
+        TINT_ASSERT(member_sym);
 
         return b.MemberAccessor(ubo_sym, *member_sym);
     }
@@ -383,7 +382,7 @@
     /// @returns the new u32 function parameter.
     const ast::Parameter* GetAndRecordFunctionParameter(const sem::Function* fn,
                                                         const sem::Variable* var) {
-        auto& param_to_info = fn_to_data.GetOrCreate(
+        auto& param_to_info = fn_to_data.GetOrAdd(
             fn, [&] { return Hashmap<const ast::Parameter*, FunctionExtraParamInfo, 4>(); });
 
         const ast::Parameter* param = nullptr;
@@ -397,7 +396,7 @@
 
         // Get or record a new u32 param to this function if first visited.
         auto entry = param_to_info.Get(param);
-        if (entry.has_value()) {
+        if (entry) {
             return entry->param;
         }
 
diff --git a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
index 9070b70..f2a8f82 100644
--- a/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/hlsl/writer/ast_printer/ast_printer.cc
@@ -460,7 +460,7 @@
 
 bool ASTPrinter::EmitDynamicVectorAssignment(const ast::AssignmentStatement* stmt,
                                              const core::type::Vector* vec) {
-    auto name = tint::GetOrCreate(dynamic_vector_write_, vec, [&]() -> std::string {
+    auto name = tint::GetOrAdd(dynamic_vector_write_, vec, [&]() -> std::string {
         std::string fn = UniqueIdentifier("set_vector_element");
         {
             auto out = Line(&helpers_);
@@ -525,7 +525,7 @@
 
 bool ASTPrinter::EmitDynamicMatrixVectorAssignment(const ast::AssignmentStatement* stmt,
                                                    const core::type::Matrix* mat) {
-    auto name = tint::GetOrCreate(dynamic_matrix_vector_write_, mat, [&]() -> std::string {
+    auto name = tint::GetOrAdd(dynamic_matrix_vector_write_, mat, [&]() -> std::string {
         std::string fn = UniqueIdentifier("set_matrix_column");
         {
             auto out = Line(&helpers_);
@@ -586,7 +586,7 @@
     auto* lhs_row_access = stmt->lhs->As<ast::IndexAccessorExpression>();
     auto* lhs_col_access = lhs_row_access->object->As<ast::IndexAccessorExpression>();
 
-    auto name = tint::GetOrCreate(dynamic_matrix_scalar_write_, mat, [&]() -> std::string {
+    auto name = tint::GetOrAdd(dynamic_matrix_scalar_write_, mat, [&]() -> std::string {
         std::string fn = UniqueIdentifier("set_matrix_scalar");
         {
             auto out = Line(&helpers_);
@@ -722,7 +722,7 @@
                 // f32tof16 to get the bits. This should be safe, because the convertion is precise
                 // for finite and infinite f16 value as they are exactly representable by f32, and
                 // WGSL spec allow any result if f16 value is NaN.
-                return tint::GetOrCreate(
+                return tint::GetOrAdd(
                     bitcast_funcs_, BinaryType{{src_type, dst_type}}, [&]() -> std::string {
                         TextBuffer b;
                         TINT_DEFER(helpers_.Append(b));
@@ -794,7 +794,7 @@
                 // convertion is precise for finite and infinite f16 result value as they are
                 // exactly representable by f32, and WGSL spec allow any result if f16 result value
                 // would be NaN.
-                return tint::GetOrCreate(
+                return tint::GetOrAdd(
                     bitcast_funcs_, BinaryType{{src_type, dst_type}}, [&]() -> std::string {
                         TextBuffer b;
                         TINT_DEFER(helpers_.Append(b));
@@ -4689,7 +4689,7 @@
                                    const sem::BuiltinFn* builtin,
                                    F&& build) {
     // Generate the helper function if it hasn't been created already
-    auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
+    auto fn = tint::GetOrAdd(builtins_, builtin, [&]() -> std::string {
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
@@ -4758,8 +4758,8 @@
 std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
-        name = tint::GetOrCreate(builtin_struct_names_, s,
-                                 [&] { return UniqueIdentifier(name.substr(2)); });
+        name = tint::GetOrAdd(builtin_struct_names_, s,
+                              [&] { return UniqueIdentifier(name.substr(2)); });
     }
     return name;
 }
diff --git a/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc b/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
index 3dd8c8a..25a23ea 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/calculate_array_length.cc
@@ -116,7 +116,7 @@
     // [RW]ByteAddressBuffer.GetDimensions().
     std::unordered_map<const core::type::Reference*, Symbol> buffer_size_intrinsics;
     auto get_buffer_size_intrinsic = [&](const core::type::Reference* buffer_type) {
-        return tint::GetOrCreate(buffer_size_intrinsics, buffer_type, [&] {
+        return tint::GetOrAdd(buffer_size_intrinsics, buffer_type, [&] {
             auto name = b.Sym();
             auto type = CreateASTTypeFor(ctx, buffer_type);
             auto* disable_validation = b.Disable(ast::DisabledValidation::kFunctionParameter);
@@ -195,7 +195,7 @@
                     auto* block = call->Stmt()->Block()->Declaration();
 
                     auto array_length =
-                        tint::GetOrCreate(array_length_by_usage, {block, storage_buffer_var}, [&] {
+                        tint::GetOrAdd(array_length_by_usage, {block, storage_buffer_var}, [&] {
                             // First time this array length is used for this block.
                             // Let's calculate it.
 
diff --git a/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc b/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
index a6e5955..91e67b5 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/decompose_memory_access.cc
@@ -482,7 +482,7 @@
     Symbol LoadFunc(const core::type::Type* el_ty,
                     core::AddressSpace address_space,
                     const Symbol& buffer) {
-        return tint::GetOrCreate(load_funcs, LoadStoreKey{el_ty, buffer}, [&] {
+        return tint::GetOrAdd(load_funcs, LoadStoreKey{el_ty, buffer}, [&] {
             Vector params{b.Param("offset", b.ty.u32())};
 
             auto name = b.Symbols().New(buffer.Name() + "_load");
@@ -562,7 +562,7 @@
     /// @param buffer the symbol of the storage buffer variable, owned by the target ProgramBuilder.
     /// @return the name of the function that performs the store
     Symbol StoreFunc(const core::type::Type* el_ty, const Symbol& buffer) {
-        return tint::GetOrCreate(store_funcs, LoadStoreKey{el_ty, buffer}, [&] {
+        return tint::GetOrAdd(store_funcs, LoadStoreKey{el_ty, buffer}, [&] {
             Vector params{
                 b.Param("offset", b.ty.u32()),
                 b.Param("value", CreateASTTypeFor(ctx, el_ty)),
@@ -653,7 +653,7 @@
                       const sem::BuiltinFn* builtin,
                       const Symbol& buffer) {
         auto fn = builtin->Fn();
-        return tint::GetOrCreate(atomic_funcs, AtomicKey{el_ty, fn, buffer}, [&] {
+        return tint::GetOrAdd(atomic_funcs, AtomicKey{el_ty, fn, buffer}, [&] {
             // The first parameter to all WGSL atomics is the expression to the
             // atomic. This is replaced with two parameters: the buffer and offset.
             Vector params{b.Param("offset", b.ty.u32())};
diff --git a/src/tint/lang/hlsl/writer/ast_raise/remove_continue_in_switch.cc b/src/tint/lang/hlsl/writer/ast_raise/remove_continue_in_switch.cc
index db94a0f..899ea10 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/remove_continue_in_switch.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/remove_continue_in_switch.cc
@@ -68,7 +68,7 @@
                 continue;
             }
 
-            auto& info = switch_infos.GetOrCreate(switch_stmt, [&] {
+            auto& info = switch_infos.GetOrAdd(switch_stmt, [&] {
                 switch_stmts.Push(switch_stmt);
                 auto* block = sem.Get(switch_stmt)->FindFirstParent<sem::LoopBlockStatement>();
                 return SwitchInfo{/* loop_block */ block, /* continues */ Empty};
@@ -89,7 +89,7 @@
         for (auto* switch_stmt : switch_stmts) {
             const auto& info = switch_infos.Get(switch_stmt);
 
-            auto var_name = loop_to_var.GetOrCreate(info->loop_block, [&] {
+            auto var_name = loop_to_var.GetOrAdd(info->loop_block, [&] {
                 // Create and insert 'var tint_continue : bool;' before loop
                 auto var = b.Symbols().New("tint_continue");
                 auto* decl = b.Decl(b.Var(var, b.ty.bool_()));
diff --git a/src/tint/lang/hlsl/writer/ast_raise/truncate_interstage_variables.cc b/src/tint/lang/hlsl/writer/ast_raise/truncate_interstage_variables.cc
index 187834e..5d38ff8 100644
--- a/src/tint/lang/hlsl/writer/ast_raise/truncate_interstage_variables.cc
+++ b/src/tint/lang/hlsl/writer/ast_raise/truncate_interstage_variables.cc
@@ -129,34 +129,33 @@
 
         // Get or create a new truncated struct/truncate function for the interstage inputs &
         // outputs.
-        auto entry =
-            old_shader_io_structs_to_new_struct_and_truncate_functions.GetOrCreate(str, [&] {
-                auto new_struct_sym = b.Symbols().New();
+        auto entry = old_shader_io_structs_to_new_struct_and_truncate_functions.GetOrAdd(str, [&] {
+            auto new_struct_sym = b.Symbols().New();
 
-                Vector<const ast::StructMember*, 20> truncated_members;
-                Vector<const ast::Expression*, 20> initializer_exprs;
+            Vector<const ast::StructMember*, 20> truncated_members;
+            Vector<const ast::Expression*, 20> initializer_exprs;
 
-                for (auto* member : str->Members()) {
-                    if (omit_members.Contains(member)) {
-                        continue;
-                    }
-
-                    truncated_members.Push(ctx.Clone(member->Declaration()));
-                    initializer_exprs.Push(b.MemberAccessor("io", ctx.Clone(member->Name())));
+            for (auto* member : str->Members()) {
+                if (omit_members.Contains(member)) {
+                    continue;
                 }
 
-                // Create the new shader io struct.
-                b.Structure(new_struct_sym, std::move(truncated_members));
+                truncated_members.Push(ctx.Clone(member->Declaration()));
+                initializer_exprs.Push(b.MemberAccessor("io", ctx.Clone(member->Name())));
+            }
 
-                // Create the mapping function to truncate the shader io.
-                auto mapping_fn_sym = b.Symbols().New("truncate_shader_output");
-                b.Func(mapping_fn_sym, Vector{b.Param("io", ctx.Clone(func_ast->return_type))},
-                       b.ty(new_struct_sym),
-                       Vector{
-                           b.Return(b.Call(new_struct_sym, std::move(initializer_exprs))),
-                       });
-                return TruncatedStructAndConverter{new_struct_sym, mapping_fn_sym};
-            });
+            // Create the new shader io struct.
+            b.Structure(new_struct_sym, std::move(truncated_members));
+
+            // Create the mapping function to truncate the shader io.
+            auto mapping_fn_sym = b.Symbols().New("truncate_shader_output");
+            b.Func(mapping_fn_sym, Vector{b.Param("io", ctx.Clone(func_ast->return_type))},
+                   b.ty(new_struct_sym),
+                   Vector{
+                       b.Return(b.Call(new_struct_sym, std::move(initializer_exprs))),
+                   });
+            return TruncatedStructAndConverter{new_struct_sym, mapping_fn_sym};
+        });
 
         ctx.Replace(func_ast->return_type.expr, b.Expr(entry.truncated_struct));
 
@@ -172,7 +171,7 @@
         [&](const ast::ReturnStatement* return_statement) -> const ast::ReturnStatement* {
             auto* return_sem = sem.Get(return_statement);
             if (auto mapping_fn_sym =
-                    entry_point_functions_to_truncate_functions.Find(return_sem->Function())) {
+                    entry_point_functions_to_truncate_functions.Get(return_sem->Function())) {
                 return b.Return(return_statement->source,
                                 b.Call(*mapping_fn_sym, ctx.Clone(return_statement->value)));
             }
@@ -181,7 +180,7 @@
 
     // Remove IO attributes from old shader IO struct which is not used as entry point output
     // anymore.
-    for (auto it : old_shader_io_structs_to_new_struct_and_truncate_functions) {
+    for (auto& it : old_shader_io_structs_to_new_struct_and_truncate_functions) {
         const ast::Struct* struct_ty = it.key->Declaration();
         for (auto* member : struct_ty->members) {
             for (auto* attr : member->attributes) {
diff --git a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
index d7d744c..4c987c9 100644
--- a/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/msl/writer/ast_printer/ast_printer.cc
@@ -947,7 +947,7 @@
             auto sc = ptr_ty->AddressSpace();
             auto* str = builtin->ReturnType()->As<core::type::Struct>();
 
-            auto func = tint::GetOrCreate(
+            auto func = tint::GetOrAdd(
                 atomicCompareExchangeWeak_, ACEWKeyType{{sc, str}}, [&]() -> std::string {
                     if (!EmitStructType(&helpers_,
                                         builtin->ReturnType()->As<core::type::Struct>())) {
@@ -1342,7 +1342,7 @@
     if (vec_ty->type()->is_integer_scalar()) {
         // MSL does not have a builtin for dot() with integer vector types.
         // Generate the helper function if it hasn't been created already
-        fn = tint::GetOrCreate(int_dot_funcs_, vec_ty->Width(), [&]() -> std::string {
+        fn = tint::GetOrAdd(int_dot_funcs_, vec_ty->Width(), [&]() -> std::string {
             TextBuffer b;
             TINT_DEFER(helpers_.Append(b));
 
@@ -2872,7 +2872,7 @@
     // largest negative value, it returns `e`.
     auto* expr_type = TypeOf(expr->expr)->UnwrapRef();
     if (expr->op == core::UnaryOp::kNegation && expr_type->is_signed_integer_scalar_or_vector()) {
-        auto fn = tint::GetOrCreate(unary_minus_funcs_, expr_type, [&]() -> std::string {
+        auto fn = tint::GetOrAdd(unary_minus_funcs_, expr_type, [&]() -> std::string {
             // e.g.:
             // int tint_unary_minus(const int v) {
             //     return (v == -2147483648) ? v : -v;
@@ -3039,7 +3039,7 @@
                                    const sem::BuiltinFn* builtin,
                                    F&& build) {
     // Generate the helper function if it hasn't been created already
-    auto fn = tint::GetOrCreate(builtins_, builtin, [&]() -> std::string {
+    auto fn = tint::GetOrAdd(builtins_, builtin, [&]() -> std::string {
         TextBuffer b;
         TINT_DEFER(helpers_.Append(b));
 
@@ -3122,8 +3122,8 @@
 std::string ASTPrinter::StructName(const core::type::Struct* s) {
     auto name = s->Name().Name();
     if (HasPrefix(name, "__")) {
-        name = tint::GetOrCreate(builtin_struct_names_, s,
-                                 [&] { return UniqueIdentifier(name.substr(2)); });
+        name = tint::GetOrAdd(builtin_struct_names_, s,
+                              [&] { return UniqueIdentifier(name.substr(2)); });
     }
     return name;
 }
diff --git a/src/tint/lang/msl/writer/ast_raise/packed_vec3.cc b/src/tint/lang/msl/writer/ast_raise/packed_vec3.cc
index a61e3f8..a1f2321 100644
--- a/src/tint/lang/msl/writer/ast_raise/packed_vec3.cc
+++ b/src/tint/lang/msl/writer/ast_raise/packed_vec3.cc
@@ -139,7 +139,7 @@
                         // Create a struct with a single `__packed_vec3` member.
                         // Give the struct member the same alignment as the original unpacked vec3
                         // type, to avoid changing the array element stride.
-                        return b.ty(packed_vec3_wrapper_struct_names.GetOrCreate(vec, [&] {
+                        return b.ty(packed_vec3_wrapper_struct_names.GetOrAdd(vec, [&] {
                             auto name = b.Symbols().New(
                                 "tint_packed_vec3_" + vec->type()->FriendlyName() +
                                 (array_element ? "_array_element" : "_struct_member"));
@@ -181,7 +181,7 @@
             },
             [&](const core::type::Struct* str) -> ast::Type {
                 if (ContainsVec3(str)) {
-                    auto name = rewritten_structs.GetOrCreate(str, [&] {
+                    auto name = rewritten_structs.GetOrAdd(str, [&] {
                         tint::Vector<const ast::StructMember*, 4> members;
                         for (auto* member : str->Members()) {
                             // If the member type contains a vec3, rewrite it.
@@ -317,7 +317,7 @@
     /// @returns an expression that holds the unpacked value
     const ast::Expression* UnpackComposite(const ast::Expression* expr,
                                            const core::type::Type* ty) {
-        auto helper = unpack_helpers.GetOrCreate(ty, [&] {
+        auto helper = unpack_helpers.GetOrAdd(ty, [&] {
             return MakePackUnpackHelper(
                 "tint_unpack_vec3_in_composite", ty,
                 [&](const ast::Expression* element,
@@ -345,7 +345,7 @@
     /// @param ty the unpacked type
     /// @returns an expression that holds the packed value
     const ast::Expression* PackComposite(const ast::Expression* expr, const core::type::Type* ty) {
-        auto helper = pack_helpers.GetOrCreate(ty, [&] {
+        auto helper = pack_helpers.GetOrAdd(ty, [&] {
             return MakePackUnpackHelper(
                 "tint_pack_vec3_in_composite", ty,
                 [&](const ast::Expression* element,
diff --git a/src/tint/lang/msl/writer/common/option_helpers.cc b/src/tint/lang/msl/writer/common/option_helpers.cc
index 2561e9f..b655301 100644
--- a/src/tint/lang/msl/writer/common/option_helpers.cc
+++ b/src/tint/lang/msl/writer/common/option_helpers.cc
@@ -52,7 +52,7 @@
 
     auto wgsl_seen = [&diagnostics, &seen_wgsl_bindings](const tint::BindingPoint& src,
                                                          const binding::BindingInfo& dst) -> bool {
-        if (auto binding = seen_wgsl_bindings.Find(src)) {
+        if (auto binding = seen_wgsl_bindings.Get(src)) {
             if (*binding != dst) {
                 std::stringstream str;
                 str << "found duplicate WGSL binding point: " << src;
@@ -67,7 +67,7 @@
 
     auto msl_seen = [&diagnostics](InfoToPointMap& map, const binding::BindingInfo& src,
                                    const tint::BindingPoint& dst) -> bool {
-        if (auto binding = map.Find(src)) {
+        if (auto binding = map.Get(src)) {
             if (*binding != dst) {
                 std::stringstream str;
                 str << "found duplicate MSL binding point: [binding: " << src.binding << "]";
diff --git a/src/tint/lang/msl/writer/helpers/generate_bindings.cc b/src/tint/lang/msl/writer/helpers/generate_bindings.cc
index a0eaf7e..71a5803 100644
--- a/src/tint/lang/msl/writer/helpers/generate_bindings.cc
+++ b/src/tint/lang/msl/writer/helpers/generate_bindings.cc
@@ -59,7 +59,7 @@
     for (auto* var : program.AST().GlobalVariables()) {
         if (auto* sem_var = program.Sem().Get(var)->As<sem::GlobalVariable>()) {
             if (auto bp = sem_var->Attributes().binding_point) {
-                if (auto val = group_to_next_binding_number.Find(bp->group)) {
+                if (auto val = group_to_next_binding_number.Get(bp->group)) {
                     *val = std::max(*val, bp->binding + 1);
                 } else {
                     group_to_next_binding_number.Add(bp->group, bp->binding + 1);
@@ -109,14 +109,12 @@
 
     for (auto bp : ext_tex_bps) {
         uint32_t g = bp.group;
-        uint32_t next_num = *(group_to_next_binding_number.GetOrZero(g));
+        uint32_t& next_num = group_to_next_binding_number.GetOrAddZero(g);
 
         binding::BindingInfo plane0{bp.binding};
         binding::BindingInfo plane1{next_num++};
         binding::BindingInfo metadata{next_num++};
 
-        group_to_next_binding_number.Replace(g, next_num);
-
         bindings.external_texture.emplace(bp, binding::ExternalTexture{metadata, plane0, plane1});
     }
 
diff --git a/src/tint/lang/msl/writer/printer/printer.cc b/src/tint/lang/msl/writer/printer/printer.cc
index 0e8988e..3c34b32 100644
--- a/src/tint/lang/msl/writer/printer/printer.cc
+++ b/src/tint/lang/msl/writer/printer/printer.cc
@@ -1432,8 +1432,8 @@
     std::string StructName(const core::type::Struct* s) {
         auto name = s->Name().Name();
         if (HasPrefix(name, "__")) {
-            name = tint::GetOrCreate(builtin_struct_names_, s,
-                                     [&] { return UniqueIdentifier(name.substr(2)); });
+            name = tint::GetOrAdd(builtin_struct_names_, s,
+                                  [&] { return UniqueIdentifier(name.substr(2)); });
         }
         return name;
     }
@@ -1442,7 +1442,7 @@
     /// @returns the name of the given value, creating a new unique name if the value is unnamed in
     /// the module.
     std::string NameOf(const core::ir::Value* value) {
-        return names_.GetOrCreate(value, [&] {
+        return names_.GetOrAdd(value, [&] {
             if (auto sym = ir_.NameOf(value); sym.IsValid()) {
                 return sym.Name();
             }
diff --git a/src/tint/lang/spirv/reader/ast_lower/decompose_strided_array.cc b/src/tint/lang/spirv/reader/ast_lower/decompose_strided_array.cc
index 47e242b..bba5bb1 100644
--- a/src/tint/lang/spirv/reader/ast_lower/decompose_strided_array.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/decompose_strided_array.cc
@@ -107,7 +107,7 @@
             return nullptr;
         }
         if (!arr->IsStrideImplicit()) {
-            auto el_ty = tint::GetOrCreate(decomposed, arr, [&] {
+            auto el_ty = tint::GetOrAdd(decomposed, arr, [&] {
                 auto name = b.Symbols().New("strided_arr");
                 auto* member_ty = ctx.Clone(ident->arguments[0]->As<ast::IdentifierExpression>());
                 auto* member = b.Member(kMemberName, ast::Type{member_ty},
diff --git a/src/tint/lang/spirv/reader/ast_lower/decompose_strided_matrix.cc b/src/tint/lang/spirv/reader/ast_lower/decompose_strided_matrix.cc
index 9521329..e28ff41 100644
--- a/src/tint/lang/spirv/reader/ast_lower/decompose_strided_matrix.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/decompose_strided_matrix.cc
@@ -150,8 +150,8 @@
     std::unordered_map<MatrixInfo, Symbol, MatrixInfo::Hasher> mat_to_arr;
     ctx.ReplaceAll([&](const ast::AssignmentStatement* stmt) -> const ast::Statement* {
         if (auto* access = src.Sem().Get<sem::StructMemberAccess>(stmt->lhs)) {
-            if (auto info = decomposed.Find(access->Member())) {
-                auto fn = tint::GetOrCreate(mat_to_arr, *info, [&] {
+            if (auto info = decomposed.Get(access->Member())) {
+                auto fn = tint::GetOrAdd(mat_to_arr, *info, [&] {
                     auto name =
                         b.Symbols().New("mat" + std::to_string(info->matrix->columns()) + "x" +
                                         std::to_string(info->matrix->rows()) + "_stride_" +
@@ -189,8 +189,8 @@
     std::unordered_map<MatrixInfo, Symbol, MatrixInfo::Hasher> arr_to_mat;
     ctx.ReplaceAll([&](const ast::MemberAccessorExpression* expr) -> const ast::Expression* {
         if (auto* access = src.Sem().Get(expr)->UnwrapLoad()->As<sem::StructMemberAccess>()) {
-            if (auto info = decomposed.Find(access->Member())) {
-                auto fn = tint::GetOrCreate(arr_to_mat, *info, [&] {
+            if (auto info = decomposed.Get(access->Member())) {
+                auto fn = tint::GetOrAdd(arr_to_mat, *info, [&] {
                     auto name =
                         b.Symbols().New("arr_to_mat" + std::to_string(info->matrix->columns()) +
                                         "x" + std::to_string(info->matrix->rows()) + "_stride_" +
diff --git a/src/tint/lang/spirv/reader/ast_lower/fold_trivial_lets.cc b/src/tint/lang/spirv/reader/ast_lower/fold_trivial_lets.cc
index 56fa298..01084c4 100644
--- a/src/tint/lang/spirv/reader/ast_lower/fold_trivial_lets.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/fold_trivial_lets.cc
@@ -73,8 +73,7 @@
         auto fold_lets = [&](const ast::Expression* expr) {
             ast::TraverseExpressions(expr, [&](const ast::IdentifierExpression* ident) {
                 if (auto* user = sem.Get<sem::VariableUser>(ident)) {
-                    auto itr = pending_lets.Find(user->Variable());
-                    if (itr) {
+                    if (auto itr = pending_lets.Get(user->Variable())) {
                         TINT_ASSERT(itr->remaining_uses > 0);
 
                         // We found a reference to a pending let, so replace it with the inlined
@@ -83,7 +82,7 @@
 
                         // Decrement the remaining uses count and remove the let declaration if this
                         // was the last remaining use.
-                        if (--itr->remaining_uses == 0) {
+                        if (--(itr->remaining_uses) == 0) {
                             ctx.Remove(block->statements, itr->decl);
                         }
                     }
diff --git a/src/tint/lang/spirv/reader/ast_lower/pass_workgroup_id_as_argument.cc b/src/tint/lang/spirv/reader/ast_lower/pass_workgroup_id_as_argument.cc
index cfaf300..6bfb652 100644
--- a/src/tint/lang/spirv/reader/ast_lower/pass_workgroup_id_as_argument.cc
+++ b/src/tint/lang/spirv/reader/ast_lower/pass_workgroup_id_as_argument.cc
@@ -133,7 +133,7 @@
     /// @param type the type of the parameter
     /// @returns the name of the parameter
     Symbol GetParameter(const ast::Function* func, const ast::Type& type) {
-        return func_to_param.GetOrCreate(func, [&] {
+        return func_to_param.GetOrAdd(func, [&] {
             // Append a new parameter to the function.
             auto name = b.Symbols().New("tint_wgid");
             ctx.InsertBack(func->params, b.Param(name, ctx.Clone(type)));
diff --git a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
index e8b5aeb..3b835c3 100644
--- a/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/ast_parser.cc
@@ -1528,7 +1528,7 @@
         // TODO(dneto): initializers (a.k.a. initializer expression)
         if (ast_var) {
             builder_.AST().AddGlobalVariable(ast_var);
-            module_variable_.GetOrCreate(var.result_id(), [&] {
+            module_variable_.GetOrAdd(var.result_id(), [&] {
                 return ModuleVariable{ast_var, ast_address_space, ast_access};
             });
         }
@@ -1564,7 +1564,7 @@
                                 storage_type, ast_initializer, {});
 
         builder_.AST().AddGlobalVariable(ast_var);
-        module_variable_.GetOrCreate(builtin_position_.per_vertex_var_id, [&] {
+        module_variable_.GetOrAdd(builtin_position_.per_vertex_var_id, [&] {
             return ModuleVariable{ast_var, ast_address_space};
         });
     }
diff --git a/src/tint/lang/spirv/reader/ast_parser/ast_parser.h b/src/tint/lang/spirv/reader/ast_parser/ast_parser.h
index ddd8ded..86f60e7 100644
--- a/src/tint/lang/spirv/reader/ast_parser/ast_parser.h
+++ b/src/tint/lang/spirv/reader/ast_parser/ast_parser.h
@@ -695,8 +695,7 @@
     /// @param id a SPIR-V ID
     /// @returns the AST variable or null.
     ModuleVariable GetModuleVariable(uint32_t id) {
-        auto entry = module_variable_.Find(id);
-        return entry ? *entry : ModuleVariable{};
+        return module_variable_.GetOr(id, ModuleVariable{});
     }
 
     /// Returns the channel component type corresponding to the given image
diff --git a/src/tint/lang/spirv/reader/ast_parser/function.cc b/src/tint/lang/spirv/reader/ast_parser/function.cc
index 2ba5673..73d5578 100644
--- a/src/tint/lang/spirv/reader/ast_parser/function.cc
+++ b/src/tint/lang/spirv/reader/ast_parser/function.cc
@@ -3428,7 +3428,7 @@
                 auto copy_name = namer_.MakeDerivedName(namer_.Name(phi_id) + "_c" +
                                                         std::to_string(block_info.id));
                 auto copy_sym = builder_.Symbols().Register(copy_name);
-                copied_phis.GetOrCreate(phi_id, [copy_sym] { return copy_sym; });
+                copied_phis.GetOrAdd(phi_id, [copy_sym] { return copy_sym; });
                 AddStatement(builder_.WrapInStatement(
                     builder_.Let(copy_sym, builder_.Expr(namer_.Name(phi_id)))));
             }
@@ -3439,7 +3439,7 @@
             const auto phi_id = assignment.phi_id;
             auto* const lhs_expr = builder_.Expr(namer_.Name(phi_id));
             // If RHS value is actually a phi we just cpatured, then use it.
-            auto copy_sym = copied_phis.Find(assignment.value_id);
+            auto copy_sym = copied_phis.Get(assignment.value_id);
             auto* const rhs_expr =
                 copy_sym ? builder_.Expr(*copy_sym) : MakeExpression(assignment.value_id).expr;
             AddStatement(builder_.Assign(lhs_expr, rhs_expr));
diff --git a/src/tint/lang/spirv/reader/parser/parser.cc b/src/tint/lang/spirv/reader/parser/parser.cc
index cfbc8cc..1976c38 100644
--- a/src/tint/lang/spirv/reader/parser/parser.cc
+++ b/src/tint/lang/spirv/reader/parser/parser.cc
@@ -165,7 +165,7 @@
     /// @returns a Tint type object
     const core::type::Type* Type(const spvtools::opt::analysis::Type* type,
                                  core::Access access_mode = core::Access::kUndefined) {
-        return types_.GetOrCreate(TypeKey{type, access_mode}, [&]() -> const core::type::Type* {
+        return types_.GetOrAdd(TypeKey{type, access_mode}, [&]() -> const core::type::Type* {
             switch (type->kind()) {
                 case spvtools::opt::analysis::Type::kVoid:
                     return ty_.void_();
@@ -324,7 +324,7 @@
     /// @param id a SPIR-V result ID for a function declaration instruction
     /// @returns a Tint function object
     core::ir::Function* Function(uint32_t id) {
-        return functions_.GetOrCreate(id, [&] {
+        return functions_.GetOrAdd(id, [&] {
             return b_.Function(ty_.void_(), core::ir::Function::PipelineStage::kUndefined,
                                std::nullopt);
         });
@@ -333,7 +333,7 @@
     /// @param id a SPIR-V result ID
     /// @returns a Tint value object
     core::ir::Value* Value(uint32_t id) {
-        return values_.GetOrCreate(id, [&]() -> core::ir::Value* {
+        return values_.GetOrAdd(id, [&]() -> core::ir::Value* {
             if (auto* c = spirv_context_->get_constant_mgr()->FindDeclaredConstant(id)) {
                 return b_.Constant(Constant(c));
             }
@@ -477,7 +477,7 @@
 
         // Handle OpExecutionMode declarations.
         for (auto& execution_mode : spirv_context_->module()->execution_modes()) {
-            auto* func = functions_.Get(execution_mode.GetSingleWordInOperand(0)).value_or(nullptr);
+            auto* func = functions_.GetOr(execution_mode.GetSingleWordInOperand(0), nullptr);
             auto mode = execution_mode.GetSingleWordInOperand(1);
             TINT_ASSERT_OR_RETURN(func);
 
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.cc b/src/tint/lang/spirv/writer/ast_printer/builder.cc
index 143a7ab..bcd175e 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.cc
@@ -622,7 +622,7 @@
 }
 
 uint32_t Builder::GenerateFunctionTypeIfNeeded(const sem::Function* func) {
-    return tint::GetOrCreate(func_sig_to_id_, func->Signature(), [&]() -> uint32_t {
+    return tint::GetOrAdd(func_sig_to_id_, func->Signature(), [&]() -> uint32_t {
         auto func_op = result_op();
         auto func_type_id = std::get<uint32_t>(func_op);
 
@@ -1400,7 +1400,7 @@
                       ? scope_stack_[0]       // Global scope
                       : scope_stack_.back();  // Lexical scope
 
-    return tint::GetOrCreate(stack.type_init_to_id_, OperandListKey{ops}, [&]() -> uint32_t {
+    return tint::GetOrAdd(stack.type_init_to_id_, OperandListKey{ops}, [&]() -> uint32_t {
         auto result = result_op();
         ops[kOpsResultIdx] = result;
 
@@ -1640,13 +1640,13 @@
         }
 
         auto& global_scope = scope_stack_[0];
-        return tint::GetOrCreate(global_scope.type_init_to_id_, OperandListKey{ops},
-                                 [&]() -> uint32_t {
-                                     auto result = result_op();
-                                     ops[kOpsResultIdx] = result;
-                                     module_.PushType(spv::Op::OpConstantComposite, std::move(ops));
-                                     return std::get<uint32_t>(result);
-                                 });
+        return tint::GetOrAdd(global_scope.type_init_to_id_, OperandListKey{ops},
+                              [&]() -> uint32_t {
+                                  auto result = result_op();
+                                  ops[kOpsResultIdx] = result;
+                                  module_.PushType(spv::Op::OpConstantComposite, std::move(ops));
+                                  return std::get<uint32_t>(result);
+                              });
     };
 
     return Switch(
@@ -1765,7 +1765,7 @@
         return 0;
     }
 
-    return tint::GetOrCreate(const_null_to_id_, type, [&] {
+    return tint::GetOrAdd(const_null_to_id_, type, [&] {
         auto result = result_op();
 
         module_.PushType(spv::Op::OpConstantNull, {Operand(type_id), result});
@@ -1782,7 +1782,7 @@
     }
 
     uint64_t key = (static_cast<uint64_t>(type->Width()) << 32) + value_id;
-    return tint::GetOrCreate(const_splat_to_id_, key, [&] {
+    return tint::GetOrAdd(const_splat_to_id_, key, [&] {
         auto result = result_op();
         auto result_id = std::get<uint32_t>(result);
 
@@ -3286,7 +3286,7 @@
     }
 
     uint32_t sampled_image_type_id =
-        tint::GetOrCreate(texture_type_to_sampled_image_type_id_, texture_type, [&] {
+        tint::GetOrAdd(texture_type_to_sampled_image_type_id_, texture_type, [&] {
             // We need to create the sampled image type and cache the result.
             auto sampled_image_type = result_op();
             auto texture_type_id = GenerateTypeIfNeeded(texture_type);
@@ -3667,7 +3667,7 @@
                                                     core::Access::kReadWrite);
     }
 
-    return tint::GetOrCreate(type_to_id_, type, [&]() -> uint32_t {
+    return tint::GetOrAdd(type_to_id_, type, [&]() -> uint32_t {
         auto result = result_op();
         auto id = std::get<uint32_t>(result);
         bool ok = Switch(
diff --git a/src/tint/lang/spirv/writer/ast_raise/vectorize_matrix_conversions.cc b/src/tint/lang/spirv/writer/ast_raise/vectorize_matrix_conversions.cc
index d443f3f..31505a0 100644
--- a/src/tint/lang/spirv/writer/ast_raise/vectorize_matrix_conversions.cc
+++ b/src/tint/lang/spirv/writer/ast_raise/vectorize_matrix_conversions.cc
@@ -137,7 +137,7 @@
             });
         } else {
             // If has side effects, use a helper function.
-            auto fn = tint::GetOrCreate(matrix_convs, HelperFunctionKey{{src_type, dst_type}}, [&] {
+            auto fn = tint::GetOrAdd(matrix_convs, HelperFunctionKey{{src_type, dst_type}}, [&] {
                 auto name = b.Symbols().New("convert_mat" + std::to_string(src_type->columns()) +
                                             "x" + std::to_string(src_type->rows()) + "_" +
                                             src_type->type()->FriendlyName() + "_" +
diff --git a/src/tint/lang/spirv/writer/common/option_helper.cc b/src/tint/lang/spirv/writer/common/option_helper.cc
index aec904a..c1a9d10 100644
--- a/src/tint/lang/spirv/writer/common/option_helper.cc
+++ b/src/tint/lang/spirv/writer/common/option_helper.cc
@@ -46,7 +46,7 @@
 
     auto wgsl_seen = [&diagnostics, &seen_wgsl_bindings](const tint::BindingPoint& src,
                                                          const binding::BindingInfo& dst) -> bool {
-        if (auto binding = seen_wgsl_bindings.Find(src)) {
+        if (auto binding = seen_wgsl_bindings.Get(src)) {
             if (*binding != dst) {
                 std::stringstream str;
                 str << "found duplicate WGSL binding point: " << src;
@@ -61,7 +61,7 @@
 
     auto spirv_seen = [&diagnostics, &seen_spirv_bindings](const binding::BindingInfo& src,
                                                            const tint::BindingPoint& dst) -> bool {
-        if (auto binding = seen_spirv_bindings.Find(src)) {
+        if (auto binding = seen_spirv_bindings.Get(src)) {
             if (*binding != dst) {
                 std::stringstream str;
                 str << "found duplicate SPIR-V binding point: [group: " << src.group
diff --git a/src/tint/lang/spirv/writer/helpers/ast_generate_bindings.cc b/src/tint/lang/spirv/writer/helpers/ast_generate_bindings.cc
index cd40f27..0659c48 100644
--- a/src/tint/lang/spirv/writer/helpers/ast_generate_bindings.cc
+++ b/src/tint/lang/spirv/writer/helpers/ast_generate_bindings.cc
@@ -56,7 +56,7 @@
     for (auto* var : program.AST().GlobalVariables()) {
         if (auto* sem_var = program.Sem().Get(var)->As<sem::GlobalVariable>()) {
             if (auto bp = sem_var->Attributes().binding_point) {
-                if (auto val = group_to_next_binding_number.Find(bp->group)) {
+                if (auto val = group_to_next_binding_number.Get(bp->group)) {
                     *val = std::max(*val, bp->binding + 1);
                 } else {
                     group_to_next_binding_number.Add(bp->group, bp->binding + 1);
@@ -106,14 +106,12 @@
 
     for (auto bp : ext_tex_bps) {
         uint32_t g = bp.group;
-        uint32_t next_num = *(group_to_next_binding_number.GetOrZero(g));
+        uint32_t& next_num = group_to_next_binding_number.GetOrAddZero(g);
 
         binding::BindingInfo plane0{bp.group, bp.binding};
         binding::BindingInfo plane1{g, next_num++};
         binding::BindingInfo metadata{g, next_num++};
 
-        group_to_next_binding_number.Replace(g, next_num);
-
         bindings.external_texture.emplace(bp, binding::ExternalTexture{metadata, plane0, plane1});
     }
 
diff --git a/src/tint/lang/spirv/writer/helpers/generate_bindings.cc b/src/tint/lang/spirv/writer/helpers/generate_bindings.cc
index 1cf3b6a..ad38631 100644
--- a/src/tint/lang/spirv/writer/helpers/generate_bindings.cc
+++ b/src/tint/lang/spirv/writer/helpers/generate_bindings.cc
@@ -56,7 +56,7 @@
         }
         auto* var = inst->As<core::ir::Var>();
         if (auto bp = var->BindingPoint()) {
-            if (auto val = group_to_next_binding_number.Find(bp->group)) {
+            if (auto val = group_to_next_binding_number.Get(bp->group)) {
                 *val = std::max(*val, bp->binding + 1);
             } else {
                 group_to_next_binding_number.Add(bp->group, bp->binding + 1);
@@ -104,14 +104,12 @@
 
     for (auto bp : ext_tex_bps) {
         uint32_t g = bp.group;
-        uint32_t next_num = *(group_to_next_binding_number.GetOrZero(g));
+        uint32_t& next_num = group_to_next_binding_number.GetOrAddZero(g);
 
         binding::BindingInfo plane0{bp.group, bp.binding};
         binding::BindingInfo plane1{g, next_num++};
         binding::BindingInfo metadata{g, next_num++};
 
-        group_to_next_binding_number.Replace(g, next_num);
-
         bindings.external_texture.emplace(bp, binding::ExternalTexture{metadata, plane0, plane1});
     }
 
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index cc4e35c..9f243f4 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -386,7 +386,7 @@
     /// @param constant the constant to get the ID for
     /// @returns the result ID of the constant
     uint32_t Constant(const core::constant::Value* constant) {
-        return constants_.GetOrCreate(constant, [&] {
+        return constants_.GetOrAdd(constant, [&] {
             auto* ty = constant->Type();
 
             // Use OpConstantNull for zero-valued composite constants.
@@ -455,7 +455,7 @@
     /// @param type the type to get the ID for
     /// @returns the result ID of the OpConstantNull instruction
     uint32_t ConstantNull(const core::type::Type* type) {
-        return constant_nulls_.GetOrCreate(type, [&] {
+        return constant_nulls_.GetOrAdd(type, [&] {
             auto id = module_.NextId();
             module_.PushType(spv::Op::OpConstantNull, {Type(type), id});
             return id;
@@ -466,7 +466,7 @@
     /// @param type the type of the undef value
     /// @returns the result ID of the instruction
     uint32_t Undef(const core::type::Type* type) {
-        return undef_values_.GetOrCreate(type, [&] {
+        return undef_values_.GetOrAdd(type, [&] {
             auto id = module_.NextId();
             module_.PushType(spv::Op::OpUndef, {Type(type), id});
             return id;
@@ -478,7 +478,7 @@
     /// @returns the result ID of the type
     uint32_t Type(const core::type::Type* ty) {
         ty = DedupType(ty, ir_.Types());
-        return types_.GetOrCreate(ty, [&] {
+        return types_.GetOrAdd(ty, [&] {
             auto id = module_.NextId();
             Switch(
                 ty,  //
@@ -548,7 +548,7 @@
             value,  //
             [&](core::ir::Constant* constant) { return Constant(constant); },
             [&](core::ir::Value*) {
-                return values_.GetOrCreate(value, [&] { return module_.NextId(); });
+                return values_.GetOrAdd(value, [&] { return module_.NextId(); });
             });
     }
 
@@ -556,7 +556,7 @@
     /// @param block the block to get the label ID for
     /// @returns the ID of the block's label
     uint32_t Label(const core::ir::Block* block) {
-        return block_labels_.GetOrCreate(block, [&] { return module_.NextId(); });
+        return block_labels_.GetOrAdd(block, [&] { return module_.NextId(); });
     }
 
     /// Emit a struct type.
@@ -717,7 +717,7 @@
         }
 
         // Get the ID for the function type (creating it if needed).
-        auto function_type_id = function_types_.GetOrCreate(function_type, [&] {
+        auto function_type_id = function_types_.GetOrAdd(function_type, [&] {
             auto func_ty_id = module_.NextId();
             OperandList operands = {func_ty_id, return_type_id};
             operands.insert(operands.end(), function_type.param_type_ids.begin(),
@@ -790,7 +790,7 @@
             // Determine if this IO variable is used by the entry point.
             bool used = false;
             for (const auto& use : var->Result(0)->Usages()) {
-                auto* block = use.instruction->Block();
+                auto* block = use->instruction->Block();
                 while (block->Parent()) {
                     block = block->Parent()->Block();
                 }
@@ -1385,7 +1385,7 @@
         auto glsl_ext_inst = [&](enum GLSLstd450 inst) {
             constexpr const char* kGLSLstd450 = "GLSL.std.450";
             op = spv::Op::OpExtInst;
-            operands.push_back(imports_.GetOrCreate(kGLSLstd450, [&] {
+            operands.push_back(imports_.GetOrAdd(kGLSLstd450, [&] {
                 // Import the instruction set the first time it is requested.
                 auto import = module_.NextId();
                 module_.PushExtImport(spv::Op::OpExtInstImport, {import, Operand(kGLSLstd450)});
@@ -2197,7 +2197,7 @@
     /// @param ci the control instruction to get the merge label for
     /// @returns the label ID
     uint32_t GetMergeLabel(core::ir::ControlInstruction* ci) {
-        return merge_block_labels_.GetOrCreate(ci, [&] { return module_.NextId(); });
+        return merge_block_labels_.GetOrAdd(ci, [&] { return module_.NextId(); });
     }
 
     /// Get the ID of the label of the block that will contain a terminator instruction.
diff --git a/src/tint/lang/spirv/writer/raise/merge_return.cc b/src/tint/lang/spirv/writer/raise/merge_return.cc
index 41bafb9..c954430 100644
--- a/src/tint/lang/spirv/writer/raise/merge_return.cc
+++ b/src/tint/lang/spirv/writer/raise/merge_return.cc
@@ -73,7 +73,7 @@
     void Process(core::ir::Function* fn) {
         // Find all of the nested return instructions in the function.
         for (const auto& usage : fn->Usages()) {
-            if (auto* ret = usage.instruction->As<core::ir::Return>()) {
+            if (auto* ret = usage->instruction->As<core::ir::Return>()) {
                 TransitivelyMarkAsReturning(ret->Block()->Parent());
             }
         }
diff --git a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
index 32f0d1b..19037f7 100644
--- a/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
+++ b/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc
@@ -149,7 +149,7 @@
         if (to_replace.first_dynamic_index > 0) {
             PartialAccess partial_access = {
                 access->Object(), access->Indices().Truncate(to_replace.first_dynamic_index)};
-            source_object = source_object_to_value.GetOrCreate(partial_access, [&] {
+            source_object = source_object_to_value.GetOrAdd(partial_access, [&] {
                 auto* intermediate_source = builder.Access(to_replace.dynamic_index_source_type,
                                                            source_object, partial_access.indices);
                 intermediate_source->InsertBefore(access);
@@ -158,7 +158,7 @@
         }
 
         // Declare a local variable and copy the source object to it.
-        auto* local = object_to_local.GetOrCreate(source_object, [&] {
+        auto* local = object_to_local.GetOrAdd(source_object, [&] {
             auto* decl = builder.Var(ir.Types().ptr(
                 core::AddressSpace::kFunction, source_object->Type(), core::Access::kReadWrite));
             decl->SetInitializer(source_object);
diff --git a/src/tint/lang/wgsl/ast/blend_src_attribute.cc b/src/tint/lang/wgsl/ast/blend_src_attribute.cc
index 089ce1e..102c0ac 100644
--- a/src/tint/lang/wgsl/ast/blend_src_attribute.cc
+++ b/src/tint/lang/wgsl/ast/blend_src_attribute.cc
@@ -37,9 +37,9 @@
 namespace tint::ast {
 
 BlendSrcAttribute::BlendSrcAttribute(GenerationID pid,
-                               NodeID nid,
-                               const Source& src,
-                               const Expression* exp)
+                                     NodeID nid,
+                                     const Source& src,
+                                     const Expression* exp)
     : Base(pid, nid, src), expr(exp) {}
 
 BlendSrcAttribute::~BlendSrcAttribute() = default;
diff --git a/src/tint/lang/wgsl/ast/clone_context.cc b/src/tint/lang/wgsl/ast/clone_context.cc
index 1159c91..3d6c69f 100644
--- a/src/tint/lang/wgsl/ast/clone_context.cc
+++ b/src/tint/lang/wgsl/ast/clone_context.cc
@@ -39,7 +39,7 @@
 CloneContext::~CloneContext() = default;
 
 Symbol CloneContext::Clone(Symbol s) {
-    return cloned_symbols_.GetOrCreate(s, [&]() -> Symbol {
+    return cloned_symbols_.GetOrAdd(s, [&]() -> Symbol {
         if (symbol_transform_) {
             return symbol_transform_(s);
         }
@@ -67,7 +67,7 @@
     }
 
     // Was Replace() called for this node?
-    if (auto fn = replacements_.Find(node)) {
+    if (auto fn = replacements_.Get(node)) {
         return (*fn)();
     }
 
diff --git a/src/tint/lang/wgsl/ast/clone_context.h b/src/tint/lang/wgsl/ast/clone_context.h
index 5115e17..b99f774 100644
--- a/src/tint/lang/wgsl/ast/clone_context.h
+++ b/src/tint/lang/wgsl/ast/clone_context.h
@@ -186,14 +186,14 @@
     void Clone(tint::Vector<T*, N>& to, const tint::Vector<T*, N>& from) {
         to.Reserve(from.Length());
 
-        auto transforms = list_transforms_.Find(&from);
+        auto transforms = list_transforms_.Get(&from);
 
         if (transforms) {
             for (auto& builder : transforms->insert_front_) {
                 to.Push(CheckedCast<T>(builder()));
             }
             for (auto& el : from) {
-                if (auto insert_before = transforms->insert_before_.Find(el)) {
+                if (auto insert_before = transforms->insert_before_.Get(el)) {
                     for (auto& builder : *insert_before) {
                         to.Push(CheckedCast<T>(builder()));
                     }
@@ -201,7 +201,7 @@
                 if (!transforms->remove_.Contains(el)) {
                     to.Push(Clone(el));
                 }
-                if (auto insert_after = transforms->insert_after_.Find(el)) {
+                if (auto insert_after = transforms->insert_after_.Get(el)) {
                     for (auto& builder : *insert_after) {
                         to.Push(CheckedCast<T>(builder()));
                     }
@@ -214,10 +214,12 @@
             for (auto& el : from) {
                 to.Push(Clone(el));
 
-                // Clone(el) may have updated the transformation list, adding an `insert_after`
-                // transform for `from`.
+                if (!transforms) {
+                    // Clone(el) may have create a transformation list
+                    transforms = list_transforms_.Get(&from);
+                }
                 if (transforms) {
-                    if (auto insert_after = transforms->insert_after_.Find(el)) {
+                    if (auto insert_after = transforms->insert_after_.Get(el)) {
                         for (auto& builder : *insert_after) {
                             to.Push(CheckedCast<T>(builder()));
                         }
@@ -225,8 +227,10 @@
                 }
             }
 
-            // Clone(el) may have updated the transformation list, adding an `insert_back_`
-            // transform for `from`.
+            if (!transforms) {
+                // Clone(el) may have create a transformation list
+                transforms = list_transforms_.Get(&from);
+            }
             if (transforms) {
                 for (auto& builder : transforms->insert_back_) {
                     to.Push(CheckedCast<T>(builder()));
@@ -374,7 +378,7 @@
             return *this;
         }
 
-        list_transforms_.GetOrZero(&vector)->remove_.Add(object);
+        list_transforms_.GetOrAddZero(&vector).remove_.Add(object);
         return *this;
     }
 
@@ -396,7 +400,7 @@
     /// @returns this CloneContext so calls can be chained
     template <typename T, size_t N, typename BUILDER>
     CloneContext& InsertFront(const tint::Vector<T, N>& vector, BUILDER&& builder) {
-        list_transforms_.GetOrZero(&vector)->insert_front_.Push(std::forward<BUILDER>(builder));
+        list_transforms_.GetOrAddZero(&vector).insert_front_.Push(std::forward<BUILDER>(builder));
         return *this;
     }
 
@@ -419,7 +423,7 @@
     /// @returns this CloneContext so calls can be chained
     template <typename T, size_t N, typename BUILDER>
     CloneContext& InsertBack(const tint::Vector<T, N>& vector, BUILDER&& builder) {
-        list_transforms_.GetOrZero(&vector)->insert_back_.Push(std::forward<BUILDER>(builder));
+        list_transforms_.GetOrAddZero(&vector).insert_back_.Push(std::forward<BUILDER>(builder));
         return *this;
     }
 
@@ -440,7 +444,7 @@
             return *this;
         }
 
-        list_transforms_.GetOrZero(&vector)->insert_before_.GetOrZero(before)->Push(
+        list_transforms_.GetOrAddZero(&vector).insert_before_.GetOrAddZero(before).Push(
             [object] { return object; });
         return *this;
     }
@@ -459,7 +463,7 @@
     CloneContext& InsertBefore(const tint::Vector<T, N>& vector,
                                const BEFORE* before,
                                BUILDER&& builder) {
-        list_transforms_.GetOrZero(&vector)->insert_before_.GetOrZero(before)->Push(
+        list_transforms_.GetOrAddZero(&vector).insert_before_.GetOrAddZero(before).Push(
             std::forward<BUILDER>(builder));
         return *this;
     }
@@ -481,7 +485,7 @@
             return *this;
         }
 
-        list_transforms_.GetOrZero(&vector)->insert_after_.GetOrZero(after)->Push(
+        list_transforms_.GetOrAddZero(&vector).insert_after_.GetOrAddZero(after).Push(
             [object] { return object; });
         return *this;
     }
@@ -500,7 +504,7 @@
     CloneContext& InsertAfter(const tint::Vector<T, N>& vector,
                               const AFTER* after,
                               BUILDER&& builder) {
-        list_transforms_.GetOrZero(&vector)->insert_after_.GetOrZero(after)->Push(
+        list_transforms_.GetOrAddZero(&vector).insert_after_.GetOrAddZero(after).Push(
             std::forward<BUILDER>(builder));
         return *this;
     }
diff --git a/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc b/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
index 82e0716..631f1bd 100644
--- a/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
+++ b/src/tint/lang/wgsl/ast/transform/add_block_attribute.cc
@@ -83,7 +83,7 @@
         if (needs_wrapping) {
             const char* kMemberName = "inner";
 
-            auto* wrapper = wrapper_structs.GetOrCreate(ty, [&] {
+            auto* wrapper = wrapper_structs.GetOrAdd(ty, [&] {
                 auto* block = b.ASTNodes().Create<BlockAttribute>(b.ID(), b.AllocateNodeID());
                 auto wrapper_name = global->name->symbol.Name() + "_block";
                 auto* ret =
diff --git a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
index b3a8ece..b1f36fc 100644
--- a/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
+++ b/src/tint/lang/wgsl/ast/transform/builtin_polyfill.cc
@@ -1117,7 +1117,7 @@
         auto* lhs_ty = src.TypeOf(bin_op->lhs)->UnwrapRef();
         auto* rhs_ty = src.TypeOf(bin_op->rhs)->UnwrapRef();
         BinaryOpSignature sig{bin_op->op, lhs_ty, rhs_ty};
-        auto fn = binary_op_polyfills.GetOrCreate(sig, [&] {
+        auto fn = binary_op_polyfills.GetOrAdd(sig, [&] {
             const bool is_div = bin_op->op == core::BinaryOp::kDivide;
 
             const auto [lhs_el_ty, lhs_width] = lhs_ty->Elements(lhs_ty, 1);
@@ -1210,7 +1210,7 @@
         auto* lhs_ty = src.TypeOf(bin_op->lhs)->UnwrapRef();
         auto* rhs_ty = src.TypeOf(bin_op->rhs)->UnwrapRef();
         BinaryOpSignature sig{bin_op->op, lhs_ty, rhs_ty};
-        auto fn = binary_op_polyfills.GetOrCreate(sig, [&] {
+        auto fn = binary_op_polyfills.GetOrAdd(sig, [&] {
             const auto [lhs_el_ty, lhs_width] = lhs_ty->Elements(lhs_ty, 1);
             const auto [rhs_el_ty, rhs_width] = rhs_ty->Elements(rhs_ty, 1);
 
@@ -1295,21 +1295,21 @@
                 switch (builtin->Fn()) {
                     case wgsl::BuiltinFn::kAcosh:
                         if (cfg.builtins.acosh != Level::kNone) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return acosh(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kAsinh:
                         if (cfg.builtins.asinh) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return asinh(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kAtanh:
                         if (cfg.builtins.atanh != Level::kNone) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return atanh(builtin->ReturnType()); });
                         }
                         return Symbol{};
@@ -1318,7 +1318,7 @@
                         if (cfg.builtins.clamp_int) {
                             auto& sig = builtin->Signature();
                             if (sig.parameters[0]->Type()->is_integer_scalar_or_vector()) {
-                                return builtin_polyfills.GetOrCreate(
+                                return builtin_polyfills.GetOrAdd(
                                     builtin, [&] { return clampInteger(builtin->ReturnType()); });
                             }
                         }
@@ -1326,42 +1326,42 @@
 
                     case wgsl::BuiltinFn::kCountLeadingZeros:
                         if (cfg.builtins.count_leading_zeros) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return countLeadingZeros(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kCountTrailingZeros:
                         if (cfg.builtins.count_trailing_zeros) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return countTrailingZeros(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kExtractBits:
                         if (cfg.builtins.extract_bits != Level::kNone) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return extractBits(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kFirstLeadingBit:
                         if (cfg.builtins.first_leading_bit) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return firstLeadingBit(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kFirstTrailingBit:
                         if (cfg.builtins.first_trailing_bit) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return firstTrailingBit(builtin->ReturnType()); });
                         }
                         return Symbol{};
 
                     case wgsl::BuiltinFn::kInsertBits:
                         if (cfg.builtins.insert_bits != Level::kNone) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return insertBits(builtin->ReturnType()); });
                         }
                         return Symbol{};
@@ -1373,7 +1373,7 @@
                             auto& sig = builtin->Signature();
                             auto* vec = sig.return_type->As<core::type::Vector>();
                             if (vec && vec->Width() == 2 && vec->type()->Is<core::type::F32>()) {
-                                return builtin_polyfills.GetOrCreate(
+                                return builtin_polyfills.GetOrAdd(
                                     builtin, [&] { return reflect(builtin->ReturnType()); });
                             }
                         }
@@ -1381,7 +1381,7 @@
 
                     case wgsl::BuiltinFn::kSaturate:
                         if (cfg.builtins.saturate) {
-                            return builtin_polyfills.GetOrCreate(
+                            return builtin_polyfills.GetOrAdd(
                                 builtin, [&] { return saturate(builtin->ReturnType()); });
                         }
                         return Symbol{};
@@ -1390,8 +1390,8 @@
                         if (cfg.builtins.sign_int) {
                             auto* ty = builtin->ReturnType();
                             if (ty->is_signed_integer_scalar_or_vector()) {
-                                return builtin_polyfills.GetOrCreate(builtin,
-                                                                     [&] { return sign_int(ty); });
+                                return builtin_polyfills.GetOrAdd(builtin,
+                                                                  [&] { return sign_int(ty); });
                             }
                         }
                         return Symbol{};
@@ -1418,7 +1418,7 @@
                             auto* tex = sig.Parameter(core::ParameterUsage::kTexture);
                             if (auto* stex = tex->Type()->As<core::type::SampledTexture>()) {
                                 if (stex->type()->Is<core::type::F32>()) {
-                                    return builtin_polyfills.GetOrCreate(builtin, [&] {
+                                    return builtin_polyfills.GetOrAdd(builtin, [&] {
                                         return textureSampleBaseClampToEdge_2d_f32();
                                     });
                                 }
@@ -1456,7 +1456,7 @@
                     case wgsl::BuiltinFn::kQuantizeToF16:
                         if (cfg.builtins.quantize_to_vec_f16) {
                             if (auto* vec = builtin->ReturnType()->As<core::type::Vector>()) {
-                                return builtin_polyfills.GetOrCreate(
+                                return builtin_polyfills.GetOrAdd(
                                     builtin, [&] { return quantizeToF16(vec); });
                             }
                         }
@@ -1464,7 +1464,7 @@
 
                     case wgsl::BuiltinFn::kWorkgroupUniformLoad:
                         if (cfg.builtins.workgroup_uniform_load) {
-                            return builtin_polyfills.GetOrCreate(builtin, [&] {
+                            return builtin_polyfills.GetOrAdd(builtin, [&] {
                                 return workgroupUniformLoad(builtin->ReturnType());
                             });
                         }
@@ -1472,64 +1472,62 @@
 
                     case wgsl::BuiltinFn::kDot4I8Packed: {
                         if (cfg.builtins.dot_4x8_packed) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Dot4I8Packed(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Dot4I8Packed(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kDot4U8Packed: {
                         if (cfg.builtins.dot_4x8_packed) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Dot4U8Packed(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Dot4U8Packed(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kPack4XI8: {
                         if (cfg.builtins.pack_unpack_4x8) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Pack4xI8(); });
+                            return builtin_polyfills.GetOrAdd(builtin, [&] { return Pack4xI8(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kPack4XU8: {
                         if (cfg.builtins.pack_unpack_4x8) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Pack4xU8(); });
+                            return builtin_polyfills.GetOrAdd(builtin, [&] { return Pack4xU8(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kPack4XI8Clamp: {
                         if (cfg.builtins.pack_unpack_4x8) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Pack4xI8Clamp(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Pack4xI8Clamp(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kPack4XU8Clamp: {
                         if (cfg.builtins.pack_4xu8_clamp) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Pack4xU8Clamp(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Pack4xU8Clamp(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kUnpack4XI8: {
                         if (cfg.builtins.pack_unpack_4x8) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Unpack4xI8(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Unpack4xI8(); });
                         }
                         return Symbol{};
                     }
 
                     case wgsl::BuiltinFn::kUnpack4XU8: {
                         if (cfg.builtins.pack_unpack_4x8) {
-                            return builtin_polyfills.GetOrCreate(builtin,
-                                                                 [&] { return Unpack4xU8(); });
+                            return builtin_polyfills.GetOrAdd(builtin,
+                                                              [&] { return Unpack4xU8(); });
                         }
                         return Symbol{};
                     }
@@ -1545,7 +1543,7 @@
                         auto* dst_ty = conv->Target();
                         if (tint::IsAnyOf<core::type::I32, core::type::U32>(
                                 dst_ty->Elements(dst_ty).type)) {
-                            return f32_conv_polyfills.GetOrCreate(dst_ty, [&] {  //
+                            return f32_conv_polyfills.GetOrAdd(dst_ty, [&] {  //
                                 return ConvF32ToIU32(src_ty, dst_ty);
                             });
                         }
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
index b056a6a..dcea861 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
@@ -265,7 +265,7 @@
 
         // Get or create the intrinsic function.
         auto builtin = BuiltinOf(attrs);
-        auto intrinsic = wave_intrinsics.GetOrCreate(builtin, [&] {
+        auto intrinsic = wave_intrinsics.GetOrAdd(builtin, [&] {
             if (builtin == core::BuiltinValue::kSubgroupInvocationId) {
                 return make_intrinsic("__WaveGetLaneIndex",
                                       HLSLWaveIntrinsic::Op::kWaveGetLaneIndex);
diff --git a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
index c87fa15..59e6dd6 100644
--- a/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
+++ b/src/tint/lang/wgsl/ast/transform/clamp_frag_depth.cc
@@ -139,7 +139,7 @@
                 //       return S(s.first, s.second, clamp_frag_depth(s.frag_depth), s.last);
                 //   }
                 auto* struct_ty = sem.Get(fn)->ReturnType()->As<sem::Struct>()->Declaration();
-                auto helper = io_structs_clamp_helpers.GetOrCreate(struct_ty, [&] {
+                auto helper = io_structs_clamp_helpers.GetOrAdd(struct_ty, [&] {
                     auto return_ty = fn->return_type;
                     auto fn_sym =
                         b.Symbols().New("clamp_frag_depth_" + struct_ty->name->symbol.Name());
diff --git a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
index 93a539c..28e776b 100644
--- a/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
+++ b/src/tint/lang/wgsl/ast/transform/demote_to_helper.cc
@@ -202,7 +202,7 @@
                             auto* result_struct = sem_call->Type()->As<core::type::Struct>();
                             auto* atomic_ty = result_struct->Members()[0]->Type();
                             result_ty =
-                                b.ty(tint::GetOrCreate(atomic_cmpxchg_result_types, atomic_ty, [&] {
+                                b.ty(tint::GetOrAdd(atomic_cmpxchg_result_types, atomic_ty, [&] {
                                     auto name = b.Sym();
                                     b.Structure(
                                         name,
diff --git a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
index 4ecea23..7cdee65 100644
--- a/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
+++ b/src/tint/lang/wgsl/ast/transform/direct_variable_access.cc
@@ -358,8 +358,8 @@
         tint::Vector<std::pair<const FnVariant::Signature*, FnVariant*>, 8> SortedVariants() {
             tint::Vector<std::pair<const FnVariant::Signature*, FnVariant*>, 8> out;
             out.Reserve(variants.Count());
-            for (auto it : variants) {
-                out.Push({&it.key, &it.value});
+            for (auto& it : variants) {
+                out.Push({&it.key.Value(), &it.value});
             }
             out.Sort([&](auto& va, auto& vb) { return va.second->order < vb.second->order; });
             return out;
@@ -539,7 +539,7 @@
 
             // The dynamic index needs to be hoisted (if it hasn't been already).
             auto fn = FnInfoFor(idx->Stmt()->Function());
-            fn->hoisted_exprs.GetOrCreate(idx, [=] {
+            fn->hoisted_exprs.GetOrAdd(idx, [=] {
                 // Create a name for the new 'let'
                 auto name = b.Symbols().New("ptr_index_save");
                 // Insert a new 'let' just above the dynamic index statement.
@@ -678,7 +678,7 @@
 
             // Construct a new FnVariant if this is the first caller of the target signature
             auto* target_info = FnInfoFor(target);
-            auto& target_variant = target_info->variants.GetOrCreate(target_signature, [&] {
+            auto& target_variant = target_info->variants.GetOrAdd(target_signature, [&] {
                 if (target_signature.IsEmpty()) {
                     // Call target does not require any argument changes.
                     FnVariant variant;
@@ -693,15 +693,15 @@
                 StringStream ss;
                 ss << target->Declaration()->name->symbol.Name();
                 for (auto* param : target->Parameters()) {
-                    if (auto indices = target_signature.Find(param)) {
+                    if (auto indices = target_signature.Get(param)) {
                         ss << "_" << AccessShapeName(*indices);
                     }
                 }
 
                 // Build the pointer parameter symbols.
                 Hashmap<const sem::Parameter*, PtrParamSymbols, 4> ptr_param_symbols;
-                for (auto param_it : target_signature) {
-                    auto* param = param_it.key;
+                for (auto& param_it : target_signature) {
+                    auto* param = param_it.key.Value();
                     auto& shape = param_it.value;
 
                     // Parameter needs replacing with either zero, one or two parameters:
@@ -770,7 +770,7 @@
     /// @returns the AccessChain for the expression @p expr, or nullptr if the expression does
     /// not hold an access chain.
     AccessChain* AccessChainFor(const sem::ValueExpression* expr) const {
-        if (auto chain = access_chains.Find(expr)) {
+        if (auto chain = access_chains.Get(expr)) {
             return *chain;
         }
         return nullptr;
@@ -781,7 +781,7 @@
     AccessShape AbsoluteAccessShape(const FnVariant::Signature& signature,
                                     const AccessShape& shape) const {
         if (auto* root_param = shape.root.variable->As<sem::Parameter>()) {
-            if (auto incoming_chain = signature.Find(root_param)) {
+            if (auto incoming_chain = signature.Get(root_param)) {
                 // Access chain originates from a parameter, which will be transformed into an array
                 // of dynamic indices. Concatenate the signature's AccessShape for the parameter
                 // to the chain's indices, skipping over the chain's initial parameter index.
@@ -831,8 +831,8 @@
                 // dynamic indices).
                 tint::Vector<const Parameter*, 8> params;
                 for (auto* param : fn->Parameters()) {
-                    if (auto incoming_shape = variant_sig.Find(param)) {
-                        auto& symbols = *variant.ptr_param_symbols.Find(param);
+                    if (auto incoming_shape = variant_sig.Get(param)) {
+                        auto& symbols = *variant.ptr_param_symbols.Get(param);
                         if (symbols.base_ptr.IsValid()) {
                             auto base_ptr_ty =
                                 b.ty.ptr(incoming_shape->root.address_space,
@@ -872,7 +872,7 @@
     void TransformCall(const sem::Call* call) {
         // Register a custom handler for the specific call expression
         ctx.Replace(call->Declaration(), [this, call] {
-            auto target_variant = clone_state->current_variant->calls.Find(call);
+            auto target_variant = clone_state->current_variant->calls.Get(call);
             if (!target_variant) {
                 // The current variant does not need to transform this call.
                 return ctx.CloneWithoutTransform(call->Declaration());
@@ -921,9 +921,9 @@
                     if (auto* root_param = chain->root.variable->As<sem::Parameter>()) {
                         // Access chain originates from a pointer parameter.
                         if (auto incoming_chain =
-                                clone_state->current_variant_sig->Find(root_param)) {
+                                clone_state->current_variant_sig->Get(root_param)) {
                             auto indices =
-                                clone_state->current_variant->ptr_param_symbols.Find(root_param)
+                                clone_state->current_variant->ptr_param_symbols.Get(root_param)
                                     ->indices;
 
                             // This pointer parameter will have been replaced with a array<u32, N>
@@ -1001,7 +1001,7 @@
 
             // If the expression has been hoisted to a 'let', then replace the expression with an
             // identifier to the hoisted let.
-            if (auto hoisted = clone_state->current_function->hoisted_exprs.Find(expr)) {
+            if (auto hoisted = clone_state->current_function->hoisted_exprs.Get(expr)) {
                 return b.Expr(*hoisted);
             }
 
@@ -1018,7 +1018,7 @@
                 return nullptr;  // Just clone the expression.
             }
 
-            auto incoming_shape = clone_state->current_variant_sig->Find(root_param);
+            auto incoming_shape = clone_state->current_variant_sig->Get(root_param);
             if (!incoming_shape) {
                 // The root parameter of the access chain is not part of the variant's signature.
                 return nullptr;  // Just clone the expression.
@@ -1033,8 +1033,8 @@
             // Replace this with the variant's incoming shape. This will bring the expression up to
             // the incoming pointer.
             size_t next_dyn_idx_from_indices = 0;
-            auto indices =
-                clone_state->current_variant->ptr_param_symbols.Find(root_param)->indices;
+            auto& indices =
+                clone_state->current_variant->ptr_param_symbols.Get(root_param)->indices;
             for (auto param_access : incoming_shape->ops) {
                 chain_expr = BuildAccessExpr(chain_expr, param_access, [&] {
                     return b.IndexAccessor(indices, AInt(next_dyn_idx_from_indices++));
@@ -1065,13 +1065,13 @@
     /// @returns the FnInfo for the given function, constructing a new FnInfo if @p fn doesn't
     /// already have one.
     FnInfo* FnInfoFor(const sem::Function* fn) {
-        return fns.GetOrCreate(fn, [this] { return fn_info_allocator.Create(); });
+        return fns.GetOrAdd(fn, [this] { return fn_info_allocator.Create(); });
     }
 
     /// @returns the type alias used to hold the dynamic indices for @p shape, declaring a new alias
     /// if this is the first call for the given shape.
     Type DynamicIndexArrayType(const AccessShape& shape) {
-        auto name = dynamic_index_array_aliases.GetOrCreate(shape, [&] {
+        auto name = dynamic_index_array_aliases.GetOrAdd(shape, [&] {
             // Count the number of dynamic indices
             uint32_t num_dyn_indices = shape.NumDynamicIndices();
             if (num_dyn_indices == 0) {
@@ -1120,7 +1120,7 @@
     /// @param deref if true, the returned expression will always be a reference type.
     const Expression* BuildAccessRootExpr(const AccessRoot& root, bool deref) {
         if (auto* param = root.variable->As<sem::Parameter>()) {
-            if (auto symbols = clone_state->current_variant->ptr_param_symbols.Find(param)) {
+            if (auto symbols = clone_state->current_variant->ptr_param_symbols.Get(param)) {
                 if (deref) {
                     return b.Deref(b.Expr(symbols->base_ptr));
                 }
@@ -1165,7 +1165,7 @@
     /// underscore and number, if the symbol is already taken.
     Symbol UniqueSymbolWithSuffix(Symbol symbol, const std::string& suffix) {
         auto str = symbol.Name() + suffix;
-        return unique_symbols.GetOrCreate(str, [&] { return b.Symbols().New(str); });
+        return unique_symbols.GetOrAdd(str, [&] { return b.Symbols().New(str); });
     }
 
     /// @returns true if the function @p fn has at least one pointer parameter.
diff --git a/src/tint/lang/wgsl/ast/transform/hoist_to_decl_before.cc b/src/tint/lang/wgsl/ast/transform/hoist_to_decl_before.cc
index 3f5fdbb..f1fa3d8 100644
--- a/src/tint/lang/wgsl/ast/transform/hoist_to_decl_before.cc
+++ b/src/tint/lang/wgsl/ast/transform/hoist_to_decl_before.cc
@@ -171,11 +171,11 @@
     /// automatically called.
     /// @warning the returned reference is invalid if this is called a second time, or the
     /// #for_loops map is mutated.
-    auto ForLoop(const sem::ForLoopStatement* for_loop) {
+    LoopInfo& ForLoop(const sem::ForLoopStatement* for_loop) {
         if (for_loops.IsEmpty()) {
             RegisterForLoopTransform();
         }
-        return for_loops.GetOrZero(for_loop);
+        return for_loops.GetOrAddZero(for_loop);
     }
 
     /// @returns a new LoopInfo reference for the given @p while_loop.
@@ -183,11 +183,11 @@
     /// automatically called.
     /// @warning the returned reference is invalid if this is called a second time, or the
     /// #for_loops map is mutated.
-    auto WhileLoop(const sem::WhileStatement* while_loop) {
+    LoopInfo& WhileLoop(const sem::WhileStatement* while_loop) {
         if (while_loops.IsEmpty()) {
             RegisterWhileLoopTransform();
         }
-        return while_loops.GetOrZero(while_loop);
+        return while_loops.GetOrAddZero(while_loop);
     }
 
     /// @returns a new ElseIfInfo reference for the given @p else_if.
@@ -195,11 +195,11 @@
     /// automatically called.
     /// @warning the returned reference is invalid if this is called a second time, or the
     /// #else_ifs map is mutated.
-    auto ElseIf(const IfStatement* else_if) {
+    ElseIfInfo& ElseIf(const IfStatement* else_if) {
         if (else_ifs.IsEmpty()) {
             RegisterElseIfTransform();
         }
-        return else_ifs.GetOrZero(else_if);
+        return else_ifs.GetOrAddZero(else_if);
     }
 
     /// Registers the handler for transforming for-loops based on the content of the #for_loops map.
@@ -208,7 +208,7 @@
             auto& sem = ctx.src->Sem();
 
             if (auto* fl = sem.Get(stmt)) {
-                if (auto info = for_loops.Find(fl)) {
+                if (auto info = for_loops.Get(fl)) {
                     auto* for_loop = fl->Declaration();
                     // For-loop needs to be decomposed to a loop.
                     // Build the loop body's statements.
@@ -267,7 +267,7 @@
             auto& sem = ctx.src->Sem();
 
             if (auto* w = sem.Get(stmt)) {
-                if (auto info = while_loops.Find(w)) {
+                if (auto info = while_loops.Get(w)) {
                     auto* while_loop = w->Declaration();
                     // While needs to be decomposed to a loop.
                     // Build the loop body's statements.
@@ -304,7 +304,7 @@
     void RegisterElseIfTransform() const {
         // Decompose 'else-if' statements into 'else { if }' blocks.
         ctx.ReplaceAll([&](const IfStatement* stmt) -> const Statement* {
-            if (auto info = else_ifs.Find(stmt)) {
+            if (auto info = else_ifs.Get(stmt)) {
                 // Build the else block's body statements, starting with let decls for the
                 // conditional expression.
                 auto body_stmts = Build(info->cond_decls);
@@ -336,10 +336,10 @@
         if (else_if && else_if->Parent()->Is<sem::IfStatement>()) {
             // Insertion point is an 'else if' condition.
             // Need to convert 'else if' to 'else { if }'.
-            auto else_if_info = ElseIf(else_if->Declaration());
+            auto& else_if_info = ElseIf(else_if->Declaration());
 
             // Index the map to decompose this else if, even if `stmt` is nullptr.
-            auto& decls = else_if_info->cond_decls;
+            auto& decls = else_if_info.cond_decls;
             if constexpr (!std::is_same_v<BUILDER, Decompose>) {
                 decls.Push(std::forward<BUILDER>(builder));
             }
@@ -351,7 +351,7 @@
             // For-loop needs to be decomposed to a loop.
 
             // Index the map to decompose this for-loop, even if `stmt` is nullptr.
-            auto& decls = ForLoop(fl)->cond_decls;
+            auto& decls = ForLoop(fl).cond_decls;
             if constexpr (!std::is_same_v<BUILDER, Decompose>) {
                 decls.Push(std::forward<BUILDER>(builder));
             }
@@ -363,7 +363,7 @@
             // While needs to be decomposed to a loop.
 
             // Index the map to decompose this while, even if `stmt` is nullptr.
-            auto& decls = WhileLoop(w)->cond_decls;
+            auto& decls = WhileLoop(w).cond_decls;
             if constexpr (!std::is_same_v<BUILDER, Decompose>) {
                 decls.Push(std::forward<BUILDER>(builder));
             }
@@ -390,7 +390,7 @@
                 // For-loop needs to be decomposed to a loop.
 
                 // Index the map to decompose this for-loop, even if `stmt` is nullptr.
-                auto& decls = ForLoop(fl)->init_decls;
+                auto& decls = ForLoop(fl).init_decls;
                 if constexpr (!std::is_same_v<BUILDER, Decompose>) {
                     decls.Push(std::forward<BUILDER>(builder));
                 }
@@ -403,7 +403,7 @@
                 // For-loop needs to be decomposed to a loop.
 
                 // Index the map to decompose this for-loop, even if `stmt` is nullptr.
-                auto& decls = ForLoop(fl)->cont_decls;
+                auto& decls = ForLoop(fl).cont_decls;
                 if constexpr (!std::is_same_v<BUILDER, Decompose>) {
                     decls.Push(std::forward<BUILDER>(builder));
                 }
diff --git a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
index bdcc60b..d32b3b7 100644
--- a/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
+++ b/src/tint/lang/wgsl/ast/transform/multiplanar_external_texture.cc
@@ -497,7 +497,7 @@
             createGammaCorrectionFn();
         }
 
-        auto texture_load_external_sym = texture_load_external_fns.GetOrCreate(call->Target(), [&] {
+        auto texture_load_external_sym = texture_load_external_fns.GetOrAdd(call->Target(), [&] {
             auto& sig = call->Target()->Signature();
             auto* coord_ty = sig.Parameter(core::ParameterUsage::kCoords)->Type();
 
diff --git a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
index d6935a9..5e28fed 100644
--- a/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
+++ b/src/tint/lang/wgsl/ast/transform/preserve_padding.cc
@@ -123,7 +123,7 @@
         const char* kDestParamName = "dest";
         const char* kValueParamName = "value";
         auto call_helper = [&](auto&& body) {
-            auto helper = helpers.GetOrCreate(ty, [&] {
+            auto helper = helpers.GetOrAdd(ty, [&] {
                 auto helper_name = b.Symbols().New("assign_and_preserve_padding");
                 tint::Vector<const Parameter*, 2> params = {
                     b.Param(kDestParamName,
diff --git a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
index 6400a5e..5094e8d 100644
--- a/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
+++ b/src/tint/lang/wgsl/ast/transform/promote_initializers_to_let.cc
@@ -135,8 +135,8 @@
 
     // After walking the full AST, const_chains only contains the outer-most constant expressions.
     // Check if any of these need hoisting, and append those to to_hoist.
-    for (auto* expr : const_chains) {
-        if (auto* sem = src.Sem().GetVal(expr); should_hoist(sem)) {
+    for (auto& expr : const_chains) {
+        if (auto* sem = src.Sem().GetVal(expr.Value()); should_hoist(sem)) {
             to_hoist.Push(sem);
         }
     }
diff --git a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
index a6b1123..ff33316c 100644
--- a/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
+++ b/src/tint/lang/wgsl/ast/transform/remove_phonies.cc
@@ -130,7 +130,7 @@
                         for (auto* arg : side_effects) {
                             sig.push_back(sem.GetVal(arg)->Type()->UnwrapRef());
                         }
-                        auto sink = sinks.GetOrCreate(sig, [&] {
+                        auto sink = sinks.GetOrAdd(sig, [&] {
                             auto name = b.Symbols().New("phony_sink");
                             tint::Vector<const Parameter*, 8> params;
                             for (auto* ty : sig) {
diff --git a/src/tint/lang/wgsl/ast/transform/renamer.cc b/src/tint/lang/wgsl/ast/transform/renamer.cc
index 7233498..487697d 100644
--- a/src/tint/lang/wgsl/ast/transform/renamer.cc
+++ b/src/tint/lang/wgsl/ast/transform/renamer.cc
@@ -1398,7 +1398,7 @@
         }
 
         // Create a replacement for this symbol, if we haven't already.
-        auto replacement = remappings.GetOrCreate(symbol, [&] {
+        auto replacement = remappings.GetOrAdd(symbol, [&] {
             if (requested_names) {
                 auto iter = requested_names->find(symbol.Name());
                 if (iter != requested_names->end()) {
@@ -1422,8 +1422,8 @@
     ctx.Clone();
 
     Remappings out;
-    for (auto it : remappings) {
-        out[it.key.Name()] = it.value.Name();
+    for (auto& it : remappings) {
+        out[it.key->Name()] = it.value.Name();
     }
     outputs.Add<Data>(std::move(out));
 
diff --git a/src/tint/lang/wgsl/ast/transform/robustness.cc b/src/tint/lang/wgsl/ast/transform/robustness.cc
index 8169d28..676a544 100644
--- a/src/tint/lang/wgsl/ast/transform/robustness.cc
+++ b/src/tint/lang/wgsl/ast/transform/robustness.cc
@@ -335,7 +335,7 @@
         }
 
         auto* stmt = expr->Stmt();
-        auto obj_pred = *predicates.GetOrZero(obj);
+        auto& obj_pred = predicates.GetOrAddZero(obj);
 
         auto idx_let = b.Symbols().New("index");
         auto pred = b.Symbols().New("predicate");
diff --git a/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc b/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
index 3095252..ad4d713 100644
--- a/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
+++ b/src/tint/lang/wgsl/ast/transform/simplify_pointers.cc
@@ -258,7 +258,7 @@
         // variable identifier.
         ctx.ReplaceAll([&](const Expression* expr) -> const Expression* {
             // Look to see if we need to swap this Expression with a saved variable.
-            if (auto saved_var = saved_vars.Find(expr)) {
+            if (auto saved_var = saved_vars.Get(expr)) {
                 return ctx.dst->Expr(*saved_var);
             }
 
diff --git a/src/tint/lang/wgsl/ast/transform/std140.cc b/src/tint/lang/wgsl/ast/transform/std140.cc
index b28e5a7..037d716 100644
--- a/src/tint/lang/wgsl/ast/transform/std140.cc
+++ b/src/tint/lang/wgsl/ast/transform/std140.cc
@@ -403,14 +403,14 @@
         return Switch(
             ty,  //
             [&](const core::type::Struct* str) {
-                if (auto std140 = std140_structs.Find(str)) {
+                if (auto std140 = std140_structs.Get(str)) {
                     return b.ty(*std140);
                 }
                 return Type{};
             },
             [&](const core::type::Matrix* mat) {
                 if (MatrixNeedsDecomposing(mat)) {
-                    auto std140_mat = std140_mats.GetOrCreate(mat, [&] {
+                    auto std140_mat = std140_mats.GetOrAdd(mat, [&] {
                         auto name = b.Symbols().New("mat" + std::to_string(mat->columns()) + "x" +
                                                     std::to_string(mat->rows()) + "_" +
                                                     mat->type()->FriendlyName());
@@ -671,7 +671,7 @@
     /// @returns the converted value expression.
     const Expression* Convert(const core::type::Type* ty, const Expression* expr) {
         // Get an existing, or create a new function for converting the std140 type to ty.
-        auto fn = conv_fns.GetOrCreate(ty, [&] {
+        auto fn = conv_fns.GetOrAdd(ty, [&] {
             auto std140_ty = Std140Type(ty);
             if (!std140_ty) {
                 // ty was not forked for std140.
@@ -690,7 +690,7 @@
                     // call, or by reassembling a std140 matrix from column vector members.
                     tint::Vector<const Expression*, 8> args;
                     for (auto* member : str->Members()) {
-                        if (auto col_members = std140_mat_members.Find(member)) {
+                        if (auto col_members = std140_mat_members.Get(member)) {
                             // std140 decomposed matrix. Reassemble.
                             auto mat_ty = CreateASTTypeFor(ctx, member->Type());
                             auto mat_args =
@@ -772,7 +772,7 @@
     const Expression* LoadMatrixWithFn(const AccessChain& access) {
         // Get an existing, or create a new function for loading the uniform buffer value.
         // This function is keyed off the uniform buffer variable and the access chain.
-        auto fn = load_fns.GetOrCreate(LoadFnKey{access.var, access.indices}, [&] {
+        auto fn = load_fns.GetOrAdd(LoadFnKey{access.var, access.indices}, [&] {
             if (access.IsMatrixSubset()) {
                 // Access chain passes through the matrix, but ends either at a column vector,
                 // column swizzle, or element.
diff --git a/src/tint/lang/wgsl/ast/transform/unshadow.cc b/src/tint/lang/wgsl/ast/transform/unshadow.cc
index eab34b0..8c61526 100644
--- a/src/tint/lang/wgsl/ast/transform/unshadow.cc
+++ b/src/tint/lang/wgsl/ast/transform/unshadow.cc
@@ -117,7 +117,7 @@
         ctx.ReplaceAll([&](const IdentifierExpression* ident) -> const IdentifierExpression* {
             if (auto* sem_ident = sem.GetVal(ident)) {
                 if (auto* user = sem_ident->Unwrap()->As<sem::VariableUser>()) {
-                    if (auto renamed = renamed_to.Find(user->Variable())) {
+                    if (auto renamed = renamed_to.Get(user->Variable())) {
                         return b.Expr(*renamed);
                     }
                 }
diff --git a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
index 45647df..e75deaa 100644
--- a/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
+++ b/src/tint/lang/wgsl/ast/transform/vectorize_scalar_matrix_initializers.cc
@@ -125,7 +125,7 @@
             // Generate a helper function for constructing the matrix.
             // This is done to ensure that the single argument value is only evaluated once, and
             // with the correct expression evaluation order.
-            auto fn = tint::GetOrCreate(scalar_inits, mat_type, [&] {
+            auto fn = tint::GetOrAdd(scalar_inits, mat_type, [&] {
                 auto name = b.Symbols().New("build_mat" + std::to_string(mat_type->columns()) +
                                             "x" + std::to_string(mat_type->rows()));
                 b.Func(name,
diff --git a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
index b3e4aa6..81ec237 100644
--- a/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
+++ b/src/tint/lang/wgsl/ast/transform/vertex_pulling.cc
@@ -318,7 +318,7 @@
     /// Generate the vertex buffer binding name
     /// @param index index to append to buffer name
     Symbol GetVertexBufferName(uint32_t index) {
-        return tint::GetOrCreate(vertex_buffer_names, index, [&] {
+        return tint::GetOrAdd(vertex_buffer_names, index, [&] {
             static const char kVertexBufferNamePrefix[] = "tint_pulling_vertex_buffer_";
             return b.Symbols().New(kVertexBufferNamePrefix + std::to_string(index));
         });
diff --git a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
index 3dba65f..235693e 100644
--- a/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
+++ b/src/tint/lang/wgsl/ast/transform/zero_init_workgroup_memory.cc
@@ -369,8 +369,8 @@
                 }
                 auto array_indices = a.array_indices;
                 array_indices.Add(ArrayIndex{modulo, division});
-                auto index = tint::GetOrCreate(array_index_names, ArrayIndex{modulo, division},
-                                               [&] { return b.Symbols().New("i"); });
+                auto index = tint::GetOrAdd(array_index_names, ArrayIndex{modulo, division},
+                                            [&] { return b.Symbols().New("i"); });
                 return Expression{b.IndexAccessor(a.expr, index), a.num_iterations, array_indices};
             };
             return BuildZeroingStatements(arr->ElemType(), get_el);
diff --git a/src/tint/lang/wgsl/inspector/inspector.cc b/src/tint/lang/wgsl/inspector/inspector.cc
index 6c5d935..e6c2b44 100644
--- a/src/tint/lang/wgsl/inspector/inspector.cc
+++ b/src/tint/lang/wgsl/inspector/inspector.cc
@@ -920,7 +920,7 @@
             // turn specified as an upper bound for Vulkan layout sizing. Since D3D
             // and Metal are even less specific, we assume Vulkan behavior as a
             // good-enough approximation everywhere.
-            total_size += tint::RoundUp(align, size);
+            total_size += tint::RoundUp(16u, tint::RoundUp(align, size));
         }
     }
 
@@ -1034,14 +1034,7 @@
 
     auto record_function_param = [&fn_to_data](const sem::Function* func,
                                                const ast::Parameter* param, TextureQueryType type) {
-        auto& param_to_type = *fn_to_data.GetOrZero(func);
-
-        auto entry = param_to_type.Get(param);
-        if (entry.has_value()) {
-            return;
-        }
-
-        param_to_type.Add(param, type);
+        fn_to_data.GetOrAddZero(func).Add(param, type);
     };
 
     auto save_if_needed = [&res, &seen](const sem::GlobalVariable* global, TextureQueryType type) {
@@ -1110,7 +1103,7 @@
                     // A function call, check to see if any params needed to be tracked back to a
                     // global texture.
 
-                    auto param_to_type = fn_to_data.Find(func);
+                    auto param_to_type = fn_to_data.Get(func);
                     if (!param_to_type) {
                         return;
                     }
@@ -1121,7 +1114,7 @@
 
                         // Determine if this had a texture we cared about
                         auto type = param_to_type->Get(param);
-                        if (!type.has_value()) {
+                        if (!type) {
                             continue;
                         }
 
@@ -1131,10 +1124,10 @@
                         tint::Switch(
                             texture_sem,
                             [&](const sem::GlobalVariable* global) {
-                                save_if_needed(global, type.value());
+                                save_if_needed(global, *type);
                             },
                             [&](const sem::Parameter* p) {
-                                record_function_param(fn, p->Declaration(), type.value());
+                                record_function_param(fn, p->Declaration(), *type);
                             },
                             TINT_ICE_ON_NO_MATCH);
                     }
diff --git a/src/tint/lang/wgsl/inspector/inspector_test.cc b/src/tint/lang/wgsl/inspector/inspector_test.cc
index 76d514e..e3d97bb 100644
--- a/src/tint/lang/wgsl/inspector/inspector_test.cc
+++ b/src/tint/lang/wgsl/inspector/inspector_test.cc
@@ -305,7 +305,7 @@
     ASSERT_FALSE(inspector.has_error()) << inspector.error();
 
     ASSERT_EQ(1u, result.size());
-    EXPECT_EQ(4u, result[0].workgroup_storage_size);
+    EXPECT_EQ(16u, result[0].workgroup_storage_size);
 }
 
 TEST_F(InspectorGetEntryPointTest, WorkgroupStorageSizeCompoundTypes) {
@@ -338,7 +338,7 @@
     ASSERT_FALSE(inspector.has_error()) << inspector.error();
 
     ASSERT_EQ(1u, result.size());
-    EXPECT_EQ(72u, result[0].workgroup_storage_size);
+    EXPECT_EQ(96u, result[0].workgroup_storage_size);
 }
 
 TEST_F(InspectorGetEntryPointTest, WorkgroupStorageSizeAlignmentPadding) {
diff --git a/src/tint/lang/wgsl/intrinsic/data.cc b/src/tint/lang/wgsl/intrinsic/data.cc
index 73b6fa4..8266687 100644
--- a/src/tint/lang/wgsl/intrinsic/data.cc
+++ b/src/tint/lang/wgsl/intrinsic/data.cc
@@ -4698,41 +4698,46 @@
   {
     /* [29] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(65),
+    /* matcher_index */ TypeMatcherIndex(67),
   },
   {
     /* [30] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(57),
+    /* matcher_index */ TypeMatcherIndex(65),
   },
   {
     /* [31] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(58),
+    /* matcher_index */ TypeMatcherIndex(57),
   },
   {
     /* [32] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(55),
+    /* matcher_index */ TypeMatcherIndex(58),
   },
   {
     /* [33] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(56),
+    /* matcher_index */ TypeMatcherIndex(55),
   },
   {
     /* [34] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(59),
+    /* matcher_index */ TypeMatcherIndex(56),
   },
   {
     /* [35] */
     /* name */ "T",
-    /* matcher_index */ TypeMatcherIndex(54),
+    /* matcher_index */ TypeMatcherIndex(59),
   },
   {
     /* [36] */
     /* name */ "T",
+    /* matcher_index */ TypeMatcherIndex(54),
+  },
+  {
+    /* [37] */
+    /* name */ "T",
     /* matcher_index */ TypeMatcherIndex(71),
   },
 };
@@ -5554,7 +5559,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(54),
@@ -6451,7 +6456,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(10),
@@ -6737,7 +6742,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(74),
@@ -7413,7 +7418,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
@@ -7426,7 +7431,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(386),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(104),
@@ -7491,7 +7496,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
@@ -7504,7 +7509,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(389),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(110),
@@ -7569,7 +7574,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
@@ -7582,7 +7587,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(392),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(116),
@@ -7647,7 +7652,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
@@ -7660,7 +7665,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(395),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(122),
@@ -7725,7 +7730,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
@@ -7738,7 +7743,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(398),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(128),
@@ -7803,7 +7808,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
@@ -7816,7 +7821,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(401),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(134),
@@ -7881,7 +7886,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
@@ -7894,7 +7899,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(404),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(140),
@@ -7959,7 +7964,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
@@ -7972,7 +7977,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(407),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(146),
@@ -8037,7 +8042,7 @@
     /* num_parameters */ 0,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(/* invalid */),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
@@ -8050,7 +8055,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(36),
+    /* template_types */ TemplateTypeIndex(37),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(410),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(152),
@@ -8440,7 +8445,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -8453,7 +8458,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -8492,7 +8497,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -8505,7 +8510,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -8622,7 +8627,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(30),
+    /* template_types */ TemplateTypeIndex(31),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(31),
@@ -8661,7 +8666,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(31),
+    /* template_types */ TemplateTypeIndex(32),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(33),
@@ -8700,7 +8705,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(32),
+    /* template_types */ TemplateTypeIndex(33),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(15),
@@ -8739,7 +8744,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(33),
+    /* template_types */ TemplateTypeIndex(34),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(87),
@@ -8778,7 +8783,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(34),
+    /* template_types */ TemplateTypeIndex(35),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(9),
@@ -10247,7 +10252,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10260,7 +10265,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10299,7 +10304,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(1),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10312,7 +10317,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(149),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10481,7 +10486,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(16),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10494,7 +10499,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(351),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10507,7 +10512,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(16),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -10520,7 +10525,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 1,
-    /* template_types */ TemplateTypeIndex(29),
+    /* template_types */ TemplateTypeIndex(30),
     /* template_numbers */ TemplateNumberIndex(4),
     /* parameters */ ParameterIndex(351),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(6),
@@ -10975,7 +10980,7 @@
     /* num_parameters */ 2,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(0),
+    /* template_types */ TemplateTypeIndex(29),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(348),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(2),
@@ -11027,7 +11032,7 @@
     /* num_parameters */ 1,
     /* num_template_types */ 1,
     /* num_template_numbers */ 0,
-    /* template_types */ TemplateTypeIndex(35),
+    /* template_types */ TemplateTypeIndex(36),
     /* template_numbers */ TemplateNumberIndex(/* invalid */),
     /* parameters */ ParameterIndex(213),
     /* return_type_matcher_indices */ TypeMatcherIndicesIndex(158),
@@ -11972,7 +11977,7 @@
   },
   {
     /* [121] */
-    /* fn subgroupBroadcast<T : fiu32>(value: T, @const sourceLaneIndex: u32) -> T */
+    /* fn subgroupBroadcast<T : fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T */
     /* num overloads */ 1,
     /* overloads */ OverloadIndex(466),
   },
diff --git a/src/tint/lang/wgsl/resolver/assignment_validation_test.cc b/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
index aeb4d61..826fbd0 100644
--- a/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/assignment_validation_test.cc
@@ -222,7 +222,7 @@
                    Assign(Expr(Source{{12, 34}}, 1_i), "my_var"));
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32')");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value of type 'i32')");
 }
 
 TEST_F(ResolverAssignmentValidationTest, AssignToOverride_Fail) {
@@ -292,7 +292,7 @@
                    Assign(MemberAccessor(Source{{12, 34}}, Expr(Source{{56, 78}}, "a"), "i"), 2_i));
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value expression of type 'i32'
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot assign to value of type 'i32'
 56:78 note: 'let' variables are immutable
 98:76 note: let 'a' declared here)");
 }
diff --git a/src/tint/lang/wgsl/resolver/call_validation_test.cc b/src/tint/lang/wgsl/resolver/call_validation_test.cc
index 9a0d7c1..d7bdc4e 100644
--- a/src/tint/lang/wgsl/resolver/call_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/call_validation_test.cc
@@ -143,7 +143,7 @@
          });
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of let 'z'");
 }
 
 TEST_F(ResolverCallValidationTest,
@@ -214,7 +214,7 @@
          });
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of value of type 'i32'");
 }
 
 TEST_F(ResolverCallValidationTest, PointerArgument_FunctionParam) {
diff --git a/src/tint/lang/wgsl/resolver/compound_assignment_validation_test.cc b/src/tint/lang/wgsl/resolver/compound_assignment_validation_test.cc
index ada0fb4..578cd22 100644
--- a/src/tint/lang/wgsl/resolver/compound_assignment_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/compound_assignment_validation_test.cc
@@ -276,7 +276,7 @@
     WrapInFunction(CompoundAssign(Expr(Source{{56, 78}}, 1_i), 1_i, core::BinaryOp::kAdd));
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), R"(56:78 error: cannot assign to value expression of type 'i32')");
+    EXPECT_EQ(r()->error(), R"(56:78 error: cannot assign to value of type 'i32')");
 }
 
 TEST_F(ResolverCompoundAssignmentValidationTest, LhsAtomic) {
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph.cc b/src/tint/lang/wgsl/resolver/dependency_graph.cc
index 890d024..f8b5425 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph.cc
+++ b/src/tint/lang/wgsl/resolver/dependency_graph.cc
@@ -166,7 +166,7 @@
           graph_(graph),
           dependency_edges_(edges) {
         // Register all the globals at global-scope
-        for (auto it : globals_by_name) {
+        for (auto& it : globals_by_name) {
             scope_stack_.Set(it.key, it.value->node);
         }
     }
@@ -242,7 +242,7 @@
         TINT_DEFER(scope_stack_.Pop());
 
         for (auto* param : func->params) {
-            if (auto* shadows = scope_stack_.Get(param->name->symbol)) {
+            if (auto shadows = scope_stack_.Get(param->name->symbol)) {
                 graph_.shadows.Add(param, shadows);
             }
             Declare(param->name->symbol, param);
@@ -465,7 +465,7 @@
     /// @param symbol the symbol
     /// @returns the builtin info
     DependencyScanner::BuiltinInfo GetBuiltinInfo(Symbol symbol) {
-        return builtin_info_map.GetOrCreate(symbol, [&] {
+        return builtin_info_map.GetOrAdd(symbol, [&] {
             if (auto builtin_fn = wgsl::ParseBuiltinFn(symbol.NameView());
                 builtin_fn != wgsl::BuiltinFn::kNone) {
                 return BuiltinInfo{BuiltinType::kFunction, builtin_fn};
@@ -549,7 +549,7 @@
             return;
         }
 
-        if (auto global = globals_.Find(to); global && (*global)->node == resolved) {
+        if (auto global = globals_.Get(to); global && (*global)->node == resolved) {
             if (dependency_edges_.Add(DependencyEdge{current_global_, *global},
                                       DependencyInfo{from->source})) {
                 current_global_->deps.Push(*global);
@@ -765,7 +765,7 @@
     /// of global `from` depending on `to`.
     /// @note will raise an ICE if the edge is not found.
     DependencyInfo DepInfoFor(const Global* from, const Global* to) const {
-        auto info = dependency_edges_.Find(DependencyEdge{from, to});
+        auto info = dependency_edges_.Get(DependencyEdge{from, to});
         if (TINT_LIKELY(info)) {
             return *info;
         }
@@ -819,7 +819,7 @@
         printf("------ dependencies ------ \n");
         for (auto* node : sorted_) {
             auto symbol = SymbolOf(node);
-            auto* global = *globals_.Find(symbol);
+            auto* global = *globals_.Get(symbol);
             printf("%s depends on:\n", symbol.Name().c_str());
             for (auto* dep : global->deps) {
                 printf("  %s\n", NameOf(dep->node).c_str());
diff --git a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
index 360ffda..5e79a3e 100644
--- a/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
+++ b/src/tint/lang/wgsl/resolver/dependency_graph_test.cc
@@ -757,8 +757,8 @@
 
     auto graph = Build();
 
-    auto resolved_identifier = graph.resolved_identifiers.Find(ident);
-    ASSERT_NE(resolved_identifier, nullptr);
+    auto resolved_identifier = graph.resolved_identifiers.Get(ident);
+    ASSERT_TRUE(resolved_identifier);
     auto* unresolved = resolved_identifier->Unresolved();
     ASSERT_NE(unresolved, nullptr);
     EXPECT_EQ(unresolved->name, "SYMBOL");
@@ -805,7 +805,7 @@
     WrapInFunction(Decl(Var(symbol, ty.i32(), Mul(Expr(ident), 123_i))));
     auto graph = Build();
 
-    auto resolved_identifier = graph.resolved_identifiers.Find(ident);
+    auto resolved_identifier = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved_identifier);
     auto* unresolved = resolved_identifier->Unresolved();
     ASSERT_NE(unresolved, nullptr);
@@ -818,7 +818,7 @@
     WrapInFunction(Decl(Let(symbol, ty.i32(), Mul(Expr(ident), 123_i))));
     auto graph = Build();
 
-    auto resolved_identifier = graph.resolved_identifiers.Find(ident);
+    auto resolved_identifier = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved_identifier);
     auto* unresolved = resolved_identifier->Unresolved();
     ASSERT_NE(unresolved, nullptr);
@@ -1155,7 +1155,7 @@
     bool expect_resolved = ScopeDepth(decl_kind) <= ScopeDepth(use_kind);
     auto graph = Build();
 
-    auto resolved_identifier = graph.resolved_identifiers.Find(use);
+    auto resolved_identifier = graph.resolved_identifiers.Get(use);
     ASSERT_TRUE(resolved_identifier);
 
     if (expect_resolved) {
@@ -1205,7 +1205,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->BuiltinFn(), builtin) << resolved->String();
 }
@@ -1244,7 +1245,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->BuiltinType(), core::ParseBuiltinType(name)) << resolved->String();
 }
@@ -1283,7 +1285,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->Access(), core::ParseAccess(name)) << resolved->String();
 }
@@ -1322,7 +1325,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->AddressSpace(), core::ParseAddressSpace(name)) << resolved->String();
 }
@@ -1361,7 +1365,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->BuiltinValue(), core::ParseBuiltinValue(name)) << resolved->String();
 }
@@ -1400,7 +1405,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->InterpolationSampling(), core::ParseInterpolationSampling(name))
         << resolved->String();
@@ -1440,7 +1446,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->InterpolationType(), core::ParseInterpolationType(name))
         << resolved->String();
@@ -1480,7 +1487,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->TexelFormat(), core::ParseTexelFormat(name)) << resolved->String();
 }
@@ -1527,7 +1535,7 @@
     helper.Build();
 
     auto shadows = Build().shadows;
-    auto shadow = shadows.Find(inner_var);
+    auto shadow = shadows.Get(inner_var);
     ASSERT_TRUE(shadow);
     EXPECT_EQ(*shadow, outer);
 }
@@ -1561,7 +1569,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
@@ -1578,7 +1587,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
@@ -1593,7 +1603,8 @@
     auto* ident = helper.Add(use, symbol);
     helper.Build();
 
-    auto resolved = Build().resolved_identifiers.Get(ident);
+    auto graph = Build();
+    auto resolved = graph.resolved_identifiers.Get(ident);
     ASSERT_TRUE(resolved);
     EXPECT_EQ(resolved->Node(), decl) << resolved->String();
 }
@@ -1760,7 +1771,7 @@
 
     auto graph = Build();
     for (auto use : symbol_uses) {
-        auto resolved_identifier = graph.resolved_identifiers.Find(use.use);
+        auto resolved_identifier = graph.resolved_identifiers.Get(use.use);
         ASSERT_TRUE(resolved_identifier) << use.where;
         EXPECT_EQ(*resolved_identifier, use.decl) << use.where;
     }
diff --git a/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc b/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
index cc61eb3..488b5c6 100644
--- a/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
+++ b/src/tint/lang/wgsl/resolver/ptr_ref_validation_test.cc
@@ -49,7 +49,7 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of value of type 'i32')");
 }
 
 TEST_F(ResolverPtrRefValidationTest, AddressOfLet) {
@@ -62,7 +62,45 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of expression");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of let 'l')");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfConst) {
+    // const c : i32 = 1;
+    // &c
+    auto* l = Const("c", ty.i32(), Expr(1_i));
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "c"));
+
+    WrapInFunction(l, expr);
+
+    EXPECT_FALSE(r()->Resolve());
+
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of const 'c')");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfOverride) {
+    // override c : i32;
+    // &o
+    Override("o", ty.i32());
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "o"));
+
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of override 'o')");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfParameter) {
+    // fn F(p : i32) { _ = &p }
+    // &F
+    Func("F", Vector{Param("p", ty.i32())}, ty.void_(),
+         Vector{
+             Assign(Phony(), AddressOf(Expr(Source{{12, 34}}, "p"))),
+         });
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of parameter 'p')");
 }
 
 TEST_F(ResolverPtrRefValidationTest, AddressOfHandle) {
@@ -75,8 +113,111 @@
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              "12:34 error: cannot take the address of expression in handle "
-              "address space");
+              R"(12:34 error: cannot take the address of var 't' in handle address space)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfFunction) {
+    // fn F() {}
+    // &F
+    Func("F", Empty, ty.void_(), Empty);
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "F"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(),
+              R"(12:34 error: cannot use function 'F' as value
+note: function 'F' declared here
+12:34 note: are you missing '()'?)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfBuiltinFunction) {
+    // &max
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "max"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(),
+              R"(12:34 error: cannot use builtin function 'max' as value
+12:34 note: are you missing '()'?)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfType) {
+    // &i32
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "i32"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(),
+              R"(12:34 error: cannot use type 'i32' as value
+12:34 note: are you missing '()'?)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfTypeAlias) {
+    // alias T = i32
+    // &T
+    Alias("T", ty.i32());
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "T"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(),
+              R"(12:34 error: cannot use type 'i32' as value
+12:34 note: are you missing '()'?)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfAccess) {
+    // &read_write
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "read_write"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot use access 'read_write' as value)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfAddressSpace) {
+    // &handle
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "uniform"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot use address space 'uniform' as value)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfBuiltinValue) {
+    // &position
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "position"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot use builtin value 'position' as value)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfInterpolationSampling) {
+    // &centroid
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "centroid"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(),
+              R"(12:34 error: cannot use interpolation sampling 'centroid' as value)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfInterpolationType) {
+    // &perspective
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "perspective"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot use interpolation type 'perspective' as value)");
+}
+
+TEST_F(ResolverPtrRefValidationTest, AddressOfTexelFormat) {
+    // &rgba8snorm
+    auto* expr = AddressOf(Expr(Source{{12, 34}}, "rgba8snorm"));
+    WrapInFunction(expr);
+
+    EXPECT_FALSE(r()->Resolve());
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot use texel format 'rgba8snorm' as value)");
 }
 
 TEST_F(ResolverPtrRefValidationTest, AddressOfVectorComponent_MemberAccessor) {
@@ -89,7 +230,7 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of a vector component");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of a vector component)");
 }
 
 TEST_F(ResolverPtrRefValidationTest, AddressOfVectorComponent_IndexAccessor) {
@@ -102,7 +243,7 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot take the address of a vector component");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot take the address of a vector component)");
 }
 
 TEST_F(ResolverPtrRefValidationTest, IndirectOfAddressOfHandle) {
@@ -115,8 +256,7 @@
 
     EXPECT_FALSE(r()->Resolve());
     EXPECT_EQ(r()->error(),
-              "12:34 error: cannot take the address of expression in handle "
-              "address space");
+              R"(12:34 error: cannot take the address of var 't' in handle address space)");
 }
 
 TEST_F(ResolverPtrRefValidationTest, DerefOfLiteral) {
@@ -128,7 +268,7 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot dereference expression of type 'i32'");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot dereference expression of type 'i32')");
 }
 
 TEST_F(ResolverPtrRefValidationTest, DerefOfVar) {
@@ -141,7 +281,7 @@
 
     EXPECT_FALSE(r()->Resolve());
 
-    EXPECT_EQ(r()->error(), "12:34 error: cannot dereference expression of type 'i32'");
+    EXPECT_EQ(r()->error(), R"(12:34 error: cannot dereference expression of type 'i32')");
 }
 
 TEST_F(ResolverPtrRefValidationTest, InferredPtrAccessMismatch) {
diff --git a/src/tint/lang/wgsl/resolver/resolver.cc b/src/tint/lang/wgsl/resolver/resolver.cc
index e8b9bcc..3e717d4 100644
--- a/src/tint/lang/wgsl/resolver/resolver.cc
+++ b/src/tint/lang/wgsl/resolver/resolver.cc
@@ -911,7 +911,7 @@
 }
 
 void Resolver::SetShadows() {
-    for (auto it : dependencies_.shadows) {
+    for (auto& it : dependencies_.shadows) {
         CastableBase* shadowed = sem_.Get(it.value);
         if (TINT_UNLIKELY(!shadowed)) {
             StringStream err;
@@ -921,7 +921,7 @@
         }
 
         Switch(
-            sem_.Get(it.key),  //
+            sem_.Get(it.key.Value()),  //
             [&](sem::LocalVariable* local) { local->SetShadows(shadowed); },
             [&](sem::Parameter* param) { param->SetShadows(shadowed); });
     }
@@ -1019,7 +1019,7 @@
             if (auto added = parameter_names.Add(param->name->symbol, param->source); !added) {
                 auto name = param->name->symbol.Name();
                 AddError("redefinition of parameter '" + name + "'", param->source);
-                AddNote("previous definition is here", *added.value);
+                AddNote("previous definition is here", added.value);
                 return nullptr;
             }
         }
@@ -1560,7 +1560,7 @@
         // If we just processed the lhs of a constexpr logical binary expression, mark the rhs for
         // short-circuiting.
         if (val && val->ConstantValue()) {
-            if (auto binary = logical_binary_lhs_to_parent_.Find(expr)) {
+            if (auto binary = logical_binary_lhs_to_parent_.Get(expr)) {
                 const bool lhs_is_true = val->ConstantValue()->ValueAs<bool>();
                 if (((*binary)->IsLogicalAnd() && !lhs_is_true) ||
                     ((*binary)->IsLogicalOr() && lhs_is_true)) {
@@ -2131,7 +2131,7 @@
         // Is this overload a constructor or conversion?
         if (match->info->flags.Contains(OverloadFlag::kIsConstructor)) {
             // Type constructor
-            target_sem = constructors_.GetOrCreate(match.Get(), [&] {
+            target_sem = constructors_.GetOrAdd(match.Get(), [&] {
                 auto params = Transform(match->parameters, [&](auto& p, size_t i) {
                     return b.create<sem::Parameter>(nullptr, static_cast<uint32_t>(i), p.type,
                                                     p.usage);
@@ -2141,7 +2141,7 @@
             });
         } else {
             // Type conversion
-            target_sem = converters_.GetOrCreate(match.Get(), [&] {
+            target_sem = converters_.GetOrAdd(match.Get(), [&] {
                 auto* param = b.create<sem::Parameter>(nullptr, 0u, match->parameters[0].type,
                                                        match->parameters[0].usage);
                 return b.create<sem::ValueConversion>(match->return_type, param, overload_stage);
@@ -2233,7 +2233,7 @@
                                     m->type());
             },
             [&](const sem::Array* arr) -> sem::Call* {
-                auto* call_target = array_ctors_.GetOrCreate(
+                auto* call_target = array_ctors_.GetOrAdd(
                     ArrayConstructorSig{{arr, args.Length(), args_stage}},
                     [&]() -> sem::ValueConstructor* {
                         auto params = tint::Transform(args, [&](auto, size_t i) {
@@ -2255,7 +2255,7 @@
                 return arr_or_str_init(arr, call_target);
             },
             [&](const core::type::Struct* str) -> sem::Call* {
-                auto* call_target = struct_ctors_.GetOrCreate(
+                auto* call_target = struct_ctors_.GetOrAdd(
                     StructConstructorSig{{str, args.Length(), args_stage}},
                     [&]() -> sem::ValueConstructor* {
                         Vector<sem::Parameter*, 8> params;
@@ -2398,7 +2398,7 @@
     }
 
     // De-duplicate builtins that are identical.
-    auto* target = builtins_.GetOrCreate(std::make_pair(overload.Get(), fn), [&] {
+    auto* target = builtins_.GetOrAdd(std::make_pair(overload.Get(), fn), [&] {
         auto params = Transform(overload->parameters, [&](auto& p, size_t i) {
             return b.create<sem::Parameter>(nullptr, static_cast<uint32_t>(i), p.type, p.usage);
         });
@@ -3312,7 +3312,7 @@
                             // If our identifier is in loop_block->decls, make sure its index is
                             // less than first_continue
                             auto symbol = ident->symbol;
-                            if (auto decl = loop_block->Decls().Find(symbol)) {
+                            if (auto decl = loop_block->Decls().Get(symbol)) {
                                 if (decl->order >= loop_block->NumDeclsAtFirstContinue()) {
                                     AddError("continue statement bypasses declaration of '" +
                                                  symbol.Name() + "'",
@@ -3694,7 +3694,8 @@
         case core::UnaryOp::kAddressOf:
             if (auto* ref = expr_ty->As<core::type::Reference>()) {
                 if (ref->StoreType()->UnwrapRef()->is_handle()) {
-                    AddError("cannot take the address of expression in handle address space",
+                    AddError("cannot take the address of " + sem_.Describe(expr) +
+                                 " in handle address space",
                              unary->expr->source);
                     return nullptr;
                 }
@@ -3713,7 +3714,7 @@
 
                 root_ident = expr->RootIdentifier();
             } else {
-                AddError("cannot take the address of expression", unary->expr->source);
+                AddError("cannot take the address of " + sem_.Describe(expr), unary->expr->source);
                 return nullptr;
             }
             break;
@@ -4314,7 +4315,7 @@
         Mark(member->name);
         if (auto added = member_map.Add(member->name->symbol, member); !added) {
             AddError("redefinition of '" + member->name->symbol.Name() + "'", member->source);
-            AddNote("previous definition is here", (*added.value)->source);
+            AddNote("previous definition is here", added.value->source);
             return nullptr;
         }
 
diff --git a/src/tint/lang/wgsl/resolver/resolver_test.cc b/src/tint/lang/wgsl/resolver/resolver_test.cc
index 8eb0457..fe4027e 100644
--- a/src/tint/lang/wgsl/resolver/resolver_test.cc
+++ b/src/tint/lang/wgsl/resolver/resolver_test.cc
@@ -138,7 +138,7 @@
     WrapInFunction(cond_var, Switch("i", Case(CaseSelector(AddressOf(1_a)), Block())));
 
     EXPECT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), "error: cannot take the address of expression");
+    EXPECT_EQ(r()->error(), "error: cannot take the address of value of type 'abstract-int'");
 }
 
 TEST_F(ResolverTest, Stmt_Block) {
@@ -2411,7 +2411,7 @@
          });
 
     ASSERT_FALSE(r()->Resolve());
-    EXPECT_EQ(r()->error(), "error: cannot take the address of expression in handle address space");
+    EXPECT_EQ(r()->error(), "error: cannot take the address of var 's' in handle address space");
 }
 
 TEST_F(ResolverTest, ModuleDependencyOrderedDeclarations) {
diff --git a/src/tint/lang/wgsl/resolver/sem_helper.cc b/src/tint/lang/wgsl/resolver/sem_helper.cc
index a68734a..d6e8b89 100644
--- a/src/tint/lang/wgsl/resolver/sem_helper.cc
+++ b/src/tint/lang/wgsl/resolver/sem_helper.cc
@@ -94,7 +94,7 @@
         },
         [&](const sem::ValueExpression* val_expr) {
             auto type = val_expr->Type()->FriendlyName();
-            return "value expression of type '" + type + "'";
+            return "value of type '" + type + "'";
         },
         [&](const sem::TypeExpression* ty_expr) {
             auto name = ty_expr->Type()->FriendlyName();
diff --git a/src/tint/lang/wgsl/resolver/uniformity.cc b/src/tint/lang/wgsl/resolver/uniformity.cc
index 709da02..cf03bc7 100644
--- a/src/tint/lang/wgsl/resolver/uniformity.cc
+++ b/src/tint/lang/wgsl/resolver/uniformity.cc
@@ -294,8 +294,8 @@
     /// @returns a LoopSwitchInfo for the given statement, allocating the LoopSwitchInfo if this is
     /// the first call with the given statement.
     LoopSwitchInfo& LoopSwitchInfoFor(const sem::Statement* stmt) {
-        return *loop_switch_infos.GetOrCreate(stmt,
-                                              [&] { return loop_switch_info_allocator.Create(); });
+        return *loop_switch_infos.GetOrAdd(stmt,
+                                           [&] { return loop_switch_info_allocator.Create(); });
     }
 
     /// Disassociates the LoopSwitchInfo for the given statement.
@@ -431,7 +431,7 @@
     /// @param func the function to process
     /// @returns true if there are no uniformity issues, false otherwise
     bool ProcessFunction(const ast::Function* func) {
-        current_function_ = functions_.Add(func, FunctionInfo(func, b)).value;
+        current_function_ = &functions_.Add(func, FunctionInfo(func, b)).value;
 
         // Process function body.
         if (func->body) {
@@ -627,7 +627,7 @@
                 // 'Next'.
                 auto& behaviors = sem->Behaviors();
                 if (behaviors.Contains(sem::Behavior::kNext)) {
-                    for (auto var : scoped_assignments) {
+                    for (auto& var : scoped_assignments) {
                         current_function_->variables.Set(var.key, var.value);
                     }
                 }
@@ -649,7 +649,7 @@
                 auto& info = current_function_->LoopSwitchInfoFor(parent);
 
                 // Propagate variable values to the loop/switch exit nodes.
-                for (auto* var : current_function_->local_var_decls) {
+                for (auto& var : current_function_->local_var_decls) {
                     // Skip variables that were declared inside this loop/switch.
                     if (auto* lv = var->As<sem::LocalVariable>();
                         lv &&
@@ -658,7 +658,7 @@
                     }
 
                     // Add an edge from the variable exit node to its value at this point.
-                    auto* exit_node = info.var_exit_nodes.GetOrCreate(var, [&] {
+                    auto* exit_node = info.var_exit_nodes.GetOrAdd(var, [&] {
                         auto name = NameFor(var);
                         return CreateNode({name, "_value_", info.type, "_exit"});
                     });
@@ -686,7 +686,7 @@
                     auto& info = current_function_->LoopSwitchInfoFor(parent);
 
                     // Propagate variable values to the loop exit nodes.
-                    for (auto* var : current_function_->local_var_decls) {
+                    for (auto& var : current_function_->local_var_decls) {
                         // Skip variables that were declared inside this loop.
                         if (auto* lv = var->As<sem::LocalVariable>();
                             lv && lv->Statement()->FindFirstParent(
@@ -695,7 +695,7 @@
                         }
 
                         // Add an edge from the variable exit node to its value at this point.
-                        auto* exit_node = info.var_exit_nodes.GetOrCreate(var, [&] {
+                        auto* exit_node = info.var_exit_nodes.GetOrAdd(var, [&] {
                             auto name = NameFor(var);
                             return CreateNode({name, "_value_", info.type, "_exit"});
                         });
@@ -780,7 +780,7 @@
                 info.type = "forloop";
 
                 // Create input nodes for any variables declared before this loop.
-                for (auto* v : current_function_->local_var_decls) {
+                for (auto& v : current_function_->local_var_decls) {
                     auto* in_node = CreateNode({NameFor(v), "_value_forloop_in"});
                     in_node->AddEdge(current_function_->variables.Get(v));
                     info.var_in_nodes.Replace(v, in_node);
@@ -796,8 +796,8 @@
                     cf_start = cf_condition_end;
 
                     // Propagate assignments to the loop exit nodes.
-                    for (auto* var : current_function_->local_var_decls) {
-                        auto* exit_node = info.var_exit_nodes.GetOrCreate(var, [&] {
+                    for (auto& var : current_function_->local_var_decls) {
+                        auto* exit_node = info.var_exit_nodes.GetOrAdd(var, [&] {
                             auto name = NameFor(var);
                             return CreateNode({name, "_value_", info.type, "_exit"});
                         });
@@ -816,7 +816,7 @@
                 cfx->AddEdge(cf);
 
                 // Add edges from variable loop input nodes to their values at the end of the loop.
-                for (auto v : info.var_in_nodes) {
+                for (auto& v : info.var_in_nodes) {
                     auto* in_node = v.value;
                     auto* out_node = current_function_->variables.Get(v.key);
                     if (out_node != in_node) {
@@ -825,7 +825,7 @@
                 }
 
                 // Set each variable's exit node as its value in the outer scope.
-                for (auto v : info.var_exit_nodes) {
+                for (auto& v : info.var_exit_nodes) {
                     current_function_->variables.Set(v.key, v.value);
                 }
 
@@ -855,7 +855,7 @@
                 info.type = "whileloop";
 
                 // Create input nodes for any variables declared before this loop.
-                for (auto* v : current_function_->local_var_decls) {
+                for (auto& v : current_function_->local_var_decls) {
                     auto* in_node = CreateNode({NameFor(v), "_value_forloop_in"});
                     in_node->AddEdge(current_function_->variables.Get(v));
                     info.var_in_nodes.Replace(v, in_node);
@@ -872,8 +872,8 @@
                 }
 
                 // Propagate assignments to the loop exit nodes.
-                for (auto* var : current_function_->local_var_decls) {
-                    auto* exit_node = info.var_exit_nodes.GetOrCreate(var, [&] {
+                for (auto& var : current_function_->local_var_decls) {
+                    auto* exit_node = info.var_exit_nodes.GetOrAdd(var, [&] {
                         auto name = NameFor(var);
                         return CreateNode({name, "_value_", info.type, "_exit"});
                     });
@@ -951,7 +951,7 @@
                 }
 
                 // Update values for any variables assigned in the if or else blocks.
-                for (auto* var : current_function_->local_var_decls) {
+                for (auto& var : current_function_->local_var_decls) {
                     // Skip variables not assigned in either block.
                     if (!true_vars.Contains(var) && !false_vars.Contains(var)) {
                         continue;
@@ -964,14 +964,14 @@
                     // Only add edges if the behavior for that block contains 'Next'.
                     if (true_has_next) {
                         if (true_vars.Contains(var)) {
-                            out_node->AddEdge(*true_vars.Find(var));
+                            out_node->AddEdge(*true_vars.Get(var));
                         } else {
                             out_node->AddEdge(current_function_->variables.Get(var));
                         }
                     }
                     if (false_has_next) {
                         if (false_vars.Contains(var)) {
-                            out_node->AddEdge(*false_vars.Find(var));
+                            out_node->AddEdge(*false_vars.Get(var));
                         } else {
                             out_node->AddEdge(current_function_->variables.Get(var));
                         }
@@ -1022,7 +1022,7 @@
                 info.type = "loop";
 
                 // Create input nodes for any variables declared before this loop.
-                for (auto* v : current_function_->local_var_decls) {
+                for (auto& v : current_function_->local_var_decls) {
                     auto name = NameFor(v);
                     auto* in_node = CreateNode({name, "_value_loop_in"}, v->Declaration());
                     in_node->AddEdge(current_function_->variables.Get(v));
@@ -1112,7 +1112,7 @@
 
                     if (sem_case->Behaviors().Contains(sem::Behavior::kNext)) {
                         // Propagate variable values to the switch exit nodes.
-                        for (auto* var : current_function_->local_var_decls) {
+                        for (auto& var : current_function_->local_var_decls) {
                             // Skip variables that were declared inside the switch.
                             if (auto* lv = var->As<sem::LocalVariable>();
                                 lv && lv->Statement()->FindFirstParent(
@@ -1121,7 +1121,7 @@
                             }
 
                             // Add an edge from the variable exit node to its new value.
-                            auto* exit_node = info.var_exit_nodes.GetOrCreate(var, [&] {
+                            auto* exit_node = info.var_exit_nodes.GetOrAdd(var, [&] {
                                 auto name = NameFor(var);
                                 return CreateNode({name, "_value_", info.type, "_exit"});
                             });
@@ -1637,11 +1637,11 @@
             [&](const sem::Function* func) {
                 // We must have already analyzed the user-defined function since we process
                 // functions in dependency order.
-                auto info = functions_.Find(func->Declaration());
-                TINT_ASSERT(info != nullptr);
+                auto info = functions_.Get(func->Declaration());
+                TINT_ASSERT(info);
                 callsite_tag = info->callsite_tag;
                 function_tag = info->function_tag;
-                func_info = info;
+                func_info = info.value;
             },
             [&](const sem::ValueConstructor*) {
                 callsite_tag = {CallSiteTag::CallSiteNoRestriction};
@@ -1798,7 +1798,7 @@
         } else if (auto* user = target->As<sem::Function>()) {
             // This is a call to a user-defined function, so inspect the functions called by that
             // function and look for one whose node has an edge from the RequiredToBeUniform node.
-            auto target_info = functions_.Find(user->Declaration());
+            auto target_info = functions_.Get(user->Declaration());
             for (auto* call_node : target_info->RequiredToBeUniform(severity)->edges) {
                 if (call_node->type == Node::kRegular) {
                     auto* child_call = call_node->ast->As<ast::CallExpression>();
@@ -1983,7 +1983,7 @@
             auto* user_func = target->As<sem::Function>();
             if (user_func) {
                 // Recurse into the called function to show the reason for the requirement.
-                auto next_function = functions_.Find(user_func->Declaration());
+                auto next_function = functions_.Get(user_func->Declaration());
                 auto& param_info = next_function->parameters[cause->arg_index];
                 MakeError(*next_function,
                           is_value ? param_info.value : param_info.ptr_input_contents, severity);
diff --git a/src/tint/lang/wgsl/resolver/validator.cc b/src/tint/lang/wgsl/resolver/validator.cc
index 0201bb4..6e0413c 100644
--- a/src/tint/lang/wgsl/resolver/validator.cc
+++ b/src/tint/lang/wgsl/resolver/validator.cc
@@ -802,7 +802,7 @@
     }
 
     if (auto id = v->Attributes().override_id) {
-        if (auto var = override_ids.Find(*id); var && *var != v) {
+        if (auto var = override_ids.Get(*id); var && *var != v) {
             auto* attr = ast::GetAttribute<ast::IdAttribute>(v->Declaration()->attributes);
             AddError("@id values must be unique", attr->source);
             AddNote("a override with an ID of " + std::to_string(id->value) +
@@ -1485,7 +1485,7 @@
             !added &&
             IsValidationEnabled(decl->attributes,
                                 ast::DisabledValidation::kBindingPointCollision) &&
-            IsValidationEnabled((*added.value)->attributes,
+            IsValidationEnabled(added.value->attributes,
                                 ast::DisabledValidation::kBindingPointCollision)) {
             // https://gpuweb.github.io/gpuweb/wgsl/#resource-interface
             // Bindings must not alias within a shader stage: two different variables in the
@@ -1497,7 +1497,7 @@
                     "' references multiple variables that use the same resource binding @group(" +
                     std::to_string(bp->group) + "), @binding(" + std::to_string(bp->binding) + ")",
                 var_decl->source);
-            AddNote("first resource binding usage declared here", (*added.value)->source);
+            AddNote("first resource binding usage declared here", added.value->source);
             return false;
         }
     }
@@ -2524,7 +2524,7 @@
                                   : std::to_string(value)) +
                              "'",
                          selector->Declaration()->source);
-                AddNote("previous case declared here", *added.value);
+                AddNote("previous case declared here", added.value);
                 return false;
             }
         }
@@ -2686,7 +2686,7 @@
             auto added = seen.Add(&d->TypeInfo(), d->source);
             if (!added && !d->Is<ast::InternalAttribute>()) {
                 AddError("duplicate " + d->Name() + " attribute", d->source);
-                AddNote("first attribute declared here", *added.value);
+                AddNote("first attribute declared here", added.value);
                 return false;
             }
         }
@@ -2704,7 +2704,7 @@
         auto name = dc->rule_name->name->symbol;
 
         auto diag_added = diagnostics.Add(std::make_pair(category, name), dc);
-        if (!diag_added && (*diag_added.value)->severity != dc->severity) {
+        if (!diag_added && diag_added.value->severity != dc->severity) {
             {
                 StringStream ss;
                 ss << "conflicting diagnostic " << use;
@@ -2714,7 +2714,7 @@
                 StringStream ss;
                 ss << "severity of '" << dc->rule_name->String() << "' set to '" << dc->severity
                    << "' here";
-                AddNote(ss.str(), (*diag_added.value)->rule_name->source);
+                AddNote(ss.str(), diag_added.value->rule_name->source);
             }
             return false;
         }
diff --git a/src/tint/lang/wgsl/wgsl.def b/src/tint/lang/wgsl/wgsl.def
index e23de8a..3e3282c 100644
--- a/src/tint/lang/wgsl/wgsl.def
+++ b/src/tint/lang/wgsl/wgsl.def
@@ -736,7 +736,7 @@
 @stage("fragment", "compute") fn atomicCompareExchangeWeak<T: iu32, S: workgroup_or_storage>(ptr<S, atomic<T>, read_write>, T, T) -> __atomic_compare_exchange_result<T>
 
 @must_use @stage("compute") fn subgroupBallot() -> vec4<u32>
-@must_use @stage("compute") fn subgroupBroadcast<T: fiu32>(value: T, @const sourceLaneIndex: u32) -> T
+@must_use @stage("compute") fn subgroupBroadcast<T: fiu32_f16>(value: T, @const sourceLaneIndex: u32) -> T
 
 ////////////////////////////////////////////////////////////////////////////////
 // Value constructors                                                         //
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
index c6498a1..028fee4 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
@@ -886,7 +886,7 @@
                 return {Constant(c), PtrKind::kRef};
             },
             [&](Default) -> ExprAndPtrKind {
-                auto lookup = bindings_.Find(value);
+                auto lookup = bindings_.Get(value);
                 if (TINT_UNLIKELY(!lookup)) {
                     TINT_ICE() << "Expr(" << (value ? value->TypeInfo().name : "null")
                                << ") value has no expression";
@@ -1064,7 +1064,7 @@
     }
 
     ast::Type Struct(const core::type::Struct* s) {
-        auto n = structs_.GetOrCreate(s, [&] {
+        auto n = structs_.GetOrAdd(s, [&] {
             auto members = tint::Transform<8>(s->Members(), [&](const core::type::StructMember* m) {
                 auto ty = Type(m->Type());
                 const auto& ir_attrs = m->Attributes();
@@ -1125,7 +1125,7 @@
     /// @returns the AST name for the given value, creating and returning a new name on the first
     /// call.
     Symbol NameFor(const core::ir::Value* value, std::string_view suggested = {}) {
-        return names_.GetOrCreate(value, [&] {
+        return names_.GetOrAdd(value, [&] {
             if (!suggested.empty()) {
                 return b.Symbols().Register(suggested);
             }
diff --git a/src/tint/lang/wgsl/writer/raise/rename_conflicts.cc b/src/tint/lang/wgsl/writer/raise/rename_conflicts.cc
index f54efd1..a6072ed 100644
--- a/src/tint/lang/wgsl/writer/raise/rename_conflicts.cc
+++ b/src/tint/lang/wgsl/writer/raise/rename_conflicts.cc
@@ -241,13 +241,13 @@
     void EnsureResolvesTo(std::string_view identifier, const CastableBase* thing) {
         for (auto& scope : tint::Reverse(scopes)) {
             if (auto decl = scope.Get(identifier)) {
-                if (decl.value() == thing) {
+                if (*decl == thing) {
                     return;  // Resolved to the right thing.
                 }
 
                 // Operand is shadowed
                 scope.Remove(identifier);
-                Rename(decl.value(), identifier);
+                Rename(*decl, identifier);
             }
         }
     }
@@ -257,7 +257,7 @@
     /// renamed.
     void Declare(Scope& scope, CastableBase* thing, std::string_view name) {
         auto add = scope.Add(name, thing);
-        if (!add && *add.value != thing) {
+        if (!add && add.value != thing) {
             // Multiple declarations with the same name in the same scope.
             // Rename the later declaration.
             Rename(thing, name);
diff --git a/src/tint/utils/cli/cli.cc b/src/tint/utils/cli/cli.cc
index 557d8bc..b6dc911 100644
--- a/src/tint/utils/cli/cli.cc
+++ b/src/tint/utils/cli/cli.cc
@@ -169,7 +169,7 @@
             unconsumed.Push(arg);
             continue;
         }
-        if (auto opt = options_by_name.Find(name)) {
+        if (auto opt = options_by_name.Get(name)) {
             if (auto err = (*opt)->Parse(arguments); !err.empty()) {
                 return Failure{err};
             }
diff --git a/src/tint/utils/containers/hashmap.h b/src/tint/utils/containers/hashmap.h
index 1b1a465..58f653d 100644
--- a/src/tint/utils/containers/hashmap.h
+++ b/src/tint/utils/containers/hashmap.h
@@ -39,128 +39,215 @@
 
 namespace tint {
 
-/// An unordered map that uses a robin-hood hashing algorithm.
+/// HashmapEntry is a key-value pair used by Hashmap as the Entry datatype.
+template <typename KEY, typename VALUE>
+struct HashmapEntry {
+    /// The key type
+    using Key = KEY;
+    /// The value type
+    using Value = VALUE;
+
+    /// @param entry a HashmapEntry
+    /// @return `entry.key`
+    static const Key& KeyOf(const HashmapEntry& entry) { return entry.key; }
+
+    /// The key
+    Key key;
+
+    /// The value
+    Value value;
+};
+
+/// Equality operator for HashmapEntry
+/// @param lhs the LHS HashmapEntry
+/// @param rhs the RHS HashmapEntry
+/// @return true if both entries have equal keys and values.
+template <typename K1, typename V1, typename K2, typename V2>
+inline static bool operator==(const HashmapEntry<K1, V1>& lhs, const HashmapEntry<K2, V2>& rhs) {
+    return lhs.key == rhs.key && lhs.value == rhs.value;
+}
+
+/// Writes the HashmapEntry to the stream.
+/// @param out the stream to write to
+/// @param key_value the HashmapEntry to write
+/// @returns out so calls can be chained
+template <typename STREAM,
+          typename KEY,
+          typename VALUE,
+          typename = traits::EnableIfIsOStream<STREAM>>
+auto& operator<<(STREAM& out, const HashmapEntry<KEY, VALUE>& key_value) {
+    return out << "[" << key_value.key << ": " << key_value.value << "]";
+}
+
+/// The return value of Hashmap::Get(Key).
+/// GetResult supports equality operators and acts similarly to std::optional, but does not make a
+/// copy.
+template <typename T>
+struct GetResult {
+    /// The value found in the map, or null if the entry was not found.
+    /// This pointer is guaranteed to be valid until the owning entry is removed, the map is
+    /// cleared, or the map is destructed.
+    T* value = nullptr;
+
+    /// @returns `true` if #value is not null.
+    operator bool() const { return value; }
+
+    /// @returns the dereferenced value, which must not be null.
+    T& operator*() const { return *value; }
+
+    /// @returns the pointer to the value, which must not be null.
+    T* operator->() const { return value; }
+
+    /// @param other the value to compare against the object that #value points to.
+    /// @returns true if #value is not null and the object that #value points to is equal to @p
+    /// other.
+    template <typename O>
+    bool operator==(const O& other) const {
+        return value && *value == other;
+    }
+
+    /// @param other the value to compare against the object that #value points to.
+    /// @returns true if #value is null or the object that #value points to is not equal to @p
+    /// other.
+    template <typename O>
+    bool operator!=(const O& other) const {
+        return !value || *value != other;
+    }
+};
+
+/// The return value of Hashmap::Add(Key, Value)
+template <typename T>
+struct AddResult {
+    /// A reference to the value of the entry with the given key.
+    /// If an existing entry was found with the key, then this is the value of the existing entry,
+    /// otherwise the value of the newly inserted entry.
+    /// This reference is guaranteed to be valid until the owning entry is removed, the map is
+    /// cleared, or the map is destructed.
+    T& value;
+
+    /// True if an entry did not already exist in the map with the given key.
+    bool added = false;
+
+    /// @returns #added
+    operator bool() const { return added; }
+};
+
+/// An unordered hashmap, with a fixed-size capacity that avoids heap allocations.
 template <typename KEY,
           typename VALUE,
           size_t N,
           typename HASH = Hasher<KEY>,
           typename EQUAL = EqualTo<KEY>>
-class Hashmap : public HashmapBase<KEY, VALUE, N, HASH, EQUAL> {
-    using Base = HashmapBase<KEY, VALUE, N, HASH, EQUAL>;
-    using PutMode = typename Base::PutMode;
-
-    template <typename T>
-    using ReferenceKeyType = traits::CharArrayToCharPtr<std::remove_reference_t<T>>;
+class Hashmap : public HashmapBase<HashmapEntry<HashmapKey<KEY, HASH, EQUAL>, VALUE>, N> {
+    using Base = HashmapBase<HashmapEntry<HashmapKey<KEY, HASH, EQUAL>, VALUE>, N>;
 
   public:
     /// The key type
-    using Key = KEY;
+    using Key = typename Base::Key;
     /// The value type
     using Value = VALUE;
     /// The key-value type for a map entry
-    using Entry = KeyValue<Key, Value>;
+    using Entry = HashmapEntry<Key, Value>;
 
-    /// Result of Add()
-    using AddResult = typename Base::PutResult;
-
-    /// Reference is returned by Hashmap::Find(), and performs dynamic Hashmap lookups.
-    /// The value returned by the Reference reflects the current state of the Hashmap, and so the
-    /// referenced value may change, or transition between valid or invalid based on the current
-    /// state of the Hashmap.
-    template <bool IS_CONST, typename K>
-    class ReferenceT {
-        /// `const Value` if IS_CONST, or `Value` if !IS_CONST
-        using T = std::conditional_t<IS_CONST, const Value, Value>;
-
-        /// `const Hashmap` if IS_CONST, or `Hashmap` if !IS_CONST
-        using Map = std::conditional_t<IS_CONST, const Hashmap, Hashmap>;
-
-      public:
-        /// @returns true if the reference is valid.
-        operator bool() const { return Get() != nullptr; }
-
-        /// @returns the pointer to the Value, or nullptr if the reference is invalid.
-        operator T*() const { return Get(); }
-
-        /// @returns the pointer to the Value
-        /// @warning if the Hashmap does not contain a value for the reference, then this will
-        /// trigger a TINT_ASSERT, or invalid pointer dereference.
-        T* operator->() const {
-            auto* hashmap_reference_lookup = Get();
-            TINT_ASSERT(hashmap_reference_lookup != nullptr);
-            return hashmap_reference_lookup;
-        }
-
-        /// @returns the pointer to the Value, or nullptr if the reference is invalid.
-        T* Get() const {
-            auto generation = map_.Generation();
-            if (generation_ != generation) {
-                cached_ = map_.Lookup(key_);
-                generation_ = generation;
-            }
-            return cached_;
-        }
-
-      private:
-        friend Hashmap;
-
-        /// Constructor
-        template <typename K_ARG>
-        ReferenceT(Map& map, K_ARG&& key)
-            : map_(map),
-              key_(std::forward<K_ARG>(key)),
-              cached_(nullptr),
-              generation_(map.Generation() - 1) {}
-
-        /// Constructor
-        template <typename K_ARG>
-        ReferenceT(Map& map, K_ARG&& key, T* value)
-            : map_(map),
-              key_(std::forward<K_ARG>(key)),
-              cached_(value),
-              generation_(map.Generation()) {}
-
-        Map& map_;
-        const K key_;
-        mutable T* cached_ = nullptr;
-        mutable size_t generation_ = 0;
-    };
-
-    /// A mutable reference returned by Find()
-    template <typename K>
-    using Reference = ReferenceT</*IS_CONST*/ false, K>;
-
-    /// An immutable reference returned by Find()
-    template <typename K>
-    using ConstReference = ReferenceT</*IS_CONST*/ true, K>;
-
-    /// Adds a value to the map, if the map does not already contain an entry with the key @p key.
-    /// @param key the entry key.
-    /// @param value the value of the entry to add to the map.
-    /// @returns A AddResult describing the result of the add
+    /// Add attempts to insert a new entry into the map.
+    /// If an existing entry exists with the given key, then the entry is not replaced.
+    /// @param key the new entry's key
+    /// @param value the new entry's value
+    /// @return an AddResult.
     template <typename K, typename V>
-    AddResult Add(K&& key, V&& value) {
-        return this->template Put<PutMode::kAdd>(std::forward<K>(key), std::forward<V>(value));
+    AddResult<Value> Add(K&& key, V&& value) {
+        if (auto idx = this->EditAt(key); idx.entry) {
+            return {idx.entry->value, /* added */ false};
+        } else {
+            idx.Insert(std::forward<K>(key), std::forward<V>(value));
+            return {idx.entry->value, /* added */ true};
+        }
     }
 
-    /// Adds a new entry to the map, replacing any entry that has a key equal to @p key.
-    /// @param key the entry key.
-    /// @param value the value of the entry to add to the map.
-    /// @returns A AddResult describing the result of the replace
+    /// Inserts a new entry into the map or updates an existing entry.
+    /// @param key the new entry's key
+    /// @param value the new entry's value
     template <typename K, typename V>
-    AddResult Replace(K&& key, V&& value) {
-        return this->template Put<PutMode::kReplace>(std::forward<K>(key), std::forward<V>(value));
+    void Replace(K&& key, V&& value) {
+        if (auto idx = this->EditAt(key); idx.entry) {
+            idx.Replace(std::forward<K>(key), std::forward<V>(value));
+        } else {
+            idx.Insert(std::forward<K>(key), std::forward<V>(value));
+        }
     }
 
-    /// @param key the key to search for.
-    /// @returns the value of the entry that is equal to `value`, or no value if the entry was not
-    ///          found.
+    /// Looks up an entry with the given key.
+    /// @param key the entry's key to search for.
+    /// @returns a GetResult holding the found entry's value, or null if the entry was not found.
     template <typename K>
-    std::optional<Value> Get(K&& key) const {
-        if (auto [found, index] = this->IndexOf(key); found) {
-            return this->slots_[index].entry->value;
+    GetResult<Value> Get(K&& key) {
+        if (auto* entry = this->GetEntry(key)) {
+            return {&entry->value};
         }
-        return std::nullopt;
+        return {nullptr};
+    }
+
+    /// Looks up an entry with the given key.
+    /// @param key the entry's key to search for.
+    /// @returns a GetResult holding the found entry's value, or null if the entry was not found.
+    template <typename K>
+    GetResult<const Value> Get(K&& key) const {
+        if (auto* entry = this->GetEntry(key)) {
+            return {&entry->value};
+        }
+        return {nullptr};
+    }
+
+    /// Searches for an entry with the given key value returning that value if found, otherwise
+    /// returns @p not_found.
+    /// @param key the entry's key value to search for.
+    /// @param not_found the value to return if a node is not found.
+    /// @returns the a reference to the value of the entry, if found otherwise @p not_found.
+    /// @note The returned reference is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
+    template <typename K>
+    const Value& GetOr(K&& key, const Value& not_found) const {
+        if (auto* entry = this->GetEntry(key)) {
+            return entry->value;
+        }
+        return not_found;
+    }
+
+    /// Searches for an entry with the given key, returning a reference to that entry if found,
+    /// otherwise a reference to a newly added entry with the key @p key and the value from calling
+    /// @p create.
+    /// @note: Before calling `create`, the map will insert a zero-initialized value for the given
+    /// key, which will be replaced with the value returned by @p create. If @p create adds an entry
+    /// with @p key to this map, it will be replaced.
+    /// @param key the entry's key value to search for.
+    /// @param create the create function to call if the map does not contain the key. Must have the
+    /// signature `Key()`.
+    /// @returns a reference to the existing entry, or the newly added entry.
+    /// @note The returned reference is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
+    template <typename K, typename CREATE>
+    Entry& GetOrAddEntry(K&& key, CREATE&& create) {
+        auto idx = this->EditAt(key);
+        if (!idx.entry) {
+            idx.Insert(std::forward<K>(key), Value{});
+            idx.entry->value = create();
+        }
+        return *idx.entry;
+    }
+
+    /// Searches for an entry with the given key, returning a reference to that entry if found,
+    /// otherwise a reference to a newly added entry with the key @p key and a zero value.
+    /// @param key the entry's key value to search for.
+    /// @returns a reference to the existing entry, or the newly added entry.
+    /// @note The returned reference is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
+    template <typename K>
+    Entry& GetOrAddZeroEntry(K&& key) {
+        auto idx = this->EditAt(key);
+        if (!idx.entry) {
+            idx.Insert(std::forward<K>(key), Value{});
+        }
+        return *idx.entry;
     }
 
     /// Searches for an entry with the given key, adding and returning the result of calling
@@ -171,58 +258,32 @@
     /// @param key the entry's key value to search for.
     /// @param create the create function to call if the map does not contain the key.
     /// @returns the value of the entry.
+    /// @note The returned reference is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
     template <typename K, typename CREATE>
-    Value& GetOrCreate(K&& key, CREATE&& create) {
-        auto res = Add(std::forward<K>(key), Value{});
-        if (res.action == MapAction::kAdded) {
-            // Store the map generation before calling create()
-            auto generation = this->Generation();
-            // Call create(), which might modify this map.
-            auto value = create();
-            // Was this map mutated?
-            if (this->Generation() == generation) {
-                // Calling create() did not touch the map. No need to lookup again.
-                *res.value = std::move(value);
-            } else {
-                // Calling create() modified the map. Need to insert again.
-                res = Replace(key, std::move(value));
-            }
-        }
-        return *res.value;
+    Value& GetOrAdd(K&& key, CREATE&& create) {
+        return GetOrAddEntry(std::forward<K>(key), std::forward<CREATE>(create)).value;
     }
 
     /// Searches for an entry with the given key value, adding and returning a newly created
     /// zero-initialized value if the entry was not found.
     /// @param key the entry's key value to search for.
     /// @returns the value of the entry.
+    /// @note The returned reference is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
     template <typename K>
-    auto GetOrZero(K&& key) {
-        auto res = Add(std::forward<K>(key), Value{});
-        return Reference<ReferenceKeyType<K>>(*this, key, res.value);
-    }
-
-    /// @param key the key to search for.
-    /// @returns a reference to the entry that is equal to the given value.
-    template <typename K>
-    auto Find(K&& key) {
-        return Reference<ReferenceKeyType<K>>(*this, std::forward<K>(key));
-    }
-
-    /// @param key the key to search for.
-    /// @returns a reference to the entry that is equal to the given value.
-    template <typename K>
-    auto Find(K&& key) const {
-        return ConstReference<ReferenceKeyType<K>>(*this, std::forward<K>(key));
+    Value& GetOrAddZero(K&& key) {
+        return GetOrAddZeroEntry(std::forward<K>(key)).value;
     }
 
     /// @returns the keys of the map as a vector.
     /// @note the order of the returned vector is non-deterministic between compilers.
     template <size_t N2 = N>
-    Vector<Key, N2> Keys() const {
-        Vector<Key, N2> out;
+    Vector<KEY, N2> Keys() const {
+        Vector<KEY, N2> out;
         out.Reserve(this->Count());
-        for (auto it : *this) {
-            out.Push(it.key);
+        for (auto& it : *this) {
+            out.Push(it.key.Value());
         }
         return out;
     }
@@ -233,7 +294,7 @@
     Vector<Value, N2> Values() const {
         Vector<Value, N2> out;
         out.Reserve(this->Count());
-        for (auto it : *this) {
+        for (auto& it : *this) {
             out.Push(it.value);
         }
         return out;
@@ -247,8 +308,8 @@
         if (this->Count() != other.Count()) {
             return false;
         }
-        for (auto it : *this) {
-            auto other_val = other.Find(it.key);
+        for (auto& it : *this) {
+            auto other_val = other.Get(it.key.Value());
             if (!other_val || it.value != *other_val) {
                 return false;
             }
@@ -263,23 +324,6 @@
     bool operator!=(const Hashmap<K, V, N2>& other) const {
         return !(*this == other);
     }
-
-  private:
-    template <typename K>
-    Value* Lookup(K&& key) {
-        if (auto [found, index] = this->IndexOf(key); found) {
-            return &this->slots_[index].entry->value;
-        }
-        return nullptr;
-    }
-
-    template <typename K>
-    const Value* Lookup(K&& key) const {
-        if (auto [found, index] = this->IndexOf(key); found) {
-            return &this->slots_[index].entry->value;
-        }
-        return nullptr;
-    }
 };
 
 /// Hasher specialization for Hashmap
@@ -292,12 +336,37 @@
         for (auto it : map) {
             // Use an XOR to ensure that the non-deterministic ordering of the map still produces
             // the same hash value for the same entries.
-            hash ^= Hash(it.key, it.value);
+            hash ^= Hash(it.key.Value(), it.value);
         }
         return hash;
     }
 };
 
+/// Writes the Hashmap to the stream.
+/// @param out the stream to write to
+/// @param map the Hashmap to write
+/// @returns out so calls can be chained
+template <typename STREAM,
+          typename KEY,
+          typename VALUE,
+          size_t N,
+          typename HASH,
+          typename EQUAL,
+          typename = traits::EnableIfIsOStream<STREAM>>
+auto& operator<<(STREAM& out, const Hashmap<KEY, VALUE, N, HASH, EQUAL>& map) {
+    out << "Hashmap{";
+    bool first = true;
+    for (auto it : map) {
+        if (!first) {
+            out << ", ";
+        }
+        first = false;
+        out << it;
+    }
+    out << "}";
+    return out;
+}
+
 }  // namespace tint
 
 #endif  // SRC_TINT_UTILS_CONTAINERS_HASHMAP_H_
diff --git a/src/tint/utils/containers/hashmap_base.h b/src/tint/utils/containers/hashmap_base.h
index 81141ba..1697959 100644
--- a/src/tint/utils/containers/hashmap_base.h
+++ b/src/tint/utils/containers/hashmap_base.h
@@ -37,271 +37,361 @@
 #include "src/tint/utils/containers/vector.h"
 #include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
+#include "src/tint/utils/math/math.h"
 #include "src/tint/utils/traits/traits.h"
 
-#define TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-
 namespace tint {
 
-/// Action taken by a map mutation
-enum class MapAction {
-    /// A new entry was added to the map
-    kAdded,
-    /// A existing entry in the map was replaced
-    kReplaced,
-    /// No action was taken as the map already contained an entry with the given key
-    kKeptExisting,
-};
+/// HashmapKey wraps the comparator type for a Hashmap and Hashset.
+/// HashmapKey acts like a read-only `T`, but can be reassigned so long as the value is equivalent.
+/// @tparam T the key comparator type.
+/// @tparam HASH the hash function for the key type.
+/// @tparam EQUAL the equality function for the key type.
+template <typename T, typename HASH = Hasher<T>, typename EQUAL = std::equal_to<T>>
+class HashmapKey {
+    T value_;
 
-/// KeyValue is a key-value pair.
-template <typename KEY, typename VALUE>
-struct KeyValue {
-    /// The key type
-    using Key = KEY;
-    /// The value type
-    using Value = VALUE;
+  public:
+    /// Key is an alias to this templated class.
+    using Key = HashmapKey<T, HASH, EQUAL>;
+    /// Hash is an alias to the hash function for the key type.
+    using Hash = HASH;
+    /// Equal is an alias to the equality function for the key type.
+    using Equal = EQUAL;
 
-    /// The key
-    Key key;
+    /// KeyOf() returns @p key, so a HashmapKey can be used as the entry type for a Hashset.
+    /// @param key the HashmapKey
+    /// @return @p key
+    static const Key& KeyOf(const Key& key) { return key; }
 
-    /// The value
-    Value value;
+    /// Constructor using copied value.
+    /// @param value the key value.
+    HashmapKey(const T& value) : value_(value), hash(HASH{}(value_)) {}  // NOLINT
+
+    /// Constructor using moved value.
+    /// @param value the key value.
+    HashmapKey(T&& value) : value_(std::forward<T>(value)), hash(HASH{}(value_)) {}  // NOLINT
+
+    /// Constructor using pre-computed hash and copied value.
+    /// @param hash_ the precomputed hash of @p value
+    /// @param value the key value
+    HashmapKey(size_t hash_, const T& value) : value_(value), hash(hash_) {}
+
+    /// Constructor using pre-computed hash and moved value.
+    /// @param hash_ the precomputed hash of @p value
+    /// @param value the key value
+    HashmapKey(size_t hash_, T&& value) : value_(std::forward<T>(value)), hash(hash_) {}
+
+    /// Copy constructor
+    HashmapKey(const HashmapKey&) = default;
+
+    /// Move constructor
+    HashmapKey(HashmapKey&&) = default;
+
+    /// Destructor
+    ~HashmapKey() = default;
+
+    /// Copy-assignment operator.
+    /// @note As a hashmap uses the HashmapKey for indexing, the new value *must* have the same hash
+    /// value and be equal to this key.
+    /// @param other the key to copy to this key.
+    /// @return this HashmapKey.
+    HashmapKey& operator=(const HashmapKey& other) {
+        TINT_ASSERT(*this == other);
+        value_ = other.Value();
+        return *this;
+    }
+
+    /// Move-assignment operator.
+    /// @note As a hashmap uses the HashmapKey for indexing, the new value *must* have the same hash
+    /// value and be equal to this key.
+    /// @param other the key to move to this key.
+    /// @return this HashmapKey.
+    HashmapKey& operator=(HashmapKey&& other) {
+        TINT_ASSERT(*this == other);
+        value_ = std::move(other.Value());
+        return *this;
+    }
 
     /// Equality operator
-    /// @param other the RHS of the operator
-    /// @returns true if both the key and value of this KeyValue are equal to the key and value
-    /// of @p other
-    template <typename K, typename V>
-    bool operator==(const KeyValue<K, V>& other) const {
-        return key == other.key && value == other.value;
+    /// @param other the other key.
+    /// @return true if the hash and value of @p other are equal to this key.
+    bool operator==(const HashmapKey& other) const {
+        return hash == other.hash && EQUAL{}(value_, other.Value());
     }
 
-    /// Inequality operator
-    /// @param other the RHS of the operator
-    /// @returns true if either the key and value of this KeyValue are not equal to the key and
-    /// value of @p other
-    template <typename K, typename V>
-    bool operator!=(const KeyValue<K, V>& other) const {
-        return *this != other;
+    /// Equality operator
+    /// @param other the other key.
+    /// @return true if the hash of other and value of @p other are equal to this key.
+    template <typename RHS>
+    bool operator==(const RHS& other) const {
+        return hash == HASH{}(other) && EQUAL{}(value_, other);
     }
+
+    /// @returns the value of the key
+    const T& Value() const { return value_; }
+
+    /// @returns the value of the key
+    operator const T&() const { return value_; }
+
+    /// @returns the pointer to the value, or the value itself if T is a pointer.
+    auto operator->() const {
+        if constexpr (std::is_pointer_v<T>) {
+            // operator-> is useless if the T is a pointer, so automatically unwrap a pointer.
+            return value_;
+        } else {
+            return &value_;
+        }
+    }
+
+    /// The hash of value
+    const size_t hash;
 };
 
-/// KeyValueRef is a pair of references to a key and value.
-/// #key is always a const reference.
-/// #value is always a const reference if @tparam VALUE_IS_CONST is true, otherwise a non-const
-/// reference.
-template <typename KEY, typename VALUE, bool VALUE_IS_CONST>
-struct KeyValueRef {
-    /// The reference to key type
-    using KeyRef = const KEY&;
-    /// The reference to value type
-    using ValueRef = std::conditional_t<VALUE_IS_CONST, const VALUE&, VALUE&>;
-
-    /// The reference to the key
-    KeyRef key;
-
-    /// The reference to the value
-    ValueRef value;
-
-    /// @returns a KeyValue<KEY, VALUE> with the referenced key and value
-    operator KeyValue<KEY, VALUE>() const { return {key, value}; }
-};
-
-/// Writes the KeyValue to the stream.
+/// Writes the HashmapKey to the stream.
 /// @param out the stream to write to
-/// @param key_value the KeyValue to write
+/// @param key the HashmapKey to write
 /// @returns out so calls can be chained
-template <typename STREAM,
-          typename KEY,
-          typename VALUE,
-          typename = traits::EnableIfIsOStream<STREAM>>
-auto& operator<<(STREAM& out, const KeyValue<KEY, VALUE>& key_value) {
-    return out << "[" << key_value.key << ": " << key_value.value << "]";
+template <typename STREAM, typename T, typename = traits::EnableIfIsOStream<STREAM>>
+auto& operator<<(STREAM& out, const HashmapKey<T>& key) {
+    if constexpr (traits::HasOperatorShiftLeft<STREAM, T>) {
+        return out << key.Value();
+    } else {
+        return out << "<hashmap-key>";
+    }
 }
 
-/// A base class for Hashmap and Hashset that uses a robin-hood hashing algorithm.
-/// @see the fantastic tutorial: https://programming.guide/robin-hood-hashing.html
-template <typename KEY,
-          typename VALUE,
-          size_t N,
-          typename HASH = Hasher<KEY>,
-          typename EQUAL = EqualTo<KEY>>
+/// HashmapBase is the base class for Hashmap and Hashset.
+/// @tparam ENTRY is the single record in the map. The entry type must alias 'Key' to the HashmapKey
+/// type, and implement the method `static HashmapKey<...> KeyOf(ENTRY)` to return the key for the
+/// entry.
+template <typename ENTRY, size_t N>
 class HashmapBase {
-    static constexpr bool ValueIsVoid = std::is_same_v<VALUE, void>;
+  protected:
+    struct Node;
+    struct Slot;
 
   public:
-    /// The key type
-    using Key = KEY;
-    /// The value type
-    using Value = VALUE;
-    /// The entry type for the map.
-    /// This is:
-    /// - Key when Value is void (used by Hashset)
-    /// - KeyValue<Key, Value> when Value is not void (used by Hashmap)
-    using Entry = std::conditional_t<ValueIsVoid, Key, KeyValue<Key, Value>>;
+    /// Entry is the type of a single record in the hashmap.
+    using Entry = ENTRY;
+    /// Key is the HashmapKey type used to find entries.
+    using Key = typename Entry::Key;
+    /// Hash is the
+    using Hash = typename Key::Hash;
+    /// Equal is the
+    using Equal = typename Key::Equal;
 
-    /// A reference to an entry in the map.
-    /// This is:
-    /// - const Key& when Value is void (used by Hashset)
-    /// - KeyValueRef<Key, Value> when Value is not void (used by Hashmap)
-    template <bool IS_CONST>
-    using EntryRef = std::conditional_t<
-        ValueIsVoid,
-        const Key&,
-        KeyValueRef<Key, std::conditional_t<ValueIsVoid, bool, Value>, IS_CONST>>;
+    /// The minimum capacity of the map.
+    static constexpr size_t kMinCapacity = std::max<size_t>(N, 8);
 
-    /// STL-friendly alias to Entry. Used by gmock.
-    using value_type = Entry;
+    /// The target number of slots, expressed as a fractional percentage of the map capacity.
+    /// e.g. a kLoadFactor of 75, would mean a target slots count of (0.75 * capacity).
+    static constexpr size_t kLoadFactor = 75;
 
-  private:
-    /// @returns the key from an entry
-    static const Key& KeyOf(const Entry& entry) {
-        if constexpr (ValueIsVoid) {
-            return entry;
-        } else {
-            return entry.key;
+    /// @param capacity the capacity of the map, as total number of entries.
+    /// @returns the target slot vector size to hold @p capacity map entries.
+    static constexpr size_t NumSlots(size_t capacity) {
+        return (std::max<size_t>(capacity, kMinCapacity) * kLoadFactor) / 100;
+    }
+
+    /// Constructor.
+    /// Constructs an empty map.
+    HashmapBase() {
+        slots_.Resize(slots_.Capacity());
+        for (auto& node : fixed_) {
+            free_.Add(&node);
         }
     }
 
-    /// @returns a pointer to the value from an entry.
-    static Value* ValueOf(Entry& entry) {
-        if constexpr (ValueIsVoid) {
-            return nullptr;  // Hashset only has keys
-        } else {
-            return &entry.value;
+    /// Copy constructor.
+    /// Constructs a map with a copy of @p other.
+    /// @param other the map to copy.
+    HashmapBase(const HashmapBase& other) : HashmapBase() {
+        if (&other != this) {
+            Copy(other);
         }
     }
 
-    /// A slot is a single entry in the underlying vector.
-    /// A slot can either be empty or filled with a value. If the slot is empty, #hash and #distance
-    /// will be zero.
-    struct Slot {
-        template <typename K>
-        bool Equals(size_t key_hash, K&& key) const {
-            return key_hash == hash && EQUAL()(std::forward<K>(key), KeyOf(*entry));
+    /// Move constructor.
+    /// Constructs a map with the moved entries of @p other.
+    /// @param other the map to move.
+    HashmapBase(HashmapBase&& other) : HashmapBase() {
+        if (&other != this) {
+            Move(std::move(other));
         }
+    }
 
-        /// The slot value. If this does not contain a value, then the slot is vacant.
-        std::optional<Entry> entry;
-        /// The precomputed hash of value.
-        size_t hash = 0;
-        size_t distance = 0;
-    };
-
-    /// The target length of the underlying vector length in relation to the number of entries in
-    /// the map, expressed as a percentage. For example a value of `150` would mean there would be
-    /// at least 50% more slots than the number of map entries.
-    static constexpr size_t kRehashFactor = 150;
-
-    /// @returns the target slot vector size to hold `n` map entries.
-    static constexpr size_t NumSlots(size_t count) { return (count * kRehashFactor) / 100; }
-
-    /// The fixed-size slot vector length, based on N and kRehashFactor.
-    static constexpr size_t kNumFixedSlots = NumSlots(N);
-
-    /// The minimum number of slots for the map.
-    static constexpr size_t kMinSlots = std::max<size_t>(kNumFixedSlots, 4);
-
-  public:
-    /// Iterator for entries in the map.
-    /// Iterators are invalidated if the map is modified.
-    template <bool IS_CONST>
-    class IteratorT {
-      public:
-        /// @returns the value pointed to by this iterator
-        EntryRef<IS_CONST> operator->() const {
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(map.Generation() == initial_generation &&
-                        "iterator invalidated by container modification");
-#endif
-            return *this;
-        }
-
-        /// @returns a reference to the value at the iterator
-        EntryRef<IS_CONST> operator*() const {
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(map.Generation() == initial_generation &&
-                        "iterator invalidated by container modification");
-#endif
-            auto& ref = current->entry.value();
-            if constexpr (ValueIsVoid) {
-                return ref;
-            } else {
-                return {ref.key, ref.value};
+    /// Destructor.
+    ~HashmapBase() {
+        // Call the destructor on all entries in the map.
+        for (size_t slot_idx = 0; slot_idx < slots_.Length(); slot_idx++) {
+            auto* node = slots_[slot_idx].nodes;
+            while (node) {
+                auto next = node->next;
+                node->Destroy();
+                node = next;
             }
         }
+    }
+
+    /// Assignment operator.
+    /// Clears this map, and populates this map with a copy of @p other.
+    /// @param other the map to copy.
+    /// @returns this HashmapBase
+    HashmapBase& operator=(const HashmapBase& other) {
+        if (&other != this) {
+            Clear();
+            Copy(other);
+        }
+        return *this;
+    }
+
+    /// Move-assignment operator.
+    /// Clears this map, and populates this map with the moved entries of @p other.
+    /// @param other the map to move.
+    /// @returns this HashmapBase
+    HashmapBase& operator=(HashmapBase&& other) {
+        if (&other != this) {
+            Clear();
+            Move(std::move(other));
+        }
+        return *this;
+    }
+
+    /// @returns the number of entries in the map.
+    size_t Count() const { return count_; }
+
+    /// @returns true if the map holds no entries.
+    bool IsEmpty() const { return count_ == 0; }
+
+    /// Removes all the entries from the map.
+    /// @note the map's capacity is not reduced, as it is assumed that a reused map will likely fill
+    /// to a similar size as before.
+    void Clear() {
+        for (size_t slot_idx = 0; slot_idx < slots_.Length(); slot_idx++) {
+            auto* node = slots_[slot_idx].nodes;
+            while (node) {
+                auto next = node->next;
+                node->Destroy();
+                free_.Add(node);
+                node = next;
+            }
+            slots_[slot_idx].nodes = nullptr;
+        }
+    }
+
+    /// Ensures that the map can hold @p n entries without heap reallocation or rehashing.
+    /// @param n the number of entries to ensure can fit in the map without reallocation or
+    /// rehashing.
+    void Reserve(size_t n) {
+        if (n > capacity_) {
+            size_t count = n - capacity_;
+            free_.Allocate(count);
+            capacity_ += count;
+        }
+    }
+
+    /// Looks up an entry with the given key.
+    /// @param key the entry's key to search for.
+    /// @returns a pointer to the matching entry, or null if no entry was found.
+    /// @note The returned pointer is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
+    template <typename K>
+    Entry* GetEntry(K&& key) {
+        size_t hash = Hash{}(key);
+        auto& slot = slots_[hash % slots_.Length()];
+        return slot.Find(hash, key);
+    }
+
+    /// Looks up an entry with the given key.
+    /// @param key the entry's key to search for.
+    /// @returns a pointer to the matching entry, or null if no entry was found.
+    /// @note The returned pointer is guaranteed to be valid until the owning entry is removed,
+    /// the map is cleared, or the map is destructed.
+    template <typename K>
+    const Entry* GetEntry(K&& key) const {
+        size_t hash = Hash{}(key);
+        auto& slot = slots_[hash % slots_.Length()];
+        return slot.Find(hash, key);
+    }
+
+    /// @returns true if the map contains an entry with a key that matches @p key.
+    /// @param key the key to look for.
+    template <typename K = Key>
+    bool Contains(K&& key) const {
+        return GetEntry(key) != nullptr;
+    }
+
+    /// Removes an entry from the map that has a key which matches @p key.
+    /// @returns true if the entry was found and removed, otherwise false.
+    /// @param key the key to look for.
+    template <typename K = Key>
+    bool Remove(K&& key) {
+        size_t hash = Hash{}(key);
+        auto& slot = slots_[hash % slots_.Length()];
+        Node** edge = &slot.nodes;
+        for (auto* node = *edge; node; node = node->next) {
+            if (node->Equals(hash, key)) {
+                *edge = node->next;
+                node->Destroy();
+                free_.Add(node);
+                count_--;
+                return true;
+            }
+            edge = &node->next;
+        }
+        return false;
+    }
+
+    /// Iterator for entries in the map.
+    template <bool IS_CONST>
+    class IteratorT {
+      private:
+        using MAP = std::conditional_t<IS_CONST, const HashmapBase, HashmapBase>;
+        using NODE = std::conditional_t<IS_CONST, const Node, Node>;
+
+      public:
+        /// @returns the entry pointed to by this iterator
+        auto& operator->() { return node_->Entry(); }
+
+        /// @returns a reference to the entry at the iterator
+        auto& operator*() { return node_->Entry(); }
 
         /// Increments the iterator
         /// @returns this iterator
         IteratorT& operator++() {
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(map.Generation() == initial_generation &&
-                        "iterator invalidated by container modification");
-#endif
-            if (current == end) {
-                return *this;
-            }
-            ++current;
-            SkipToNextValue();
+            node_ = node_->next;
+            SkipEmptySlots();
             return *this;
         }
 
         /// Equality operator
         /// @param other the other iterator to compare this iterator to
         /// @returns true if this iterator is equal to other
-        bool operator==(const IteratorT& other) const {
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(map.Generation() == initial_generation &&
-                        "iterator invalidated by container modification");
-#endif
-            return current == other.current;
-        }
+        bool operator==(const IteratorT& other) const { return node_ == other.node_; }
 
         /// Inequality operator
         /// @param other the other iterator to compare this iterator to
         /// @returns true if this iterator is not equal to other
-        bool operator!=(const IteratorT& other) const {
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-            TINT_ASSERT(map.Generation() == initial_generation &&
-                        "iterator invalidated by container modification");
-#endif
-            return current != other.current;
-        }
+        bool operator!=(const IteratorT& other) const { return node_ != other.node_; }
 
       private:
         /// Friend class
         friend class HashmapBase;
 
-        using SLOT = std::conditional_t<IS_CONST, const Slot, Slot>;
-
-        IteratorT(VectorIterator<SLOT> c,
-                  VectorIterator<SLOT> e,
-                  [[maybe_unused]] const HashmapBase& m)
-            : current(std::move(c)),
-              end(std::move(e))
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-              ,
-              map(m),
-              initial_generation(m.Generation())
-#endif
-        {
-            SkipToNextValue();
+        IteratorT(MAP& map, size_t slot, NODE* node) : map_(map), slot_(slot), node_(node) {
+            SkipEmptySlots();
         }
 
-        /// Moves the iterator forward, stopping at the next slot that is not empty.
-        void SkipToNextValue() {
-            while (current != end && !current->entry.has_value()) {
-                ++current;
+        void SkipEmptySlots() {
+            while (!node_ && slot_ + 1 < map_.slots_.Length()) {
+                node_ = map_.slots_[++slot_].nodes;
             }
         }
 
-        VectorIterator<SLOT> current;  /// The slot the iterator is pointing to
-        VectorIterator<SLOT> end;      /// One past the last slot in the map
-
-#ifdef TINT_ASSERT_ITERATORS_NOT_INVALIDATED
-        const HashmapBase& map;     /// The hashmap that is being iterated over.
-        size_t initial_generation;  /// The generation ID when the iterator was created.
-#endif
+        MAP& map_;
+        size_t slot_ = 0;
+        NODE* node_ = nullptr;
     };
 
     /// An immutable key and mutable value iterator
@@ -310,342 +400,289 @@
     /// An immutable key and value iterator
     using ConstIterator = IteratorT</*IS_CONST*/ true>;
 
-    /// Constructor
-    HashmapBase() { slots_.Resize(kMinSlots); }
-
-    /// Copy constructor
-    /// @param other the other HashmapBase to copy
-    HashmapBase(const HashmapBase& other) = default;
-
-    /// Move constructor
-    /// @param other the other HashmapBase to move
-    HashmapBase(HashmapBase&& other) = default;
-
-    /// Destructor
-    ~HashmapBase() { Clear(); }
-
-    /// Copy-assignment operator
-    /// @param other the other HashmapBase to copy
-    /// @returns this so calls can be chained
-    HashmapBase& operator=(const HashmapBase& other) = default;
-
-    /// Move-assignment operator
-    /// @param other the other HashmapBase to move
-    /// @returns this so calls can be chained
-    HashmapBase& operator=(HashmapBase&& other) = default;
-
-    /// Removes all entries from the map.
-    void Clear() {
-        slots_.Clear();  // Destructs all entries
-        slots_.Resize(kMinSlots);
-        count_ = 0;
-        generation_++;
-    }
-
-    /// Removes an entry from the map.
-    /// @param key the entry key.
-    /// @returns true if an entry was removed.
-    bool Remove(const Key& key) {
-        const auto [found, start] = IndexOf(key);
-        if (!found) {
-            return false;
-        }
-
-        // Shuffle the entries backwards until we either find a free slot, or a slot that has zero
-        // distance.
-        Slot* prev = nullptr;
-
-        const auto count = slots_.Length();
-        for (size_t distance = 0, index = start; distance < count; distance++) {
-            auto& slot = slots_[index];
-            if (prev) {
-                // note: `distance == 0` also includes empty slots.
-                if (slot.distance == 0) {
-                    // Clear the previous slot, and stop shuffling.
-                    *prev = {};
-                    break;
-                }
-                // Shuffle the slot backwards.
-                prev->entry = std::move(slot.entry);
-                prev->hash = slot.hash;
-                prev->distance = slot.distance - 1;
-            }
-            prev = &slot;
-
-            index = (index == count - 1) ? 0 : index + 1;
-        }
-
-        // Entry was removed.
-        count_--;
-        generation_++;
-
-        return true;
-    }
-
-    /// Checks whether an entry exists in the map
-    /// @param key the key to search for.
-    /// @returns true if the map contains an entry with the given value.
-    bool Contains(const Key& key) const {
-        const auto [found, _] = IndexOf(key);
-        return found;
-    }
-
-    /// Pre-allocates memory so that the map can hold at least `capacity` entries.
-    /// @param capacity the new capacity of the map.
-    void Reserve(size_t capacity) {
-        // Calculate the number of slots required to hold `capacity` entries.
-        const size_t num_slots = std::max(NumSlots(capacity), kMinSlots);
-        if (slots_.Length() >= num_slots) {
-            // Already have enough slots.
-            return;
-        }
-
-        // Move all the values out of the map and into a vector.
-        Vector<Entry, N> entries;
-        entries.Reserve(count_);
-        for (auto& slot : slots_) {
-            if (slot.entry.has_value()) {
-                entries.Push(std::move(slot.entry.value()));
-            }
-        }
-
-        // Clear the map, grow the number of slots.
-        Clear();
-        slots_.Resize(num_slots);
-
-        // As the number of slots has grown, the slot indices will have changed from before, so
-        // re-add all the entries back into the map.
-        for (auto& entry : entries) {
-            if constexpr (ValueIsVoid) {
-                struct NoValue {};
-                Put<PutMode::kAdd>(std::move(entry), NoValue{});
-            } else {
-                Put<PutMode::kAdd>(std::move(entry.key), std::move(entry.value));
-            }
-        }
-    }
-
-    /// @returns the number of entries in the map.
-    size_t Count() const { return count_; }
-
-    /// @returns true if the map contains no entries.
-    bool IsEmpty() const { return count_ == 0; }
-
-    /// @returns a monotonic counter which is incremented whenever the map is mutated.
-    size_t Generation() const { return generation_; }
-
     /// @returns an immutable iterator to the start of the map.
-    ConstIterator begin() const { return ConstIterator{slots_.begin(), slots_.end(), *this}; }
+    ConstIterator begin() const { return ConstIterator{*this, 0, slots_.Front().nodes}; }
 
     /// @returns an immutable iterator to the end of the map.
-    ConstIterator end() const { return ConstIterator{slots_.end(), slots_.end(), *this}; }
+    ConstIterator end() const { return ConstIterator{*this, slots_.Length(), nullptr}; }
 
     /// @returns an iterator to the start of the map.
-    Iterator begin() { return Iterator{slots_.begin(), slots_.end(), *this}; }
+    Iterator begin() { return Iterator{*this, 0, slots_.Front().nodes}; }
 
     /// @returns an iterator to the end of the map.
-    Iterator end() { return Iterator{slots_.end(), slots_.end(), *this}; }
+    Iterator end() { return Iterator{*this, slots_.Length(), nullptr}; }
 
-    /// A debug function for checking that the map is in good health.
-    /// Asserts if the map is corrupted.
-    void ValidateIntegrity() const {
-        size_t num_alive = 0;
-        for (size_t slot_idx = 0; slot_idx < slots_.Length(); slot_idx++) {
-            const auto& slot = slots_[slot_idx];
-            if (slot.entry.has_value()) {
-                num_alive++;
-                auto const [index, hash] = Hash(KeyOf(*slot.entry));
-                TINT_ASSERT(hash == slot.hash);
-                TINT_ASSERT(slot_idx == Wrap(index + slot.distance));
-            }
-        }
-        TINT_ASSERT(num_alive == count_);
-    }
+    /// STL-friendly alias to Entry. Used by gmock.
+    using value_type = const Entry&;
 
   protected:
-    /// The behaviour of Put() when an entry already exists with the given key.
-    enum class PutMode {
-        /// Do not replace existing entries with the new value.
-        kAdd,
-        /// Replace existing entries with the new value.
-        kReplace,
-    };
-
-    /// Result of Put()
-    struct PutResult {
-        /// Whether the insert replaced or added a new entry to the map.
-        MapAction action = MapAction::kAdded;
-        /// A pointer to the inserted entry value.
-        Value* value = nullptr;
-
-        /// @returns true if the entry was added to the map, or an existing entry was replaced.
-        operator bool() const { return action != MapAction::kKeptExisting; }
-    };
-
-    /// The common implementation for Add() and Replace()
-    /// @param key the key of the entry to add to the map.
-    /// @param value the value of the entry to add to the map.
-    /// @returns A PutResult describing the result of the insertion
-    template <PutMode MODE, typename K, typename V>
-    PutResult Put(K&& key, V&& value) {
-        // Ensure the map can fit a new entry
-        if (ShouldRehash(count_ + 1)) {
-            Reserve((count_ + 1) * 2);
-        }
-
-        const auto hash = Hash(key);
-
-        auto make_entry = [&] {
-            if constexpr (ValueIsVoid) {
-                return std::forward<K>(key);
-            } else {
-                return Entry{std::forward<K>(key), std::forward<V>(value)};
-            }
+    /// Node holds an Entry in a linked list.
+    struct Node {
+        /// A structure that has the same size and alignment as Entry.
+        /// Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
+        struct alignas(alignof(ENTRY)) Storage {
+            /// Byte array of length sizeof(ENTRY)
+            uint8_t data[sizeof(ENTRY)];
         };
 
-        const auto count = slots_.Length();
-        for (size_t distance = 0, index = hash.scan_start; distance < count; distance++) {
-            auto& slot = slots_[index];
-            if (!slot.entry.has_value()) {
-                // Found an empty slot.
-                // Place value directly into the slot, and we're done.
-                slot.entry.emplace(make_entry());
-                slot.hash = hash.code;
-                slot.distance = distance;
-                count_++;
-                generation_++;
-                return PutResult{MapAction::kAdded, ValueOf(*slot.entry)};
-            }
+        /// Destructs the entry.
+        void Destroy() { Entry().~ENTRY(); }
 
-            // Slot has an entry
+        /// @returns the storage reinterpreted as an `Entry&`
+        ENTRY& Entry() { return *Bitcast<ENTRY*>(&storage.data[0]); }
 
-            if (slot.Equals(hash.code, key)) {
-                // Slot is equal to value. Replace or preserve?
-                if constexpr (MODE == PutMode::kReplace) {
-                    slot.entry = make_entry();
-                    generation_++;
-                    return PutResult{MapAction::kReplaced, ValueOf(*slot.entry)};
-                } else {
-                    return PutResult{MapAction::kKeptExisting, ValueOf(*slot.entry)};
-                }
-            }
+        /// @returns the storage reinterpreted as a `const Entry&`
+        const ENTRY& Entry() const { return *Bitcast<const ENTRY*>(&storage.data[0]); }
 
-            if (slot.distance < distance) {
-                // Existing slot has a closer distance than the value we're attempting to insert.
-                // Steal from the rich!
-                // Move the current slot to a temporary (evicted), and put the value into the slot.
-                Slot evicted{make_entry(), hash.code, distance};
-                std::swap(evicted, slot);
+        /// @returns a reference to the Entry's HashmapKey
+        const HashmapBase::Key& Key() const { return HashmapBase::Entry::KeyOf(Entry()); }
 
-                // Find a new home for the evicted slot.
-                evicted.distance++;  // We've already swapped at index.
-                InsertShuffle(Wrap(index + 1), std::move(evicted));
-
-                count_++;
-                generation_++;
-                return PutResult{MapAction::kAdded, ValueOf(*slot.entry)};
-            }
-
-            index = (index == count - 1) ? 0 : index + 1;
+        /// @param hash the hash value to compare against the Entry's key hash value
+        /// @param value the value to compare against the Entry's key
+        /// @returns true if the Entry's hash is equal to @p hash, and the Entry's key is equal to
+        /// @p value.
+        template <typename T>
+        bool Equals(size_t hash, T&& value) const {
+            auto& key = Key();
+            return key.hash == hash && HashmapBase::Equal{}(key.Value(), value);
         }
 
-        TINT_ICE() << "HashmapBase::Put() looped entire map without finding a slot";
-        return PutResult{};
-    }
+        /// storage is a buffer that has the same size and alignment as Entry.
+        /// The storage holds a constructed Entry when linked in the slots, and is destructed when
+        /// removed from slots.
+        Storage storage;
 
-    /// HashResult is the return value of Hash()
-    struct HashResult {
-        /// The target (zero-distance) slot index for the key.
-        size_t scan_start;
-        /// The calculated hash code of the key.
-        size_t code;
+        /// next is the next Node in the slot, or in the free list.
+        Node* next;
     };
 
-    /// @param key the key to hash
-    /// @returns a tuple holding the target slot index for the given value, and the hash of the
-    /// value, respectively.
-    template <typename K>
-    HashResult Hash(K&& key) const {
-        size_t hash = HASH()(std::forward<K>(key));
-        size_t index = Wrap(hash);
-        return {index, hash};
+    /// Copies the hashmap @p other into this empty hashmap.
+    /// @note This hashmap must be empty before calling
+    /// @param other the hashmap to copy
+    void Copy(const HashmapBase& other) {
+        Reserve(other.capacity_);
+        slots_.Resize(other.slots_.Length());
+        for (size_t slot_idx = 0; slot_idx < slots_.Length(); slot_idx++) {
+            for (auto* o = other.slots_[slot_idx].nodes; o; o = o->next) {
+                auto* node = free_.Take();
+                new (&node->Entry()) Entry{o->Entry()};
+                slots_[slot_idx].Add(node);
+            }
+        }
+        count_ = other.count_;
     }
 
-    /// Looks for the key in the map.
-    /// @param key the key to search for.
-    /// @returns a tuple holding a boolean representing whether the key was found in the map, and
-    /// if found, the index of the slot that holds the key.
-    template <typename K>
-    std::tuple<bool, size_t> IndexOf(K&& key) const {
-        const auto hash = Hash(key);
-        const auto count = slots_.Length();
-        for (size_t distance = 0, index = hash.scan_start; distance < count; distance++) {
-            auto& slot = slots_[index];
-            if (!slot.entry.has_value()) {
-                return {/* found */ false, /* index */ 0};
+    /// Moves the the hashmap @p other into this empty hashmap.
+    /// @note This hashmap must be empty before calling
+    /// @param other the hashmap to move
+    void Move(HashmapBase&& other) {
+        Reserve(other.capacity_);
+        slots_.Resize(other.slots_.Length());
+        for (size_t slot_idx = 0; slot_idx < slots_.Length(); slot_idx++) {
+            for (auto* o = other.slots_[slot_idx].nodes; o; o = o->next) {
+                auto* node = free_.Take();
+                new (&node->Entry()) Entry{std::move(o->Entry())};
+                slots_[slot_idx].Add(node);
             }
-            if (slot.Equals(hash.code, key)) {
-                return {/* found */ true, index};
-            }
-            if (slot.distance < distance) {
-                // If the slot distance is less than the current probe distance, then the slot
-                // must be for entry that has an index that comes after key. In this situation,
-                // we know that the map does not contain the key, as it would have been found
-                // before this slot. The "Lookup" section of
-                // https://programming.guide/robin-hood-hashing.html suggests that the condition
-                // should inverted, but this is wrong.
-                return {/* found */ false, /* index */ 0};
-            }
-            index = (index == count - 1) ? 0 : index + 1;
+        }
+        count_ = other.count_;
+        other.Clear();
+    }
+
+    /// EditIndex is the structure returned by EditAt(), used to simplify entry replacement and
+    /// insertion.
+    struct EditIndex {
+        /// The HashmapBase that created this EditIndex
+        HashmapBase& map;
+        /// The slot that will hold the edit.
+        Slot& slot;
+        /// The hash of the key, passed to EditAt().
+        size_t hash;
+        /// The resolved node entry, or nullptr if EditAt() did not resolve to an existing entry.
+        Entry* entry = nullptr;
+
+        /// Replace will replace the entry with a new Entry built from @p key and @p values.
+        /// @note #entry must not be null before calling.
+        /// @note the new key must have equality to the old key.
+        /// @param key the key value (inner value of a HashmapKey).
+        /// @param values optional additional values to pass to the Entry constructor.
+        template <typename K, typename... V>
+        void Replace(K&& key, V&&... values) {
+            *entry = Entry{Key{hash, std::forward<K>(key)}, std::forward<V>(values)...};
         }
 
-        TINT_ICE() << "HashmapBase::IndexOf() looped entire map without finding a slot";
-        return {/* found */ false, /* index */ 0};
+        /// Insert will create a new entry using @p key and @p values and insert it into the slot.
+        /// The created entry will be assigned to #entry before returning.
+        /// @note #entry must be null before calling.
+        /// @note the key must not already exist in the map.
+        /// @param key the key value (inner value of a HashmapKey).
+        /// @param values optional additional values to pass to the Entry constructor.
+        template <typename K, typename... V>
+        void Insert(K&& key, V&&... values) {
+            auto* node = map.free_.Take();
+            slot.Add(node);
+            map.count_++;
+            entry = &node->Entry();
+            new (entry) Entry{Key{hash, std::forward<K>(key)}, std::forward<V>(values)...};
+        }
+    };
+
+    /// EditAt is a helper for map entry replacement and entry insertion.
+    /// Before indexing, EditAt will ensure there's at least one free node available, potentially
+    /// allocating and rehashing if there's no free nodes available.
+    /// @param key the key used to compute the hash, look up the slot and search for the existing
+    /// node.
+    /// @returns a EditIndex used to modify or insert a new entry into the map with the given key.
+    template <typename K>
+    EditIndex EditAt(K&& key) {
+        if (!free_.nodes_) {
+            free_.Allocate(capacity_);
+            capacity_ += capacity_;
+            Rehash();
+        }
+        size_t hash = Hash{}(key);
+        auto& slot = slots_[hash % slots_.Length()];
+        auto* entry = slot.Find(hash, key);
+        return {*this, slot, hash, entry};
     }
 
-    /// Shuffles slots for an insertion that has been placed one slot before `start`.
-    /// @param start the index of the first slot to start shuffling.
-    /// @param evicted the slot content that was evicted for the insertion.
-    void InsertShuffle(size_t start, Slot&& evicted) {
-        const auto count = slots_.Length();
-        for (size_t distance = 0, index = start; distance < count; distance++) {
-            auto& slot = slots_[index];
-
-            if (!slot.entry.has_value()) {
-                // Empty slot found for evicted.
-                slot = std::move(evicted);
-                return;  //  We're done.
+    /// Rehash resizes the slots vector proportionally to the map capacity, and then reinserts the
+    /// nodes so they're linked in the correct slots linked lists.
+    void Rehash() {
+        size_t num_slots = NumSlots(capacity_);
+        decltype(slots_) old_slots;
+        std::swap(slots_, old_slots);
+        slots_.Resize(num_slots);
+        for (size_t old_slot_idx = 0; old_slot_idx < old_slots.Length(); old_slot_idx++) {
+            auto* node = old_slots[old_slot_idx].nodes;
+            while (node) {
+                auto next = node->next;
+                size_t new_slot_idx = node->Key().hash % num_slots;
+                slots_[new_slot_idx].Add(node);
+                node = next;
             }
-
-            if (slot.distance < evicted.distance) {
-                // Occupied slot has shorter distance to evicted.
-                // Swap slot and evicted.
-                std::swap(slot, evicted);
-            }
-
-            // evicted moves further from the target slot...
-            evicted.distance++;
-
-            index = (index == count - 1) ? 0 : index + 1;
         }
     }
 
-    /// @param count the number of new entries in the map
-    /// @returns true if the map should grow the slot vector, and rehash the items.
-    bool ShouldRehash(size_t count) const { return NumSlots(count) > slots_.Length(); }
+    /// Slot holds a linked list of nodes. Nodes are assigned to the slot list by calculating the
+    /// modulo of the entry's hash with the slot_ vector length.
+    struct Slot {
+        /// The linked list of nodes in this slot.
+        Node* nodes = nullptr;
 
-    /// @param index an input value
-    /// @returns the input value modulo the number of slots.
-    size_t Wrap(size_t index) const { return index % slots_.Length(); }
+        /// Add adds the node @p node to this slot.
+        /// @note The node must be unlinked from any existing list before calling.
+        /// @param node the node to add.
+        void Add(Node* node) {
+            node->next = nodes;
+            nodes = node;
+        }
 
-    /// The vector of slots. The vector length is equal to its capacity.
-    Vector<Slot, kMinSlots> slots_;
+        /// @returns the node in the slot with the given hash and key.
+        /// @param hash the key hash to search for.
+        /// @param key the key value to search for.
+        template <typename K>
+        const Entry* Find(size_t hash, K&& key) const {
+            for (auto* node = nodes; node; node = node->next) {
+                if (node->Equals(hash, key)) {
+                    return &node->Entry();
+                }
+            }
+            return nullptr;
+        }
 
-    /// The number of entries in the map.
+        /// @returns the node in the slot with the given hash and key.
+        /// @param hash the key hash to search for.
+        /// @param key the key value to search for.
+        template <typename K>
+        Entry* Find(size_t hash, K&& key) {
+            for (auto* node = nodes; node; node = node->next) {
+                if (node->Equals(hash, key)) {
+                    return &node->Entry();
+                }
+            }
+            return nullptr;
+        }
+    };
+
+    /// Free holds a linked list of nodes which are currently not used by entries in the map, and a
+    /// linked list of node allocations.
+    struct FreeNodes {
+        /// Allocation is the header of a block of memory that holds Nodes.
+        struct Allocation {
+            /// The linked list of allocations.
+            Allocation* next = nullptr;
+            // Node[] array follows this structure.
+        };
+
+        /// The linked list of free nodes.
+        Node* nodes_ = nullptr;
+
+        /// The linked list of allocations.
+        Allocation* allocations_ = nullptr;
+
+        /// Destructor.
+        /// Frees all the allocations made.
+        ~FreeNodes() {
+            auto* allocation = allocations_;
+            while (allocation) {
+                auto* next = allocation->next;
+                free(allocation);
+                allocation = next;
+            }
+        }
+
+        /// @returns the next free node in the list
+        Node* Take() {
+            auto* node = nodes_;
+            nodes_ = node->next;
+            node->next = nullptr;
+            return node;
+        }
+
+        /// Add adds the node @p node to the list of free nodes.
+        /// @note The node must be unlinked from any existing list before calling.
+        /// @param node the node to add.
+        void Add(Node* node) {
+            node->next = nodes_;
+            nodes_ = node;
+        }
+
+        /// Allocate allocates an additional @p count nodes and adds them to the free node list.
+        /// @param count the number of new nodes to allocate.
+        /// @note callers must remember to increment HashmapBase::capacity_ by the same amount.
+        void Allocate(size_t count) {
+            static_assert(std::is_trivial_v<Node>,
+                          "Node is not trivial, and will require construction / destruction");
+            constexpr size_t kAllocationSize = RoundUp(alignof(Node), sizeof(Allocation));
+            auto* memory =
+                reinterpret_cast<std::byte*>(malloc(kAllocationSize + sizeof(Node) * count));
+            if (TINT_UNLIKELY(!memory)) {
+                TINT_ICE() << "out of memory";
+                return;
+            }
+            auto* nodes_allocation = Bitcast<Allocation*>(memory);
+            nodes_allocation->next = allocations_;
+            allocations_ = nodes_allocation;
+
+            auto* nodes = Bitcast<Node*>(memory + kAllocationSize);
+            for (size_t i = 0; i < count; i++) {
+                Add(&nodes[i]);
+            }
+        }
+    };
+
+    /// The fixed-size array of nodes, used for the first kMinCapacity entries of the map, before
+    /// allocating from the heap.
+    std::array<Node, kMinCapacity> fixed_;
+    /// The vector of slots. Each slot holds a linked list of nodes which hold entries in the map.
+    Vector<Slot, NumSlots(N)> slots_;
+    /// The linked list of free nodes, and node allocations from the heap.
+    FreeNodes free_;
+    /// The total number of nodes, including free nodes (kMinCapacity + heap-allocated)
+    size_t capacity_ = kMinCapacity;
+    /// The total number of nodes that currently hold map entries.
     size_t count_ = 0;
-
-    /// Counter that's incremented with each modification to the map.
-    size_t generation_ = 0;
 };
 
 }  // namespace tint
diff --git a/src/tint/utils/containers/hashmap_test.cc b/src/tint/utils/containers/hashmap_test.cc
index af3efee..af926a2 100644
--- a/src/tint/utils/containers/hashmap_test.cc
+++ b/src/tint/utils/containers/hashmap_test.cc
@@ -82,40 +82,19 @@
     EXPECT_FALSE(map.Contains("world"));
 }
 
-TEST(Hashmap, Generation) {
-    Hashmap<int, std::string, 8> map;
-    EXPECT_EQ(map.Generation(), 0u);
-    map.Add(1, "one");
-    EXPECT_EQ(map.Generation(), 1u);
-    map.Add(1, "uno");
-    EXPECT_EQ(map.Generation(), 1u);
-    map.Replace(1, "une");
-    EXPECT_EQ(map.Generation(), 2u);
-    map.Add(2, "dos");
-    EXPECT_EQ(map.Generation(), 3u);
-    map.Remove(1);
-    EXPECT_EQ(map.Generation(), 4u);
-    map.Clear();
-    EXPECT_EQ(map.Generation(), 5u);
-    map.Find(2);
-    EXPECT_EQ(map.Generation(), 5u);
-    map.Get(2);
-    EXPECT_EQ(map.Generation(), 5u);
-}
-
 TEST(Hashmap, Index) {
     Hashmap<int, std::string, 4> map;
-    auto zero = map.Find(0);
+    auto zero = map.Get(0);
     EXPECT_FALSE(zero);
 
     map.Add(3, "three");
-    auto three = map.Find(3);
+    auto three = map.Get(3);
     map.Add(2, "two");
-    auto two = map.Find(2);
+    auto two = map.Get(2);
     map.Add(4, "four");
-    auto four = map.Find(4);
+    auto four = map.Get(4);
     map.Add(8, "eight");
-    auto eight = map.Find(8);
+    auto eight = map.Get(8);
 
     EXPECT_FALSE(zero);
     ASSERT_TRUE(three);
@@ -123,23 +102,23 @@
     ASSERT_TRUE(four);
     ASSERT_TRUE(eight);
 
-    EXPECT_EQ(*three, "three");
-    EXPECT_EQ(*two, "two");
-    EXPECT_EQ(*four, "four");
-    EXPECT_EQ(*eight, "eight");
+    EXPECT_EQ(three, "three");
+    EXPECT_EQ(two, "two");
+    EXPECT_EQ(four, "four");
+    EXPECT_EQ(eight, "eight");
 
-    map.Add(0, "zero");  // Note: Find called before Add() is okay!
+    map.Add(0, "zero");
+    EXPECT_FALSE(zero);
 
     map.Add(5, "five");
-    auto five = map.Find(5);
+    auto five = map.Get(5);
     map.Add(6, "six");
-    auto six = map.Find(6);
+    auto six = map.Get(6);
     map.Add(1, "one");
-    auto one = map.Find(1);
+    auto one = map.Get(1);
     map.Add(7, "seven");
-    auto seven = map.Find(7);
+    auto seven = map.Get(7);
 
-    ASSERT_TRUE(zero);
     ASSERT_TRUE(three);
     ASSERT_TRUE(two);
     ASSERT_TRUE(four);
@@ -149,47 +128,38 @@
     ASSERT_TRUE(one);
     ASSERT_TRUE(seven);
 
-    EXPECT_EQ(*zero, "zero");
-    EXPECT_EQ(*three, "three");
-    EXPECT_EQ(*two, "two");
-    EXPECT_EQ(*four, "four");
-    EXPECT_EQ(*eight, "eight");
-    EXPECT_EQ(*five, "five");
-    EXPECT_EQ(*six, "six");
-    EXPECT_EQ(*one, "one");
-    EXPECT_EQ(*seven, "seven");
-
-    map.Remove(2);
-    map.Remove(8);
-    map.Remove(1);
-
-    EXPECT_FALSE(two);
-    EXPECT_FALSE(eight);
-    EXPECT_FALSE(one);
+    EXPECT_EQ(three, "three");
+    EXPECT_EQ(two, "two");
+    EXPECT_EQ(four, "four");
+    EXPECT_EQ(eight, "eight");
+    EXPECT_EQ(five, "five");
+    EXPECT_EQ(six, "six");
+    EXPECT_EQ(one, "one");
+    EXPECT_EQ(seven, "seven");
 }
 
 TEST(Hashmap, StringKeys) {
     Hashmap<std::string, int, 4> map;
-    EXPECT_FALSE(map.Find("zero"));
-    EXPECT_FALSE(map.Find(std::string("zero")));
-    EXPECT_FALSE(map.Find(std::string_view("zero")));
+    EXPECT_FALSE(map.Get("zero"));
+    EXPECT_FALSE(map.Get(std::string("zero")));
+    EXPECT_FALSE(map.Get(std::string_view("zero")));
 
     map.Add("three", 3);
-    auto three_cstr = map.Find("three");
-    auto three_str = map.Find(std::string("three"));
-    auto three_sv = map.Find(std::string_view("three"));
+    auto three_cstr = map.Get("three");
+    auto three_str = map.Get(std::string("three"));
+    auto three_sv = map.Get(std::string_view("three"));
     map.Add(std::string("two"), 2);
-    auto two_cstr = map.Find("two");
-    auto two_str = map.Find(std::string("two"));
-    auto two_sv = map.Find(std::string_view("two"));
+    auto two_cstr = map.Get("two");
+    auto two_str = map.Get(std::string("two"));
+    auto two_sv = map.Get(std::string_view("two"));
     map.Add("four", 4);
-    auto four_cstr = map.Find("four");
-    auto four_str = map.Find(std::string("four"));
-    auto four_sv = map.Find(std::string_view("four"));
+    auto four_cstr = map.Get("four");
+    auto four_str = map.Get(std::string("four"));
+    auto four_sv = map.Get(std::string_view("four"));
     map.Add(std::string("eight"), 8);
-    auto eight_cstr = map.Find("eight");
-    auto eight_str = map.Find(std::string("eight"));
-    auto eight_sv = map.Find(std::string_view("eight"));
+    auto eight_cstr = map.Get("eight");
+    auto eight_str = map.Get(std::string("eight"));
+    auto eight_sv = map.Get(std::string_view("eight"));
 
     ASSERT_TRUE(three_cstr);
     ASSERT_TRUE(three_str);
@@ -204,40 +174,40 @@
     ASSERT_TRUE(eight_str);
     ASSERT_TRUE(eight_sv);
 
-    EXPECT_EQ(*three_cstr, 3);
-    EXPECT_EQ(*three_str, 3);
-    EXPECT_EQ(*three_sv, 3);
-    EXPECT_EQ(*two_cstr, 2);
-    EXPECT_EQ(*two_str, 2);
-    EXPECT_EQ(*two_sv, 2);
-    EXPECT_EQ(*four_cstr, 4);
-    EXPECT_EQ(*four_str, 4);
-    EXPECT_EQ(*four_sv, 4);
-    EXPECT_EQ(*eight_cstr, 8);
-    EXPECT_EQ(*eight_str, 8);
-    EXPECT_EQ(*eight_sv, 8);
+    EXPECT_EQ(three_cstr, 3);
+    EXPECT_EQ(three_str, 3);
+    EXPECT_EQ(three_sv, 3);
+    EXPECT_EQ(two_cstr, 2);
+    EXPECT_EQ(two_str, 2);
+    EXPECT_EQ(two_sv, 2);
+    EXPECT_EQ(four_cstr, 4);
+    EXPECT_EQ(four_str, 4);
+    EXPECT_EQ(four_sv, 4);
+    EXPECT_EQ(eight_cstr, 8);
+    EXPECT_EQ(eight_str, 8);
+    EXPECT_EQ(eight_sv, 8);
 
-    map.Add("zero", 0);  // Note: Find called before Add() is okay!
-    auto zero_cstr = map.Find("zero");
-    auto zero_str = map.Find(std::string("zero"));
-    auto zero_sv = map.Find(std::string_view("zero"));
+    map.Add("zero", 0);
+    auto zero_cstr = map.Get("zero");
+    auto zero_str = map.Get(std::string("zero"));
+    auto zero_sv = map.Get(std::string_view("zero"));
 
     map.Add(std::string("five"), 5);
-    auto five_cstr = map.Find("five");
-    auto five_str = map.Find(std::string("five"));
-    auto five_sv = map.Find(std::string_view("five"));
+    auto five_cstr = map.Get("five");
+    auto five_str = map.Get(std::string("five"));
+    auto five_sv = map.Get(std::string_view("five"));
     map.Add("six", 6);
-    auto six_cstr = map.Find("six");
-    auto six_str = map.Find(std::string("six"));
-    auto six_sv = map.Find(std::string_view("six"));
+    auto six_cstr = map.Get("six");
+    auto six_str = map.Get(std::string("six"));
+    auto six_sv = map.Get(std::string_view("six"));
     map.Add("one", 1);
-    auto one_cstr = map.Find("one");
-    auto one_str = map.Find(std::string("one"));
-    auto one_sv = map.Find(std::string_view("one"));
+    auto one_cstr = map.Get("one");
+    auto one_str = map.Get(std::string("one"));
+    auto one_sv = map.Get(std::string_view("one"));
     map.Add(std::string("seven"), 7);
-    auto seven_cstr = map.Find("seven");
-    auto seven_str = map.Find(std::string("seven"));
-    auto seven_sv = map.Find(std::string_view("seven"));
+    auto seven_cstr = map.Get("seven");
+    auto seven_str = map.Get(std::string("seven"));
+    auto seven_sv = map.Get(std::string_view("seven"));
 
     ASSERT_TRUE(zero_cstr);
     ASSERT_TRUE(zero_str);
@@ -267,33 +237,33 @@
     ASSERT_TRUE(seven_str);
     ASSERT_TRUE(seven_sv);
 
-    EXPECT_EQ(*zero_cstr, 0);
-    EXPECT_EQ(*zero_str, 0);
-    EXPECT_EQ(*zero_sv, 0);
-    EXPECT_EQ(*three_cstr, 3);
-    EXPECT_EQ(*three_str, 3);
-    EXPECT_EQ(*three_sv, 3);
-    EXPECT_EQ(*two_cstr, 2);
-    EXPECT_EQ(*two_str, 2);
-    EXPECT_EQ(*two_sv, 2);
-    EXPECT_EQ(*four_cstr, 4);
-    EXPECT_EQ(*four_str, 4);
-    EXPECT_EQ(*four_sv, 4);
-    EXPECT_EQ(*eight_cstr, 8);
-    EXPECT_EQ(*eight_str, 8);
-    EXPECT_EQ(*eight_sv, 8);
-    EXPECT_EQ(*five_cstr, 5);
-    EXPECT_EQ(*five_str, 5);
-    EXPECT_EQ(*five_sv, 5);
-    EXPECT_EQ(*six_cstr, 6);
-    EXPECT_EQ(*six_str, 6);
-    EXPECT_EQ(*six_sv, 6);
-    EXPECT_EQ(*one_cstr, 1);
-    EXPECT_EQ(*one_str, 1);
-    EXPECT_EQ(*one_sv, 1);
-    EXPECT_EQ(*seven_cstr, 7);
-    EXPECT_EQ(*seven_str, 7);
-    EXPECT_EQ(*seven_sv, 7);
+    EXPECT_EQ(zero_cstr, 0);
+    EXPECT_EQ(zero_str, 0);
+    EXPECT_EQ(zero_sv, 0);
+    EXPECT_EQ(three_cstr, 3);
+    EXPECT_EQ(three_str, 3);
+    EXPECT_EQ(three_sv, 3);
+    EXPECT_EQ(two_cstr, 2);
+    EXPECT_EQ(two_str, 2);
+    EXPECT_EQ(two_sv, 2);
+    EXPECT_EQ(four_cstr, 4);
+    EXPECT_EQ(four_str, 4);
+    EXPECT_EQ(four_sv, 4);
+    EXPECT_EQ(eight_cstr, 8);
+    EXPECT_EQ(eight_str, 8);
+    EXPECT_EQ(eight_sv, 8);
+    EXPECT_EQ(five_cstr, 5);
+    EXPECT_EQ(five_str, 5);
+    EXPECT_EQ(five_sv, 5);
+    EXPECT_EQ(six_cstr, 6);
+    EXPECT_EQ(six_str, 6);
+    EXPECT_EQ(six_sv, 6);
+    EXPECT_EQ(one_cstr, 1);
+    EXPECT_EQ(one_str, 1);
+    EXPECT_EQ(one_sv, 1);
+    EXPECT_EQ(seven_cstr, 7);
+    EXPECT_EQ(seven_str, 7);
+    EXPECT_EQ(seven_sv, 7);
 }
 
 TEST(Hashmap, Iterator) {
@@ -316,7 +286,7 @@
     map.Add(4, "four");
     map.Add(3, "three");
     map.Add(2, "two");
-    for (auto pair : map) {
+    for (auto& pair : map) {
         pair.value += "!";
     }
     EXPECT_THAT(map, testing::UnorderedElementsAre(Entry{1, "one!"}, Entry{2, "two!"},
@@ -349,44 +319,46 @@
     }
 }
 
-TEST(Hashmap, GetOrCreate) {
+TEST(Hashmap, GetOrAdd) {
     Hashmap<int, std::string, 8> map;
     std::optional<std::string> value_of_key_0_at_create;
-    EXPECT_EQ(map.GetOrCreate(0,
-                              [&] {
-                                  value_of_key_0_at_create = map.Get(0);
-                                  return "zero";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(0,
+                           [&] {
+                               if (auto existing = map.Get(0)) {
+                                   value_of_key_0_at_create = *existing;
+                               }
+                               return "zero";
+                           }),
               "zero");
     EXPECT_EQ(map.Count(), 1u);
     EXPECT_EQ(map.Get(0), "zero");
     EXPECT_EQ(value_of_key_0_at_create, "");
 
     bool create_called = false;
-    EXPECT_EQ(map.GetOrCreate(0,
-                              [&] {
-                                  create_called = true;
-                                  return "oh noes";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(0,
+                           [&] {
+                               create_called = true;
+                               return "oh noes";
+                           }),
               "zero");
     EXPECT_FALSE(create_called);
     EXPECT_EQ(map.Count(), 1u);
     EXPECT_EQ(map.Get(0), "zero");
 
-    EXPECT_EQ(map.GetOrCreate(1, [&] { return "one"; }), "one");
+    EXPECT_EQ(map.GetOrAdd(1, [&] { return "one"; }), "one");
     EXPECT_EQ(map.Count(), 2u);
     EXPECT_EQ(map.Get(1), "one");
 }
 
-TEST(Hashmap, GetOrCreate_CreateModifiesMap) {
+TEST(Hashmap, GetOrAdd_CreateModifiesMap) {
     Hashmap<int, std::string, 8> map;
-    EXPECT_EQ(map.GetOrCreate(0,
-                              [&] {
-                                  map.Add(3, "three");
-                                  map.Add(1, "one");
-                                  map.Add(2, "two");
-                                  return "zero";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(0,
+                           [&] {
+                               map.Add(3, "three");
+                               map.Add(1, "one");
+                               map.Add(2, "two");
+                               return "zero";
+                           }),
               "zero");
     EXPECT_EQ(map.Count(), 4u);
     EXPECT_EQ(map.Get(0), "zero");
@@ -395,11 +367,11 @@
     EXPECT_EQ(map.Get(3), "three");
 
     bool create_called = false;
-    EXPECT_EQ(map.GetOrCreate(0,
-                              [&] {
-                                  create_called = true;
-                                  return "oh noes";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(0,
+                           [&] {
+                               create_called = true;
+                               return "oh noes";
+                           }),
               "zero");
     EXPECT_FALSE(create_called);
     EXPECT_EQ(map.Count(), 4u);
@@ -408,13 +380,13 @@
     EXPECT_EQ(map.Get(2), "two");
     EXPECT_EQ(map.Get(3), "three");
 
-    EXPECT_EQ(map.GetOrCreate(4,
-                              [&] {
-                                  map.Add(6, "six");
-                                  map.Add(5, "five");
-                                  map.Add(7, "seven");
-                                  return "four";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(4,
+                           [&] {
+                               map.Add(6, "six");
+                               map.Add(5, "five");
+                               map.Add(7, "seven");
+                               return "four";
+                           }),
               "four");
     EXPECT_EQ(map.Count(), 8u);
     EXPECT_EQ(map.Get(0), "zero");
@@ -427,13 +399,13 @@
     EXPECT_EQ(map.Get(7), "seven");
 }
 
-TEST(Hashmap, GetOrCreate_CreateAddsSameKeyedValue) {
+TEST(Hashmap, GetOrAdd_CreateAddsSameKeyedValue) {
     Hashmap<int, std::string, 8> map;
-    EXPECT_EQ(map.GetOrCreate(42,
-                              [&] {
-                                  map.Add(42, "should-be-replaced");
-                                  return "expected-value";
-                              }),
+    EXPECT_EQ(map.GetOrAdd(42,
+                           [&] {
+                               map.Add(42, "should-be-replaced");
+                               return "expected-value";
+                           }),
               "expected-value");
     EXPECT_EQ(map.Count(), 1u);
     EXPECT_EQ(map.Get(42), "expected-value");
@@ -464,7 +436,7 @@
             case 2: {  // Remove
                 auto expected = reference.erase(key) != 0;
                 EXPECT_EQ(map.Remove(key), expected) << "i:" << i;
-                EXPECT_FALSE(map.Get(key).has_value()) << "i:" << i;
+                EXPECT_FALSE(map.Get(key)) << "i:" << i;
                 EXPECT_FALSE(map.Contains(key)) << "i:" << i;
                 break;
             }
@@ -478,7 +450,7 @@
                     auto expected = reference[key];
                     EXPECT_EQ(map.Get(key), expected) << "i:" << i;
                 } else {
-                    EXPECT_FALSE(map.Get(key).has_value()) << "i:" << i;
+                    EXPECT_FALSE(map.Get(key)) << "i:" << i;
                 }
                 break;
             }
diff --git a/src/tint/utils/containers/hashset.h b/src/tint/utils/containers/hashset.h
index da07e43..9bdc7ef 100644
--- a/src/tint/utils/containers/hashset.h
+++ b/src/tint/utils/containers/hashset.h
@@ -40,11 +40,10 @@
 
 namespace tint {
 
-/// An unordered set that uses a robin-hood hashing algorithm.
+/// An unordered hashset, with a fixed-size capacity that avoids heap allocations.
 template <typename KEY, size_t N, typename HASH = Hasher<KEY>, typename EQUAL = std::equal_to<KEY>>
-class Hashset : public HashmapBase<KEY, void, N, HASH, EQUAL> {
-    using Base = HashmapBase<KEY, void, N, HASH, EQUAL>;
-    using PutMode = typename Base::PutMode;
+class Hashset : public HashmapBase<HashmapKey<KEY, HASH, EQUAL>, N> {
+    using Base = HashmapBase<HashmapKey<KEY, HASH, EQUAL>, N>;
 
   public:
     using Base::Base;
@@ -63,8 +62,12 @@
     /// @returns true if the value was added, false if there was an existing value in the set.
     template <typename V>
     bool Add(V&& value) {
-        struct NoValue {};
-        return this->template Put<PutMode::kAdd>(std::forward<V>(value), NoValue{});
+        auto idx = this->EditAt(value);
+        if (idx.entry) {
+            return false;  // Entry already exists
+        }
+        idx.Insert(std::forward<V>(value));
+        return true;
     }
 
     /// @returns the set entries of the map as a vector
@@ -73,8 +76,8 @@
     tint::Vector<KEY, N2> Vector() const {
         tint::Vector<KEY, N2> out;
         out.Reserve(this->Count());
-        for (auto& value : *this) {
-            out.Push(value);
+        for (auto& key : *this) {
+            out.Push(key.Value());
         }
         return out;
     }
@@ -83,8 +86,8 @@
     /// @param pred a function-like with the signature `bool(T)`
     template <typename PREDICATE>
     bool Any(PREDICATE&& pred) const {
-        for (const auto& it : *this) {
-            if (pred(it)) {
+        for (const auto& key : *this) {
+            if (pred(key.Value())) {
                 return true;
             }
         }
@@ -95,13 +98,23 @@
     /// @param pred a function-like with the signature `bool(T)`
     template <typename PREDICATE>
     bool All(PREDICATE&& pred) const {
-        for (const auto& it : *this) {
-            if (!pred(it)) {
+        for (const auto& key : *this) {
+            if (!pred(key.Value())) {
                 return false;
             }
         }
         return true;
     }
+
+    /// Looks up an entry in the set that is equal to @p key
+    /// @param key the key to search for.
+    /// @returns the entry that is equal to @p key
+    std::optional<KEY> Get(const KEY& key) const {
+        if (auto [found, index] = this->IndexOf(key); found) {
+            return this->slots_[index].entry;
+        }
+        return std::nullopt;
+    }
 };
 
 }  // namespace tint
diff --git a/src/tint/utils/containers/hashset_test.cc b/src/tint/utils/containers/hashset_test.cc
index 96e22bc..e9ae39e 100644
--- a/src/tint/utils/containers/hashset_test.cc
+++ b/src/tint/utils/containers/hashset_test.cc
@@ -55,11 +55,11 @@
 TEST(Hashset, InitializerConstructor) {
     Hashset<int, 8> set{1, 5, 7};
     EXPECT_EQ(set.Count(), 3u);
-    EXPECT_TRUE(set.Contains(1u));
-    EXPECT_FALSE(set.Contains(3u));
-    EXPECT_TRUE(set.Contains(5u));
-    EXPECT_TRUE(set.Contains(7u));
-    EXPECT_FALSE(set.Contains(9u));
+    EXPECT_TRUE(set.Contains(1));
+    EXPECT_FALSE(set.Contains(3));
+    EXPECT_TRUE(set.Contains(5));
+    EXPECT_TRUE(set.Contains(7));
+    EXPECT_FALSE(set.Contains(9));
 }
 
 TEST(Hashset, AddRemove) {
@@ -83,7 +83,6 @@
         ASSERT_TRUE(set.Add(prime)) << "i: " << i;
         ASSERT_FALSE(set.Add(prime)) << "i: " << i;
         ASSERT_EQ(set.Count(), i + 1);
-        set.ValidateIntegrity();
     }
     ASSERT_EQ(set.Count(), kPrimes.size());
     for (int prime : kPrimes) {
@@ -91,21 +90,6 @@
     }
 }
 
-TEST(Hashset, Generation) {
-    Hashset<int, 8> set;
-    EXPECT_EQ(set.Generation(), 0u);
-    set.Add(1);
-    EXPECT_EQ(set.Generation(), 1u);
-    set.Add(1);
-    EXPECT_EQ(set.Generation(), 1u);
-    set.Add(2);
-    EXPECT_EQ(set.Generation(), 2u);
-    set.Remove(1);
-    EXPECT_EQ(set.Generation(), 3u);
-    set.Clear();
-    EXPECT_EQ(set.Generation(), 4u);
-}
-
 TEST(Hashset, Iterator) {
     Hashset<std::string, 8> set;
     set.Add("one");
@@ -160,7 +144,6 @@
                 break;
             }
         }
-        set.ValidateIntegrity();
     }
 }
 
diff --git a/src/tint/utils/containers/map.h b/src/tint/utils/containers/map.h
index 3a2830c..5de5538 100644
--- a/src/tint/utils/containers/map.h
+++ b/src/tint/utils/containers/map.h
@@ -46,7 +46,7 @@
     return it != map.end() ? it->second : if_missing;
 }
 
-/// GetOrCreate is a utility function for lazily adding to an unordered map.
+/// GetOrAdd is a utility function for lazily adding to an unordered map.
 /// If the map already contains the key `key` then this is returned, otherwise
 /// `create()` is called and the result is added to the map and is returned.
 /// @param map the unordered_map
@@ -54,7 +54,7 @@
 /// @param create a callable function-like object with the signature `V()`
 /// @return the value of the item with the given key, or the newly created item
 template <typename K, typename V, typename H, typename C, typename CREATE>
-V GetOrCreate(std::unordered_map<K, V, H, C>& map, const K& key, CREATE&& create) {
+V GetOrAdd(std::unordered_map<K, V, H, C>& map, const K& key, CREATE&& create) {
     auto it = map.find(key);
     if (it != map.end()) {
         return it->second;
diff --git a/src/tint/utils/containers/map_test.cc b/src/tint/utils/containers/map_test.cc
index 8b66b6d..34e2d1f 100644
--- a/src/tint/utils/containers/map_test.cc
+++ b/src/tint/utils/containers/map_test.cc
@@ -43,22 +43,22 @@
     EXPECT_EQ(Lookup(map, 20), 0);       // missing, without if_missing
 }
 
-TEST(GetOrCreateTest, NewKey) {
+TEST(GetOrAddTest, NewKey) {
     std::unordered_map<int, int> map;
-    EXPECT_EQ(GetOrCreate(map, 1, [&] { return 2; }), 2);
+    EXPECT_EQ(GetOrAdd(map, 1, [&] { return 2; }), 2);
     EXPECT_EQ(map.size(), 1u);
     EXPECT_EQ(map[1], 2);
 }
 
-TEST(GetOrCreateTest, ExistingKey) {
+TEST(GetOrAddTest, ExistingKey) {
     std::unordered_map<int, int> map;
     map[1] = 2;
     bool called = false;
-    EXPECT_EQ(GetOrCreate(map, 1,
-                          [&] {
-                              called = true;
-                              return -2;
-                          }),
+    EXPECT_EQ(GetOrAdd(map, 1,
+                       [&] {
+                           called = true;
+                           return -2;
+                       }),
               2);
     EXPECT_EQ(called, false);
     EXPECT_EQ(map.size(), 1u);
diff --git a/src/tint/utils/containers/scope_stack.h b/src/tint/utils/containers/scope_stack.h
index e87bff5..066d367 100644
--- a/src/tint/utils/containers/scope_stack.h
+++ b/src/tint/utils/containers/scope_stack.h
@@ -65,7 +65,7 @@
     /// @returns the old value if there was an existing key at the top of the
     /// stack, otherwise the zero initializer for type T.
     V Set(const K& key, V val) {
-        if (auto el = Top().Find(key)) {
+        if (auto el = Top().Get(key)) {
             std::swap(val, *el);
             return val;
         }
@@ -78,7 +78,7 @@
     /// @returns the value, or the zero initializer if the value was not found
     V Get(const K& key) const {
         for (size_t i = depth_; i > 0; i--) {
-            if (auto val = stack_[i - 1].Find(key)) {
+            if (auto val = stack_[i - 1].Get(key)) {
                 return *val;
             }
         }
diff --git a/src/tint/utils/containers/unique_allocator.h b/src/tint/utils/containers/unique_allocator.h
index 124adc4..8d88623 100644
--- a/src/tint/utils/containers/unique_allocator.h
+++ b/src/tint/utils/containers/unique_allocator.h
@@ -29,15 +29,14 @@
 #define SRC_TINT_UTILS_CONTAINERS_UNIQUE_ALLOCATOR_H_
 
 #include <functional>
-#include <unordered_set>
 #include <utility>
 
+#include "src/tint/utils/containers/hashmap_base.h"
 #include "src/tint/utils/memory/block_allocator.h"
 
 namespace tint {
 
-/// UniqueAllocator is used to allocate unique instances of the template type
-/// `T`.
+/// UniqueAllocator is used to allocate unique instances of the template type `T`.
 template <typename T, typename HASH = std::hash<T>, typename EQUAL = std::equal_to<T>>
 class UniqueAllocator {
   public:
@@ -50,19 +49,15 @@
     ///         pointer is returned.
     template <typename TYPE = T, typename... ARGS>
     TYPE* Get(ARGS&&... args) {
-        // Create a temporary T instance on the stack so that we can hash it, and
-        // use it for equality lookup for the std::unordered_set. If the item is not
-        // found in the set, then we create the persisted instance with the
-        // allocator.
-        TYPE key{args...};
-        auto hash = Hasher{}(key);
-        auto it = items.find(Entry{hash, &key});
-        if (it != items.end()) {
-            return static_cast<TYPE*>(it->ptr);
+        // Create a temporary T instance on the stack so that we can hash it, and use it for
+        // equality lookup for the Set. If the item is not found in the set, then we create the
+        // persisted instance with the allocator.
+        TYPE prototype{args...};
+        Key& key = items.Add(&prototype);
+        if (key.Value() == &prototype) {
+            key = allocator.template Create<TYPE>(std::forward<ARGS>(args)...);
         }
-        auto* ptr = allocator.template Create<TYPE>(std::forward<ARGS>(args)...);
-        items.emplace_hint(it, Entry{hash, ptr});
-        return ptr;
+        return static_cast<TYPE*>(key.Value());
     }
 
     /// @param args the arguments used to create the temporary used for the search.
@@ -70,15 +65,10 @@
     ///         was not found.
     template <typename TYPE = T, typename... ARGS>
     TYPE* Find(ARGS&&... args) const {
-        // Create a temporary T instance on the stack so that we can hash it, and
-        // use it for equality lookup for the std::unordered_set.
-        TYPE key{args...};
-        auto hash = Hasher{}(key);
-        auto it = items.find(Entry{hash, &key});
-        if (it != items.end()) {
-            return static_cast<TYPE*>(it->ptr);
-        }
-        return nullptr;
+        // Create a temporary T instance on the stack so that we can hash it, and use it for
+        // equality lookup for the Set.
+        TYPE prototype{std::forward<ARGS>(args)...};
+        return static_cast<TYPE*>(items.Get(&prototype));
     }
 
     /// Wrap sets this allocator to the objects created with the content of `inner`.
@@ -95,36 +85,52 @@
     Iterator end() const { return allocator.Objects().end(); }
 
   private:
-    /// The hash function
-    using Hasher = HASH;
-    /// The equality function
-    using Equality = EQUAL;
-
-    /// Entry is used as the entry to the unordered_set
-    struct Entry {
-        /// The pre-calculated hash of the entry
-        size_t hash;
-        /// The pointer to the unique object
-        T* ptr;
-    };
-    /// Comparator is the hashing and equality function used by the unordered_set
-    struct Comparator {
+    /// Comparator is the hashing function used by the Hashset
+    struct Hasher {
         /// Hashing function
         /// @param e the entry
         /// @returns the hash of the entry
-        size_t operator()(Entry e) const { return e.hash; }
+        size_t operator()(T* e) const { return HASH{}(*e); }
+    };
 
+    /// Equality is the equality function used by the Hashset
+    struct Equality {
         /// Equality function
         /// @param a the first entry to compare
         /// @param b the second entry to compare
         /// @returns true if the two entries are equal
-        bool operator()(Entry a, Entry b) const { return EQUAL{}(*a.ptr, *b.ptr); }
+        bool operator()(T* a, T* b) const { return EQUAL{}(*a, *b); }
+    };
+
+    /// The maximum capacity of Set before it performs heap allocations.
+    static constexpr size_t kFixedSize = 32;
+
+    /// The key type of Set.
+    using Key = HashmapKey<T*, Hasher, Equality>;
+
+    /// A custom Hashset implementation that allows keys to be modified.
+    class Set : public HashmapBase<Key, kFixedSize> {
+      public:
+        Key& Add(T* key) {
+            auto idx = this->EditAt(key);
+            if (!idx.entry) {
+                idx.Insert(std::forward<T*>(key));
+            }
+            return *idx.entry;
+        }
+
+        T* Get(T* key) const {
+            if (auto* entry = this->GetEntry(key)) {
+                return *entry;
+            }
+            return nullptr;
+        }
     };
 
     /// The block allocator used to allocate the unique objects
     BlockAllocator<T> allocator;
-    /// The unordered_set of unique item entries
-    std::unordered_set<Entry, Comparator, Comparator> items;
+    /// The set of unique item entries
+    Set items;
 };
 
 }  // namespace tint
diff --git a/src/tint/utils/math/hash.h b/src/tint/utils/math/hash.h
index e143d07..43c97f4 100644
--- a/src/tint/utils/math/hash.h
+++ b/src/tint/utils/math/hash.h
@@ -122,11 +122,11 @@
     /// @param ptr the pointer to hash
     /// @returns a hash of the pointer
     size_t operator()(T* ptr) const {
-        auto hash = std::hash<T*>()(ptr);
+        auto hash = static_cast<size_t>(reinterpret_cast<uintptr_t>(ptr));
 #ifdef TINT_HASH_SEED
         hash ^= static_cast<uint32_t>(TINT_HASH_SEED);
 #endif
-        return hash ^ (hash >> 4);
+        return hash >> 4;
     }
 };
 
diff --git a/src/tint/utils/symbol/symbol_table.cc b/src/tint/utils/symbol/symbol_table.cc
index e2ffae0..6685517 100644
--- a/src/tint/utils/symbol/symbol_table.cc
+++ b/src/tint/utils/symbol/symbol_table.cc
@@ -42,33 +42,22 @@
 Symbol SymbolTable::Register(std::string_view name) {
     TINT_ASSERT(!name.empty());
 
-    auto it = name_to_symbol_.Find(name);
-    if (it) {
-        return *it;
-    }
-    return RegisterInternal(name);
-}
-
-Symbol SymbolTable::RegisterInternal(std::string_view name) {
-    char* name_mem = Bitcast<char*>(name_allocator_.Allocate(name.length() + 1));
-    if (name_mem == nullptr) {
-        TINT_ICE() << "failed to allocate memory for symbol's string";
-        return Symbol();
+    auto& it = name_to_symbol_.GetOrAddZeroEntry(name);
+    if (it.value) {
+        return Symbol{it.value, generation_id_, it.key};
     }
 
-    memcpy(name_mem, name.data(), name.length() + 1);
-    std::string_view nv(name_mem, name.length());
-
-    Symbol sym(next_symbol_, generation_id_, nv);
-    ++next_symbol_;
-    name_to_symbol_.Add(sym.NameView(), sym);
-
-    return sym;
+    auto view = Allocate(name);
+    it.key = view;
+    it.value = next_symbol_++;
+    return Symbol{it.value, generation_id_, view};
 }
 
 Symbol SymbolTable::Get(std::string_view name) const {
-    auto it = name_to_symbol_.Find(name);
-    return it ? *it : Symbol();
+    if (auto* entry = name_to_symbol_.GetEntry(name)) {
+        return Symbol{entry->value, generation_id_, entry->key};
+    }
+    return Symbol{};
 }
 
 Symbol SymbolTable::New(std::string_view prefix_view /* = "" */) {
@@ -79,30 +68,37 @@
         prefix = std::string(prefix_view);
     }
 
-    auto it = name_to_symbol_.Find(prefix);
-    if (!it) {
-        return RegisterInternal(prefix);
+    auto& it = name_to_symbol_.GetOrAddZeroEntry(prefix);
+    if (it.value == 0) {
+        // prefix is a unique name
+        auto view = Allocate(prefix);
+        it.key = view;
+        it.value = next_symbol_++;
+        return Symbol{it.value, generation_id_, view};
     }
 
-    size_t i = 0;
-    auto last_prefix = last_prefix_to_index_.Find(prefix);
-    if (last_prefix) {
-        i = *last_prefix;
-    }
-
+    size_t& i = last_prefix_to_index_.GetOrAddZero(prefix);
     std::string name;
     do {
         ++i;
         name = prefix + "_" + std::to_string(i);
     } while (name_to_symbol_.Contains(name));
 
-    auto sym = RegisterInternal(name);
-    if (last_prefix) {
-        *last_prefix = i;
-    } else {
-        last_prefix_to_index_.Add(prefix, i);
+    auto view = Allocate(name);
+    auto id = name_to_symbol_.Add(view, next_symbol_++);
+    return Symbol{id.value, generation_id_, view};
+}
+
+std::string_view SymbolTable::Allocate(std::string_view name) {
+    static_assert(sizeof(char) == 1);
+    char* name_mem = Bitcast<char*>(name_allocator_.Allocate(name.length() + 1));
+    if (name_mem == nullptr) {
+        TINT_ICE() << "failed to allocate memory for symbol's string";
+        return {};
     }
-    return sym;
+
+    memcpy(name_mem, name.data(), name.length() + 1);
+    return {name_mem, name.length()};
 }
 
 }  // namespace tint
diff --git a/src/tint/utils/symbol/symbol_table.h b/src/tint/utils/symbol/symbol_table.h
index 7c39512..0fefa67 100644
--- a/src/tint/utils/symbol/symbol_table.h
+++ b/src/tint/utils/symbol/symbol_table.h
@@ -91,8 +91,8 @@
     /// signature: `void(Symbol)`
     template <typename F>
     void Foreach(F&& callback) const {
-        for (auto it : name_to_symbol_) {
-            callback(it.value);
+        for (auto& it : name_to_symbol_) {
+            callback(Symbol{it.value, generation_id_, it.key});
         }
     }
 
@@ -103,12 +103,12 @@
     SymbolTable(const SymbolTable&) = delete;
     SymbolTable& operator=(const SymbolTable& other) = delete;
 
-    Symbol RegisterInternal(std::string_view name);
+    std::string_view Allocate(std::string_view name);
 
     // The value to be associated to the next registered symbol table entry.
     uint32_t next_symbol_ = 1;
 
-    Hashmap<std::string_view, Symbol, 0> name_to_symbol_;
+    Hashmap<std::string_view, uint32_t, 0> name_to_symbol_;
     Hashmap<std::string, size_t, 0> last_prefix_to_index_;
     tint::GenerationID generation_id_;